· 4 years ago · Jul 09, 2021, 06:06 PM
1(function(scope){
2'use strict';
3
4function F(arity, fun, wrapper) {
5 wrapper.a = arity;
6 wrapper.f = fun;
7 return wrapper;
8}
9
10function F2(fun) {
11 return F(2, fun, function(a) { return function(b) { return fun(a,b); }; })
12}
13function F3(fun) {
14 return F(3, fun, function(a) {
15 return function(b) { return function(c) { return fun(a, b, c); }; };
16 });
17}
18function F4(fun) {
19 return F(4, fun, function(a) { return function(b) { return function(c) {
20 return function(d) { return fun(a, b, c, d); }; }; };
21 });
22}
23function F5(fun) {
24 return F(5, fun, function(a) { return function(b) { return function(c) {
25 return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };
26 });
27}
28function F6(fun) {
29 return F(6, fun, function(a) { return function(b) { return function(c) {
30 return function(d) { return function(e) { return function(f) {
31 return fun(a, b, c, d, e, f); }; }; }; }; };
32 });
33}
34function F7(fun) {
35 return F(7, fun, function(a) { return function(b) { return function(c) {
36 return function(d) { return function(e) { return function(f) {
37 return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };
38 });
39}
40function F8(fun) {
41 return F(8, fun, function(a) { return function(b) { return function(c) {
42 return function(d) { return function(e) { return function(f) {
43 return function(g) { return function(h) {
44 return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };
45 });
46}
47function F9(fun) {
48 return F(9, fun, function(a) { return function(b) { return function(c) {
49 return function(d) { return function(e) { return function(f) {
50 return function(g) { return function(h) { return function(i) {
51 return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };
52 });
53}
54
55function A2(fun, a, b) {
56 return fun.a === 2 ? fun.f(a, b) : fun(a)(b);
57}
58function A3(fun, a, b, c) {
59 return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c);
60}
61function A4(fun, a, b, c, d) {
62 return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d);
63}
64function A5(fun, a, b, c, d, e) {
65 return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e);
66}
67function A6(fun, a, b, c, d, e, f) {
68 return fun.a === 6 ? fun.f(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f);
69}
70function A7(fun, a, b, c, d, e, f, g) {
71 return fun.a === 7 ? fun.f(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g);
72}
73function A8(fun, a, b, c, d, e, f, g, h) {
74 return fun.a === 8 ? fun.f(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h);
75}
76function A9(fun, a, b, c, d, e, f, g, h, i) {
77 return fun.a === 9 ? fun.f(a, b, c, d, e, f, g, h, i) : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
78}
79
80
81
82
83// EQUALITY
84
85function _Utils_eq(x, y)
86{
87 for (
88 var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);
89 isEqual && (pair = stack.pop());
90 isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack)
91 )
92 {}
93
94 return isEqual;
95}
96
97function _Utils_eqHelp(x, y, depth, stack)
98{
99 if (x === y)
100 {
101 return true;
102 }
103
104 if (typeof x !== 'object' || x === null || y === null)
105 {
106 typeof x === 'function' && _Debug_crash(5);
107 return false;
108 }
109
110 if (depth > 100)
111 {
112 stack.push(_Utils_Tuple2(x,y));
113 return true;
114 }
115
116 /**_UNUSED/
117 if (x.$ === 'Set_elm_builtin')
118 {
119 x = $elm$core$Set$toList(x);
120 y = $elm$core$Set$toList(y);
121 }
122 if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')
123 {
124 x = $elm$core$Dict$toList(x);
125 y = $elm$core$Dict$toList(y);
126 }
127 //*/
128
129 /**/
130 if (x.$ < 0)
131 {
132 x = $elm$core$Dict$toList(x);
133 y = $elm$core$Dict$toList(y);
134 }
135 //*/
136
137 for (var key in x)
138 {
139 if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))
140 {
141 return false;
142 }
143 }
144 return true;
145}
146
147var _Utils_equal = F2(_Utils_eq);
148var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); });
149
150
151
152// COMPARISONS
153
154// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
155// the particular integer values assigned to LT, EQ, and GT.
156
157function _Utils_cmp(x, y, ord)
158{
159 if (typeof x !== 'object')
160 {
161 return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1;
162 }
163
164 /**_UNUSED/
165 if (x instanceof String)
166 {
167 var a = x.valueOf();
168 var b = y.valueOf();
169 return a === b ? 0 : a < b ? -1 : 1;
170 }
171 //*/
172
173 /**/
174 if (typeof x.$ === 'undefined')
175 //*/
176 /**_UNUSED/
177 if (x.$[0] === '#')
178 //*/
179 {
180 return (ord = _Utils_cmp(x.a, y.a))
181 ? ord
182 : (ord = _Utils_cmp(x.b, y.b))
183 ? ord
184 : _Utils_cmp(x.c, y.c);
185 }
186
187 // traverse conses until end of a list or a mismatch
188 for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES
189 return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);
190}
191
192var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; });
193var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; });
194var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; });
195var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; });
196
197var _Utils_compare = F2(function(x, y)
198{
199 var n = _Utils_cmp(x, y);
200 return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ;
201});
202
203
204// COMMON VALUES
205
206var _Utils_Tuple0 = 0;
207var _Utils_Tuple0_UNUSED = { $: '#0' };
208
209function _Utils_Tuple2(a, b) { return { a: a, b: b }; }
210function _Utils_Tuple2_UNUSED(a, b) { return { $: '#2', a: a, b: b }; }
211
212function _Utils_Tuple3(a, b, c) { return { a: a, b: b, c: c }; }
213function _Utils_Tuple3_UNUSED(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }
214
215function _Utils_chr(c) { return c; }
216function _Utils_chr_UNUSED(c) { return new String(c); }
217
218
219// RECORDS
220
221function _Utils_update(oldRecord, updatedFields)
222{
223 var newRecord = {};
224
225 for (var key in oldRecord)
226 {
227 newRecord[key] = oldRecord[key];
228 }
229
230 for (var key in updatedFields)
231 {
232 newRecord[key] = updatedFields[key];
233 }
234
235 return newRecord;
236}
237
238
239// APPEND
240
241var _Utils_append = F2(_Utils_ap);
242
243function _Utils_ap(xs, ys)
244{
245 // append Strings
246 if (typeof xs === 'string')
247 {
248 return xs + ys;
249 }
250
251 // append Lists
252 if (!xs.b)
253 {
254 return ys;
255 }
256 var root = _List_Cons(xs.a, ys);
257 xs = xs.b
258 for (var curr = root; xs.b; xs = xs.b) // WHILE_CONS
259 {
260 curr = curr.b = _List_Cons(xs.a, ys);
261 }
262 return root;
263}
264
265
266
267var _List_Nil = { $: 0 };
268var _List_Nil_UNUSED = { $: '[]' };
269
270function _List_Cons(hd, tl) { return { $: 1, a: hd, b: tl }; }
271function _List_Cons_UNUSED(hd, tl) { return { $: '::', a: hd, b: tl }; }
272
273
274var _List_cons = F2(_List_Cons);
275
276function _List_fromArray(arr)
277{
278 var out = _List_Nil;
279 for (var i = arr.length; i--; )
280 {
281 out = _List_Cons(arr[i], out);
282 }
283 return out;
284}
285
286function _List_toArray(xs)
287{
288 for (var out = []; xs.b; xs = xs.b) // WHILE_CONS
289 {
290 out.push(xs.a);
291 }
292 return out;
293}
294
295var _List_map2 = F3(function(f, xs, ys)
296{
297 for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES
298 {
299 arr.push(A2(f, xs.a, ys.a));
300 }
301 return _List_fromArray(arr);
302});
303
304var _List_map3 = F4(function(f, xs, ys, zs)
305{
306 for (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
307 {
308 arr.push(A3(f, xs.a, ys.a, zs.a));
309 }
310 return _List_fromArray(arr);
311});
312
313var _List_map4 = F5(function(f, ws, xs, ys, zs)
314{
315 for (var arr = []; ws.b && xs.b && ys.b && zs.b; ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
316 {
317 arr.push(A4(f, ws.a, xs.a, ys.a, zs.a));
318 }
319 return _List_fromArray(arr);
320});
321
322var _List_map5 = F6(function(f, vs, ws, xs, ys, zs)
323{
324 for (var arr = []; vs.b && ws.b && xs.b && ys.b && zs.b; vs = vs.b, ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
325 {
326 arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a));
327 }
328 return _List_fromArray(arr);
329});
330
331var _List_sortBy = F2(function(f, xs)
332{
333 return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
334 return _Utils_cmp(f(a), f(b));
335 }));
336});
337
338var _List_sortWith = F2(function(f, xs)
339{
340 return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
341 var ord = A2(f, a, b);
342 return ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1;
343 }));
344});
345
346
347
348var _JsArray_empty = [];
349
350function _JsArray_singleton(value)
351{
352 return [value];
353}
354
355function _JsArray_length(array)
356{
357 return array.length;
358}
359
360var _JsArray_initialize = F3(function(size, offset, func)
361{
362 var result = new Array(size);
363
364 for (var i = 0; i < size; i++)
365 {
366 result[i] = func(offset + i);
367 }
368
369 return result;
370});
371
372var _JsArray_initializeFromList = F2(function (max, ls)
373{
374 var result = new Array(max);
375
376 for (var i = 0; i < max && ls.b; i++)
377 {
378 result[i] = ls.a;
379 ls = ls.b;
380 }
381
382 result.length = i;
383 return _Utils_Tuple2(result, ls);
384});
385
386var _JsArray_unsafeGet = F2(function(index, array)
387{
388 return array[index];
389});
390
391var _JsArray_unsafeSet = F3(function(index, value, array)
392{
393 var length = array.length;
394 var result = new Array(length);
395
396 for (var i = 0; i < length; i++)
397 {
398 result[i] = array[i];
399 }
400
401 result[index] = value;
402 return result;
403});
404
405var _JsArray_push = F2(function(value, array)
406{
407 var length = array.length;
408 var result = new Array(length + 1);
409
410 for (var i = 0; i < length; i++)
411 {
412 result[i] = array[i];
413 }
414
415 result[length] = value;
416 return result;
417});
418
419var _JsArray_foldl = F3(function(func, acc, array)
420{
421 var length = array.length;
422
423 for (var i = 0; i < length; i++)
424 {
425 acc = A2(func, array[i], acc);
426 }
427
428 return acc;
429});
430
431var _JsArray_foldr = F3(function(func, acc, array)
432{
433 for (var i = array.length - 1; i >= 0; i--)
434 {
435 acc = A2(func, array[i], acc);
436 }
437
438 return acc;
439});
440
441var _JsArray_map = F2(function(func, array)
442{
443 var length = array.length;
444 var result = new Array(length);
445
446 for (var i = 0; i < length; i++)
447 {
448 result[i] = func(array[i]);
449 }
450
451 return result;
452});
453
454var _JsArray_indexedMap = F3(function(func, offset, array)
455{
456 var length = array.length;
457 var result = new Array(length);
458
459 for (var i = 0; i < length; i++)
460 {
461 result[i] = A2(func, offset + i, array[i]);
462 }
463
464 return result;
465});
466
467var _JsArray_slice = F3(function(from, to, array)
468{
469 return array.slice(from, to);
470});
471
472var _JsArray_appendN = F3(function(n, dest, source)
473{
474 var destLen = dest.length;
475 var itemsToCopy = n - destLen;
476
477 if (itemsToCopy > source.length)
478 {
479 itemsToCopy = source.length;
480 }
481
482 var size = destLen + itemsToCopy;
483 var result = new Array(size);
484
485 for (var i = 0; i < destLen; i++)
486 {
487 result[i] = dest[i];
488 }
489
490 for (var i = 0; i < itemsToCopy; i++)
491 {
492 result[i + destLen] = source[i];
493 }
494
495 return result;
496});
497
498
499
500// LOG
501
502var _Debug_log = F2(function(tag, value)
503{
504 return value;
505});
506
507var _Debug_log_UNUSED = F2(function(tag, value)
508{
509 console.log(tag + ': ' + _Debug_toString(value));
510 return value;
511});
512
513
514// TODOS
515
516function _Debug_todo(moduleName, region)
517{
518 return function(message) {
519 _Debug_crash(8, moduleName, region, message);
520 };
521}
522
523function _Debug_todoCase(moduleName, region, value)
524{
525 return function(message) {
526 _Debug_crash(9, moduleName, region, value, message);
527 };
528}
529
530
531// TO STRING
532
533function _Debug_toString(value)
534{
535 return '<internals>';
536}
537
538function _Debug_toString_UNUSED(value)
539{
540 return _Debug_toAnsiString(false, value);
541}
542
543function _Debug_toAnsiString(ansi, value)
544{
545 if (typeof value === 'function')
546 {
547 return _Debug_internalColor(ansi, '<function>');
548 }
549
550 if (typeof value === 'boolean')
551 {
552 return _Debug_ctorColor(ansi, value ? 'True' : 'False');
553 }
554
555 if (typeof value === 'number')
556 {
557 return _Debug_numberColor(ansi, value + '');
558 }
559
560 if (value instanceof String)
561 {
562 return _Debug_charColor(ansi, "'" + _Debug_addSlashes(value, true) + "'");
563 }
564
565 if (typeof value === 'string')
566 {
567 return _Debug_stringColor(ansi, '"' + _Debug_addSlashes(value, false) + '"');
568 }
569
570 if (typeof value === 'object' && '$' in value)
571 {
572 var tag = value.$;
573
574 if (typeof tag === 'number')
575 {
576 return _Debug_internalColor(ansi, '<internals>');
577 }
578
579 if (tag[0] === '#')
580 {
581 var output = [];
582 for (var k in value)
583 {
584 if (k === '$') continue;
585 output.push(_Debug_toAnsiString(ansi, value[k]));
586 }
587 return '(' + output.join(',') + ')';
588 }
589
590 if (tag === 'Set_elm_builtin')
591 {
592 return _Debug_ctorColor(ansi, 'Set')
593 + _Debug_fadeColor(ansi, '.fromList') + ' '
594 + _Debug_toAnsiString(ansi, $elm$core$Set$toList(value));
595 }
596
597 if (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin')
598 {
599 return _Debug_ctorColor(ansi, 'Dict')
600 + _Debug_fadeColor(ansi, '.fromList') + ' '
601 + _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value));
602 }
603
604 if (tag === 'Array_elm_builtin')
605 {
606 return _Debug_ctorColor(ansi, 'Array')
607 + _Debug_fadeColor(ansi, '.fromList') + ' '
608 + _Debug_toAnsiString(ansi, $elm$core$Array$toList(value));
609 }
610
611 if (tag === '::' || tag === '[]')
612 {
613 var output = '[';
614
615 value.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b)
616
617 for (; value.b; value = value.b) // WHILE_CONS
618 {
619 output += ',' + _Debug_toAnsiString(ansi, value.a);
620 }
621 return output + ']';
622 }
623
624 var output = '';
625 for (var i in value)
626 {
627 if (i === '$') continue;
628 var str = _Debug_toAnsiString(ansi, value[i]);
629 var c0 = str[0];
630 var parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
631 output += ' ' + (parenless ? str : '(' + str + ')');
632 }
633 return _Debug_ctorColor(ansi, tag) + output;
634 }
635
636 if (typeof DataView === 'function' && value instanceof DataView)
637 {
638 return _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>');
639 }
640
641 if (typeof File !== 'undefined' && value instanceof File)
642 {
643 return _Debug_internalColor(ansi, '<' + value.name + '>');
644 }
645
646 if (typeof value === 'object')
647 {
648 var output = [];
649 for (var key in value)
650 {
651 var field = key[0] === '_' ? key.slice(1) : key;
652 output.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key]));
653 }
654 if (output.length === 0)
655 {
656 return '{}';
657 }
658 return '{ ' + output.join(', ') + ' }';
659 }
660
661 return _Debug_internalColor(ansi, '<internals>');
662}
663
664function _Debug_addSlashes(str, isChar)
665{
666 var s = str
667 .replace(/\\/g, '\\\\')
668 .replace(/\n/g, '\\n')
669 .replace(/\t/g, '\\t')
670 .replace(/\r/g, '\\r')
671 .replace(/\v/g, '\\v')
672 .replace(/\0/g, '\\0');
673
674 if (isChar)
675 {
676 return s.replace(/\'/g, '\\\'');
677 }
678 else
679 {
680 return s.replace(/\"/g, '\\"');
681 }
682}
683
684function _Debug_ctorColor(ansi, string)
685{
686 return ansi ? '\x1b[96m' + string + '\x1b[0m' : string;
687}
688
689function _Debug_numberColor(ansi, string)
690{
691 return ansi ? '\x1b[95m' + string + '\x1b[0m' : string;
692}
693
694function _Debug_stringColor(ansi, string)
695{
696 return ansi ? '\x1b[93m' + string + '\x1b[0m' : string;
697}
698
699function _Debug_charColor(ansi, string)
700{
701 return ansi ? '\x1b[92m' + string + '\x1b[0m' : string;
702}
703
704function _Debug_fadeColor(ansi, string)
705{
706 return ansi ? '\x1b[37m' + string + '\x1b[0m' : string;
707}
708
709function _Debug_internalColor(ansi, string)
710{
711 return ansi ? '\x1b[36m' + string + '\x1b[0m' : string;
712}
713
714function _Debug_toHexDigit(n)
715{
716 return String.fromCharCode(n < 10 ? 48 + n : 55 + n);
717}
718
719
720// CRASH
721
722
723function _Debug_crash(identifier)
724{
725 throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');
726}
727
728
729function _Debug_crash_UNUSED(identifier, fact1, fact2, fact3, fact4)
730{
731 switch(identifier)
732 {
733 case 0:
734 throw new Error('What node should I take over? In JavaScript I need something like:\n\n Elm.Main.init({\n node: document.getElementById("elm-node")\n })\n\nYou need to do this with any Browser.sandbox or Browser.element program.');
735
736 case 1:
737 throw new Error('Browser.application programs cannot handle URLs like this:\n\n ' + document.location.href + '\n\nWhat is the root? The root of your file system? Try looking at this program with `elm reactor` or some other server.');
738
739 case 2:
740 var jsonErrorString = fact1;
741 throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString);
742
743 case 3:
744 var portName = fact1;
745 throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.');
746
747 case 4:
748 var portName = fact1;
749 var problem = fact2;
750 throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem);
751
752 case 5:
753 throw new Error('Trying to use `(==)` on functions.\nThere is no way to know if functions are "the same" in the Elm sense.\nRead more about this at https://package.elm-lang.org/packages/elm/core/latest/Basics#== which describes why it is this way and what the better version will look like.');
754
755 case 6:
756 var moduleName = fact1;
757 throw new Error('Your page is loading multiple Elm scripts with a module named ' + moduleName + '. Maybe a duplicate script is getting loaded accidentally? If not, rename one of them so I know which is which!');
758
759 case 8:
760 var moduleName = fact1;
761 var region = fact2;
762 var message = fact3;
763 throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message);
764
765 case 9:
766 var moduleName = fact1;
767 var region = fact2;
768 var value = fact3;
769 var message = fact4;
770 throw new Error(
771 'TODO in module `' + moduleName + '` from the `case` expression '
772 + _Debug_regionToString(region) + '\n\nIt received the following value:\n\n '
773 + _Debug_toString(value).replace('\n', '\n ')
774 + '\n\nBut the branch that handles it says:\n\n ' + message.replace('\n', '\n ')
775 );
776
777 case 10:
778 throw new Error('Bug in https://github.com/elm/virtual-dom/issues');
779
780 case 11:
781 throw new Error('Cannot perform mod 0. Division by zero error.');
782 }
783}
784
785function _Debug_regionToString(region)
786{
787 if (region.cQ.aG === region.c8.aG)
788 {
789 return 'on line ' + region.cQ.aG;
790 }
791 return 'on lines ' + region.cQ.aG + ' through ' + region.c8.aG;
792}
793
794
795
796// MATH
797
798var _Basics_add = F2(function(a, b) { return a + b; });
799var _Basics_sub = F2(function(a, b) { return a - b; });
800var _Basics_mul = F2(function(a, b) { return a * b; });
801var _Basics_fdiv = F2(function(a, b) { return a / b; });
802var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; });
803var _Basics_pow = F2(Math.pow);
804
805var _Basics_remainderBy = F2(function(b, a) { return a % b; });
806
807// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
808var _Basics_modBy = F2(function(modulus, x)
809{
810 var answer = x % modulus;
811 return modulus === 0
812 ? _Debug_crash(11)
813 :
814 ((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0))
815 ? answer + modulus
816 : answer;
817});
818
819
820// TRIGONOMETRY
821
822var _Basics_pi = Math.PI;
823var _Basics_e = Math.E;
824var _Basics_cos = Math.cos;
825var _Basics_sin = Math.sin;
826var _Basics_tan = Math.tan;
827var _Basics_acos = Math.acos;
828var _Basics_asin = Math.asin;
829var _Basics_atan = Math.atan;
830var _Basics_atan2 = F2(Math.atan2);
831
832
833// MORE MATH
834
835function _Basics_toFloat(x) { return x; }
836function _Basics_truncate(n) { return n | 0; }
837function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; }
838
839var _Basics_ceiling = Math.ceil;
840var _Basics_floor = Math.floor;
841var _Basics_round = Math.round;
842var _Basics_sqrt = Math.sqrt;
843var _Basics_log = Math.log;
844var _Basics_isNaN = isNaN;
845
846
847// BOOLEANS
848
849function _Basics_not(bool) { return !bool; }
850var _Basics_and = F2(function(a, b) { return a && b; });
851var _Basics_or = F2(function(a, b) { return a || b; });
852var _Basics_xor = F2(function(a, b) { return a !== b; });
853
854
855
856var _String_cons = F2(function(chr, str)
857{
858 return chr + str;
859});
860
861function _String_uncons(string)
862{
863 var word = string.charCodeAt(0);
864 return !isNaN(word)
865 ? $elm$core$Maybe$Just(
866 0xD800 <= word && word <= 0xDBFF
867 ? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))
868 : _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))
869 )
870 : $elm$core$Maybe$Nothing;
871}
872
873var _String_append = F2(function(a, b)
874{
875 return a + b;
876});
877
878function _String_length(str)
879{
880 return str.length;
881}
882
883var _String_map = F2(function(func, string)
884{
885 var len = string.length;
886 var array = new Array(len);
887 var i = 0;
888 while (i < len)
889 {
890 var word = string.charCodeAt(i);
891 if (0xD800 <= word && word <= 0xDBFF)
892 {
893 array[i] = func(_Utils_chr(string[i] + string[i+1]));
894 i += 2;
895 continue;
896 }
897 array[i] = func(_Utils_chr(string[i]));
898 i++;
899 }
900 return array.join('');
901});
902
903var _String_filter = F2(function(isGood, str)
904{
905 var arr = [];
906 var len = str.length;
907 var i = 0;
908 while (i < len)
909 {
910 var char = str[i];
911 var word = str.charCodeAt(i);
912 i++;
913 if (0xD800 <= word && word <= 0xDBFF)
914 {
915 char += str[i];
916 i++;
917 }
918
919 if (isGood(_Utils_chr(char)))
920 {
921 arr.push(char);
922 }
923 }
924 return arr.join('');
925});
926
927function _String_reverse(str)
928{
929 var len = str.length;
930 var arr = new Array(len);
931 var i = 0;
932 while (i < len)
933 {
934 var word = str.charCodeAt(i);
935 if (0xD800 <= word && word <= 0xDBFF)
936 {
937 arr[len - i] = str[i + 1];
938 i++;
939 arr[len - i] = str[i - 1];
940 i++;
941 }
942 else
943 {
944 arr[len - i] = str[i];
945 i++;
946 }
947 }
948 return arr.join('');
949}
950
951var _String_foldl = F3(function(func, state, string)
952{
953 var len = string.length;
954 var i = 0;
955 while (i < len)
956 {
957 var char = string[i];
958 var word = string.charCodeAt(i);
959 i++;
960 if (0xD800 <= word && word <= 0xDBFF)
961 {
962 char += string[i];
963 i++;
964 }
965 state = A2(func, _Utils_chr(char), state);
966 }
967 return state;
968});
969
970var _String_foldr = F3(function(func, state, string)
971{
972 var i = string.length;
973 while (i--)
974 {
975 var char = string[i];
976 var word = string.charCodeAt(i);
977 if (0xDC00 <= word && word <= 0xDFFF)
978 {
979 i--;
980 char = string[i] + char;
981 }
982 state = A2(func, _Utils_chr(char), state);
983 }
984 return state;
985});
986
987var _String_split = F2(function(sep, str)
988{
989 return str.split(sep);
990});
991
992var _String_join = F2(function(sep, strs)
993{
994 return strs.join(sep);
995});
996
997var _String_slice = F3(function(start, end, str) {
998 return str.slice(start, end);
999});
1000
1001function _String_trim(str)
1002{
1003 return str.trim();
1004}
1005
1006function _String_trimLeft(str)
1007{
1008 return str.replace(/^\s+/, '');
1009}
1010
1011function _String_trimRight(str)
1012{
1013 return str.replace(/\s+$/, '');
1014}
1015
1016function _String_words(str)
1017{
1018 return _List_fromArray(str.trim().split(/\s+/g));
1019}
1020
1021function _String_lines(str)
1022{
1023 return _List_fromArray(str.split(/\r\n|\r|\n/g));
1024}
1025
1026function _String_toUpper(str)
1027{
1028 return str.toUpperCase();
1029}
1030
1031function _String_toLower(str)
1032{
1033 return str.toLowerCase();
1034}
1035
1036var _String_any = F2(function(isGood, string)
1037{
1038 var i = string.length;
1039 while (i--)
1040 {
1041 var char = string[i];
1042 var word = string.charCodeAt(i);
1043 if (0xDC00 <= word && word <= 0xDFFF)
1044 {
1045 i--;
1046 char = string[i] + char;
1047 }
1048 if (isGood(_Utils_chr(char)))
1049 {
1050 return true;
1051 }
1052 }
1053 return false;
1054});
1055
1056var _String_all = F2(function(isGood, string)
1057{
1058 var i = string.length;
1059 while (i--)
1060 {
1061 var char = string[i];
1062 var word = string.charCodeAt(i);
1063 if (0xDC00 <= word && word <= 0xDFFF)
1064 {
1065 i--;
1066 char = string[i] + char;
1067 }
1068 if (!isGood(_Utils_chr(char)))
1069 {
1070 return false;
1071 }
1072 }
1073 return true;
1074});
1075
1076var _String_contains = F2(function(sub, str)
1077{
1078 return str.indexOf(sub) > -1;
1079});
1080
1081var _String_startsWith = F2(function(sub, str)
1082{
1083 return str.indexOf(sub) === 0;
1084});
1085
1086var _String_endsWith = F2(function(sub, str)
1087{
1088 return str.length >= sub.length &&
1089 str.lastIndexOf(sub) === str.length - sub.length;
1090});
1091
1092var _String_indexes = F2(function(sub, str)
1093{
1094 var subLen = sub.length;
1095
1096 if (subLen < 1)
1097 {
1098 return _List_Nil;
1099 }
1100
1101 var i = 0;
1102 var is = [];
1103
1104 while ((i = str.indexOf(sub, i)) > -1)
1105 {
1106 is.push(i);
1107 i = i + subLen;
1108 }
1109
1110 return _List_fromArray(is);
1111});
1112
1113
1114// TO STRING
1115
1116function _String_fromNumber(number)
1117{
1118 return number + '';
1119}
1120
1121
1122// INT CONVERSIONS
1123
1124function _String_toInt(str)
1125{
1126 var total = 0;
1127 var code0 = str.charCodeAt(0);
1128 var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;
1129
1130 for (var i = start; i < str.length; ++i)
1131 {
1132 var code = str.charCodeAt(i);
1133 if (code < 0x30 || 0x39 < code)
1134 {
1135 return $elm$core$Maybe$Nothing;
1136 }
1137 total = 10 * total + code - 0x30;
1138 }
1139
1140 return i == start
1141 ? $elm$core$Maybe$Nothing
1142 : $elm$core$Maybe$Just(code0 == 0x2D ? -total : total);
1143}
1144
1145
1146// FLOAT CONVERSIONS
1147
1148function _String_toFloat(s)
1149{
1150 // check if it is a hex, octal, or binary number
1151 if (s.length === 0 || /[\sxbo]/.test(s))
1152 {
1153 return $elm$core$Maybe$Nothing;
1154 }
1155 var n = +s;
1156 // faster isNaN check
1157 return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing;
1158}
1159
1160function _String_fromList(chars)
1161{
1162 return _List_toArray(chars).join('');
1163}
1164
1165
1166
1167
1168function _Char_toCode(char)
1169{
1170 var code = char.charCodeAt(0);
1171 if (0xD800 <= code && code <= 0xDBFF)
1172 {
1173 return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000
1174 }
1175 return code;
1176}
1177
1178function _Char_fromCode(code)
1179{
1180 return _Utils_chr(
1181 (code < 0 || 0x10FFFF < code)
1182 ? '\uFFFD'
1183 :
1184 (code <= 0xFFFF)
1185 ? String.fromCharCode(code)
1186 :
1187 (code -= 0x10000,
1188 String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)
1189 )
1190 );
1191}
1192
1193function _Char_toUpper(char)
1194{
1195 return _Utils_chr(char.toUpperCase());
1196}
1197
1198function _Char_toLower(char)
1199{
1200 return _Utils_chr(char.toLowerCase());
1201}
1202
1203function _Char_toLocaleUpper(char)
1204{
1205 return _Utils_chr(char.toLocaleUpperCase());
1206}
1207
1208function _Char_toLocaleLower(char)
1209{
1210 return _Utils_chr(char.toLocaleLowerCase());
1211}
1212
1213
1214
1215/**_UNUSED/
1216function _Json_errorToString(error)
1217{
1218 return $elm$json$Json$Decode$errorToString(error);
1219}
1220//*/
1221
1222
1223// CORE DECODERS
1224
1225function _Json_succeed(msg)
1226{
1227 return {
1228 $: 0,
1229 a: msg
1230 };
1231}
1232
1233function _Json_fail(msg)
1234{
1235 return {
1236 $: 1,
1237 a: msg
1238 };
1239}
1240
1241function _Json_decodePrim(decoder)
1242{
1243 return { $: 2, b: decoder };
1244}
1245
1246var _Json_decodeInt = _Json_decodePrim(function(value) {
1247 return (typeof value !== 'number')
1248 ? _Json_expecting('an INT', value)
1249 :
1250 (-2147483647 < value && value < 2147483647 && (value | 0) === value)
1251 ? $elm$core$Result$Ok(value)
1252 :
1253 (isFinite(value) && !(value % 1))
1254 ? $elm$core$Result$Ok(value)
1255 : _Json_expecting('an INT', value);
1256});
1257
1258var _Json_decodeBool = _Json_decodePrim(function(value) {
1259 return (typeof value === 'boolean')
1260 ? $elm$core$Result$Ok(value)
1261 : _Json_expecting('a BOOL', value);
1262});
1263
1264var _Json_decodeFloat = _Json_decodePrim(function(value) {
1265 return (typeof value === 'number')
1266 ? $elm$core$Result$Ok(value)
1267 : _Json_expecting('a FLOAT', value);
1268});
1269
1270var _Json_decodeValue = _Json_decodePrim(function(value) {
1271 return $elm$core$Result$Ok(_Json_wrap(value));
1272});
1273
1274var _Json_decodeString = _Json_decodePrim(function(value) {
1275 return (typeof value === 'string')
1276 ? $elm$core$Result$Ok(value)
1277 : (value instanceof String)
1278 ? $elm$core$Result$Ok(value + '')
1279 : _Json_expecting('a STRING', value);
1280});
1281
1282function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }
1283function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }
1284
1285function _Json_decodeNull(value) { return { $: 5, c: value }; }
1286
1287var _Json_decodeField = F2(function(field, decoder)
1288{
1289 return {
1290 $: 6,
1291 d: field,
1292 b: decoder
1293 };
1294});
1295
1296var _Json_decodeIndex = F2(function(index, decoder)
1297{
1298 return {
1299 $: 7,
1300 e: index,
1301 b: decoder
1302 };
1303});
1304
1305function _Json_decodeKeyValuePairs(decoder)
1306{
1307 return {
1308 $: 8,
1309 b: decoder
1310 };
1311}
1312
1313function _Json_mapMany(f, decoders)
1314{
1315 return {
1316 $: 9,
1317 f: f,
1318 g: decoders
1319 };
1320}
1321
1322var _Json_andThen = F2(function(callback, decoder)
1323{
1324 return {
1325 $: 10,
1326 b: decoder,
1327 h: callback
1328 };
1329});
1330
1331function _Json_oneOf(decoders)
1332{
1333 return {
1334 $: 11,
1335 g: decoders
1336 };
1337}
1338
1339
1340// DECODING OBJECTS
1341
1342var _Json_map1 = F2(function(f, d1)
1343{
1344 return _Json_mapMany(f, [d1]);
1345});
1346
1347var _Json_map2 = F3(function(f, d1, d2)
1348{
1349 return _Json_mapMany(f, [d1, d2]);
1350});
1351
1352var _Json_map3 = F4(function(f, d1, d2, d3)
1353{
1354 return _Json_mapMany(f, [d1, d2, d3]);
1355});
1356
1357var _Json_map4 = F5(function(f, d1, d2, d3, d4)
1358{
1359 return _Json_mapMany(f, [d1, d2, d3, d4]);
1360});
1361
1362var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)
1363{
1364 return _Json_mapMany(f, [d1, d2, d3, d4, d5]);
1365});
1366
1367var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)
1368{
1369 return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);
1370});
1371
1372var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)
1373{
1374 return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
1375});
1376
1377var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)
1378{
1379 return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
1380});
1381
1382
1383// DECODE
1384
1385var _Json_runOnString = F2(function(decoder, string)
1386{
1387 try
1388 {
1389 var value = JSON.parse(string);
1390 return _Json_runHelp(decoder, value);
1391 }
1392 catch (e)
1393 {
1394 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string)));
1395 }
1396});
1397
1398var _Json_run = F2(function(decoder, value)
1399{
1400 return _Json_runHelp(decoder, _Json_unwrap(value));
1401});
1402
1403function _Json_runHelp(decoder, value)
1404{
1405 switch (decoder.$)
1406 {
1407 case 2:
1408 return decoder.b(value);
1409
1410 case 5:
1411 return (value === null)
1412 ? $elm$core$Result$Ok(decoder.c)
1413 : _Json_expecting('null', value);
1414
1415 case 3:
1416 if (!_Json_isArray(value))
1417 {
1418 return _Json_expecting('a LIST', value);
1419 }
1420 return _Json_runArrayDecoder(decoder.b, value, _List_fromArray);
1421
1422 case 4:
1423 if (!_Json_isArray(value))
1424 {
1425 return _Json_expecting('an ARRAY', value);
1426 }
1427 return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);
1428
1429 case 6:
1430 var field = decoder.d;
1431 if (typeof value !== 'object' || value === null || !(field in value))
1432 {
1433 return _Json_expecting('an OBJECT with a field named `' + field + '`', value);
1434 }
1435 var result = _Json_runHelp(decoder.b, value[field]);
1436 return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a));
1437
1438 case 7:
1439 var index = decoder.e;
1440 if (!_Json_isArray(value))
1441 {
1442 return _Json_expecting('an ARRAY', value);
1443 }
1444 if (index >= value.length)
1445 {
1446 return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);
1447 }
1448 var result = _Json_runHelp(decoder.b, value[index]);
1449 return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a));
1450
1451 case 8:
1452 if (typeof value !== 'object' || value === null || _Json_isArray(value))
1453 {
1454 return _Json_expecting('an OBJECT', value);
1455 }
1456
1457 var keyValuePairs = _List_Nil;
1458 // TODO test perf of Object.keys and switch when support is good enough
1459 for (var key in value)
1460 {
1461 if (value.hasOwnProperty(key))
1462 {
1463 var result = _Json_runHelp(decoder.b, value[key]);
1464 if (!$elm$core$Result$isOk(result))
1465 {
1466 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a));
1467 }
1468 keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);
1469 }
1470 }
1471 return $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs));
1472
1473 case 9:
1474 var answer = decoder.f;
1475 var decoders = decoder.g;
1476 for (var i = 0; i < decoders.length; i++)
1477 {
1478 var result = _Json_runHelp(decoders[i], value);
1479 if (!$elm$core$Result$isOk(result))
1480 {
1481 return result;
1482 }
1483 answer = answer(result.a);
1484 }
1485 return $elm$core$Result$Ok(answer);
1486
1487 case 10:
1488 var result = _Json_runHelp(decoder.b, value);
1489 return (!$elm$core$Result$isOk(result))
1490 ? result
1491 : _Json_runHelp(decoder.h(result.a), value);
1492
1493 case 11:
1494 var errors = _List_Nil;
1495 for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS
1496 {
1497 var result = _Json_runHelp(temp.a, value);
1498 if ($elm$core$Result$isOk(result))
1499 {
1500 return result;
1501 }
1502 errors = _List_Cons(result.a, errors);
1503 }
1504 return $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)));
1505
1506 case 1:
1507 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));
1508
1509 case 0:
1510 return $elm$core$Result$Ok(decoder.a);
1511 }
1512}
1513
1514function _Json_runArrayDecoder(decoder, value, toElmValue)
1515{
1516 var len = value.length;
1517 var array = new Array(len);
1518 for (var i = 0; i < len; i++)
1519 {
1520 var result = _Json_runHelp(decoder, value[i]);
1521 if (!$elm$core$Result$isOk(result))
1522 {
1523 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a));
1524 }
1525 array[i] = result.a;
1526 }
1527 return $elm$core$Result$Ok(toElmValue(array));
1528}
1529
1530function _Json_isArray(value)
1531{
1532 return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);
1533}
1534
1535function _Json_toElmArray(array)
1536{
1537 return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; });
1538}
1539
1540function _Json_expecting(type, value)
1541{
1542 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));
1543}
1544
1545
1546// EQUALITY
1547
1548function _Json_equality(x, y)
1549{
1550 if (x === y)
1551 {
1552 return true;
1553 }
1554
1555 if (x.$ !== y.$)
1556 {
1557 return false;
1558 }
1559
1560 switch (x.$)
1561 {
1562 case 0:
1563 case 1:
1564 return x.a === y.a;
1565
1566 case 2:
1567 return x.b === y.b;
1568
1569 case 5:
1570 return x.c === y.c;
1571
1572 case 3:
1573 case 4:
1574 case 8:
1575 return _Json_equality(x.b, y.b);
1576
1577 case 6:
1578 return x.d === y.d && _Json_equality(x.b, y.b);
1579
1580 case 7:
1581 return x.e === y.e && _Json_equality(x.b, y.b);
1582
1583 case 9:
1584 return x.f === y.f && _Json_listEquality(x.g, y.g);
1585
1586 case 10:
1587 return x.h === y.h && _Json_equality(x.b, y.b);
1588
1589 case 11:
1590 return _Json_listEquality(x.g, y.g);
1591 }
1592}
1593
1594function _Json_listEquality(aDecoders, bDecoders)
1595{
1596 var len = aDecoders.length;
1597 if (len !== bDecoders.length)
1598 {
1599 return false;
1600 }
1601 for (var i = 0; i < len; i++)
1602 {
1603 if (!_Json_equality(aDecoders[i], bDecoders[i]))
1604 {
1605 return false;
1606 }
1607 }
1608 return true;
1609}
1610
1611
1612// ENCODE
1613
1614var _Json_encode = F2(function(indentLevel, value)
1615{
1616 return JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';
1617});
1618
1619function _Json_wrap_UNUSED(value) { return { $: 0, a: value }; }
1620function _Json_unwrap_UNUSED(value) { return value.a; }
1621
1622function _Json_wrap(value) { return value; }
1623function _Json_unwrap(value) { return value; }
1624
1625function _Json_emptyArray() { return []; }
1626function _Json_emptyObject() { return {}; }
1627
1628var _Json_addField = F3(function(key, value, object)
1629{
1630 object[key] = _Json_unwrap(value);
1631 return object;
1632});
1633
1634function _Json_addEntry(func)
1635{
1636 return F2(function(entry, array)
1637 {
1638 array.push(_Json_unwrap(func(entry)));
1639 return array;
1640 });
1641}
1642
1643var _Json_encodeNull = _Json_wrap(null);
1644
1645
1646
1647// TASKS
1648
1649function _Scheduler_succeed(value)
1650{
1651 return {
1652 $: 0,
1653 a: value
1654 };
1655}
1656
1657function _Scheduler_fail(error)
1658{
1659 return {
1660 $: 1,
1661 a: error
1662 };
1663}
1664
1665function _Scheduler_binding(callback)
1666{
1667 return {
1668 $: 2,
1669 b: callback,
1670 c: null
1671 };
1672}
1673
1674var _Scheduler_andThen = F2(function(callback, task)
1675{
1676 return {
1677 $: 3,
1678 b: callback,
1679 d: task
1680 };
1681});
1682
1683var _Scheduler_onError = F2(function(callback, task)
1684{
1685 return {
1686 $: 4,
1687 b: callback,
1688 d: task
1689 };
1690});
1691
1692function _Scheduler_receive(callback)
1693{
1694 return {
1695 $: 5,
1696 b: callback
1697 };
1698}
1699
1700
1701// PROCESSES
1702
1703var _Scheduler_guid = 0;
1704
1705function _Scheduler_rawSpawn(task)
1706{
1707 var proc = {
1708 $: 0,
1709 e: _Scheduler_guid++,
1710 f: task,
1711 g: null,
1712 h: []
1713 };
1714
1715 _Scheduler_enqueue(proc);
1716
1717 return proc;
1718}
1719
1720function _Scheduler_spawn(task)
1721{
1722 return _Scheduler_binding(function(callback) {
1723 callback(_Scheduler_succeed(_Scheduler_rawSpawn(task)));
1724 });
1725}
1726
1727function _Scheduler_rawSend(proc, msg)
1728{
1729 proc.h.push(msg);
1730 _Scheduler_enqueue(proc);
1731}
1732
1733var _Scheduler_send = F2(function(proc, msg)
1734{
1735 return _Scheduler_binding(function(callback) {
1736 _Scheduler_rawSend(proc, msg);
1737 callback(_Scheduler_succeed(_Utils_Tuple0));
1738 });
1739});
1740
1741function _Scheduler_kill(proc)
1742{
1743 return _Scheduler_binding(function(callback) {
1744 var task = proc.f;
1745 if (task.$ === 2 && task.c)
1746 {
1747 task.c();
1748 }
1749
1750 proc.f = null;
1751
1752 callback(_Scheduler_succeed(_Utils_Tuple0));
1753 });
1754}
1755
1756
1757/* STEP PROCESSES
1758
1759type alias Process =
1760 { $ : tag
1761 , id : unique_id
1762 , root : Task
1763 , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack }
1764 , mailbox : [msg]
1765 }
1766
1767*/
1768
1769
1770var _Scheduler_working = false;
1771var _Scheduler_queue = [];
1772
1773
1774function _Scheduler_enqueue(proc)
1775{
1776 _Scheduler_queue.push(proc);
1777 if (_Scheduler_working)
1778 {
1779 return;
1780 }
1781 _Scheduler_working = true;
1782 while (proc = _Scheduler_queue.shift())
1783 {
1784 _Scheduler_step(proc);
1785 }
1786 _Scheduler_working = false;
1787}
1788
1789
1790function _Scheduler_step(proc)
1791{
1792 while (proc.f)
1793 {
1794 var rootTag = proc.f.$;
1795 if (rootTag === 0 || rootTag === 1)
1796 {
1797 while (proc.g && proc.g.$ !== rootTag)
1798 {
1799 proc.g = proc.g.i;
1800 }
1801 if (!proc.g)
1802 {
1803 return;
1804 }
1805 proc.f = proc.g.b(proc.f.a);
1806 proc.g = proc.g.i;
1807 }
1808 else if (rootTag === 2)
1809 {
1810 proc.f.c = proc.f.b(function(newRoot) {
1811 proc.f = newRoot;
1812 _Scheduler_enqueue(proc);
1813 });
1814 return;
1815 }
1816 else if (rootTag === 5)
1817 {
1818 if (proc.h.length === 0)
1819 {
1820 return;
1821 }
1822 proc.f = proc.f.b(proc.h.shift());
1823 }
1824 else // if (rootTag === 3 || rootTag === 4)
1825 {
1826 proc.g = {
1827 $: rootTag === 3 ? 0 : 1,
1828 b: proc.f.b,
1829 i: proc.g
1830 };
1831 proc.f = proc.f.d;
1832 }
1833 }
1834}
1835
1836
1837
1838function _Process_sleep(time)
1839{
1840 return _Scheduler_binding(function(callback) {
1841 var id = setTimeout(function() {
1842 callback(_Scheduler_succeed(_Utils_Tuple0));
1843 }, time);
1844
1845 return function() { clearTimeout(id); };
1846 });
1847}
1848
1849
1850
1851
1852// PROGRAMS
1853
1854
1855var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args)
1856{
1857 return _Platform_initialize(
1858 flagDecoder,
1859 args,
1860 impl.en,
1861 impl.eO,
1862 impl.eI,
1863 function() { return function() {} }
1864 );
1865});
1866
1867
1868
1869// INITIALIZE A PROGRAM
1870
1871
1872function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder)
1873{
1874 var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined));
1875 $elm$core$Result$isOk(result) || _Debug_crash(2 /**_UNUSED/, _Json_errorToString(result.a) /**/);
1876 var managers = {};
1877 var initPair = init(result.a);
1878 var model = initPair.a;
1879 var stepper = stepperBuilder(sendToApp, model);
1880 var ports = _Platform_setupEffects(managers, sendToApp);
1881
1882 function sendToApp(msg, viewMetadata)
1883 {
1884 var pair = A2(update, msg, model);
1885 stepper(model = pair.a, viewMetadata);
1886 _Platform_enqueueEffects(managers, pair.b, subscriptions(model));
1887 }
1888
1889 _Platform_enqueueEffects(managers, initPair.b, subscriptions(model));
1890
1891 return ports ? { ports: ports } : {};
1892}
1893
1894
1895
1896// TRACK PRELOADS
1897//
1898// This is used by code in elm/browser and elm/http
1899// to register any HTTP requests that are triggered by init.
1900//
1901
1902
1903var _Platform_preload;
1904
1905
1906function _Platform_registerPreload(url)
1907{
1908 _Platform_preload.add(url);
1909}
1910
1911
1912
1913// EFFECT MANAGERS
1914
1915
1916var _Platform_effectManagers = {};
1917
1918
1919function _Platform_setupEffects(managers, sendToApp)
1920{
1921 var ports;
1922
1923 // setup all necessary effect managers
1924 for (var key in _Platform_effectManagers)
1925 {
1926 var manager = _Platform_effectManagers[key];
1927
1928 if (manager.a)
1929 {
1930 ports = ports || {};
1931 ports[key] = manager.a(key, sendToApp);
1932 }
1933
1934 managers[key] = _Platform_instantiateManager(manager, sendToApp);
1935 }
1936
1937 return ports;
1938}
1939
1940
1941function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap)
1942{
1943 return {
1944 b: init,
1945 c: onEffects,
1946 d: onSelfMsg,
1947 e: cmdMap,
1948 f: subMap
1949 };
1950}
1951
1952
1953function _Platform_instantiateManager(info, sendToApp)
1954{
1955 var router = {
1956 g: sendToApp,
1957 h: undefined
1958 };
1959
1960 var onEffects = info.c;
1961 var onSelfMsg = info.d;
1962 var cmdMap = info.e;
1963 var subMap = info.f;
1964
1965 function loop(state)
1966 {
1967 return A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg)
1968 {
1969 var value = msg.a;
1970
1971 if (msg.$ === 0)
1972 {
1973 return A3(onSelfMsg, router, value, state);
1974 }
1975
1976 return cmdMap && subMap
1977 ? A4(onEffects, router, value.i, value.j, state)
1978 : A3(onEffects, router, cmdMap ? value.i : value.j, state);
1979 }));
1980 }
1981
1982 return router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b));
1983}
1984
1985
1986
1987// ROUTING
1988
1989
1990var _Platform_sendToApp = F2(function(router, msg)
1991{
1992 return _Scheduler_binding(function(callback)
1993 {
1994 router.g(msg);
1995 callback(_Scheduler_succeed(_Utils_Tuple0));
1996 });
1997});
1998
1999
2000var _Platform_sendToSelf = F2(function(router, msg)
2001{
2002 return A2(_Scheduler_send, router.h, {
2003 $: 0,
2004 a: msg
2005 });
2006});
2007
2008
2009
2010// BAGS
2011
2012
2013function _Platform_leaf(home)
2014{
2015 return function(value)
2016 {
2017 return {
2018 $: 1,
2019 k: home,
2020 l: value
2021 };
2022 };
2023}
2024
2025
2026function _Platform_batch(list)
2027{
2028 return {
2029 $: 2,
2030 m: list
2031 };
2032}
2033
2034
2035var _Platform_map = F2(function(tagger, bag)
2036{
2037 return {
2038 $: 3,
2039 n: tagger,
2040 o: bag
2041 }
2042});
2043
2044
2045
2046// PIPE BAGS INTO EFFECT MANAGERS
2047//
2048// Effects must be queued!
2049//
2050// Say your init contains a synchronous command, like Time.now or Time.here
2051//
2052// - This will produce a batch of effects (FX_1)
2053// - The synchronous task triggers the subsequent `update` call
2054// - This will produce a batch of effects (FX_2)
2055//
2056// If we just start dispatching FX_2, subscriptions from FX_2 can be processed
2057// before subscriptions from FX_1. No good! Earlier versions of this code had
2058// this problem, leading to these reports:
2059//
2060// https://github.com/elm/core/issues/980
2061// https://github.com/elm/core/pull/981
2062// https://github.com/elm/compiler/issues/1776
2063//
2064// The queue is necessary to avoid ordering issues for synchronous commands.
2065
2066
2067// Why use true/false here? Why not just check the length of the queue?
2068// The goal is to detect "are we currently dispatching effects?" If we
2069// are, we need to bail and let the ongoing while loop handle things.
2070//
2071// Now say the queue has 1 element. When we dequeue the final element,
2072// the queue will be empty, but we are still actively dispatching effects.
2073// So you could get queue jumping in a really tricky category of cases.
2074//
2075var _Platform_effectsQueue = [];
2076var _Platform_effectsActive = false;
2077
2078
2079function _Platform_enqueueEffects(managers, cmdBag, subBag)
2080{
2081 _Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag });
2082
2083 if (_Platform_effectsActive) return;
2084
2085 _Platform_effectsActive = true;
2086 for (var fx; fx = _Platform_effectsQueue.shift(); )
2087 {
2088 _Platform_dispatchEffects(fx.p, fx.q, fx.r);
2089 }
2090 _Platform_effectsActive = false;
2091}
2092
2093
2094function _Platform_dispatchEffects(managers, cmdBag, subBag)
2095{
2096 var effectsDict = {};
2097 _Platform_gatherEffects(true, cmdBag, effectsDict, null);
2098 _Platform_gatherEffects(false, subBag, effectsDict, null);
2099
2100 for (var home in managers)
2101 {
2102 _Scheduler_rawSend(managers[home], {
2103 $: 'fx',
2104 a: effectsDict[home] || { i: _List_Nil, j: _List_Nil }
2105 });
2106 }
2107}
2108
2109
2110function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers)
2111{
2112 switch (bag.$)
2113 {
2114 case 1:
2115 var home = bag.k;
2116 var effect = _Platform_toEffect(isCmd, home, taggers, bag.l);
2117 effectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]);
2118 return;
2119
2120 case 2:
2121 for (var list = bag.m; list.b; list = list.b) // WHILE_CONS
2122 {
2123 _Platform_gatherEffects(isCmd, list.a, effectsDict, taggers);
2124 }
2125 return;
2126
2127 case 3:
2128 _Platform_gatherEffects(isCmd, bag.o, effectsDict, {
2129 s: bag.n,
2130 t: taggers
2131 });
2132 return;
2133 }
2134}
2135
2136
2137function _Platform_toEffect(isCmd, home, taggers, value)
2138{
2139 function applyTaggers(x)
2140 {
2141 for (var temp = taggers; temp; temp = temp.t)
2142 {
2143 x = temp.s(x);
2144 }
2145 return x;
2146 }
2147
2148 var map = isCmd
2149 ? _Platform_effectManagers[home].e
2150 : _Platform_effectManagers[home].f;
2151
2152 return A2(map, applyTaggers, value)
2153}
2154
2155
2156function _Platform_insert(isCmd, newEffect, effects)
2157{
2158 effects = effects || { i: _List_Nil, j: _List_Nil };
2159
2160 isCmd
2161 ? (effects.i = _List_Cons(newEffect, effects.i))
2162 : (effects.j = _List_Cons(newEffect, effects.j));
2163
2164 return effects;
2165}
2166
2167
2168
2169// PORTS
2170
2171
2172function _Platform_checkPortName(name)
2173{
2174 if (_Platform_effectManagers[name])
2175 {
2176 _Debug_crash(3, name)
2177 }
2178}
2179
2180
2181
2182// OUTGOING PORTS
2183
2184
2185function _Platform_outgoingPort(name, converter)
2186{
2187 _Platform_checkPortName(name);
2188 _Platform_effectManagers[name] = {
2189 e: _Platform_outgoingPortMap,
2190 u: converter,
2191 a: _Platform_setupOutgoingPort
2192 };
2193 return _Platform_leaf(name);
2194}
2195
2196
2197var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; });
2198
2199
2200function _Platform_setupOutgoingPort(name)
2201{
2202 var subs = [];
2203 var converter = _Platform_effectManagers[name].u;
2204
2205 // CREATE MANAGER
2206
2207 var init = _Process_sleep(0);
2208
2209 _Platform_effectManagers[name].b = init;
2210 _Platform_effectManagers[name].c = F3(function(router, cmdList, state)
2211 {
2212 for ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS
2213 {
2214 // grab a separate reference to subs in case unsubscribe is called
2215 var currentSubs = subs;
2216 var value = _Json_unwrap(converter(cmdList.a));
2217 for (var i = 0; i < currentSubs.length; i++)
2218 {
2219 currentSubs[i](value);
2220 }
2221 }
2222 return init;
2223 });
2224
2225 // PUBLIC API
2226
2227 function subscribe(callback)
2228 {
2229 subs.push(callback);
2230 }
2231
2232 function unsubscribe(callback)
2233 {
2234 // copy subs into a new array in case unsubscribe is called within a
2235 // subscribed callback
2236 subs = subs.slice();
2237 var index = subs.indexOf(callback);
2238 if (index >= 0)
2239 {
2240 subs.splice(index, 1);
2241 }
2242 }
2243
2244 return {
2245 subscribe: subscribe,
2246 unsubscribe: unsubscribe
2247 };
2248}
2249
2250
2251
2252// INCOMING PORTS
2253
2254
2255function _Platform_incomingPort(name, converter)
2256{
2257 _Platform_checkPortName(name);
2258 _Platform_effectManagers[name] = {
2259 f: _Platform_incomingPortMap,
2260 u: converter,
2261 a: _Platform_setupIncomingPort
2262 };
2263 return _Platform_leaf(name);
2264}
2265
2266
2267var _Platform_incomingPortMap = F2(function(tagger, finalTagger)
2268{
2269 return function(value)
2270 {
2271 return tagger(finalTagger(value));
2272 };
2273});
2274
2275
2276function _Platform_setupIncomingPort(name, sendToApp)
2277{
2278 var subs = _List_Nil;
2279 var converter = _Platform_effectManagers[name].u;
2280
2281 // CREATE MANAGER
2282
2283 var init = _Scheduler_succeed(null);
2284
2285 _Platform_effectManagers[name].b = init;
2286 _Platform_effectManagers[name].c = F3(function(router, subList, state)
2287 {
2288 subs = subList;
2289 return init;
2290 });
2291
2292 // PUBLIC API
2293
2294 function send(incomingValue)
2295 {
2296 var result = A2(_Json_run, converter, _Json_wrap(incomingValue));
2297
2298 $elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a);
2299
2300 var value = result.a;
2301 for (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS
2302 {
2303 sendToApp(temp.a(value));
2304 }
2305 }
2306
2307 return { send: send };
2308}
2309
2310
2311
2312// EXPORT ELM MODULES
2313//
2314// Have DEBUG and PROD versions so that we can (1) give nicer errors in
2315// debug mode and (2) not pay for the bits needed for that in prod mode.
2316//
2317
2318
2319function _Platform_export(exports)
2320{
2321 scope['Elm']
2322 ? _Platform_mergeExportsProd(scope['Elm'], exports)
2323 : scope['Elm'] = exports;
2324}
2325
2326
2327function _Platform_mergeExportsProd(obj, exports)
2328{
2329 for (var name in exports)
2330 {
2331 (name in obj)
2332 ? (name == 'init')
2333 ? _Debug_crash(6)
2334 : _Platform_mergeExportsProd(obj[name], exports[name])
2335 : (obj[name] = exports[name]);
2336 }
2337}
2338
2339
2340function _Platform_export_UNUSED(exports)
2341{
2342 scope['Elm']
2343 ? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports)
2344 : scope['Elm'] = exports;
2345}
2346
2347
2348function _Platform_mergeExportsDebug(moduleName, obj, exports)
2349{
2350 for (var name in exports)
2351 {
2352 (name in obj)
2353 ? (name == 'init')
2354 ? _Debug_crash(6, moduleName)
2355 : _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name])
2356 : (obj[name] = exports[name]);
2357 }
2358}
2359
2360
2361
2362
2363// HELPERS
2364
2365
2366var _VirtualDom_divertHrefToApp;
2367
2368var _VirtualDom_doc = typeof document !== 'undefined' ? document : {};
2369
2370
2371function _VirtualDom_appendChild(parent, child)
2372{
2373 parent.appendChild(child);
2374}
2375
2376var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args)
2377{
2378 // NOTE: this function needs _Platform_export available to work
2379
2380 /**/
2381 var node = args['node'];
2382 //*/
2383 /**_UNUSED/
2384 var node = args && args['node'] ? args['node'] : _Debug_crash(0);
2385 //*/
2386
2387 node.parentNode.replaceChild(
2388 _VirtualDom_render(virtualNode, function() {}),
2389 node
2390 );
2391
2392 return {};
2393});
2394
2395
2396
2397// TEXT
2398
2399
2400function _VirtualDom_text(string)
2401{
2402 return {
2403 $: 0,
2404 a: string
2405 };
2406}
2407
2408
2409
2410// NODE
2411
2412
2413var _VirtualDom_nodeNS = F2(function(namespace, tag)
2414{
2415 return F2(function(factList, kidList)
2416 {
2417 for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
2418 {
2419 var kid = kidList.a;
2420 descendantsCount += (kid.b || 0);
2421 kids.push(kid);
2422 }
2423 descendantsCount += kids.length;
2424
2425 return {
2426 $: 1,
2427 c: tag,
2428 d: _VirtualDom_organizeFacts(factList),
2429 e: kids,
2430 f: namespace,
2431 b: descendantsCount
2432 };
2433 });
2434});
2435
2436
2437var _VirtualDom_node = _VirtualDom_nodeNS(undefined);
2438
2439
2440
2441// KEYED NODE
2442
2443
2444var _VirtualDom_keyedNodeNS = F2(function(namespace, tag)
2445{
2446 return F2(function(factList, kidList)
2447 {
2448 for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
2449 {
2450 var kid = kidList.a;
2451 descendantsCount += (kid.b.b || 0);
2452 kids.push(kid);
2453 }
2454 descendantsCount += kids.length;
2455
2456 return {
2457 $: 2,
2458 c: tag,
2459 d: _VirtualDom_organizeFacts(factList),
2460 e: kids,
2461 f: namespace,
2462 b: descendantsCount
2463 };
2464 });
2465});
2466
2467
2468var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined);
2469
2470
2471
2472// CUSTOM
2473
2474
2475function _VirtualDom_custom(factList, model, render, diff)
2476{
2477 return {
2478 $: 3,
2479 d: _VirtualDom_organizeFacts(factList),
2480 g: model,
2481 h: render,
2482 i: diff
2483 };
2484}
2485
2486
2487
2488// MAP
2489
2490
2491var _VirtualDom_map = F2(function(tagger, node)
2492{
2493 return {
2494 $: 4,
2495 j: tagger,
2496 k: node,
2497 b: 1 + (node.b || 0)
2498 };
2499});
2500
2501
2502
2503// LAZY
2504
2505
2506function _VirtualDom_thunk(refs, thunk)
2507{
2508 return {
2509 $: 5,
2510 l: refs,
2511 m: thunk,
2512 k: undefined
2513 };
2514}
2515
2516var _VirtualDom_lazy = F2(function(func, a)
2517{
2518 return _VirtualDom_thunk([func, a], function() {
2519 return func(a);
2520 });
2521});
2522
2523var _VirtualDom_lazy2 = F3(function(func, a, b)
2524{
2525 return _VirtualDom_thunk([func, a, b], function() {
2526 return A2(func, a, b);
2527 });
2528});
2529
2530var _VirtualDom_lazy3 = F4(function(func, a, b, c)
2531{
2532 return _VirtualDom_thunk([func, a, b, c], function() {
2533 return A3(func, a, b, c);
2534 });
2535});
2536
2537var _VirtualDom_lazy4 = F5(function(func, a, b, c, d)
2538{
2539 return _VirtualDom_thunk([func, a, b, c, d], function() {
2540 return A4(func, a, b, c, d);
2541 });
2542});
2543
2544var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e)
2545{
2546 return _VirtualDom_thunk([func, a, b, c, d, e], function() {
2547 return A5(func, a, b, c, d, e);
2548 });
2549});
2550
2551var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f)
2552{
2553 return _VirtualDom_thunk([func, a, b, c, d, e, f], function() {
2554 return A6(func, a, b, c, d, e, f);
2555 });
2556});
2557
2558var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g)
2559{
2560 return _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() {
2561 return A7(func, a, b, c, d, e, f, g);
2562 });
2563});
2564
2565var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h)
2566{
2567 return _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() {
2568 return A8(func, a, b, c, d, e, f, g, h);
2569 });
2570});
2571
2572
2573
2574// FACTS
2575
2576
2577var _VirtualDom_on = F2(function(key, handler)
2578{
2579 return {
2580 $: 'a0',
2581 n: key,
2582 o: handler
2583 };
2584});
2585var _VirtualDom_style = F2(function(key, value)
2586{
2587 return {
2588 $: 'a1',
2589 n: key,
2590 o: value
2591 };
2592});
2593var _VirtualDom_property = F2(function(key, value)
2594{
2595 return {
2596 $: 'a2',
2597 n: key,
2598 o: value
2599 };
2600});
2601var _VirtualDom_attribute = F2(function(key, value)
2602{
2603 return {
2604 $: 'a3',
2605 n: key,
2606 o: value
2607 };
2608});
2609var _VirtualDom_attributeNS = F3(function(namespace, key, value)
2610{
2611 return {
2612 $: 'a4',
2613 n: key,
2614 o: { f: namespace, o: value }
2615 };
2616});
2617
2618
2619
2620// XSS ATTACK VECTOR CHECKS
2621
2622
2623function _VirtualDom_noScript(tag)
2624{
2625 return tag == 'script' ? 'p' : tag;
2626}
2627
2628function _VirtualDom_noOnOrFormAction(key)
2629{
2630 return /^(on|formAction$)/i.test(key) ? 'data-' + key : key;
2631}
2632
2633function _VirtualDom_noInnerHtmlOrFormAction(key)
2634{
2635 return key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key;
2636}
2637
2638function _VirtualDom_noJavaScriptUri(value)
2639{
2640 return /^javascript:/i.test(value.replace(/\s/g,'')) ? '' : value;
2641}
2642
2643function _VirtualDom_noJavaScriptUri_UNUSED(value)
2644{
2645 return /^javascript:/i.test(value.replace(/\s/g,''))
2646 ? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'
2647 : value;
2648}
2649
2650function _VirtualDom_noJavaScriptOrHtmlUri(value)
2651{
2652 return /^\s*(javascript:|data:text\/html)/i.test(value) ? '' : value;
2653}
2654
2655function _VirtualDom_noJavaScriptOrHtmlUri_UNUSED(value)
2656{
2657 return /^\s*(javascript:|data:text\/html)/i.test(value)
2658 ? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'
2659 : value;
2660}
2661
2662
2663
2664// MAP FACTS
2665
2666
2667var _VirtualDom_mapAttribute = F2(function(func, attr)
2668{
2669 return (attr.$ === 'a0')
2670 ? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o))
2671 : attr;
2672});
2673
2674function _VirtualDom_mapHandler(func, handler)
2675{
2676 var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2677
2678 // 0 = Normal
2679 // 1 = MayStopPropagation
2680 // 2 = MayPreventDefault
2681 // 3 = Custom
2682
2683 return {
2684 $: handler.$,
2685 a:
2686 !tag
2687 ? A2($elm$json$Json$Decode$map, func, handler.a)
2688 :
2689 A3($elm$json$Json$Decode$map2,
2690 tag < 3
2691 ? _VirtualDom_mapEventTuple
2692 : _VirtualDom_mapEventRecord,
2693 $elm$json$Json$Decode$succeed(func),
2694 handler.a
2695 )
2696 };
2697}
2698
2699var _VirtualDom_mapEventTuple = F2(function(func, tuple)
2700{
2701 return _Utils_Tuple2(func(tuple.a), tuple.b);
2702});
2703
2704var _VirtualDom_mapEventRecord = F2(function(func, record)
2705{
2706 return {
2707 I: func(record.I),
2708 cS: record.cS,
2709 cM: record.cM
2710 }
2711});
2712
2713
2714
2715// ORGANIZE FACTS
2716
2717
2718function _VirtualDom_organizeFacts(factList)
2719{
2720 for (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS
2721 {
2722 var entry = factList.a;
2723
2724 var tag = entry.$;
2725 var key = entry.n;
2726 var value = entry.o;
2727
2728 if (tag === 'a2')
2729 {
2730 (key === 'className')
2731 ? _VirtualDom_addClass(facts, key, _Json_unwrap(value))
2732 : facts[key] = _Json_unwrap(value);
2733
2734 continue;
2735 }
2736
2737 var subFacts = facts[tag] || (facts[tag] = {});
2738 (tag === 'a3' && key === 'class')
2739 ? _VirtualDom_addClass(subFacts, key, value)
2740 : subFacts[key] = value;
2741 }
2742
2743 return facts;
2744}
2745
2746function _VirtualDom_addClass(object, key, newClass)
2747{
2748 var classes = object[key];
2749 object[key] = classes ? classes + ' ' + newClass : newClass;
2750}
2751
2752
2753
2754// RENDER
2755
2756
2757function _VirtualDom_render(vNode, eventNode)
2758{
2759 var tag = vNode.$;
2760
2761 if (tag === 5)
2762 {
2763 return _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode);
2764 }
2765
2766 if (tag === 0)
2767 {
2768 return _VirtualDom_doc.createTextNode(vNode.a);
2769 }
2770
2771 if (tag === 4)
2772 {
2773 var subNode = vNode.k;
2774 var tagger = vNode.j;
2775
2776 while (subNode.$ === 4)
2777 {
2778 typeof tagger !== 'object'
2779 ? tagger = [tagger, subNode.j]
2780 : tagger.push(subNode.j);
2781
2782 subNode = subNode.k;
2783 }
2784
2785 var subEventRoot = { j: tagger, p: eventNode };
2786 var domNode = _VirtualDom_render(subNode, subEventRoot);
2787 domNode.elm_event_node_ref = subEventRoot;
2788 return domNode;
2789 }
2790
2791 if (tag === 3)
2792 {
2793 var domNode = vNode.h(vNode.g);
2794 _VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2795 return domNode;
2796 }
2797
2798 // at this point `tag` must be 1 or 2
2799
2800 var domNode = vNode.f
2801 ? _VirtualDom_doc.createElementNS(vNode.f, vNode.c)
2802 : _VirtualDom_doc.createElement(vNode.c);
2803
2804 if (_VirtualDom_divertHrefToApp && vNode.c == 'a')
2805 {
2806 domNode.addEventListener('click', _VirtualDom_divertHrefToApp(domNode));
2807 }
2808
2809 _VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2810
2811 for (var kids = vNode.e, i = 0; i < kids.length; i++)
2812 {
2813 _VirtualDom_appendChild(domNode, _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode));
2814 }
2815
2816 return domNode;
2817}
2818
2819
2820
2821// APPLY FACTS
2822
2823
2824function _VirtualDom_applyFacts(domNode, eventNode, facts)
2825{
2826 for (var key in facts)
2827 {
2828 var value = facts[key];
2829
2830 key === 'a1'
2831 ? _VirtualDom_applyStyles(domNode, value)
2832 :
2833 key === 'a0'
2834 ? _VirtualDom_applyEvents(domNode, eventNode, value)
2835 :
2836 key === 'a3'
2837 ? _VirtualDom_applyAttrs(domNode, value)
2838 :
2839 key === 'a4'
2840 ? _VirtualDom_applyAttrsNS(domNode, value)
2841 :
2842 ((key !== 'value' && key !== 'checked') || domNode[key] !== value) && (domNode[key] = value);
2843 }
2844}
2845
2846
2847
2848// APPLY STYLES
2849
2850
2851function _VirtualDom_applyStyles(domNode, styles)
2852{
2853 var domNodeStyle = domNode.style;
2854
2855 for (var key in styles)
2856 {
2857 domNodeStyle[key] = styles[key];
2858 }
2859}
2860
2861
2862
2863// APPLY ATTRS
2864
2865
2866function _VirtualDom_applyAttrs(domNode, attrs)
2867{
2868 for (var key in attrs)
2869 {
2870 var value = attrs[key];
2871 typeof value !== 'undefined'
2872 ? domNode.setAttribute(key, value)
2873 : domNode.removeAttribute(key);
2874 }
2875}
2876
2877
2878
2879// APPLY NAMESPACED ATTRS
2880
2881
2882function _VirtualDom_applyAttrsNS(domNode, nsAttrs)
2883{
2884 for (var key in nsAttrs)
2885 {
2886 var pair = nsAttrs[key];
2887 var namespace = pair.f;
2888 var value = pair.o;
2889
2890 typeof value !== 'undefined'
2891 ? domNode.setAttributeNS(namespace, key, value)
2892 : domNode.removeAttributeNS(namespace, key);
2893 }
2894}
2895
2896
2897
2898// APPLY EVENTS
2899
2900
2901function _VirtualDom_applyEvents(domNode, eventNode, events)
2902{
2903 var allCallbacks = domNode.elmFs || (domNode.elmFs = {});
2904
2905 for (var key in events)
2906 {
2907 var newHandler = events[key];
2908 var oldCallback = allCallbacks[key];
2909
2910 if (!newHandler)
2911 {
2912 domNode.removeEventListener(key, oldCallback);
2913 allCallbacks[key] = undefined;
2914 continue;
2915 }
2916
2917 if (oldCallback)
2918 {
2919 var oldHandler = oldCallback.q;
2920 if (oldHandler.$ === newHandler.$)
2921 {
2922 oldCallback.q = newHandler;
2923 continue;
2924 }
2925 domNode.removeEventListener(key, oldCallback);
2926 }
2927
2928 oldCallback = _VirtualDom_makeCallback(eventNode, newHandler);
2929 domNode.addEventListener(key, oldCallback,
2930 _VirtualDom_passiveSupported
2931 && { passive: $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 }
2932 );
2933 allCallbacks[key] = oldCallback;
2934 }
2935}
2936
2937
2938
2939// PASSIVE EVENTS
2940
2941
2942var _VirtualDom_passiveSupported;
2943
2944try
2945{
2946 window.addEventListener('t', null, Object.defineProperty({}, 'passive', {
2947 get: function() { _VirtualDom_passiveSupported = true; }
2948 }));
2949}
2950catch(e) {}
2951
2952
2953
2954// EVENT HANDLERS
2955
2956
2957function _VirtualDom_makeCallback(eventNode, initialHandler)
2958{
2959 function callback(event)
2960 {
2961 var handler = callback.q;
2962 var result = _Json_runHelp(handler.a, event);
2963
2964 if (!$elm$core$Result$isOk(result))
2965 {
2966 return;
2967 }
2968
2969 var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2970
2971 // 0 = Normal
2972 // 1 = MayStopPropagation
2973 // 2 = MayPreventDefault
2974 // 3 = Custom
2975
2976 var value = result.a;
2977 var message = !tag ? value : tag < 3 ? value.a : value.I;
2978 var stopPropagation = tag == 1 ? value.b : tag == 3 && value.cS;
2979 var currentEventNode = (
2980 stopPropagation && event.stopPropagation(),
2981 (tag == 2 ? value.b : tag == 3 && value.cM) && event.preventDefault(),
2982 eventNode
2983 );
2984 var tagger;
2985 var i;
2986 while (tagger = currentEventNode.j)
2987 {
2988 if (typeof tagger == 'function')
2989 {
2990 message = tagger(message);
2991 }
2992 else
2993 {
2994 for (var i = tagger.length; i--; )
2995 {
2996 message = tagger[i](message);
2997 }
2998 }
2999 currentEventNode = currentEventNode.p;
3000 }
3001 currentEventNode(message, stopPropagation); // stopPropagation implies isSync
3002 }
3003
3004 callback.q = initialHandler;
3005
3006 return callback;
3007}
3008
3009function _VirtualDom_equalEvents(x, y)
3010{
3011 return x.$ == y.$ && _Json_equality(x.a, y.a);
3012}
3013
3014
3015
3016// DIFF
3017
3018
3019// TODO: Should we do patches like in iOS?
3020//
3021// type Patch
3022// = At Int Patch
3023// | Batch (List Patch)
3024// | Change ...
3025//
3026// How could it not be better?
3027//
3028function _VirtualDom_diff(x, y)
3029{
3030 var patches = [];
3031 _VirtualDom_diffHelp(x, y, patches, 0);
3032 return patches;
3033}
3034
3035
3036function _VirtualDom_pushPatch(patches, type, index, data)
3037{
3038 var patch = {
3039 $: type,
3040 r: index,
3041 s: data,
3042 t: undefined,
3043 u: undefined
3044 };
3045 patches.push(patch);
3046 return patch;
3047}
3048
3049
3050function _VirtualDom_diffHelp(x, y, patches, index)
3051{
3052 if (x === y)
3053 {
3054 return;
3055 }
3056
3057 var xType = x.$;
3058 var yType = y.$;
3059
3060 // Bail if you run into different types of nodes. Implies that the
3061 // structure has changed significantly and it's not worth a diff.
3062 if (xType !== yType)
3063 {
3064 if (xType === 1 && yType === 2)
3065 {
3066 y = _VirtualDom_dekey(y);
3067 yType = 1;
3068 }
3069 else
3070 {
3071 _VirtualDom_pushPatch(patches, 0, index, y);
3072 return;
3073 }
3074 }
3075
3076 // Now we know that both nodes are the same $.
3077 switch (yType)
3078 {
3079 case 5:
3080 var xRefs = x.l;
3081 var yRefs = y.l;
3082 var i = xRefs.length;
3083 var same = i === yRefs.length;
3084 while (same && i--)
3085 {
3086 same = xRefs[i] === yRefs[i];
3087 }
3088 if (same)
3089 {
3090 y.k = x.k;
3091 return;
3092 }
3093 y.k = y.m();
3094 var subPatches = [];
3095 _VirtualDom_diffHelp(x.k, y.k, subPatches, 0);
3096 subPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches);
3097 return;
3098
3099 case 4:
3100 // gather nested taggers
3101 var xTaggers = x.j;
3102 var yTaggers = y.j;
3103 var nesting = false;
3104
3105 var xSubNode = x.k;
3106 while (xSubNode.$ === 4)
3107 {
3108 nesting = true;
3109
3110 typeof xTaggers !== 'object'
3111 ? xTaggers = [xTaggers, xSubNode.j]
3112 : xTaggers.push(xSubNode.j);
3113
3114 xSubNode = xSubNode.k;
3115 }
3116
3117 var ySubNode = y.k;
3118 while (ySubNode.$ === 4)
3119 {
3120 nesting = true;
3121
3122 typeof yTaggers !== 'object'
3123 ? yTaggers = [yTaggers, ySubNode.j]
3124 : yTaggers.push(ySubNode.j);
3125
3126 ySubNode = ySubNode.k;
3127 }
3128
3129 // Just bail if different numbers of taggers. This implies the
3130 // structure of the virtual DOM has changed.
3131 if (nesting && xTaggers.length !== yTaggers.length)
3132 {
3133 _VirtualDom_pushPatch(patches, 0, index, y);
3134 return;
3135 }
3136
3137 // check if taggers are "the same"
3138 if (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers)
3139 {
3140 _VirtualDom_pushPatch(patches, 2, index, yTaggers);
3141 }
3142
3143 // diff everything below the taggers
3144 _VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1);
3145 return;
3146
3147 case 0:
3148 if (x.a !== y.a)
3149 {
3150 _VirtualDom_pushPatch(patches, 3, index, y.a);
3151 }
3152 return;
3153
3154 case 1:
3155 _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids);
3156 return;
3157
3158 case 2:
3159 _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids);
3160 return;
3161
3162 case 3:
3163 if (x.h !== y.h)
3164 {
3165 _VirtualDom_pushPatch(patches, 0, index, y);
3166 return;
3167 }
3168
3169 var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3170 factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3171
3172 var patch = y.i(x.g, y.g);
3173 patch && _VirtualDom_pushPatch(patches, 5, index, patch);
3174
3175 return;
3176 }
3177}
3178
3179// assumes the incoming arrays are the same length
3180function _VirtualDom_pairwiseRefEqual(as, bs)
3181{
3182 for (var i = 0; i < as.length; i++)
3183 {
3184 if (as[i] !== bs[i])
3185 {
3186 return false;
3187 }
3188 }
3189
3190 return true;
3191}
3192
3193function _VirtualDom_diffNodes(x, y, patches, index, diffKids)
3194{
3195 // Bail if obvious indicators have changed. Implies more serious
3196 // structural changes such that it's not worth it to diff.
3197 if (x.c !== y.c || x.f !== y.f)
3198 {
3199 _VirtualDom_pushPatch(patches, 0, index, y);
3200 return;
3201 }
3202
3203 var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3204 factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3205
3206 diffKids(x, y, patches, index);
3207}
3208
3209
3210
3211// DIFF FACTS
3212
3213
3214// TODO Instead of creating a new diff object, it's possible to just test if
3215// there *is* a diff. During the actual patch, do the diff again and make the
3216// modifications directly. This way, there's no new allocations. Worth it?
3217function _VirtualDom_diffFacts(x, y, category)
3218{
3219 var diff;
3220
3221 // look for changes and removals
3222 for (var xKey in x)
3223 {
3224 if (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4')
3225 {
3226 var subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey);
3227 if (subDiff)
3228 {
3229 diff = diff || {};
3230 diff[xKey] = subDiff;
3231 }
3232 continue;
3233 }
3234
3235 // remove if not in the new facts
3236 if (!(xKey in y))
3237 {
3238 diff = diff || {};
3239 diff[xKey] =
3240 !category
3241 ? (typeof x[xKey] === 'string' ? '' : null)
3242 :
3243 (category === 'a1')
3244 ? ''
3245 :
3246 (category === 'a0' || category === 'a3')
3247 ? undefined
3248 :
3249 { f: x[xKey].f, o: undefined };
3250
3251 continue;
3252 }
3253
3254 var xValue = x[xKey];
3255 var yValue = y[xKey];
3256
3257 // reference equal, so don't worry about it
3258 if (xValue === yValue && xKey !== 'value' && xKey !== 'checked'
3259 || category === 'a0' && _VirtualDom_equalEvents(xValue, yValue))
3260 {
3261 continue;
3262 }
3263
3264 diff = diff || {};
3265 diff[xKey] = yValue;
3266 }
3267
3268 // add new stuff
3269 for (var yKey in y)
3270 {
3271 if (!(yKey in x))
3272 {
3273 diff = diff || {};
3274 diff[yKey] = y[yKey];
3275 }
3276 }
3277
3278 return diff;
3279}
3280
3281
3282
3283// DIFF KIDS
3284
3285
3286function _VirtualDom_diffKids(xParent, yParent, patches, index)
3287{
3288 var xKids = xParent.e;
3289 var yKids = yParent.e;
3290
3291 var xLen = xKids.length;
3292 var yLen = yKids.length;
3293
3294 // FIGURE OUT IF THERE ARE INSERTS OR REMOVALS
3295
3296 if (xLen > yLen)
3297 {
3298 _VirtualDom_pushPatch(patches, 6, index, {
3299 v: yLen,
3300 i: xLen - yLen
3301 });
3302 }
3303 else if (xLen < yLen)
3304 {
3305 _VirtualDom_pushPatch(patches, 7, index, {
3306 v: xLen,
3307 e: yKids
3308 });
3309 }
3310
3311 // PAIRWISE DIFF EVERYTHING ELSE
3312
3313 for (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++)
3314 {
3315 var xKid = xKids[i];
3316 _VirtualDom_diffHelp(xKid, yKids[i], patches, ++index);
3317 index += xKid.b || 0;
3318 }
3319}
3320
3321
3322
3323// KEYED DIFF
3324
3325
3326function _VirtualDom_diffKeyedKids(xParent, yParent, patches, rootIndex)
3327{
3328 var localPatches = [];
3329
3330 var changes = {}; // Dict String Entry
3331 var inserts = []; // Array { index : Int, entry : Entry }
3332 // type Entry = { tag : String, vnode : VNode, index : Int, data : _ }
3333
3334 var xKids = xParent.e;
3335 var yKids = yParent.e;
3336 var xLen = xKids.length;
3337 var yLen = yKids.length;
3338 var xIndex = 0;
3339 var yIndex = 0;
3340
3341 var index = rootIndex;
3342
3343 while (xIndex < xLen && yIndex < yLen)
3344 {
3345 var x = xKids[xIndex];
3346 var y = yKids[yIndex];
3347
3348 var xKey = x.a;
3349 var yKey = y.a;
3350 var xNode = x.b;
3351 var yNode = y.b;
3352
3353 var newMatch = undefined;
3354 var oldMatch = undefined;
3355
3356 // check if keys match
3357
3358 if (xKey === yKey)
3359 {
3360 index++;
3361 _VirtualDom_diffHelp(xNode, yNode, localPatches, index);
3362 index += xNode.b || 0;
3363
3364 xIndex++;
3365 yIndex++;
3366 continue;
3367 }
3368
3369 // look ahead 1 to detect insertions and removals.
3370
3371 var xNext = xKids[xIndex + 1];
3372 var yNext = yKids[yIndex + 1];
3373
3374 if (xNext)
3375 {
3376 var xNextKey = xNext.a;
3377 var xNextNode = xNext.b;
3378 oldMatch = yKey === xNextKey;
3379 }
3380
3381 if (yNext)
3382 {
3383 var yNextKey = yNext.a;
3384 var yNextNode = yNext.b;
3385 newMatch = xKey === yNextKey;
3386 }
3387
3388
3389 // swap x and y
3390 if (newMatch && oldMatch)
3391 {
3392 index++;
3393 _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3394 _VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts);
3395 index += xNode.b || 0;
3396
3397 index++;
3398 _VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index);
3399 index += xNextNode.b || 0;
3400
3401 xIndex += 2;
3402 yIndex += 2;
3403 continue;
3404 }
3405
3406 // insert y
3407 if (newMatch)
3408 {
3409 index++;
3410 _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3411 _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3412 index += xNode.b || 0;
3413
3414 xIndex += 1;
3415 yIndex += 2;
3416 continue;
3417 }
3418
3419 // remove x
3420 if (oldMatch)
3421 {
3422 index++;
3423 _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3424 index += xNode.b || 0;
3425
3426 index++;
3427 _VirtualDom_diffHelp(xNextNode, yNode, localPatches, index);
3428 index += xNextNode.b || 0;
3429
3430 xIndex += 2;
3431 yIndex += 1;
3432 continue;
3433 }
3434
3435 // remove x, insert y
3436 if (xNext && xNextKey === yNextKey)
3437 {
3438 index++;
3439 _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3440 _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3441 index += xNode.b || 0;
3442
3443 index++;
3444 _VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index);
3445 index += xNextNode.b || 0;
3446
3447 xIndex += 2;
3448 yIndex += 2;
3449 continue;
3450 }
3451
3452 break;
3453 }
3454
3455 // eat up any remaining nodes with removeNode and insertNode
3456
3457 while (xIndex < xLen)
3458 {
3459 index++;
3460 var x = xKids[xIndex];
3461 var xNode = x.b;
3462 _VirtualDom_removeNode(changes, localPatches, x.a, xNode, index);
3463 index += xNode.b || 0;
3464 xIndex++;
3465 }
3466
3467 while (yIndex < yLen)
3468 {
3469 var endInserts = endInserts || [];
3470 var y = yKids[yIndex];
3471 _VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts);
3472 yIndex++;
3473 }
3474
3475 if (localPatches.length > 0 || inserts.length > 0 || endInserts)
3476 {
3477 _VirtualDom_pushPatch(patches, 8, rootIndex, {
3478 w: localPatches,
3479 x: inserts,
3480 y: endInserts
3481 });
3482 }
3483}
3484
3485
3486
3487// CHANGES FROM KEYED DIFF
3488
3489
3490var _VirtualDom_POSTFIX = '_elmW6BL';
3491
3492
3493function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts)
3494{
3495 var entry = changes[key];
3496
3497 // never seen this key before
3498 if (!entry)
3499 {
3500 entry = {
3501 c: 0,
3502 z: vnode,
3503 r: yIndex,
3504 s: undefined
3505 };
3506
3507 inserts.push({ r: yIndex, A: entry });
3508 changes[key] = entry;
3509
3510 return;
3511 }
3512
3513 // this key was removed earlier, a match!
3514 if (entry.c === 1)
3515 {
3516 inserts.push({ r: yIndex, A: entry });
3517
3518 entry.c = 2;
3519 var subPatches = [];
3520 _VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r);
3521 entry.r = yIndex;
3522 entry.s.s = {
3523 w: subPatches,
3524 A: entry
3525 };
3526
3527 return;
3528 }
3529
3530 // this key has already been inserted or moved, a duplicate!
3531 _VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts);
3532}
3533
3534
3535function _VirtualDom_removeNode(changes, localPatches, key, vnode, index)
3536{
3537 var entry = changes[key];
3538
3539 // never seen this key before
3540 if (!entry)
3541 {
3542 var patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined);
3543
3544 changes[key] = {
3545 c: 1,
3546 z: vnode,
3547 r: index,
3548 s: patch
3549 };
3550
3551 return;
3552 }
3553
3554 // this key was inserted earlier, a match!
3555 if (entry.c === 0)
3556 {
3557 entry.c = 2;
3558 var subPatches = [];
3559 _VirtualDom_diffHelp(vnode, entry.z, subPatches, index);
3560
3561 _VirtualDom_pushPatch(localPatches, 9, index, {
3562 w: subPatches,
3563 A: entry
3564 });
3565
3566 return;
3567 }
3568
3569 // this key has already been removed or moved, a duplicate!
3570 _VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, index);
3571}
3572
3573
3574
3575// ADD DOM NODES
3576//
3577// Each DOM node has an "index" assigned in order of traversal. It is important
3578// to minimize our crawl over the actual DOM, so these indexes (along with the
3579// descendantsCount of virtual nodes) let us skip touching entire subtrees of
3580// the DOM if we know there are no patches there.
3581
3582
3583function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode)
3584{
3585 _VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode);
3586}
3587
3588
3589// assumes `patches` is non-empty and indexes increase monotonically.
3590function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode)
3591{
3592 var patch = patches[i];
3593 var index = patch.r;
3594
3595 while (index === low)
3596 {
3597 var patchType = patch.$;
3598
3599 if (patchType === 1)
3600 {
3601 _VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode);
3602 }
3603 else if (patchType === 8)
3604 {
3605 patch.t = domNode;
3606 patch.u = eventNode;
3607
3608 var subPatches = patch.s.w;
3609 if (subPatches.length > 0)
3610 {
3611 _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3612 }
3613 }
3614 else if (patchType === 9)
3615 {
3616 patch.t = domNode;
3617 patch.u = eventNode;
3618
3619 var data = patch.s;
3620 if (data)
3621 {
3622 data.A.s = domNode;
3623 var subPatches = data.w;
3624 if (subPatches.length > 0)
3625 {
3626 _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3627 }
3628 }
3629 }
3630 else
3631 {
3632 patch.t = domNode;
3633 patch.u = eventNode;
3634 }
3635
3636 i++;
3637
3638 if (!(patch = patches[i]) || (index = patch.r) > high)
3639 {
3640 return i;
3641 }
3642 }
3643
3644 var tag = vNode.$;
3645
3646 if (tag === 4)
3647 {
3648 var subNode = vNode.k;
3649
3650 while (subNode.$ === 4)
3651 {
3652 subNode = subNode.k;
3653 }
3654
3655 return _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);
3656 }
3657
3658 // tag must be 1 or 2 at this point
3659
3660 var vKids = vNode.e;
3661 var childNodes = domNode.childNodes;
3662 for (var j = 0; j < vKids.length; j++)
3663 {
3664 low++;
3665 var vKid = tag === 1 ? vKids[j] : vKids[j].b;
3666 var nextLow = low + (vKid.b || 0);
3667 if (low <= index && index <= nextLow)
3668 {
3669 i = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode);
3670 if (!(patch = patches[i]) || (index = patch.r) > high)
3671 {
3672 return i;
3673 }
3674 }
3675 low = nextLow;
3676 }
3677 return i;
3678}
3679
3680
3681
3682// APPLY PATCHES
3683
3684
3685function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode)
3686{
3687 if (patches.length === 0)
3688 {
3689 return rootDomNode;
3690 }
3691
3692 _VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);
3693 return _VirtualDom_applyPatchesHelp(rootDomNode, patches);
3694}
3695
3696function _VirtualDom_applyPatchesHelp(rootDomNode, patches)
3697{
3698 for (var i = 0; i < patches.length; i++)
3699 {
3700 var patch = patches[i];
3701 var localDomNode = patch.t
3702 var newNode = _VirtualDom_applyPatch(localDomNode, patch);
3703 if (localDomNode === rootDomNode)
3704 {
3705 rootDomNode = newNode;
3706 }
3707 }
3708 return rootDomNode;
3709}
3710
3711function _VirtualDom_applyPatch(domNode, patch)
3712{
3713 switch (patch.$)
3714 {
3715 case 0:
3716 return _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u);
3717
3718 case 4:
3719 _VirtualDom_applyFacts(domNode, patch.u, patch.s);
3720 return domNode;
3721
3722 case 3:
3723 domNode.replaceData(0, domNode.length, patch.s);
3724 return domNode;
3725
3726 case 1:
3727 return _VirtualDom_applyPatchesHelp(domNode, patch.s);
3728
3729 case 2:
3730 if (domNode.elm_event_node_ref)
3731 {
3732 domNode.elm_event_node_ref.j = patch.s;
3733 }
3734 else
3735 {
3736 domNode.elm_event_node_ref = { j: patch.s, p: patch.u };
3737 }
3738 return domNode;
3739
3740 case 6:
3741 var data = patch.s;
3742 for (var i = 0; i < data.i; i++)
3743 {
3744 domNode.removeChild(domNode.childNodes[data.v]);
3745 }
3746 return domNode;
3747
3748 case 7:
3749 var data = patch.s;
3750 var kids = data.e;
3751 var i = data.v;
3752 var theEnd = domNode.childNodes[i];
3753 for (; i < kids.length; i++)
3754 {
3755 domNode.insertBefore(_VirtualDom_render(kids[i], patch.u), theEnd);
3756 }
3757 return domNode;
3758
3759 case 9:
3760 var data = patch.s;
3761 if (!data)
3762 {
3763 domNode.parentNode.removeChild(domNode);
3764 return domNode;
3765 }
3766 var entry = data.A;
3767 if (typeof entry.r !== 'undefined')
3768 {
3769 domNode.parentNode.removeChild(domNode);
3770 }
3771 entry.s = _VirtualDom_applyPatchesHelp(domNode, data.w);
3772 return domNode;
3773
3774 case 8:
3775 return _VirtualDom_applyPatchReorder(domNode, patch);
3776
3777 case 5:
3778 return patch.s(domNode);
3779
3780 default:
3781 _Debug_crash(10); // 'Ran into an unknown patch!'
3782 }
3783}
3784
3785
3786function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode)
3787{
3788 var parentNode = domNode.parentNode;
3789 var newNode = _VirtualDom_render(vNode, eventNode);
3790
3791 if (!newNode.elm_event_node_ref)
3792 {
3793 newNode.elm_event_node_ref = domNode.elm_event_node_ref;
3794 }
3795
3796 if (parentNode && newNode !== domNode)
3797 {
3798 parentNode.replaceChild(newNode, domNode);
3799 }
3800 return newNode;
3801}
3802
3803
3804function _VirtualDom_applyPatchReorder(domNode, patch)
3805{
3806 var data = patch.s;
3807
3808 // remove end inserts
3809 var frag = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch);
3810
3811 // removals
3812 domNode = _VirtualDom_applyPatchesHelp(domNode, data.w);
3813
3814 // inserts
3815 var inserts = data.x;
3816 for (var i = 0; i < inserts.length; i++)
3817 {
3818 var insert = inserts[i];
3819 var entry = insert.A;
3820 var node = entry.c === 2
3821 ? entry.s
3822 : _VirtualDom_render(entry.z, patch.u);
3823 domNode.insertBefore(node, domNode.childNodes[insert.r]);
3824 }
3825
3826 // add end inserts
3827 if (frag)
3828 {
3829 _VirtualDom_appendChild(domNode, frag);
3830 }
3831
3832 return domNode;
3833}
3834
3835
3836function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch)
3837{
3838 if (!endInserts)
3839 {
3840 return;
3841 }
3842
3843 var frag = _VirtualDom_doc.createDocumentFragment();
3844 for (var i = 0; i < endInserts.length; i++)
3845 {
3846 var insert = endInserts[i];
3847 var entry = insert.A;
3848 _VirtualDom_appendChild(frag, entry.c === 2
3849 ? entry.s
3850 : _VirtualDom_render(entry.z, patch.u)
3851 );
3852 }
3853 return frag;
3854}
3855
3856
3857function _VirtualDom_virtualize(node)
3858{
3859 // TEXT NODES
3860
3861 if (node.nodeType === 3)
3862 {
3863 return _VirtualDom_text(node.textContent);
3864 }
3865
3866
3867 // WEIRD NODES
3868
3869 if (node.nodeType !== 1)
3870 {
3871 return _VirtualDom_text('');
3872 }
3873
3874
3875 // ELEMENT NODES
3876
3877 var attrList = _List_Nil;
3878 var attrs = node.attributes;
3879 for (var i = attrs.length; i--; )
3880 {
3881 var attr = attrs[i];
3882 var name = attr.name;
3883 var value = attr.value;
3884 attrList = _List_Cons( A2(_VirtualDom_attribute, name, value), attrList );
3885 }
3886
3887 var tag = node.tagName.toLowerCase();
3888 var kidList = _List_Nil;
3889 var kids = node.childNodes;
3890
3891 for (var i = kids.length; i--; )
3892 {
3893 kidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList);
3894 }
3895 return A3(_VirtualDom_node, tag, attrList, kidList);
3896}
3897
3898function _VirtualDom_dekey(keyedNode)
3899{
3900 var keyedKids = keyedNode.e;
3901 var len = keyedKids.length;
3902 var kids = new Array(len);
3903 for (var i = 0; i < len; i++)
3904 {
3905 kids[i] = keyedKids[i].b;
3906 }
3907
3908 return {
3909 $: 1,
3910 c: keyedNode.c,
3911 d: keyedNode.d,
3912 e: kids,
3913 f: keyedNode.f,
3914 b: keyedNode.b
3915 };
3916}
3917
3918
3919
3920
3921// ELEMENT
3922
3923
3924var _Debugger_element;
3925
3926var _Browser_element = _Debugger_element || F4(function(impl, flagDecoder, debugMetadata, args)
3927{
3928 return _Platform_initialize(
3929 flagDecoder,
3930 args,
3931 impl.en,
3932 impl.eO,
3933 impl.eI,
3934 function(sendToApp, initialModel) {
3935 var view = impl.eP;
3936 /**/
3937 var domNode = args['node'];
3938 //*/
3939 /**_UNUSED/
3940 var domNode = args && args['node'] ? args['node'] : _Debug_crash(0);
3941 //*/
3942 var currNode = _VirtualDom_virtualize(domNode);
3943
3944 return _Browser_makeAnimator(initialModel, function(model)
3945 {
3946 var nextNode = view(model);
3947 var patches = _VirtualDom_diff(currNode, nextNode);
3948 domNode = _VirtualDom_applyPatches(domNode, currNode, patches, sendToApp);
3949 currNode = nextNode;
3950 });
3951 }
3952 );
3953});
3954
3955
3956
3957// DOCUMENT
3958
3959
3960var _Debugger_document;
3961
3962var _Browser_document = _Debugger_document || F4(function(impl, flagDecoder, debugMetadata, args)
3963{
3964 return _Platform_initialize(
3965 flagDecoder,
3966 args,
3967 impl.en,
3968 impl.eO,
3969 impl.eI,
3970 function(sendToApp, initialModel) {
3971 var divertHrefToApp = impl.cP && impl.cP(sendToApp)
3972 var view = impl.eP;
3973 var title = _VirtualDom_doc.title;
3974 var bodyNode = _VirtualDom_doc.body;
3975 var currNode = _VirtualDom_virtualize(bodyNode);
3976 return _Browser_makeAnimator(initialModel, function(model)
3977 {
3978 _VirtualDom_divertHrefToApp = divertHrefToApp;
3979 var doc = view(model);
3980 var nextNode = _VirtualDom_node('body')(_List_Nil)(doc.d4);
3981 var patches = _VirtualDom_diff(currNode, nextNode);
3982 bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp);
3983 currNode = nextNode;
3984 _VirtualDom_divertHrefToApp = 0;
3985 (title !== doc.ap) && (_VirtualDom_doc.title = title = doc.ap);
3986 });
3987 }
3988 );
3989});
3990
3991
3992
3993// ANIMATION
3994
3995
3996var _Browser_cancelAnimationFrame =
3997 typeof cancelAnimationFrame !== 'undefined'
3998 ? cancelAnimationFrame
3999 : function(id) { clearTimeout(id); };
4000
4001var _Browser_requestAnimationFrame =
4002 typeof requestAnimationFrame !== 'undefined'
4003 ? requestAnimationFrame
4004 : function(callback) { return setTimeout(callback, 1000 / 60); };
4005
4006
4007function _Browser_makeAnimator(model, draw)
4008{
4009 draw(model);
4010
4011 var state = 0;
4012
4013 function updateIfNeeded()
4014 {
4015 state = state === 1
4016 ? 0
4017 : ( _Browser_requestAnimationFrame(updateIfNeeded), draw(model), 1 );
4018 }
4019
4020 return function(nextModel, isSync)
4021 {
4022 model = nextModel;
4023
4024 isSync
4025 ? ( draw(model),
4026 state === 2 && (state = 1)
4027 )
4028 : ( state === 0 && _Browser_requestAnimationFrame(updateIfNeeded),
4029 state = 2
4030 );
4031 };
4032}
4033
4034
4035
4036// APPLICATION
4037
4038
4039function _Browser_application(impl)
4040{
4041 var onUrlChange = impl.ev;
4042 var onUrlRequest = impl.ew;
4043 var key = function() { key.a(onUrlChange(_Browser_getUrl())); };
4044
4045 return _Browser_document({
4046 cP: function(sendToApp)
4047 {
4048 key.a = sendToApp;
4049 _Browser_window.addEventListener('popstate', key);
4050 _Browser_window.navigator.userAgent.indexOf('Trident') < 0 || _Browser_window.addEventListener('hashchange', key);
4051
4052 return F2(function(domNode, event)
4053 {
4054 if (!event.ctrlKey && !event.metaKey && !event.shiftKey && event.button < 1 && !domNode.target && !domNode.hasAttribute('download'))
4055 {
4056 event.preventDefault();
4057 var href = domNode.href;
4058 var curr = _Browser_getUrl();
4059 var next = $elm$url$Url$fromString(href).a;
4060 sendToApp(onUrlRequest(
4061 (next
4062 && curr.dB === next.dB
4063 && curr.dd === next.dd
4064 && curr.dx.a === next.dx.a
4065 )
4066 ? $elm$browser$Browser$Internal(next)
4067 : $elm$browser$Browser$External(href)
4068 ));
4069 }
4070 });
4071 },
4072 en: function(flags)
4073 {
4074 return A3(impl.en, flags, _Browser_getUrl(), key);
4075 },
4076 eP: impl.eP,
4077 eO: impl.eO,
4078 eI: impl.eI
4079 });
4080}
4081
4082function _Browser_getUrl()
4083{
4084 return $elm$url$Url$fromString(_VirtualDom_doc.location.href).a || _Debug_crash(1);
4085}
4086
4087var _Browser_go = F2(function(key, n)
4088{
4089 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4090 n && history.go(n);
4091 key();
4092 }));
4093});
4094
4095var _Browser_pushUrl = F2(function(key, url)
4096{
4097 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4098 history.pushState({}, '', url);
4099 key();
4100 }));
4101});
4102
4103var _Browser_replaceUrl = F2(function(key, url)
4104{
4105 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4106 history.replaceState({}, '', url);
4107 key();
4108 }));
4109});
4110
4111
4112
4113// GLOBAL EVENTS
4114
4115
4116var _Browser_fakeNode = { addEventListener: function() {}, removeEventListener: function() {} };
4117var _Browser_doc = typeof document !== 'undefined' ? document : _Browser_fakeNode;
4118var _Browser_window = typeof window !== 'undefined' ? window : _Browser_fakeNode;
4119
4120var _Browser_on = F3(function(node, eventName, sendToSelf)
4121{
4122 return _Scheduler_spawn(_Scheduler_binding(function(callback)
4123 {
4124 function handler(event) { _Scheduler_rawSpawn(sendToSelf(event)); }
4125 node.addEventListener(eventName, handler, _VirtualDom_passiveSupported && { passive: true });
4126 return function() { node.removeEventListener(eventName, handler); };
4127 }));
4128});
4129
4130var _Browser_decodeEvent = F2(function(decoder, event)
4131{
4132 var result = _Json_runHelp(decoder, event);
4133 return $elm$core$Result$isOk(result) ? $elm$core$Maybe$Just(result.a) : $elm$core$Maybe$Nothing;
4134});
4135
4136
4137
4138// PAGE VISIBILITY
4139
4140
4141function _Browser_visibilityInfo()
4142{
4143 return (typeof _VirtualDom_doc.hidden !== 'undefined')
4144 ? { ei: 'hidden', d6: 'visibilitychange' }
4145 :
4146 (typeof _VirtualDom_doc.mozHidden !== 'undefined')
4147 ? { ei: 'mozHidden', d6: 'mozvisibilitychange' }
4148 :
4149 (typeof _VirtualDom_doc.msHidden !== 'undefined')
4150 ? { ei: 'msHidden', d6: 'msvisibilitychange' }
4151 :
4152 (typeof _VirtualDom_doc.webkitHidden !== 'undefined')
4153 ? { ei: 'webkitHidden', d6: 'webkitvisibilitychange' }
4154 : { ei: 'hidden', d6: 'visibilitychange' };
4155}
4156
4157
4158
4159// ANIMATION FRAMES
4160
4161
4162function _Browser_rAF()
4163{
4164 return _Scheduler_binding(function(callback)
4165 {
4166 var id = _Browser_requestAnimationFrame(function() {
4167 callback(_Scheduler_succeed(Date.now()));
4168 });
4169
4170 return function() {
4171 _Browser_cancelAnimationFrame(id);
4172 };
4173 });
4174}
4175
4176
4177function _Browser_now()
4178{
4179 return _Scheduler_binding(function(callback)
4180 {
4181 callback(_Scheduler_succeed(Date.now()));
4182 });
4183}
4184
4185
4186
4187// DOM STUFF
4188
4189
4190function _Browser_withNode(id, doStuff)
4191{
4192 return _Scheduler_binding(function(callback)
4193 {
4194 _Browser_requestAnimationFrame(function() {
4195 var node = document.getElementById(id);
4196 callback(node
4197 ? _Scheduler_succeed(doStuff(node))
4198 : _Scheduler_fail($elm$browser$Browser$Dom$NotFound(id))
4199 );
4200 });
4201 });
4202}
4203
4204
4205function _Browser_withWindow(doStuff)
4206{
4207 return _Scheduler_binding(function(callback)
4208 {
4209 _Browser_requestAnimationFrame(function() {
4210 callback(_Scheduler_succeed(doStuff()));
4211 });
4212 });
4213}
4214
4215
4216// FOCUS and BLUR
4217
4218
4219var _Browser_call = F2(function(functionName, id)
4220{
4221 return _Browser_withNode(id, function(node) {
4222 node[functionName]();
4223 return _Utils_Tuple0;
4224 });
4225});
4226
4227
4228
4229// WINDOW VIEWPORT
4230
4231
4232function _Browser_getViewport()
4233{
4234 return {
4235 dH: _Browser_getScene(),
4236 dW: {
4237 dY: _Browser_window.pageXOffset,
4238 dZ: _Browser_window.pageYOffset,
4239 dX: _Browser_doc.documentElement.clientWidth,
4240 dc: _Browser_doc.documentElement.clientHeight
4241 }
4242 };
4243}
4244
4245function _Browser_getScene()
4246{
4247 var body = _Browser_doc.body;
4248 var elem = _Browser_doc.documentElement;
4249 return {
4250 dX: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth),
4251 dc: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight)
4252 };
4253}
4254
4255var _Browser_setViewport = F2(function(x, y)
4256{
4257 return _Browser_withWindow(function()
4258 {
4259 _Browser_window.scroll(x, y);
4260 return _Utils_Tuple0;
4261 });
4262});
4263
4264
4265
4266// ELEMENT VIEWPORT
4267
4268
4269function _Browser_getViewportOf(id)
4270{
4271 return _Browser_withNode(id, function(node)
4272 {
4273 return {
4274 dH: {
4275 dX: node.scrollWidth,
4276 dc: node.scrollHeight
4277 },
4278 dW: {
4279 dY: node.scrollLeft,
4280 dZ: node.scrollTop,
4281 dX: node.clientWidth,
4282 dc: node.clientHeight
4283 }
4284 };
4285 });
4286}
4287
4288
4289var _Browser_setViewportOf = F3(function(id, x, y)
4290{
4291 return _Browser_withNode(id, function(node)
4292 {
4293 node.scrollLeft = x;
4294 node.scrollTop = y;
4295 return _Utils_Tuple0;
4296 });
4297});
4298
4299
4300
4301// ELEMENT
4302
4303
4304function _Browser_getElement(id)
4305{
4306 return _Browser_withNode(id, function(node)
4307 {
4308 var rect = node.getBoundingClientRect();
4309 var x = _Browser_window.pageXOffset;
4310 var y = _Browser_window.pageYOffset;
4311 return {
4312 dH: _Browser_getScene(),
4313 dW: {
4314 dY: x,
4315 dZ: y,
4316 dX: _Browser_doc.documentElement.clientWidth,
4317 dc: _Browser_doc.documentElement.clientHeight
4318 },
4319 ed: {
4320 dY: x + rect.left,
4321 dZ: y + rect.top,
4322 dX: rect.width,
4323 dc: rect.height
4324 }
4325 };
4326 });
4327}
4328
4329
4330
4331// LOAD and RELOAD
4332
4333
4334function _Browser_reload(skipCache)
4335{
4336 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4337 {
4338 _VirtualDom_doc.location.reload(skipCache);
4339 }));
4340}
4341
4342function _Browser_load(url)
4343{
4344 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4345 {
4346 try
4347 {
4348 _Browser_window.location = url;
4349 }
4350 catch(err)
4351 {
4352 // Only Firefox can throw a NS_ERROR_MALFORMED_URI exception here.
4353 // Other browsers reload the page, so let's be consistent about that.
4354 _VirtualDom_doc.location.reload(false);
4355 }
4356 }));
4357}
4358
4359
4360function _Url_percentEncode(string)
4361{
4362 return encodeURIComponent(string);
4363}
4364
4365function _Url_percentDecode(string)
4366{
4367 try
4368 {
4369 return $elm$core$Maybe$Just(decodeURIComponent(string));
4370 }
4371 catch (e)
4372 {
4373 return $elm$core$Maybe$Nothing;
4374 }
4375}var $author$project$Main$ClickedLink = function (a) {
4376 return {$: 1, a: a};
4377};
4378var $author$project$Main$UrlChanged = function (a) {
4379 return {$: 2, a: a};
4380};
4381var $elm$core$Basics$EQ = 1;
4382var $elm$core$Basics$GT = 2;
4383var $elm$core$Basics$LT = 0;
4384var $elm$core$List$cons = _List_cons;
4385var $elm$core$Dict$foldr = F3(
4386 function (func, acc, t) {
4387 foldr:
4388 while (true) {
4389 if (t.$ === -2) {
4390 return acc;
4391 } else {
4392 var key = t.b;
4393 var value = t.c;
4394 var left = t.d;
4395 var right = t.e;
4396 var $temp$func = func,
4397 $temp$acc = A3(
4398 func,
4399 key,
4400 value,
4401 A3($elm$core$Dict$foldr, func, acc, right)),
4402 $temp$t = left;
4403 func = $temp$func;
4404 acc = $temp$acc;
4405 t = $temp$t;
4406 continue foldr;
4407 }
4408 }
4409 });
4410var $elm$core$Dict$toList = function (dict) {
4411 return A3(
4412 $elm$core$Dict$foldr,
4413 F3(
4414 function (key, value, list) {
4415 return A2(
4416 $elm$core$List$cons,
4417 _Utils_Tuple2(key, value),
4418 list);
4419 }),
4420 _List_Nil,
4421 dict);
4422};
4423var $elm$core$Dict$keys = function (dict) {
4424 return A3(
4425 $elm$core$Dict$foldr,
4426 F3(
4427 function (key, value, keyList) {
4428 return A2($elm$core$List$cons, key, keyList);
4429 }),
4430 _List_Nil,
4431 dict);
4432};
4433var $elm$core$Set$toList = function (_v0) {
4434 var dict = _v0;
4435 return $elm$core$Dict$keys(dict);
4436};
4437var $elm$core$Elm$JsArray$foldr = _JsArray_foldr;
4438var $elm$core$Array$foldr = F3(
4439 function (func, baseCase, _v0) {
4440 var tree = _v0.c;
4441 var tail = _v0.d;
4442 var helper = F2(
4443 function (node, acc) {
4444 if (!node.$) {
4445 var subTree = node.a;
4446 return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);
4447 } else {
4448 var values = node.a;
4449 return A3($elm$core$Elm$JsArray$foldr, func, acc, values);
4450 }
4451 });
4452 return A3(
4453 $elm$core$Elm$JsArray$foldr,
4454 helper,
4455 A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail),
4456 tree);
4457 });
4458var $elm$core$Array$toList = function (array) {
4459 return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array);
4460};
4461var $elm$core$Result$Err = function (a) {
4462 return {$: 1, a: a};
4463};
4464var $elm$json$Json$Decode$Failure = F2(
4465 function (a, b) {
4466 return {$: 3, a: a, b: b};
4467 });
4468var $elm$json$Json$Decode$Field = F2(
4469 function (a, b) {
4470 return {$: 0, a: a, b: b};
4471 });
4472var $elm$json$Json$Decode$Index = F2(
4473 function (a, b) {
4474 return {$: 1, a: a, b: b};
4475 });
4476var $elm$core$Result$Ok = function (a) {
4477 return {$: 0, a: a};
4478};
4479var $elm$json$Json$Decode$OneOf = function (a) {
4480 return {$: 2, a: a};
4481};
4482var $elm$core$Basics$False = 1;
4483var $elm$core$Basics$add = _Basics_add;
4484var $elm$core$Maybe$Just = function (a) {
4485 return {$: 0, a: a};
4486};
4487var $elm$core$Maybe$Nothing = {$: 1};
4488var $elm$core$String$all = _String_all;
4489var $elm$core$Basics$and = _Basics_and;
4490var $elm$core$Basics$append = _Utils_append;
4491var $elm$json$Json$Encode$encode = _Json_encode;
4492var $elm$core$String$fromInt = _String_fromNumber;
4493var $elm$core$String$join = F2(
4494 function (sep, chunks) {
4495 return A2(
4496 _String_join,
4497 sep,
4498 _List_toArray(chunks));
4499 });
4500var $elm$core$String$split = F2(
4501 function (sep, string) {
4502 return _List_fromArray(
4503 A2(_String_split, sep, string));
4504 });
4505var $elm$json$Json$Decode$indent = function (str) {
4506 return A2(
4507 $elm$core$String$join,
4508 '\n ',
4509 A2($elm$core$String$split, '\n', str));
4510};
4511var $elm$core$List$foldl = F3(
4512 function (func, acc, list) {
4513 foldl:
4514 while (true) {
4515 if (!list.b) {
4516 return acc;
4517 } else {
4518 var x = list.a;
4519 var xs = list.b;
4520 var $temp$func = func,
4521 $temp$acc = A2(func, x, acc),
4522 $temp$list = xs;
4523 func = $temp$func;
4524 acc = $temp$acc;
4525 list = $temp$list;
4526 continue foldl;
4527 }
4528 }
4529 });
4530var $elm$core$List$length = function (xs) {
4531 return A3(
4532 $elm$core$List$foldl,
4533 F2(
4534 function (_v0, i) {
4535 return i + 1;
4536 }),
4537 0,
4538 xs);
4539};
4540var $elm$core$List$map2 = _List_map2;
4541var $elm$core$Basics$le = _Utils_le;
4542var $elm$core$Basics$sub = _Basics_sub;
4543var $elm$core$List$rangeHelp = F3(
4544 function (lo, hi, list) {
4545 rangeHelp:
4546 while (true) {
4547 if (_Utils_cmp(lo, hi) < 1) {
4548 var $temp$lo = lo,
4549 $temp$hi = hi - 1,
4550 $temp$list = A2($elm$core$List$cons, hi, list);
4551 lo = $temp$lo;
4552 hi = $temp$hi;
4553 list = $temp$list;
4554 continue rangeHelp;
4555 } else {
4556 return list;
4557 }
4558 }
4559 });
4560var $elm$core$List$range = F2(
4561 function (lo, hi) {
4562 return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil);
4563 });
4564var $elm$core$List$indexedMap = F2(
4565 function (f, xs) {
4566 return A3(
4567 $elm$core$List$map2,
4568 f,
4569 A2(
4570 $elm$core$List$range,
4571 0,
4572 $elm$core$List$length(xs) - 1),
4573 xs);
4574 });
4575var $elm$core$Char$toCode = _Char_toCode;
4576var $elm$core$Char$isLower = function (_char) {
4577 var code = $elm$core$Char$toCode(_char);
4578 return (97 <= code) && (code <= 122);
4579};
4580var $elm$core$Char$isUpper = function (_char) {
4581 var code = $elm$core$Char$toCode(_char);
4582 return (code <= 90) && (65 <= code);
4583};
4584var $elm$core$Basics$or = _Basics_or;
4585var $elm$core$Char$isAlpha = function (_char) {
4586 return $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char);
4587};
4588var $elm$core$Char$isDigit = function (_char) {
4589 var code = $elm$core$Char$toCode(_char);
4590 return (code <= 57) && (48 <= code);
4591};
4592var $elm$core$Char$isAlphaNum = function (_char) {
4593 return $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char));
4594};
4595var $elm$core$List$reverse = function (list) {
4596 return A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list);
4597};
4598var $elm$core$String$uncons = _String_uncons;
4599var $elm$json$Json$Decode$errorOneOf = F2(
4600 function (i, error) {
4601 return '\n\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent(
4602 $elm$json$Json$Decode$errorToString(error))));
4603 });
4604var $elm$json$Json$Decode$errorToString = function (error) {
4605 return A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);
4606};
4607var $elm$json$Json$Decode$errorToStringHelp = F2(
4608 function (error, context) {
4609 errorToStringHelp:
4610 while (true) {
4611 switch (error.$) {
4612 case 0:
4613 var f = error.a;
4614 var err = error.b;
4615 var isSimple = function () {
4616 var _v1 = $elm$core$String$uncons(f);
4617 if (_v1.$ === 1) {
4618 return false;
4619 } else {
4620 var _v2 = _v1.a;
4621 var _char = _v2.a;
4622 var rest = _v2.b;
4623 return $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest);
4624 }
4625 }();
4626 var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']'));
4627 var $temp$error = err,
4628 $temp$context = A2($elm$core$List$cons, fieldName, context);
4629 error = $temp$error;
4630 context = $temp$context;
4631 continue errorToStringHelp;
4632 case 1:
4633 var i = error.a;
4634 var err = error.b;
4635 var indexName = '[' + ($elm$core$String$fromInt(i) + ']');
4636 var $temp$error = err,
4637 $temp$context = A2($elm$core$List$cons, indexName, context);
4638 error = $temp$error;
4639 context = $temp$context;
4640 continue errorToStringHelp;
4641 case 2:
4642 var errors = error.a;
4643 if (!errors.b) {
4644 return 'Ran into a Json.Decode.oneOf with no possibilities' + function () {
4645 if (!context.b) {
4646 return '!';
4647 } else {
4648 return ' at json' + A2(
4649 $elm$core$String$join,
4650 '',
4651 $elm$core$List$reverse(context));
4652 }
4653 }();
4654 } else {
4655 if (!errors.b.b) {
4656 var err = errors.a;
4657 var $temp$error = err,
4658 $temp$context = context;
4659 error = $temp$error;
4660 context = $temp$context;
4661 continue errorToStringHelp;
4662 } else {
4663 var starter = function () {
4664 if (!context.b) {
4665 return 'Json.Decode.oneOf';
4666 } else {
4667 return 'The Json.Decode.oneOf at json' + A2(
4668 $elm$core$String$join,
4669 '',
4670 $elm$core$List$reverse(context));
4671 }
4672 }();
4673 var introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt(
4674 $elm$core$List$length(errors)) + ' ways:'));
4675 return A2(
4676 $elm$core$String$join,
4677 '\n\n',
4678 A2(
4679 $elm$core$List$cons,
4680 introduction,
4681 A2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors)));
4682 }
4683 }
4684 default:
4685 var msg = error.a;
4686 var json = error.b;
4687 var introduction = function () {
4688 if (!context.b) {
4689 return 'Problem with the given value:\n\n';
4690 } else {
4691 return 'Problem with the value at json' + (A2(
4692 $elm$core$String$join,
4693 '',
4694 $elm$core$List$reverse(context)) + ':\n\n ');
4695 }
4696 }();
4697 return introduction + ($elm$json$Json$Decode$indent(
4698 A2($elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg));
4699 }
4700 }
4701 });
4702var $elm$core$Array$branchFactor = 32;
4703var $elm$core$Array$Array_elm_builtin = F4(
4704 function (a, b, c, d) {
4705 return {$: 0, a: a, b: b, c: c, d: d};
4706 });
4707var $elm$core$Elm$JsArray$empty = _JsArray_empty;
4708var $elm$core$Basics$ceiling = _Basics_ceiling;
4709var $elm$core$Basics$fdiv = _Basics_fdiv;
4710var $elm$core$Basics$logBase = F2(
4711 function (base, number) {
4712 return _Basics_log(number) / _Basics_log(base);
4713 });
4714var $elm$core$Basics$toFloat = _Basics_toFloat;
4715var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling(
4716 A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor));
4717var $elm$core$Array$empty = A4($elm$core$Array$Array_elm_builtin, 0, $elm$core$Array$shiftStep, $elm$core$Elm$JsArray$empty, $elm$core$Elm$JsArray$empty);
4718var $elm$core$Elm$JsArray$initialize = _JsArray_initialize;
4719var $elm$core$Array$Leaf = function (a) {
4720 return {$: 1, a: a};
4721};
4722var $elm$core$Basics$apL = F2(
4723 function (f, x) {
4724 return f(x);
4725 });
4726var $elm$core$Basics$apR = F2(
4727 function (x, f) {
4728 return f(x);
4729 });
4730var $elm$core$Basics$eq = _Utils_equal;
4731var $elm$core$Basics$floor = _Basics_floor;
4732var $elm$core$Elm$JsArray$length = _JsArray_length;
4733var $elm$core$Basics$gt = _Utils_gt;
4734var $elm$core$Basics$max = F2(
4735 function (x, y) {
4736 return (_Utils_cmp(x, y) > 0) ? x : y;
4737 });
4738var $elm$core$Basics$mul = _Basics_mul;
4739var $elm$core$Array$SubTree = function (a) {
4740 return {$: 0, a: a};
4741};
4742var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;
4743var $elm$core$Array$compressNodes = F2(
4744 function (nodes, acc) {
4745 compressNodes:
4746 while (true) {
4747 var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes);
4748 var node = _v0.a;
4749 var remainingNodes = _v0.b;
4750 var newAcc = A2(
4751 $elm$core$List$cons,
4752 $elm$core$Array$SubTree(node),
4753 acc);
4754 if (!remainingNodes.b) {
4755 return $elm$core$List$reverse(newAcc);
4756 } else {
4757 var $temp$nodes = remainingNodes,
4758 $temp$acc = newAcc;
4759 nodes = $temp$nodes;
4760 acc = $temp$acc;
4761 continue compressNodes;
4762 }
4763 }
4764 });
4765var $elm$core$Tuple$first = function (_v0) {
4766 var x = _v0.a;
4767 return x;
4768};
4769var $elm$core$Array$treeFromBuilder = F2(
4770 function (nodeList, nodeListSize) {
4771 treeFromBuilder:
4772 while (true) {
4773 var newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor);
4774 if (newNodeSize === 1) {
4775 return A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a;
4776 } else {
4777 var $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil),
4778 $temp$nodeListSize = newNodeSize;
4779 nodeList = $temp$nodeList;
4780 nodeListSize = $temp$nodeListSize;
4781 continue treeFromBuilder;
4782 }
4783 }
4784 });
4785var $elm$core$Array$builderToArray = F2(
4786 function (reverseNodeList, builder) {
4787 if (!builder.b) {
4788 return A4(
4789 $elm$core$Array$Array_elm_builtin,
4790 $elm$core$Elm$JsArray$length(builder.d),
4791 $elm$core$Array$shiftStep,
4792 $elm$core$Elm$JsArray$empty,
4793 builder.d);
4794 } else {
4795 var treeLen = builder.b * $elm$core$Array$branchFactor;
4796 var depth = $elm$core$Basics$floor(
4797 A2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1));
4798 var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.e) : builder.e;
4799 var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.b);
4800 return A4(
4801 $elm$core$Array$Array_elm_builtin,
4802 $elm$core$Elm$JsArray$length(builder.d) + treeLen,
4803 A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep),
4804 tree,
4805 builder.d);
4806 }
4807 });
4808var $elm$core$Basics$idiv = _Basics_idiv;
4809var $elm$core$Basics$lt = _Utils_lt;
4810var $elm$core$Array$initializeHelp = F5(
4811 function (fn, fromIndex, len, nodeList, tail) {
4812 initializeHelp:
4813 while (true) {
4814 if (fromIndex < 0) {
4815 return A2(
4816 $elm$core$Array$builderToArray,
4817 false,
4818 {e: nodeList, b: (len / $elm$core$Array$branchFactor) | 0, d: tail});
4819 } else {
4820 var leaf = $elm$core$Array$Leaf(
4821 A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn));
4822 var $temp$fn = fn,
4823 $temp$fromIndex = fromIndex - $elm$core$Array$branchFactor,
4824 $temp$len = len,
4825 $temp$nodeList = A2($elm$core$List$cons, leaf, nodeList),
4826 $temp$tail = tail;
4827 fn = $temp$fn;
4828 fromIndex = $temp$fromIndex;
4829 len = $temp$len;
4830 nodeList = $temp$nodeList;
4831 tail = $temp$tail;
4832 continue initializeHelp;
4833 }
4834 }
4835 });
4836var $elm$core$Basics$remainderBy = _Basics_remainderBy;
4837var $elm$core$Array$initialize = F2(
4838 function (len, fn) {
4839 if (len <= 0) {
4840 return $elm$core$Array$empty;
4841 } else {
4842 var tailLen = len % $elm$core$Array$branchFactor;
4843 var tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn);
4844 var initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor;
4845 return A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);
4846 }
4847 });
4848var $elm$core$Basics$True = 0;
4849var $elm$core$Result$isOk = function (result) {
4850 if (!result.$) {
4851 return true;
4852 } else {
4853 return false;
4854 }
4855};
4856var $elm$json$Json$Decode$map = _Json_map1;
4857var $elm$json$Json$Decode$map2 = _Json_map2;
4858var $elm$json$Json$Decode$succeed = _Json_succeed;
4859var $elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) {
4860 switch (handler.$) {
4861 case 0:
4862 return 0;
4863 case 1:
4864 return 1;
4865 case 2:
4866 return 2;
4867 default:
4868 return 3;
4869 }
4870};
4871var $elm$browser$Browser$External = function (a) {
4872 return {$: 1, a: a};
4873};
4874var $elm$browser$Browser$Internal = function (a) {
4875 return {$: 0, a: a};
4876};
4877var $elm$core$Basics$identity = function (x) {
4878 return x;
4879};
4880var $elm$browser$Browser$Dom$NotFound = $elm$core$Basics$identity;
4881var $elm$url$Url$Http = 0;
4882var $elm$url$Url$Https = 1;
4883var $elm$url$Url$Url = F6(
4884 function (protocol, host, port_, path, query, fragment) {
4885 return {db: fragment, dd: host, dv: path, dx: port_, dB: protocol, dC: query};
4886 });
4887var $elm$core$String$contains = _String_contains;
4888var $elm$core$String$length = _String_length;
4889var $elm$core$String$slice = _String_slice;
4890var $elm$core$String$dropLeft = F2(
4891 function (n, string) {
4892 return (n < 1) ? string : A3(
4893 $elm$core$String$slice,
4894 n,
4895 $elm$core$String$length(string),
4896 string);
4897 });
4898var $elm$core$String$indexes = _String_indexes;
4899var $elm$core$String$isEmpty = function (string) {
4900 return string === '';
4901};
4902var $elm$core$String$left = F2(
4903 function (n, string) {
4904 return (n < 1) ? '' : A3($elm$core$String$slice, 0, n, string);
4905 });
4906var $elm$core$String$toInt = _String_toInt;
4907var $elm$url$Url$chompBeforePath = F5(
4908 function (protocol, path, params, frag, str) {
4909 if ($elm$core$String$isEmpty(str) || A2($elm$core$String$contains, '@', str)) {
4910 return $elm$core$Maybe$Nothing;
4911 } else {
4912 var _v0 = A2($elm$core$String$indexes, ':', str);
4913 if (!_v0.b) {
4914 return $elm$core$Maybe$Just(
4915 A6($elm$url$Url$Url, protocol, str, $elm$core$Maybe$Nothing, path, params, frag));
4916 } else {
4917 if (!_v0.b.b) {
4918 var i = _v0.a;
4919 var _v1 = $elm$core$String$toInt(
4920 A2($elm$core$String$dropLeft, i + 1, str));
4921 if (_v1.$ === 1) {
4922 return $elm$core$Maybe$Nothing;
4923 } else {
4924 var port_ = _v1;
4925 return $elm$core$Maybe$Just(
4926 A6(
4927 $elm$url$Url$Url,
4928 protocol,
4929 A2($elm$core$String$left, i, str),
4930 port_,
4931 path,
4932 params,
4933 frag));
4934 }
4935 } else {
4936 return $elm$core$Maybe$Nothing;
4937 }
4938 }
4939 }
4940 });
4941var $elm$url$Url$chompBeforeQuery = F4(
4942 function (protocol, params, frag, str) {
4943 if ($elm$core$String$isEmpty(str)) {
4944 return $elm$core$Maybe$Nothing;
4945 } else {
4946 var _v0 = A2($elm$core$String$indexes, '/', str);
4947 if (!_v0.b) {
4948 return A5($elm$url$Url$chompBeforePath, protocol, '/', params, frag, str);
4949 } else {
4950 var i = _v0.a;
4951 return A5(
4952 $elm$url$Url$chompBeforePath,
4953 protocol,
4954 A2($elm$core$String$dropLeft, i, str),
4955 params,
4956 frag,
4957 A2($elm$core$String$left, i, str));
4958 }
4959 }
4960 });
4961var $elm$url$Url$chompBeforeFragment = F3(
4962 function (protocol, frag, str) {
4963 if ($elm$core$String$isEmpty(str)) {
4964 return $elm$core$Maybe$Nothing;
4965 } else {
4966 var _v0 = A2($elm$core$String$indexes, '?', str);
4967 if (!_v0.b) {
4968 return A4($elm$url$Url$chompBeforeQuery, protocol, $elm$core$Maybe$Nothing, frag, str);
4969 } else {
4970 var i = _v0.a;
4971 return A4(
4972 $elm$url$Url$chompBeforeQuery,
4973 protocol,
4974 $elm$core$Maybe$Just(
4975 A2($elm$core$String$dropLeft, i + 1, str)),
4976 frag,
4977 A2($elm$core$String$left, i, str));
4978 }
4979 }
4980 });
4981var $elm$url$Url$chompAfterProtocol = F2(
4982 function (protocol, str) {
4983 if ($elm$core$String$isEmpty(str)) {
4984 return $elm$core$Maybe$Nothing;
4985 } else {
4986 var _v0 = A2($elm$core$String$indexes, '#', str);
4987 if (!_v0.b) {
4988 return A3($elm$url$Url$chompBeforeFragment, protocol, $elm$core$Maybe$Nothing, str);
4989 } else {
4990 var i = _v0.a;
4991 return A3(
4992 $elm$url$Url$chompBeforeFragment,
4993 protocol,
4994 $elm$core$Maybe$Just(
4995 A2($elm$core$String$dropLeft, i + 1, str)),
4996 A2($elm$core$String$left, i, str));
4997 }
4998 }
4999 });
5000var $elm$core$String$startsWith = _String_startsWith;
5001var $elm$url$Url$fromString = function (str) {
5002 return A2($elm$core$String$startsWith, 'http://', str) ? A2(
5003 $elm$url$Url$chompAfterProtocol,
5004 0,
5005 A2($elm$core$String$dropLeft, 7, str)) : (A2($elm$core$String$startsWith, 'https://', str) ? A2(
5006 $elm$url$Url$chompAfterProtocol,
5007 1,
5008 A2($elm$core$String$dropLeft, 8, str)) : $elm$core$Maybe$Nothing);
5009};
5010var $elm$core$Basics$never = function (_v0) {
5011 never:
5012 while (true) {
5013 var nvr = _v0;
5014 var $temp$_v0 = nvr;
5015 _v0 = $temp$_v0;
5016 continue never;
5017 }
5018};
5019var $elm$core$Task$Perform = $elm$core$Basics$identity;
5020var $elm$core$Task$succeed = _Scheduler_succeed;
5021var $elm$core$Task$init = $elm$core$Task$succeed(0);
5022var $elm$core$List$foldrHelper = F4(
5023 function (fn, acc, ctr, ls) {
5024 if (!ls.b) {
5025 return acc;
5026 } else {
5027 var a = ls.a;
5028 var r1 = ls.b;
5029 if (!r1.b) {
5030 return A2(fn, a, acc);
5031 } else {
5032 var b = r1.a;
5033 var r2 = r1.b;
5034 if (!r2.b) {
5035 return A2(
5036 fn,
5037 a,
5038 A2(fn, b, acc));
5039 } else {
5040 var c = r2.a;
5041 var r3 = r2.b;
5042 if (!r3.b) {
5043 return A2(
5044 fn,
5045 a,
5046 A2(
5047 fn,
5048 b,
5049 A2(fn, c, acc)));
5050 } else {
5051 var d = r3.a;
5052 var r4 = r3.b;
5053 var res = (ctr > 500) ? A3(
5054 $elm$core$List$foldl,
5055 fn,
5056 acc,
5057 $elm$core$List$reverse(r4)) : A4($elm$core$List$foldrHelper, fn, acc, ctr + 1, r4);
5058 return A2(
5059 fn,
5060 a,
5061 A2(
5062 fn,
5063 b,
5064 A2(
5065 fn,
5066 c,
5067 A2(fn, d, res))));
5068 }
5069 }
5070 }
5071 }
5072 });
5073var $elm$core$List$foldr = F3(
5074 function (fn, acc, ls) {
5075 return A4($elm$core$List$foldrHelper, fn, acc, 0, ls);
5076 });
5077var $elm$core$List$map = F2(
5078 function (f, xs) {
5079 return A3(
5080 $elm$core$List$foldr,
5081 F2(
5082 function (x, acc) {
5083 return A2(
5084 $elm$core$List$cons,
5085 f(x),
5086 acc);
5087 }),
5088 _List_Nil,
5089 xs);
5090 });
5091var $elm$core$Task$andThen = _Scheduler_andThen;
5092var $elm$core$Task$map = F2(
5093 function (func, taskA) {
5094 return A2(
5095 $elm$core$Task$andThen,
5096 function (a) {
5097 return $elm$core$Task$succeed(
5098 func(a));
5099 },
5100 taskA);
5101 });
5102var $elm$core$Task$map2 = F3(
5103 function (func, taskA, taskB) {
5104 return A2(
5105 $elm$core$Task$andThen,
5106 function (a) {
5107 return A2(
5108 $elm$core$Task$andThen,
5109 function (b) {
5110 return $elm$core$Task$succeed(
5111 A2(func, a, b));
5112 },
5113 taskB);
5114 },
5115 taskA);
5116 });
5117var $elm$core$Task$sequence = function (tasks) {
5118 return A3(
5119 $elm$core$List$foldr,
5120 $elm$core$Task$map2($elm$core$List$cons),
5121 $elm$core$Task$succeed(_List_Nil),
5122 tasks);
5123};
5124var $elm$core$Platform$sendToApp = _Platform_sendToApp;
5125var $elm$core$Task$spawnCmd = F2(
5126 function (router, _v0) {
5127 var task = _v0;
5128 return _Scheduler_spawn(
5129 A2(
5130 $elm$core$Task$andThen,
5131 $elm$core$Platform$sendToApp(router),
5132 task));
5133 });
5134var $elm$core$Task$onEffects = F3(
5135 function (router, commands, state) {
5136 return A2(
5137 $elm$core$Task$map,
5138 function (_v0) {
5139 return 0;
5140 },
5141 $elm$core$Task$sequence(
5142 A2(
5143 $elm$core$List$map,
5144 $elm$core$Task$spawnCmd(router),
5145 commands)));
5146 });
5147var $elm$core$Task$onSelfMsg = F3(
5148 function (_v0, _v1, _v2) {
5149 return $elm$core$Task$succeed(0);
5150 });
5151var $elm$core$Task$cmdMap = F2(
5152 function (tagger, _v0) {
5153 var task = _v0;
5154 return A2($elm$core$Task$map, tagger, task);
5155 });
5156_Platform_effectManagers['Task'] = _Platform_createManager($elm$core$Task$init, $elm$core$Task$onEffects, $elm$core$Task$onSelfMsg, $elm$core$Task$cmdMap);
5157var $elm$core$Task$command = _Platform_leaf('Task');
5158var $elm$core$Task$perform = F2(
5159 function (toMessage, task) {
5160 return $elm$core$Task$command(
5161 A2($elm$core$Task$map, toMessage, task));
5162 });
5163var $elm$browser$Browser$application = _Browser_application;
5164var $author$project$Main$NavbarMsg = function (a) {
5165 return {$: 3, a: a};
5166};
5167var $author$project$Main$NotFound = 4;
5168var $mdgriffith$elm_animator$Internal$Timeline$Timeline = $elm$core$Basics$identity;
5169var $mdgriffith$elm_animator$Internal$Timeline$Timetable = $elm$core$Basics$identity;
5170var $ianmackenzie$elm_units$Quantity$Quantity = $elm$core$Basics$identity;
5171var $elm$time$Time$posixToMillis = function (_v0) {
5172 var millis = _v0;
5173 return millis;
5174};
5175var $mdgriffith$elm_animator$Internal$Time$absolute = function (posix) {
5176 return $elm$time$Time$posixToMillis(posix);
5177};
5178var $elm$time$Time$Posix = $elm$core$Basics$identity;
5179var $elm$time$Time$millisToPosix = $elm$core$Basics$identity;
5180var $mdgriffith$elm_animator$Animator$init = function (first) {
5181 return {
5182 da: _List_Nil,
5183 dh: first,
5184 aC: _List_Nil,
5185 ds: $mdgriffith$elm_animator$Internal$Time$absolute(
5186 $elm$time$Time$millisToPosix(0)),
5187 aN: $elm$core$Maybe$Nothing,
5188 b7: true
5189 };
5190};
5191var $rundis$elm_bootstrap$Bootstrap$Navbar$Hidden = 0;
5192var $rundis$elm_bootstrap$Bootstrap$Navbar$State = $elm$core$Basics$identity;
5193var $elm$core$Dict$RBEmpty_elm_builtin = {$: -2};
5194var $elm$core$Dict$empty = $elm$core$Dict$RBEmpty_elm_builtin;
5195var $elm$browser$Browser$Dom$getViewport = _Browser_withWindow(_Browser_getViewport);
5196var $rundis$elm_bootstrap$Bootstrap$Navbar$mapState = F2(
5197 function (mapper, _v0) {
5198 var state = _v0;
5199 return mapper(state);
5200 });
5201var $rundis$elm_bootstrap$Bootstrap$Navbar$initWindowSize = F2(
5202 function (toMsg, state) {
5203 return A2(
5204 $elm$core$Task$perform,
5205 function (vp) {
5206 return toMsg(
5207 A2(
5208 $rundis$elm_bootstrap$Bootstrap$Navbar$mapState,
5209 function (s) {
5210 return _Utils_update(
5211 s,
5212 {
5213 a_: $elm$core$Maybe$Just(vp.dW.dX)
5214 });
5215 },
5216 state));
5217 },
5218 $elm$browser$Browser$Dom$getViewport);
5219 });
5220var $rundis$elm_bootstrap$Bootstrap$Navbar$initialState = function (toMsg) {
5221 var state = {O: $elm$core$Dict$empty, dc: $elm$core$Maybe$Nothing, j: 0, a_: $elm$core$Maybe$Nothing};
5222 return _Utils_Tuple2(
5223 state,
5224 A2($rundis$elm_bootstrap$Bootstrap$Navbar$initWindowSize, toMsg, state));
5225};
5226var $elm$url$Url$Parser$State = F5(
5227 function (visited, unvisited, params, frag, value) {
5228 return {P: frag, R: params, L: unvisited, C: value, U: visited};
5229 });
5230var $elm$url$Url$Parser$getFirstMatch = function (states) {
5231 getFirstMatch:
5232 while (true) {
5233 if (!states.b) {
5234 return $elm$core$Maybe$Nothing;
5235 } else {
5236 var state = states.a;
5237 var rest = states.b;
5238 var _v1 = state.L;
5239 if (!_v1.b) {
5240 return $elm$core$Maybe$Just(state.C);
5241 } else {
5242 if ((_v1.a === '') && (!_v1.b.b)) {
5243 return $elm$core$Maybe$Just(state.C);
5244 } else {
5245 var $temp$states = rest;
5246 states = $temp$states;
5247 continue getFirstMatch;
5248 }
5249 }
5250 }
5251 }
5252};
5253var $elm$url$Url$Parser$removeFinalEmpty = function (segments) {
5254 if (!segments.b) {
5255 return _List_Nil;
5256 } else {
5257 if ((segments.a === '') && (!segments.b.b)) {
5258 return _List_Nil;
5259 } else {
5260 var segment = segments.a;
5261 var rest = segments.b;
5262 return A2(
5263 $elm$core$List$cons,
5264 segment,
5265 $elm$url$Url$Parser$removeFinalEmpty(rest));
5266 }
5267 }
5268};
5269var $elm$url$Url$Parser$preparePath = function (path) {
5270 var _v0 = A2($elm$core$String$split, '/', path);
5271 if (_v0.b && (_v0.a === '')) {
5272 var segments = _v0.b;
5273 return $elm$url$Url$Parser$removeFinalEmpty(segments);
5274 } else {
5275 var segments = _v0;
5276 return $elm$url$Url$Parser$removeFinalEmpty(segments);
5277 }
5278};
5279var $elm$url$Url$Parser$addToParametersHelp = F2(
5280 function (value, maybeList) {
5281 if (maybeList.$ === 1) {
5282 return $elm$core$Maybe$Just(
5283 _List_fromArray(
5284 [value]));
5285 } else {
5286 var list = maybeList.a;
5287 return $elm$core$Maybe$Just(
5288 A2($elm$core$List$cons, value, list));
5289 }
5290 });
5291var $elm$url$Url$percentDecode = _Url_percentDecode;
5292var $elm$core$Basics$compare = _Utils_compare;
5293var $elm$core$Dict$get = F2(
5294 function (targetKey, dict) {
5295 get:
5296 while (true) {
5297 if (dict.$ === -2) {
5298 return $elm$core$Maybe$Nothing;
5299 } else {
5300 var key = dict.b;
5301 var value = dict.c;
5302 var left = dict.d;
5303 var right = dict.e;
5304 var _v1 = A2($elm$core$Basics$compare, targetKey, key);
5305 switch (_v1) {
5306 case 0:
5307 var $temp$targetKey = targetKey,
5308 $temp$dict = left;
5309 targetKey = $temp$targetKey;
5310 dict = $temp$dict;
5311 continue get;
5312 case 1:
5313 return $elm$core$Maybe$Just(value);
5314 default:
5315 var $temp$targetKey = targetKey,
5316 $temp$dict = right;
5317 targetKey = $temp$targetKey;
5318 dict = $temp$dict;
5319 continue get;
5320 }
5321 }
5322 }
5323 });
5324var $elm$core$Dict$Black = 1;
5325var $elm$core$Dict$RBNode_elm_builtin = F5(
5326 function (a, b, c, d, e) {
5327 return {$: -1, a: a, b: b, c: c, d: d, e: e};
5328 });
5329var $elm$core$Dict$Red = 0;
5330var $elm$core$Dict$balance = F5(
5331 function (color, key, value, left, right) {
5332 if ((right.$ === -1) && (!right.a)) {
5333 var _v1 = right.a;
5334 var rK = right.b;
5335 var rV = right.c;
5336 var rLeft = right.d;
5337 var rRight = right.e;
5338 if ((left.$ === -1) && (!left.a)) {
5339 var _v3 = left.a;
5340 var lK = left.b;
5341 var lV = left.c;
5342 var lLeft = left.d;
5343 var lRight = left.e;
5344 return A5(
5345 $elm$core$Dict$RBNode_elm_builtin,
5346 0,
5347 key,
5348 value,
5349 A5($elm$core$Dict$RBNode_elm_builtin, 1, lK, lV, lLeft, lRight),
5350 A5($elm$core$Dict$RBNode_elm_builtin, 1, rK, rV, rLeft, rRight));
5351 } else {
5352 return A5(
5353 $elm$core$Dict$RBNode_elm_builtin,
5354 color,
5355 rK,
5356 rV,
5357 A5($elm$core$Dict$RBNode_elm_builtin, 0, key, value, left, rLeft),
5358 rRight);
5359 }
5360 } else {
5361 if ((((left.$ === -1) && (!left.a)) && (left.d.$ === -1)) && (!left.d.a)) {
5362 var _v5 = left.a;
5363 var lK = left.b;
5364 var lV = left.c;
5365 var _v6 = left.d;
5366 var _v7 = _v6.a;
5367 var llK = _v6.b;
5368 var llV = _v6.c;
5369 var llLeft = _v6.d;
5370 var llRight = _v6.e;
5371 var lRight = left.e;
5372 return A5(
5373 $elm$core$Dict$RBNode_elm_builtin,
5374 0,
5375 lK,
5376 lV,
5377 A5($elm$core$Dict$RBNode_elm_builtin, 1, llK, llV, llLeft, llRight),
5378 A5($elm$core$Dict$RBNode_elm_builtin, 1, key, value, lRight, right));
5379 } else {
5380 return A5($elm$core$Dict$RBNode_elm_builtin, color, key, value, left, right);
5381 }
5382 }
5383 });
5384var $elm$core$Dict$insertHelp = F3(
5385 function (key, value, dict) {
5386 if (dict.$ === -2) {
5387 return A5($elm$core$Dict$RBNode_elm_builtin, 0, key, value, $elm$core$Dict$RBEmpty_elm_builtin, $elm$core$Dict$RBEmpty_elm_builtin);
5388 } else {
5389 var nColor = dict.a;
5390 var nKey = dict.b;
5391 var nValue = dict.c;
5392 var nLeft = dict.d;
5393 var nRight = dict.e;
5394 var _v1 = A2($elm$core$Basics$compare, key, nKey);
5395 switch (_v1) {
5396 case 0:
5397 return A5(
5398 $elm$core$Dict$balance,
5399 nColor,
5400 nKey,
5401 nValue,
5402 A3($elm$core$Dict$insertHelp, key, value, nLeft),
5403 nRight);
5404 case 1:
5405 return A5($elm$core$Dict$RBNode_elm_builtin, nColor, nKey, value, nLeft, nRight);
5406 default:
5407 return A5(
5408 $elm$core$Dict$balance,
5409 nColor,
5410 nKey,
5411 nValue,
5412 nLeft,
5413 A3($elm$core$Dict$insertHelp, key, value, nRight));
5414 }
5415 }
5416 });
5417var $elm$core$Dict$insert = F3(
5418 function (key, value, dict) {
5419 var _v0 = A3($elm$core$Dict$insertHelp, key, value, dict);
5420 if ((_v0.$ === -1) && (!_v0.a)) {
5421 var _v1 = _v0.a;
5422 var k = _v0.b;
5423 var v = _v0.c;
5424 var l = _v0.d;
5425 var r = _v0.e;
5426 return A5($elm$core$Dict$RBNode_elm_builtin, 1, k, v, l, r);
5427 } else {
5428 var x = _v0;
5429 return x;
5430 }
5431 });
5432var $elm$core$Dict$getMin = function (dict) {
5433 getMin:
5434 while (true) {
5435 if ((dict.$ === -1) && (dict.d.$ === -1)) {
5436 var left = dict.d;
5437 var $temp$dict = left;
5438 dict = $temp$dict;
5439 continue getMin;
5440 } else {
5441 return dict;
5442 }
5443 }
5444};
5445var $elm$core$Dict$moveRedLeft = function (dict) {
5446 if (((dict.$ === -1) && (dict.d.$ === -1)) && (dict.e.$ === -1)) {
5447 if ((dict.e.d.$ === -1) && (!dict.e.d.a)) {
5448 var clr = dict.a;
5449 var k = dict.b;
5450 var v = dict.c;
5451 var _v1 = dict.d;
5452 var lClr = _v1.a;
5453 var lK = _v1.b;
5454 var lV = _v1.c;
5455 var lLeft = _v1.d;
5456 var lRight = _v1.e;
5457 var _v2 = dict.e;
5458 var rClr = _v2.a;
5459 var rK = _v2.b;
5460 var rV = _v2.c;
5461 var rLeft = _v2.d;
5462 var _v3 = rLeft.a;
5463 var rlK = rLeft.b;
5464 var rlV = rLeft.c;
5465 var rlL = rLeft.d;
5466 var rlR = rLeft.e;
5467 var rRight = _v2.e;
5468 return A5(
5469 $elm$core$Dict$RBNode_elm_builtin,
5470 0,
5471 rlK,
5472 rlV,
5473 A5(
5474 $elm$core$Dict$RBNode_elm_builtin,
5475 1,
5476 k,
5477 v,
5478 A5($elm$core$Dict$RBNode_elm_builtin, 0, lK, lV, lLeft, lRight),
5479 rlL),
5480 A5($elm$core$Dict$RBNode_elm_builtin, 1, rK, rV, rlR, rRight));
5481 } else {
5482 var clr = dict.a;
5483 var k = dict.b;
5484 var v = dict.c;
5485 var _v4 = dict.d;
5486 var lClr = _v4.a;
5487 var lK = _v4.b;
5488 var lV = _v4.c;
5489 var lLeft = _v4.d;
5490 var lRight = _v4.e;
5491 var _v5 = dict.e;
5492 var rClr = _v5.a;
5493 var rK = _v5.b;
5494 var rV = _v5.c;
5495 var rLeft = _v5.d;
5496 var rRight = _v5.e;
5497 if (clr === 1) {
5498 return A5(
5499 $elm$core$Dict$RBNode_elm_builtin,
5500 1,
5501 k,
5502 v,
5503 A5($elm$core$Dict$RBNode_elm_builtin, 0, lK, lV, lLeft, lRight),
5504 A5($elm$core$Dict$RBNode_elm_builtin, 0, rK, rV, rLeft, rRight));
5505 } else {
5506 return A5(
5507 $elm$core$Dict$RBNode_elm_builtin,
5508 1,
5509 k,
5510 v,
5511 A5($elm$core$Dict$RBNode_elm_builtin, 0, lK, lV, lLeft, lRight),
5512 A5($elm$core$Dict$RBNode_elm_builtin, 0, rK, rV, rLeft, rRight));
5513 }
5514 }
5515 } else {
5516 return dict;
5517 }
5518};
5519var $elm$core$Dict$moveRedRight = function (dict) {
5520 if (((dict.$ === -1) && (dict.d.$ === -1)) && (dict.e.$ === -1)) {
5521 if ((dict.d.d.$ === -1) && (!dict.d.d.a)) {
5522 var clr = dict.a;
5523 var k = dict.b;
5524 var v = dict.c;
5525 var _v1 = dict.d;
5526 var lClr = _v1.a;
5527 var lK = _v1.b;
5528 var lV = _v1.c;
5529 var _v2 = _v1.d;
5530 var _v3 = _v2.a;
5531 var llK = _v2.b;
5532 var llV = _v2.c;
5533 var llLeft = _v2.d;
5534 var llRight = _v2.e;
5535 var lRight = _v1.e;
5536 var _v4 = dict.e;
5537 var rClr = _v4.a;
5538 var rK = _v4.b;
5539 var rV = _v4.c;
5540 var rLeft = _v4.d;
5541 var rRight = _v4.e;
5542 return A5(
5543 $elm$core$Dict$RBNode_elm_builtin,
5544 0,
5545 lK,
5546 lV,
5547 A5($elm$core$Dict$RBNode_elm_builtin, 1, llK, llV, llLeft, llRight),
5548 A5(
5549 $elm$core$Dict$RBNode_elm_builtin,
5550 1,
5551 k,
5552 v,
5553 lRight,
5554 A5($elm$core$Dict$RBNode_elm_builtin, 0, rK, rV, rLeft, rRight)));
5555 } else {
5556 var clr = dict.a;
5557 var k = dict.b;
5558 var v = dict.c;
5559 var _v5 = dict.d;
5560 var lClr = _v5.a;
5561 var lK = _v5.b;
5562 var lV = _v5.c;
5563 var lLeft = _v5.d;
5564 var lRight = _v5.e;
5565 var _v6 = dict.e;
5566 var rClr = _v6.a;
5567 var rK = _v6.b;
5568 var rV = _v6.c;
5569 var rLeft = _v6.d;
5570 var rRight = _v6.e;
5571 if (clr === 1) {
5572 return A5(
5573 $elm$core$Dict$RBNode_elm_builtin,
5574 1,
5575 k,
5576 v,
5577 A5($elm$core$Dict$RBNode_elm_builtin, 0, lK, lV, lLeft, lRight),
5578 A5($elm$core$Dict$RBNode_elm_builtin, 0, rK, rV, rLeft, rRight));
5579 } else {
5580 return A5(
5581 $elm$core$Dict$RBNode_elm_builtin,
5582 1,
5583 k,
5584 v,
5585 A5($elm$core$Dict$RBNode_elm_builtin, 0, lK, lV, lLeft, lRight),
5586 A5($elm$core$Dict$RBNode_elm_builtin, 0, rK, rV, rLeft, rRight));
5587 }
5588 }
5589 } else {
5590 return dict;
5591 }
5592};
5593var $elm$core$Dict$removeHelpPrepEQGT = F7(
5594 function (targetKey, dict, color, key, value, left, right) {
5595 if ((left.$ === -1) && (!left.a)) {
5596 var _v1 = left.a;
5597 var lK = left.b;
5598 var lV = left.c;
5599 var lLeft = left.d;
5600 var lRight = left.e;
5601 return A5(
5602 $elm$core$Dict$RBNode_elm_builtin,
5603 color,
5604 lK,
5605 lV,
5606 lLeft,
5607 A5($elm$core$Dict$RBNode_elm_builtin, 0, key, value, lRight, right));
5608 } else {
5609 _v2$2:
5610 while (true) {
5611 if ((right.$ === -1) && (right.a === 1)) {
5612 if (right.d.$ === -1) {
5613 if (right.d.a === 1) {
5614 var _v3 = right.a;
5615 var _v4 = right.d;
5616 var _v5 = _v4.a;
5617 return $elm$core$Dict$moveRedRight(dict);
5618 } else {
5619 break _v2$2;
5620 }
5621 } else {
5622 var _v6 = right.a;
5623 var _v7 = right.d;
5624 return $elm$core$Dict$moveRedRight(dict);
5625 }
5626 } else {
5627 break _v2$2;
5628 }
5629 }
5630 return dict;
5631 }
5632 });
5633var $elm$core$Dict$removeMin = function (dict) {
5634 if ((dict.$ === -1) && (dict.d.$ === -1)) {
5635 var color = dict.a;
5636 var key = dict.b;
5637 var value = dict.c;
5638 var left = dict.d;
5639 var lColor = left.a;
5640 var lLeft = left.d;
5641 var right = dict.e;
5642 if (lColor === 1) {
5643 if ((lLeft.$ === -1) && (!lLeft.a)) {
5644 var _v3 = lLeft.a;
5645 return A5(
5646 $elm$core$Dict$RBNode_elm_builtin,
5647 color,
5648 key,
5649 value,
5650 $elm$core$Dict$removeMin(left),
5651 right);
5652 } else {
5653 var _v4 = $elm$core$Dict$moveRedLeft(dict);
5654 if (_v4.$ === -1) {
5655 var nColor = _v4.a;
5656 var nKey = _v4.b;
5657 var nValue = _v4.c;
5658 var nLeft = _v4.d;
5659 var nRight = _v4.e;
5660 return A5(
5661 $elm$core$Dict$balance,
5662 nColor,
5663 nKey,
5664 nValue,
5665 $elm$core$Dict$removeMin(nLeft),
5666 nRight);
5667 } else {
5668 return $elm$core$Dict$RBEmpty_elm_builtin;
5669 }
5670 }
5671 } else {
5672 return A5(
5673 $elm$core$Dict$RBNode_elm_builtin,
5674 color,
5675 key,
5676 value,
5677 $elm$core$Dict$removeMin(left),
5678 right);
5679 }
5680 } else {
5681 return $elm$core$Dict$RBEmpty_elm_builtin;
5682 }
5683};
5684var $elm$core$Dict$removeHelp = F2(
5685 function (targetKey, dict) {
5686 if (dict.$ === -2) {
5687 return $elm$core$Dict$RBEmpty_elm_builtin;
5688 } else {
5689 var color = dict.a;
5690 var key = dict.b;
5691 var value = dict.c;
5692 var left = dict.d;
5693 var right = dict.e;
5694 if (_Utils_cmp(targetKey, key) < 0) {
5695 if ((left.$ === -1) && (left.a === 1)) {
5696 var _v4 = left.a;
5697 var lLeft = left.d;
5698 if ((lLeft.$ === -1) && (!lLeft.a)) {
5699 var _v6 = lLeft.a;
5700 return A5(
5701 $elm$core$Dict$RBNode_elm_builtin,
5702 color,
5703 key,
5704 value,
5705 A2($elm$core$Dict$removeHelp, targetKey, left),
5706 right);
5707 } else {
5708 var _v7 = $elm$core$Dict$moveRedLeft(dict);
5709 if (_v7.$ === -1) {
5710 var nColor = _v7.a;
5711 var nKey = _v7.b;
5712 var nValue = _v7.c;
5713 var nLeft = _v7.d;
5714 var nRight = _v7.e;
5715 return A5(
5716 $elm$core$Dict$balance,
5717 nColor,
5718 nKey,
5719 nValue,
5720 A2($elm$core$Dict$removeHelp, targetKey, nLeft),
5721 nRight);
5722 } else {
5723 return $elm$core$Dict$RBEmpty_elm_builtin;
5724 }
5725 }
5726 } else {
5727 return A5(
5728 $elm$core$Dict$RBNode_elm_builtin,
5729 color,
5730 key,
5731 value,
5732 A2($elm$core$Dict$removeHelp, targetKey, left),
5733 right);
5734 }
5735 } else {
5736 return A2(
5737 $elm$core$Dict$removeHelpEQGT,
5738 targetKey,
5739 A7($elm$core$Dict$removeHelpPrepEQGT, targetKey, dict, color, key, value, left, right));
5740 }
5741 }
5742 });
5743var $elm$core$Dict$removeHelpEQGT = F2(
5744 function (targetKey, dict) {
5745 if (dict.$ === -1) {
5746 var color = dict.a;
5747 var key = dict.b;
5748 var value = dict.c;
5749 var left = dict.d;
5750 var right = dict.e;
5751 if (_Utils_eq(targetKey, key)) {
5752 var _v1 = $elm$core$Dict$getMin(right);
5753 if (_v1.$ === -1) {
5754 var minKey = _v1.b;
5755 var minValue = _v1.c;
5756 return A5(
5757 $elm$core$Dict$balance,
5758 color,
5759 minKey,
5760 minValue,
5761 left,
5762 $elm$core$Dict$removeMin(right));
5763 } else {
5764 return $elm$core$Dict$RBEmpty_elm_builtin;
5765 }
5766 } else {
5767 return A5(
5768 $elm$core$Dict$balance,
5769 color,
5770 key,
5771 value,
5772 left,
5773 A2($elm$core$Dict$removeHelp, targetKey, right));
5774 }
5775 } else {
5776 return $elm$core$Dict$RBEmpty_elm_builtin;
5777 }
5778 });
5779var $elm$core$Dict$remove = F2(
5780 function (key, dict) {
5781 var _v0 = A2($elm$core$Dict$removeHelp, key, dict);
5782 if ((_v0.$ === -1) && (!_v0.a)) {
5783 var _v1 = _v0.a;
5784 var k = _v0.b;
5785 var v = _v0.c;
5786 var l = _v0.d;
5787 var r = _v0.e;
5788 return A5($elm$core$Dict$RBNode_elm_builtin, 1, k, v, l, r);
5789 } else {
5790 var x = _v0;
5791 return x;
5792 }
5793 });
5794var $elm$core$Dict$update = F3(
5795 function (targetKey, alter, dictionary) {
5796 var _v0 = alter(
5797 A2($elm$core$Dict$get, targetKey, dictionary));
5798 if (!_v0.$) {
5799 var value = _v0.a;
5800 return A3($elm$core$Dict$insert, targetKey, value, dictionary);
5801 } else {
5802 return A2($elm$core$Dict$remove, targetKey, dictionary);
5803 }
5804 });
5805var $elm$url$Url$Parser$addParam = F2(
5806 function (segment, dict) {
5807 var _v0 = A2($elm$core$String$split, '=', segment);
5808 if ((_v0.b && _v0.b.b) && (!_v0.b.b.b)) {
5809 var rawKey = _v0.a;
5810 var _v1 = _v0.b;
5811 var rawValue = _v1.a;
5812 var _v2 = $elm$url$Url$percentDecode(rawKey);
5813 if (_v2.$ === 1) {
5814 return dict;
5815 } else {
5816 var key = _v2.a;
5817 var _v3 = $elm$url$Url$percentDecode(rawValue);
5818 if (_v3.$ === 1) {
5819 return dict;
5820 } else {
5821 var value = _v3.a;
5822 return A3(
5823 $elm$core$Dict$update,
5824 key,
5825 $elm$url$Url$Parser$addToParametersHelp(value),
5826 dict);
5827 }
5828 }
5829 } else {
5830 return dict;
5831 }
5832 });
5833var $elm$url$Url$Parser$prepareQuery = function (maybeQuery) {
5834 if (maybeQuery.$ === 1) {
5835 return $elm$core$Dict$empty;
5836 } else {
5837 var qry = maybeQuery.a;
5838 return A3(
5839 $elm$core$List$foldr,
5840 $elm$url$Url$Parser$addParam,
5841 $elm$core$Dict$empty,
5842 A2($elm$core$String$split, '&', qry));
5843 }
5844};
5845var $elm$url$Url$Parser$parse = F2(
5846 function (_v0, url) {
5847 var parser = _v0;
5848 return $elm$url$Url$Parser$getFirstMatch(
5849 parser(
5850 A5(
5851 $elm$url$Url$Parser$State,
5852 _List_Nil,
5853 $elm$url$Url$Parser$preparePath(url.dv),
5854 $elm$url$Url$Parser$prepareQuery(url.dC),
5855 url.db,
5856 $elm$core$Basics$identity)));
5857 });
5858var $author$project$Main$About = 1;
5859var $author$project$Main$Blog = 2;
5860var $author$project$Main$Home = 0;
5861var $author$project$Main$Login = 3;
5862var $elm$url$Url$Parser$Parser = $elm$core$Basics$identity;
5863var $elm$url$Url$Parser$mapState = F2(
5864 function (func, _v0) {
5865 var visited = _v0.U;
5866 var unvisited = _v0.L;
5867 var params = _v0.R;
5868 var frag = _v0.P;
5869 var value = _v0.C;
5870 return A5(
5871 $elm$url$Url$Parser$State,
5872 visited,
5873 unvisited,
5874 params,
5875 frag,
5876 func(value));
5877 });
5878var $elm$url$Url$Parser$map = F2(
5879 function (subValue, _v0) {
5880 var parseArg = _v0;
5881 return function (_v1) {
5882 var visited = _v1.U;
5883 var unvisited = _v1.L;
5884 var params = _v1.R;
5885 var frag = _v1.P;
5886 var value = _v1.C;
5887 return A2(
5888 $elm$core$List$map,
5889 $elm$url$Url$Parser$mapState(value),
5890 parseArg(
5891 A5($elm$url$Url$Parser$State, visited, unvisited, params, frag, subValue)));
5892 };
5893 });
5894var $elm$core$List$append = F2(
5895 function (xs, ys) {
5896 if (!ys.b) {
5897 return xs;
5898 } else {
5899 return A3($elm$core$List$foldr, $elm$core$List$cons, ys, xs);
5900 }
5901 });
5902var $elm$core$List$concat = function (lists) {
5903 return A3($elm$core$List$foldr, $elm$core$List$append, _List_Nil, lists);
5904};
5905var $elm$core$List$concatMap = F2(
5906 function (f, list) {
5907 return $elm$core$List$concat(
5908 A2($elm$core$List$map, f, list));
5909 });
5910var $elm$url$Url$Parser$oneOf = function (parsers) {
5911 return function (state) {
5912 return A2(
5913 $elm$core$List$concatMap,
5914 function (_v0) {
5915 var parser = _v0;
5916 return parser(state);
5917 },
5918 parsers);
5919 };
5920};
5921var $elm$url$Url$Parser$s = function (str) {
5922 return function (_v0) {
5923 var visited = _v0.U;
5924 var unvisited = _v0.L;
5925 var params = _v0.R;
5926 var frag = _v0.P;
5927 var value = _v0.C;
5928 if (!unvisited.b) {
5929 return _List_Nil;
5930 } else {
5931 var next = unvisited.a;
5932 var rest = unvisited.b;
5933 return _Utils_eq(next, str) ? _List_fromArray(
5934 [
5935 A5(
5936 $elm$url$Url$Parser$State,
5937 A2($elm$core$List$cons, next, visited),
5938 rest,
5939 params,
5940 frag,
5941 value)
5942 ]) : _List_Nil;
5943 }
5944 };
5945};
5946var $elm$url$Url$Parser$top = function (state) {
5947 return _List_fromArray(
5948 [state]);
5949};
5950var $author$project$Main$urlParser = $elm$url$Url$Parser$oneOf(
5951 _List_fromArray(
5952 [
5953 A2($elm$url$Url$Parser$map, 0, $elm$url$Url$Parser$top),
5954 A2(
5955 $elm$url$Url$Parser$map,
5956 2,
5957 $elm$url$Url$Parser$s('blog')),
5958 A2(
5959 $elm$url$Url$Parser$map,
5960 1,
5961 $elm$url$Url$Parser$s('about')),
5962 A2(
5963 $elm$url$Url$Parser$map,
5964 3,
5965 $elm$url$Url$Parser$s('login'))
5966 ]));
5967var $elm$core$Maybe$withDefault = F2(
5968 function (_default, maybe) {
5969 if (!maybe.$) {
5970 var value = maybe.a;
5971 return value;
5972 } else {
5973 return _default;
5974 }
5975 });
5976var $author$project$Main$init = F3(
5977 function (_v0, url, navKey) {
5978 var initialPage = A2(
5979 $elm$core$Maybe$withDefault,
5980 4,
5981 A2($elm$url$Url$Parser$parse, $author$project$Main$urlParser, url));
5982 var _v1 = $rundis$elm_bootstrap$Bootstrap$Navbar$initialState($author$project$Main$NavbarMsg);
5983 var navbarState = _v1.a;
5984 var navbarCmd = _v1.b;
5985 return _Utils_Tuple2(
5986 {
5987 dg: 0,
5988 cA: '',
5989 cD: navKey,
5990 aK: navbarState,
5991 dq: false,
5992 x: $mdgriffith$elm_animator$Animator$init(initialPage),
5993 dD: _List_Nil
5994 },
5995 navbarCmd);
5996 });
5997var $author$project$Main$ReceivedDataFromJS = function (a) {
5998 return {$: 5, a: a};
5999};
6000var $author$project$Main$Tick = function (a) {
6001 return {$: 0, a: a};
6002};
6003var $mdgriffith$elm_animator$Internal$Timeline$Animator = F2(
6004 function (a, b) {
6005 return {$: 0, a: a, b: b};
6006 });
6007var $elm$core$Basics$always = F2(
6008 function (a, _v0) {
6009 return a;
6010 });
6011var $mdgriffith$elm_animator$Animator$animator = A2(
6012 $mdgriffith$elm_animator$Internal$Timeline$Animator,
6013 $elm$core$Basics$always(false),
6014 F2(
6015 function (now, model) {
6016 return model;
6017 }));
6018var $mdgriffith$elm_animator$Internal$Timeline$hasChanged = function (_v0) {
6019 var timeline = _v0;
6020 var _v1 = timeline.aN;
6021 if (_v1.$ === 1) {
6022 var _v2 = timeline.aC;
6023 if (!_v2.b) {
6024 return false;
6025 } else {
6026 return true;
6027 }
6028 } else {
6029 return true;
6030 }
6031};
6032var $mdgriffith$elm_animator$Internal$Timeline$justInitialized = function (_v0) {
6033 var timeline = _v0;
6034 var _v1 = timeline.ds;
6035 var qty = _v1;
6036 return !qty;
6037};
6038var $mdgriffith$elm_animator$Internal$Timeline$Line = F3(
6039 function (a, b, c) {
6040 return {$: 0, a: a, b: b, c: c};
6041 });
6042var $mdgriffith$elm_animator$Internal$Timeline$Occurring = F3(
6043 function (a, b, c) {
6044 return {$: 0, a: a, b: b, c: c};
6045 });
6046var $ianmackenzie$elm_units$Duration$inSeconds = function (_v0) {
6047 var numSeconds = _v0;
6048 return numSeconds;
6049};
6050var $ianmackenzie$elm_units$Duration$inMilliseconds = function (duration) {
6051 return $ianmackenzie$elm_units$Duration$inSeconds(duration) * 1000;
6052};
6053var $ianmackenzie$elm_units$Quantity$plus = F2(
6054 function (_v0, _v1) {
6055 var y = _v0;
6056 var x = _v1;
6057 return x + y;
6058 });
6059var $mdgriffith$elm_animator$Internal$Time$advanceBy = F2(
6060 function (dur, time) {
6061 return A2(
6062 $ianmackenzie$elm_units$Quantity$plus,
6063 time,
6064 $ianmackenzie$elm_units$Duration$inMilliseconds(dur));
6065 });
6066var $elm$core$Tuple$second = function (_v0) {
6067 var y = _v0.b;
6068 return y;
6069};
6070var $mdgriffith$elm_animator$Internal$Timeline$toOccurring = F2(
6071 function (_v0, _v1) {
6072 var duration = _v0.a;
6073 var event = _v0.b;
6074 var maybeDwell = _v0.c;
6075 var now = _v1.a;
6076 var events = _v1.b;
6077 var occursAt = A2($mdgriffith$elm_animator$Internal$Time$advanceBy, duration, now);
6078 var endsAt = function () {
6079 if (maybeDwell.$ === 1) {
6080 return occursAt;
6081 } else {
6082 var dwell = maybeDwell.a;
6083 return A2($mdgriffith$elm_animator$Internal$Time$advanceBy, dwell, occursAt);
6084 }
6085 }();
6086 return _Utils_Tuple2(
6087 endsAt,
6088 A2(
6089 $elm$core$List$cons,
6090 A3($mdgriffith$elm_animator$Internal$Timeline$Occurring, event, occursAt, endsAt),
6091 events));
6092 });
6093var $mdgriffith$elm_animator$Internal$Timeline$createLine = F2(
6094 function (now, scheduled) {
6095 var _v0 = scheduled.b;
6096 var dur = _v0.a;
6097 var startEvent = _v0.b;
6098 var maybeDwell = _v0.c;
6099 var reverseQueued = scheduled.c;
6100 var start = A2($mdgriffith$elm_animator$Internal$Time$advanceBy, dur, now);
6101 var startNextEvent = function () {
6102 if (maybeDwell.$ === 1) {
6103 return start;
6104 } else {
6105 var dwell = maybeDwell.a;
6106 return A2($mdgriffith$elm_animator$Internal$Time$advanceBy, dwell, start);
6107 }
6108 }();
6109 var events = $elm$core$List$reverse(
6110 A3(
6111 $elm$core$List$foldl,
6112 $mdgriffith$elm_animator$Internal$Timeline$toOccurring,
6113 _Utils_Tuple2(startNextEvent, _List_Nil),
6114 $elm$core$List$reverse(reverseQueued)).b);
6115 return A3(
6116 $mdgriffith$elm_animator$Internal$Timeline$Line,
6117 now,
6118 A3($mdgriffith$elm_animator$Internal$Timeline$Occurring, startEvent, start, startNextEvent),
6119 events);
6120 });
6121var $mdgriffith$elm_animator$Internal$Timeline$endTime = function (_v0) {
6122 var end = _v0.c;
6123 return end;
6124};
6125var $mdgriffith$elm_animator$Internal$Time$latest = F2(
6126 function (oneQty, twoQty) {
6127 var one = oneQty;
6128 var two = twoQty;
6129 return ((one - two) <= 0) ? twoQty : oneQty;
6130 });
6131var $mdgriffith$elm_animator$Internal$Time$thisAfterThat = F2(
6132 function (_v0, _v1) {
6133 var _this = _v0;
6134 var that = _v1;
6135 return (_this - that) > 0;
6136 });
6137var $mdgriffith$elm_animator$Internal$Timeline$addEventsToLine = F4(
6138 function (now, scheduled, existing, lines) {
6139 var delay = scheduled.a;
6140 var scheduledStartingEvent = scheduled.b;
6141 var reverseQueued = scheduled.c;
6142 var startLineAt = existing.a;
6143 var startingEvent = existing.b;
6144 var events = existing.c;
6145 var start = A2($mdgriffith$elm_animator$Internal$Time$advanceBy, delay, now);
6146 var _v0 = $elm$core$List$reverse(events);
6147 if (!_v0.b) {
6148 var startingEventWithDwell = function () {
6149 var ev = startingEvent.a;
6150 var lastEventTime = startingEvent.b;
6151 return A2($mdgriffith$elm_animator$Internal$Time$thisAfterThat, start, lastEventTime) ? A3($mdgriffith$elm_animator$Internal$Timeline$Occurring, ev, lastEventTime, start) : A3($mdgriffith$elm_animator$Internal$Timeline$Occurring, ev, lastEventTime, lastEventTime);
6152 }();
6153 var startNewEventsAt = A2(
6154 $mdgriffith$elm_animator$Internal$Time$latest,
6155 A2(
6156 $mdgriffith$elm_animator$Internal$Time$advanceBy,
6157 delay,
6158 $mdgriffith$elm_animator$Internal$Timeline$endTime(startingEvent)),
6159 start);
6160 var newLine = A2($mdgriffith$elm_animator$Internal$Timeline$createLine, startNewEventsAt, scheduled);
6161 return A2(
6162 $elm$core$List$cons,
6163 A3($mdgriffith$elm_animator$Internal$Timeline$Line, startLineAt, startingEventWithDwell, _List_Nil),
6164 A2($elm$core$List$cons, newLine, lines));
6165 } else {
6166 var _v2 = _v0.a;
6167 var lastEvent = _v2.a;
6168 var lastEventTime = _v2.b;
6169 var lastEventFinish = _v2.c;
6170 var eventTail = _v0.b;
6171 var startNewEventsAt = A2(
6172 $mdgriffith$elm_animator$Internal$Time$latest,
6173 A2($mdgriffith$elm_animator$Internal$Time$advanceBy, delay, lastEventFinish),
6174 start);
6175 var newLine = A2($mdgriffith$elm_animator$Internal$Timeline$createLine, startNewEventsAt, scheduled);
6176 var newLastEvent = A3($mdgriffith$elm_animator$Internal$Timeline$Occurring, lastEvent, lastEventTime, startNewEventsAt);
6177 return A2(
6178 $elm$core$List$cons,
6179 A3(
6180 $mdgriffith$elm_animator$Internal$Timeline$Line,
6181 startLineAt,
6182 startingEvent,
6183 $elm$core$List$reverse(
6184 A2($elm$core$List$cons, newLastEvent, eventTail))),
6185 A2($elm$core$List$cons, newLine, lines));
6186 }
6187 });
6188var $elm$core$Basics$ge = _Utils_ge;
6189var $mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat = F2(
6190 function (_v0, _v1) {
6191 var _this = _v0;
6192 var that = _v1;
6193 return (_this - that) >= 0;
6194 });
6195var $mdgriffith$elm_animator$Internal$Time$thisBeforeOrEqualThat = F2(
6196 function (_v0, _v1) {
6197 var _this = _v0;
6198 var that = _v1;
6199 return (_this - that) <= 0;
6200 });
6201var $mdgriffith$elm_animator$Internal$Timeline$addToCurrentLine = F3(
6202 function (now, scheduled, lines) {
6203 if (!lines.b) {
6204 return _List_fromArray(
6205 [
6206 A2($mdgriffith$elm_animator$Internal$Timeline$createLine, now, scheduled)
6207 ]);
6208 } else {
6209 if (!lines.b.b) {
6210 var line = lines.a;
6211 return A4($mdgriffith$elm_animator$Internal$Timeline$addEventsToLine, now, scheduled, line, _List_Nil);
6212 } else {
6213 var _v1 = lines.a;
6214 var startOne = _v1.a;
6215 var startEventOne = _v1.b;
6216 var one = _v1.c;
6217 var _v2 = lines.b;
6218 var _v3 = _v2.a;
6219 var startTwo = _v3.a;
6220 var startEventTwo = _v3.b;
6221 var two = _v3.c;
6222 var remaining = _v2.b;
6223 return (A2($mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat, now, startOne) && A2($mdgriffith$elm_animator$Internal$Time$thisBeforeOrEqualThat, now, startTwo)) ? A4(
6224 $mdgriffith$elm_animator$Internal$Timeline$addEventsToLine,
6225 now,
6226 scheduled,
6227 A3($mdgriffith$elm_animator$Internal$Timeline$Line, startOne, startEventOne, one),
6228 A2(
6229 $elm$core$List$cons,
6230 A3($mdgriffith$elm_animator$Internal$Timeline$Line, startTwo, startEventTwo, two),
6231 remaining)) : A2(
6232 $elm$core$List$cons,
6233 A3($mdgriffith$elm_animator$Internal$Timeline$Line, startOne, startEventOne, one),
6234 A3(
6235 $mdgriffith$elm_animator$Internal$Timeline$addToCurrentLine,
6236 now,
6237 scheduled,
6238 A2(
6239 $elm$core$List$cons,
6240 A3($mdgriffith$elm_animator$Internal$Timeline$Line, startTwo, startEventTwo, two),
6241 remaining)));
6242 }
6243 }
6244 });
6245var $mdgriffith$elm_animator$Internal$Timeline$enqueue = F3(
6246 function (timeline, now, scheduled) {
6247 var _v0 = timeline.da;
6248 var lines = _v0;
6249 return A3($mdgriffith$elm_animator$Internal$Timeline$addToCurrentLine, now, scheduled, lines);
6250 });
6251var $mdgriffith$elm_animator$Internal$Timeline$LastTwoEvents = F4(
6252 function (a, b, c, d) {
6253 return {$: 0, a: a, b: b, c: c, d: d};
6254 });
6255var $mdgriffith$elm_animator$Internal$Time$thisBeforeThat = F2(
6256 function (_v0, _v1) {
6257 var _this = _v0;
6258 var that = _v1;
6259 return (_this - that) < 0;
6260 });
6261var $mdgriffith$elm_animator$Internal$Timeline$beforeEventEnd = F2(
6262 function (time, events) {
6263 beforeEventEnd:
6264 while (true) {
6265 if (!events.b) {
6266 return false;
6267 } else {
6268 var top = events.a;
6269 var remain = events.b;
6270 if (A2(
6271 $mdgriffith$elm_animator$Internal$Time$thisBeforeThat,
6272 time,
6273 $mdgriffith$elm_animator$Internal$Timeline$endTime(top))) {
6274 return true;
6275 } else {
6276 var $temp$time = time,
6277 $temp$events = remain;
6278 time = $temp$time;
6279 events = $temp$events;
6280 continue beforeEventEnd;
6281 }
6282 }
6283 }
6284 });
6285var $mdgriffith$elm_animator$Internal$Timeline$beforeLineEnd = F2(
6286 function (time, _v0) {
6287 var lineStartAt = _v0.a;
6288 var startingEvent = _v0.b;
6289 var trailing = _v0.c;
6290 if (A2($mdgriffith$elm_animator$Internal$Time$thisBeforeOrEqualThat, time, lineStartAt)) {
6291 return true;
6292 } else {
6293 if (!trailing.b) {
6294 return A2(
6295 $mdgriffith$elm_animator$Internal$Time$thisBeforeThat,
6296 time,
6297 $mdgriffith$elm_animator$Internal$Timeline$endTime(startingEvent));
6298 } else {
6299 return A2($mdgriffith$elm_animator$Internal$Timeline$beforeEventEnd, time, trailing);
6300 }
6301 }
6302 });
6303var $mdgriffith$elm_animator$Internal$Timeline$getEvent = function (_v0) {
6304 var ev = _v0.a;
6305 return ev;
6306};
6307var $mdgriffith$elm_animator$Internal$Timeline$startTime = function (_v0) {
6308 var time = _v0.b;
6309 return time;
6310};
6311var $mdgriffith$elm_animator$Internal$Timeline$getTransitionAt = F3(
6312 function (interruptionTime, prev, trailing) {
6313 getTransitionAt:
6314 while (true) {
6315 if (!trailing.b) {
6316 return $elm$core$Maybe$Nothing;
6317 } else {
6318 var next = trailing.a;
6319 var remain = trailing.b;
6320 if (A2(
6321 $mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat,
6322 interruptionTime,
6323 $mdgriffith$elm_animator$Internal$Timeline$endTime(prev)) && A2(
6324 $mdgriffith$elm_animator$Internal$Time$thisBeforeThat,
6325 interruptionTime,
6326 $mdgriffith$elm_animator$Internal$Timeline$startTime(next))) {
6327 return $elm$core$Maybe$Just(
6328 A4(
6329 $mdgriffith$elm_animator$Internal$Timeline$LastTwoEvents,
6330 $mdgriffith$elm_animator$Internal$Timeline$endTime(prev),
6331 $mdgriffith$elm_animator$Internal$Timeline$getEvent(prev),
6332 $mdgriffith$elm_animator$Internal$Timeline$startTime(next),
6333 $mdgriffith$elm_animator$Internal$Timeline$getEvent(next)));
6334 } else {
6335 var $temp$interruptionTime = interruptionTime,
6336 $temp$prev = next,
6337 $temp$trailing = remain;
6338 interruptionTime = $temp$interruptionTime;
6339 prev = $temp$prev;
6340 trailing = $temp$trailing;
6341 continue getTransitionAt;
6342 }
6343 }
6344 }
6345 });
6346var $mdgriffith$elm_animator$Internal$Timeline$Schedule = F3(
6347 function (a, b, c) {
6348 return {$: 0, a: a, b: b, c: c};
6349 });
6350var $mdgriffith$elm_animator$Internal$Timeline$Event = F3(
6351 function (a, b, c) {
6352 return {$: 0, a: a, b: b, c: c};
6353 });
6354var $mdgriffith$elm_animator$Internal$Timeline$adjustScheduledDuration = F2(
6355 function (fn, _v0) {
6356 var dur = _v0.a;
6357 var ev = _v0.b;
6358 var maybeDwell = _v0.c;
6359 return A3(
6360 $mdgriffith$elm_animator$Internal$Timeline$Event,
6361 fn(dur),
6362 ev,
6363 maybeDwell);
6364 });
6365var $mdgriffith$elm_animator$Internal$Timeline$getScheduledEvent = function (_v0) {
6366 var ev = _v0.b;
6367 return ev;
6368};
6369var $ianmackenzie$elm_units$Quantity$multiplyBy = F2(
6370 function (scale, _v0) {
6371 var value = _v0;
6372 return scale * value;
6373 });
6374var $elm$core$Basics$negate = function (n) {
6375 return -n;
6376};
6377var $elm$core$Basics$abs = function (n) {
6378 return (n < 0) ? (-n) : n;
6379};
6380var $elm$core$Basics$min = F2(
6381 function (x, y) {
6382 return (_Utils_cmp(x, y) < 0) ? x : y;
6383 });
6384var $mdgriffith$elm_animator$Internal$Time$progress = F3(
6385 function (_v0, _v1, _v2) {
6386 var start = _v0;
6387 var end = _v1;
6388 var current = _v2;
6389 var total = $elm$core$Basics$abs(end - start);
6390 return (!total) ? 0 : A2(
6391 $elm$core$Basics$min,
6392 1,
6393 A2($elm$core$Basics$max, 0, (current - start) / total));
6394 });
6395var $mdgriffith$elm_animator$Internal$Timeline$interruptAtExactly = F3(
6396 function (startInterruption, scheduled, last) {
6397 var penultimateTime = last.a;
6398 var penultimate = last.b;
6399 var lastEventTime = last.c;
6400 var lastEvent = last.d;
6401 var delay_ = scheduled.a;
6402 var startingEvent = scheduled.b;
6403 var reverseQueued = scheduled.c;
6404 var amountProgress = A3($mdgriffith$elm_animator$Internal$Time$progress, penultimateTime, lastEventTime, startInterruption);
6405 var newStartingEvent = _Utils_eq(
6406 penultimate,
6407 $mdgriffith$elm_animator$Internal$Timeline$getScheduledEvent(startingEvent)) ? A2(
6408 $mdgriffith$elm_animator$Internal$Timeline$adjustScheduledDuration,
6409 $ianmackenzie$elm_units$Quantity$multiplyBy(amountProgress),
6410 startingEvent) : startingEvent;
6411 return A2(
6412 $mdgriffith$elm_animator$Internal$Timeline$createLine,
6413 startInterruption,
6414 A3($mdgriffith$elm_animator$Internal$Timeline$Schedule, delay_, newStartingEvent, reverseQueued));
6415 });
6416var $mdgriffith$elm_animator$Internal$Timeline$interruptLine = F4(
6417 function (startInterruption, scheduled, line, future) {
6418 var start = line.a;
6419 var startEvent = line.b;
6420 var trailing = line.c;
6421 if (A2($mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat, startInterruption, start)) {
6422 if (!future.b) {
6423 var _v2 = A3($mdgriffith$elm_animator$Internal$Timeline$getTransitionAt, startInterruption, startEvent, trailing);
6424 if (_v2.$ === 1) {
6425 return A2($mdgriffith$elm_animator$Internal$Timeline$beforeLineEnd, startInterruption, line) ? $elm$core$Maybe$Just(
6426 _List_fromArray(
6427 [
6428 A2($mdgriffith$elm_animator$Internal$Timeline$createLine, startInterruption, scheduled)
6429 ])) : $elm$core$Maybe$Nothing;
6430 } else {
6431 var last2Events = _v2.a;
6432 return $elm$core$Maybe$Just(
6433 _List_fromArray(
6434 [
6435 A3($mdgriffith$elm_animator$Internal$Timeline$interruptAtExactly, startInterruption, scheduled, last2Events)
6436 ]));
6437 }
6438 } else {
6439 var _v3 = future.a;
6440 var nextStart = _v3.a;
6441 var next = _v3.b;
6442 var nextEvents = _v3.c;
6443 var futureRemaining = future.b;
6444 return (A2($mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat, startInterruption, nextStart) && A2(
6445 $mdgriffith$elm_animator$Internal$Time$thisBeforeOrEqualThat,
6446 startInterruption,
6447 $mdgriffith$elm_animator$Internal$Timeline$startTime(next))) ? $elm$core$Maybe$Just(
6448 A2(
6449 $elm$core$List$cons,
6450 A3($mdgriffith$elm_animator$Internal$Timeline$Line, nextStart, next, nextEvents),
6451 A2(
6452 $elm$core$List$cons,
6453 A3(
6454 $mdgriffith$elm_animator$Internal$Timeline$interruptAtExactly,
6455 startInterruption,
6456 scheduled,
6457 A4(
6458 $mdgriffith$elm_animator$Internal$Timeline$LastTwoEvents,
6459 $mdgriffith$elm_animator$Internal$Timeline$endTime(startEvent),
6460 $mdgriffith$elm_animator$Internal$Timeline$getEvent(startEvent),
6461 $mdgriffith$elm_animator$Internal$Timeline$startTime(next),
6462 $mdgriffith$elm_animator$Internal$Timeline$getEvent(next))),
6463 futureRemaining))) : $elm$core$Maybe$Nothing;
6464 }
6465 } else {
6466 return $elm$core$Maybe$Nothing;
6467 }
6468 });
6469var $mdgriffith$elm_animator$Internal$Timeline$lineStartTime = function (_v0) {
6470 var start = _v0.a;
6471 return start;
6472};
6473var $mdgriffith$elm_animator$Internal$Timeline$interruptionHappensLater = F2(
6474 function (startInterruption, remaining) {
6475 if (!remaining.b) {
6476 return false;
6477 } else {
6478 var top = remaining.a;
6479 return A2(
6480 $mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat,
6481 startInterruption,
6482 $mdgriffith$elm_animator$Internal$Timeline$lineStartTime(top));
6483 }
6484 });
6485var $mdgriffith$elm_animator$Internal$Timeline$interruptLines = F5(
6486 function (now, startInterruption, scheduled, pastLines, lines) {
6487 interruptLines:
6488 while (true) {
6489 if (!lines.b) {
6490 return $elm$core$Maybe$Nothing;
6491 } else {
6492 var startLine = lines.a;
6493 var remaining = lines.b;
6494 if (A2($mdgriffith$elm_animator$Internal$Timeline$interruptionHappensLater, startInterruption, remaining)) {
6495 var $temp$now = now,
6496 $temp$startInterruption = startInterruption,
6497 $temp$scheduled = scheduled,
6498 $temp$pastLines = A2($elm$core$List$cons, startLine, pastLines),
6499 $temp$lines = remaining;
6500 now = $temp$now;
6501 startInterruption = $temp$startInterruption;
6502 scheduled = $temp$scheduled;
6503 pastLines = $temp$pastLines;
6504 lines = $temp$lines;
6505 continue interruptLines;
6506 } else {
6507 var _v1 = A4($mdgriffith$elm_animator$Internal$Timeline$interruptLine, startInterruption, scheduled, startLine, remaining);
6508 if (_v1.$ === 1) {
6509 var $temp$now = now,
6510 $temp$startInterruption = startInterruption,
6511 $temp$scheduled = scheduled,
6512 $temp$pastLines = A2($elm$core$List$cons, startLine, pastLines),
6513 $temp$lines = remaining;
6514 now = $temp$now;
6515 startInterruption = $temp$startInterruption;
6516 scheduled = $temp$scheduled;
6517 pastLines = $temp$pastLines;
6518 lines = $temp$lines;
6519 continue interruptLines;
6520 } else {
6521 var interruption = _v1.a;
6522 return (_Utils_eq(
6523 startInterruption,
6524 $mdgriffith$elm_animator$Internal$Timeline$lineStartTime(startLine)) && A2($mdgriffith$elm_animator$Internal$Time$thisAfterThat, startInterruption, now)) ? $elm$core$Maybe$Just(
6525 _Utils_ap(
6526 $elm$core$List$reverse(pastLines),
6527 interruption)) : $elm$core$Maybe$Just(
6528 _Utils_ap(
6529 $elm$core$List$reverse(pastLines),
6530 A2($elm$core$List$cons, startLine, interruption)));
6531 }
6532 }
6533 }
6534 }
6535 });
6536var $mdgriffith$elm_animator$Internal$Timeline$interrupt = F3(
6537 function (details, startAt, scheduled) {
6538 var _v0 = details.da;
6539 var lines = _v0;
6540 var _v1 = A5($mdgriffith$elm_animator$Internal$Timeline$interruptLines, details.ds, startAt, scheduled, _List_Nil, lines);
6541 if (_v1.$ === 1) {
6542 return A3($mdgriffith$elm_animator$Internal$Timeline$enqueue, details, startAt, scheduled);
6543 } else {
6544 var interrupted = _v1.a;
6545 return interrupted;
6546 }
6547 });
6548var $mdgriffith$elm_animator$Internal$Timeline$applyInterruptionHelper = F2(
6549 function (interrupts, timeline) {
6550 applyInterruptionHelper:
6551 while (true) {
6552 if (!interrupts.b) {
6553 return timeline;
6554 } else {
6555 var inter = interrupts.a;
6556 var remaining = interrupts.b;
6557 var delay = function () {
6558 var d = inter.a;
6559 return d;
6560 }();
6561 var newEvents = A3(
6562 $mdgriffith$elm_animator$Internal$Timeline$interrupt,
6563 timeline,
6564 A2($mdgriffith$elm_animator$Internal$Time$advanceBy, delay, timeline.ds),
6565 inter);
6566 var $temp$interrupts = remaining,
6567 $temp$timeline = _Utils_update(
6568 timeline,
6569 {da: newEvents});
6570 interrupts = $temp$interrupts;
6571 timeline = $temp$timeline;
6572 continue applyInterruptionHelper;
6573 }
6574 }
6575 });
6576var $mdgriffith$elm_animator$Internal$Timeline$applyInterruptions = function (timeline) {
6577 var _v0 = timeline.aC;
6578 if (!_v0.b) {
6579 return timeline;
6580 } else {
6581 return A2(
6582 $mdgriffith$elm_animator$Internal$Timeline$applyInterruptionHelper,
6583 $elm$core$List$reverse(timeline.aC),
6584 _Utils_update(
6585 timeline,
6586 {aC: _List_Nil}));
6587 }
6588};
6589var $mdgriffith$elm_animator$Internal$Timeline$applyQueued = function (timeline) {
6590 var _v0 = timeline.aN;
6591 if (_v0.$ === 1) {
6592 return timeline;
6593 } else {
6594 var queued = _v0.a;
6595 return _Utils_update(
6596 timeline,
6597 {
6598 da: A3($mdgriffith$elm_animator$Internal$Timeline$enqueue, timeline, timeline.ds, queued),
6599 aN: $elm$core$Maybe$Nothing
6600 });
6601 }
6602};
6603var $mdgriffith$elm_animator$Internal$Timeline$dwellingAt = F2(
6604 function (now, event) {
6605 var eventStartTime = $mdgriffith$elm_animator$Internal$Timeline$startTime(event);
6606 var eventEndTime = $mdgriffith$elm_animator$Internal$Timeline$endTime(event);
6607 return A2($mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat, now, eventStartTime) && A2($mdgriffith$elm_animator$Internal$Time$thisBeforeOrEqualThat, now, eventEndTime);
6608 });
6609var $elm$core$List$head = function (list) {
6610 if (list.b) {
6611 var x = list.a;
6612 var xs = list.b;
6613 return $elm$core$Maybe$Just(x);
6614 } else {
6615 return $elm$core$Maybe$Nothing;
6616 }
6617};
6618var $mdgriffith$elm_animator$Internal$Timeline$Captured = function (a) {
6619 return {$: 0, a: a};
6620};
6621var $mdgriffith$elm_animator$Internal$Timeline$NothingCaptured = {$: 1};
6622var $mdgriffith$elm_animator$Internal$Timeline$hewLine = F2(
6623 function (now, events) {
6624 hewLine:
6625 while (true) {
6626 if (!events.b) {
6627 return $mdgriffith$elm_animator$Internal$Timeline$NothingCaptured;
6628 } else {
6629 var top = events.a;
6630 var remaining = events.b;
6631 if (A2($mdgriffith$elm_animator$Internal$Timeline$dwellingAt, now, top)) {
6632 return $mdgriffith$elm_animator$Internal$Timeline$Captured(
6633 A3(
6634 $mdgriffith$elm_animator$Internal$Timeline$Line,
6635 $mdgriffith$elm_animator$Internal$Timeline$startTime(top),
6636 top,
6637 remaining));
6638 } else {
6639 if (A2(
6640 $mdgriffith$elm_animator$Internal$Time$thisAfterThat,
6641 now,
6642 $mdgriffith$elm_animator$Internal$Timeline$endTime(top))) {
6643 var $temp$now = now,
6644 $temp$events = remaining;
6645 now = $temp$now;
6646 events = $temp$events;
6647 continue hewLine;
6648 } else {
6649 return $mdgriffith$elm_animator$Internal$Timeline$NothingCaptured;
6650 }
6651 }
6652 }
6653 }
6654 });
6655var $elm$core$Maybe$map = F2(
6656 function (f, maybe) {
6657 if (!maybe.$) {
6658 var value = maybe.a;
6659 return $elm$core$Maybe$Just(
6660 f(value));
6661 } else {
6662 return $elm$core$Maybe$Nothing;
6663 }
6664 });
6665var $mdgriffith$elm_animator$Internal$Timeline$garbageCollectOldEvents = F3(
6666 function (now, droppable, lines) {
6667 garbageCollectOldEvents:
6668 while (true) {
6669 if (!lines.b) {
6670 return $elm$core$List$reverse(droppable);
6671 } else {
6672 var _v1 = lines.a;
6673 var startAt = _v1.a;
6674 var startingEvent = _v1.b;
6675 var events = _v1.c;
6676 var remaining = lines.b;
6677 if (A2($mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat, startAt, now)) {
6678 return _Utils_ap(
6679 $elm$core$List$reverse(droppable),
6680 lines);
6681 } else {
6682 if (A2($mdgriffith$elm_animator$Internal$Timeline$dwellingAt, now, startingEvent)) {
6683 return lines;
6684 } else {
6685 var maybeInterruptionTime = A2(
6686 $elm$core$Maybe$map,
6687 $mdgriffith$elm_animator$Internal$Timeline$lineStartTime,
6688 $elm$core$List$head(remaining));
6689 var interrupted = function () {
6690 if (maybeInterruptionTime.$ === 1) {
6691 return false;
6692 } else {
6693 var interruptionTime = maybeInterruptionTime.a;
6694 return A2($mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat, now, interruptionTime);
6695 }
6696 }();
6697 if (interrupted) {
6698 var $temp$now = now,
6699 $temp$droppable = A2(
6700 $elm$core$List$cons,
6701 A3($mdgriffith$elm_animator$Internal$Timeline$Line, startAt, startingEvent, events),
6702 droppable),
6703 $temp$lines = remaining;
6704 now = $temp$now;
6705 droppable = $temp$droppable;
6706 lines = $temp$lines;
6707 continue garbageCollectOldEvents;
6708 } else {
6709 var _v2 = A2($mdgriffith$elm_animator$Internal$Timeline$hewLine, now, events);
6710 if (_v2.$ === 1) {
6711 return _Utils_ap(
6712 $elm$core$List$reverse(droppable),
6713 lines);
6714 } else {
6715 var capturedLine = _v2.a;
6716 return A2($elm$core$List$cons, capturedLine, remaining);
6717 }
6718 }
6719 }
6720 }
6721 }
6722 }
6723 });
6724var $mdgriffith$elm_animator$Internal$Timeline$linesAreActive = F2(
6725 function (now, lines) {
6726 linesAreActive:
6727 while (true) {
6728 if (!lines.b) {
6729 return false;
6730 } else {
6731 var _v1 = lines.a;
6732 var startAt = _v1.a;
6733 var startingEvent = _v1.b;
6734 var events = _v1.c;
6735 var remaining = lines.b;
6736 if (A2($mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat, startAt, now)) {
6737 return true;
6738 } else {
6739 var maybeInterruption = function () {
6740 var _v5 = $elm$core$List$head(remaining);
6741 if (_v5.$ === 1) {
6742 return $elm$core$Maybe$Nothing;
6743 } else {
6744 var _v6 = _v5.a;
6745 var interruptionTime = _v6.a;
6746 return $elm$core$Maybe$Just(interruptionTime);
6747 }
6748 }();
6749 var last = A2(
6750 $elm$core$Maybe$withDefault,
6751 startingEvent,
6752 $elm$core$List$head(
6753 $elm$core$List$reverse(events)));
6754 if (!maybeInterruption.$) {
6755 var interruptTime = maybeInterruption.a;
6756 if (A2($mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat, interruptTime, now)) {
6757 return true;
6758 } else {
6759 var time = last.b;
6760 if (A2($mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat, time, now)) {
6761 return true;
6762 } else {
6763 var $temp$now = now,
6764 $temp$lines = remaining;
6765 now = $temp$now;
6766 lines = $temp$lines;
6767 continue linesAreActive;
6768 }
6769 }
6770 } else {
6771 var time = last.b;
6772 if (A2($mdgriffith$elm_animator$Internal$Time$thisAfterOrEqualThat, time, now)) {
6773 return true;
6774 } else {
6775 var $temp$now = now,
6776 $temp$lines = remaining;
6777 now = $temp$now;
6778 lines = $temp$lines;
6779 continue linesAreActive;
6780 }
6781 }
6782 }
6783 }
6784 }
6785 });
6786var $mdgriffith$elm_animator$Internal$Timeline$clean = F2(
6787 function (runGC, details) {
6788 var running = function () {
6789 var _v1 = details.da;
6790 var lines = _v1;
6791 return A2($mdgriffith$elm_animator$Internal$Timeline$linesAreActive, details.ds, lines);
6792 }();
6793 var events = function () {
6794 var _v0 = details.da;
6795 var evs = _v0;
6796 return evs;
6797 }();
6798 return _Utils_update(
6799 details,
6800 {
6801 da: runGC ? A3($mdgriffith$elm_animator$Internal$Timeline$garbageCollectOldEvents, details.ds, _List_Nil, events) : details.da,
6802 b7: running
6803 });
6804 });
6805var $ianmackenzie$elm_units$Quantity$max = F2(
6806 function (_v0, _v1) {
6807 var x = _v0;
6808 var y = _v1;
6809 return A2($elm$core$Basics$max, x, y);
6810 });
6811var $mdgriffith$elm_animator$Internal$Timeline$updateWith = F3(
6812 function (withGC, possiblyNow, _v0) {
6813 var timeline = _v0;
6814 var now = A2(
6815 $ianmackenzie$elm_units$Quantity$max,
6816 $mdgriffith$elm_animator$Internal$Time$absolute(possiblyNow),
6817 timeline.ds);
6818 return _Utils_eq(timeline.da, _List_Nil) ? A2(
6819 $mdgriffith$elm_animator$Internal$Timeline$clean,
6820 withGC,
6821 $mdgriffith$elm_animator$Internal$Timeline$applyInterruptions(
6822 $mdgriffith$elm_animator$Internal$Timeline$applyQueued(
6823 _Utils_update(
6824 timeline,
6825 {
6826 da: function () {
6827 var firstOccurring = A3($mdgriffith$elm_animator$Internal$Timeline$Occurring, timeline.dh, now, now);
6828 return _List_fromArray(
6829 [
6830 A3($mdgriffith$elm_animator$Internal$Timeline$Line, now, firstOccurring, _List_Nil)
6831 ]);
6832 }(),
6833 ds: now
6834 })))) : A2(
6835 $mdgriffith$elm_animator$Internal$Timeline$clean,
6836 withGC,
6837 $mdgriffith$elm_animator$Internal$Timeline$applyInterruptions(
6838 $mdgriffith$elm_animator$Internal$Timeline$applyQueued(
6839 _Utils_update(
6840 timeline,
6841 {ds: now}))));
6842 });
6843var $mdgriffith$elm_animator$Internal$Timeline$update = $mdgriffith$elm_animator$Internal$Timeline$updateWith(true);
6844var $mdgriffith$elm_animator$Animator$Css$watching = F3(
6845 function (get, set, _v0) {
6846 var isRunning = _v0.a;
6847 var updateModel = _v0.b;
6848 return A2(
6849 $mdgriffith$elm_animator$Internal$Timeline$Animator,
6850 function (model) {
6851 if (isRunning(model)) {
6852 return true;
6853 } else {
6854 var tl = get(model);
6855 return $mdgriffith$elm_animator$Internal$Timeline$hasChanged(tl) || $mdgriffith$elm_animator$Internal$Timeline$justInitialized(tl);
6856 }
6857 },
6858 F2(
6859 function (now, model) {
6860 var newModel = A2(updateModel, now, model);
6861 return A2(
6862 set,
6863 A2(
6864 $mdgriffith$elm_animator$Internal$Timeline$update,
6865 now,
6866 get(newModel)),
6867 newModel);
6868 }));
6869 });
6870var $author$project$Main$animator = A3(
6871 $mdgriffith$elm_animator$Animator$Css$watching,
6872 function ($) {
6873 return $.x;
6874 },
6875 F2(
6876 function (newPage, model) {
6877 return _Utils_update(
6878 model,
6879 {x: newPage});
6880 }),
6881 $mdgriffith$elm_animator$Animator$animator);
6882var $elm$core$Platform$Sub$batch = _Platform_batch;
6883var $elm$json$Json$Decode$string = _Json_decodeString;
6884var $author$project$Main$messageReceiver = _Platform_incomingPort('messageReceiver', $elm$json$Json$Decode$string);
6885var $rundis$elm_bootstrap$Bootstrap$Navbar$AnimatingDown = 2;
6886var $rundis$elm_bootstrap$Bootstrap$Navbar$AnimatingUp = 4;
6887var $rundis$elm_bootstrap$Bootstrap$Navbar$Closed = 2;
6888var $rundis$elm_bootstrap$Bootstrap$Navbar$ListenClicks = 1;
6889var $rundis$elm_bootstrap$Bootstrap$Navbar$Open = 0;
6890var $elm$core$List$any = F2(
6891 function (isOkay, list) {
6892 any:
6893 while (true) {
6894 if (!list.b) {
6895 return false;
6896 } else {
6897 var x = list.a;
6898 var xs = list.b;
6899 if (isOkay(x)) {
6900 return true;
6901 } else {
6902 var $temp$isOkay = isOkay,
6903 $temp$list = xs;
6904 isOkay = $temp$isOkay;
6905 list = $temp$list;
6906 continue any;
6907 }
6908 }
6909 }
6910 });
6911var $elm$core$Dict$map = F2(
6912 function (func, dict) {
6913 if (dict.$ === -2) {
6914 return $elm$core$Dict$RBEmpty_elm_builtin;
6915 } else {
6916 var color = dict.a;
6917 var key = dict.b;
6918 var value = dict.c;
6919 var left = dict.d;
6920 var right = dict.e;
6921 return A5(
6922 $elm$core$Dict$RBNode_elm_builtin,
6923 color,
6924 key,
6925 A2(func, key, value),
6926 A2($elm$core$Dict$map, func, left),
6927 A2($elm$core$Dict$map, func, right));
6928 }
6929 });
6930var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil);
6931var $elm$browser$Browser$AnimationManager$Time = function (a) {
6932 return {$: 0, a: a};
6933};
6934var $elm$browser$Browser$AnimationManager$State = F3(
6935 function (subs, request, oldTime) {
6936 return {cF: oldTime, dF: request, dL: subs};
6937 });
6938var $elm$browser$Browser$AnimationManager$init = $elm$core$Task$succeed(
6939 A3($elm$browser$Browser$AnimationManager$State, _List_Nil, $elm$core$Maybe$Nothing, 0));
6940var $elm$core$Process$kill = _Scheduler_kill;
6941var $elm$browser$Browser$AnimationManager$now = _Browser_now(0);
6942var $elm$browser$Browser$AnimationManager$rAF = _Browser_rAF(0);
6943var $elm$core$Platform$sendToSelf = _Platform_sendToSelf;
6944var $elm$core$Process$spawn = _Scheduler_spawn;
6945var $elm$browser$Browser$AnimationManager$onEffects = F3(
6946 function (router, subs, _v0) {
6947 var request = _v0.dF;
6948 var oldTime = _v0.cF;
6949 var _v1 = _Utils_Tuple2(request, subs);
6950 if (_v1.a.$ === 1) {
6951 if (!_v1.b.b) {
6952 var _v2 = _v1.a;
6953 return $elm$browser$Browser$AnimationManager$init;
6954 } else {
6955 var _v4 = _v1.a;
6956 return A2(
6957 $elm$core$Task$andThen,
6958 function (pid) {
6959 return A2(
6960 $elm$core$Task$andThen,
6961 function (time) {
6962 return $elm$core$Task$succeed(
6963 A3(
6964 $elm$browser$Browser$AnimationManager$State,
6965 subs,
6966 $elm$core$Maybe$Just(pid),
6967 time));
6968 },
6969 $elm$browser$Browser$AnimationManager$now);
6970 },
6971 $elm$core$Process$spawn(
6972 A2(
6973 $elm$core$Task$andThen,
6974 $elm$core$Platform$sendToSelf(router),
6975 $elm$browser$Browser$AnimationManager$rAF)));
6976 }
6977 } else {
6978 if (!_v1.b.b) {
6979 var pid = _v1.a.a;
6980 return A2(
6981 $elm$core$Task$andThen,
6982 function (_v3) {
6983 return $elm$browser$Browser$AnimationManager$init;
6984 },
6985 $elm$core$Process$kill(pid));
6986 } else {
6987 return $elm$core$Task$succeed(
6988 A3($elm$browser$Browser$AnimationManager$State, subs, request, oldTime));
6989 }
6990 }
6991 });
6992var $elm$browser$Browser$AnimationManager$onSelfMsg = F3(
6993 function (router, newTime, _v0) {
6994 var subs = _v0.dL;
6995 var oldTime = _v0.cF;
6996 var send = function (sub) {
6997 if (!sub.$) {
6998 var tagger = sub.a;
6999 return A2(
7000 $elm$core$Platform$sendToApp,
7001 router,
7002 tagger(
7003 $elm$time$Time$millisToPosix(newTime)));
7004 } else {
7005 var tagger = sub.a;
7006 return A2(
7007 $elm$core$Platform$sendToApp,
7008 router,
7009 tagger(newTime - oldTime));
7010 }
7011 };
7012 return A2(
7013 $elm$core$Task$andThen,
7014 function (pid) {
7015 return A2(
7016 $elm$core$Task$andThen,
7017 function (_v1) {
7018 return $elm$core$Task$succeed(
7019 A3(
7020 $elm$browser$Browser$AnimationManager$State,
7021 subs,
7022 $elm$core$Maybe$Just(pid),
7023 newTime));
7024 },
7025 $elm$core$Task$sequence(
7026 A2($elm$core$List$map, send, subs)));
7027 },
7028 $elm$core$Process$spawn(
7029 A2(
7030 $elm$core$Task$andThen,
7031 $elm$core$Platform$sendToSelf(router),
7032 $elm$browser$Browser$AnimationManager$rAF)));
7033 });
7034var $elm$browser$Browser$AnimationManager$Delta = function (a) {
7035 return {$: 1, a: a};
7036};
7037var $elm$core$Basics$composeL = F3(
7038 function (g, f, x) {
7039 return g(
7040 f(x));
7041 });
7042var $elm$browser$Browser$AnimationManager$subMap = F2(
7043 function (func, sub) {
7044 if (!sub.$) {
7045 var tagger = sub.a;
7046 return $elm$browser$Browser$AnimationManager$Time(
7047 A2($elm$core$Basics$composeL, func, tagger));
7048 } else {
7049 var tagger = sub.a;
7050 return $elm$browser$Browser$AnimationManager$Delta(
7051 A2($elm$core$Basics$composeL, func, tagger));
7052 }
7053 });
7054_Platform_effectManagers['Browser.AnimationManager'] = _Platform_createManager($elm$browser$Browser$AnimationManager$init, $elm$browser$Browser$AnimationManager$onEffects, $elm$browser$Browser$AnimationManager$onSelfMsg, 0, $elm$browser$Browser$AnimationManager$subMap);
7055var $elm$browser$Browser$AnimationManager$subscription = _Platform_leaf('Browser.AnimationManager');
7056var $elm$browser$Browser$AnimationManager$onAnimationFrame = function (tagger) {
7057 return $elm$browser$Browser$AnimationManager$subscription(
7058 $elm$browser$Browser$AnimationManager$Time(tagger));
7059};
7060var $elm$browser$Browser$Events$onAnimationFrame = $elm$browser$Browser$AnimationManager$onAnimationFrame;
7061var $elm$browser$Browser$Events$Document = 0;
7062var $elm$browser$Browser$Events$MySub = F3(
7063 function (a, b, c) {
7064 return {$: 0, a: a, b: b, c: c};
7065 });
7066var $elm$browser$Browser$Events$State = F2(
7067 function (subs, pids) {
7068 return {dw: pids, dL: subs};
7069 });
7070var $elm$browser$Browser$Events$init = $elm$core$Task$succeed(
7071 A2($elm$browser$Browser$Events$State, _List_Nil, $elm$core$Dict$empty));
7072var $elm$browser$Browser$Events$nodeToKey = function (node) {
7073 if (!node) {
7074 return 'd_';
7075 } else {
7076 return 'w_';
7077 }
7078};
7079var $elm$browser$Browser$Events$addKey = function (sub) {
7080 var node = sub.a;
7081 var name = sub.b;
7082 return _Utils_Tuple2(
7083 _Utils_ap(
7084 $elm$browser$Browser$Events$nodeToKey(node),
7085 name),
7086 sub);
7087};
7088var $elm$core$Dict$fromList = function (assocs) {
7089 return A3(
7090 $elm$core$List$foldl,
7091 F2(
7092 function (_v0, dict) {
7093 var key = _v0.a;
7094 var value = _v0.b;
7095 return A3($elm$core$Dict$insert, key, value, dict);
7096 }),
7097 $elm$core$Dict$empty,
7098 assocs);
7099};
7100var $elm$core$Dict$foldl = F3(
7101 function (func, acc, dict) {
7102 foldl:
7103 while (true) {
7104 if (dict.$ === -2) {
7105 return acc;
7106 } else {
7107 var key = dict.b;
7108 var value = dict.c;
7109 var left = dict.d;
7110 var right = dict.e;
7111 var $temp$func = func,
7112 $temp$acc = A3(
7113 func,
7114 key,
7115 value,
7116 A3($elm$core$Dict$foldl, func, acc, left)),
7117 $temp$dict = right;
7118 func = $temp$func;
7119 acc = $temp$acc;
7120 dict = $temp$dict;
7121 continue foldl;
7122 }
7123 }
7124 });
7125var $elm$core$Dict$merge = F6(
7126 function (leftStep, bothStep, rightStep, leftDict, rightDict, initialResult) {
7127 var stepState = F3(
7128 function (rKey, rValue, _v0) {
7129 stepState:
7130 while (true) {
7131 var list = _v0.a;
7132 var result = _v0.b;
7133 if (!list.b) {
7134 return _Utils_Tuple2(
7135 list,
7136 A3(rightStep, rKey, rValue, result));
7137 } else {
7138 var _v2 = list.a;
7139 var lKey = _v2.a;
7140 var lValue = _v2.b;
7141 var rest = list.b;
7142 if (_Utils_cmp(lKey, rKey) < 0) {
7143 var $temp$rKey = rKey,
7144 $temp$rValue = rValue,
7145 $temp$_v0 = _Utils_Tuple2(
7146 rest,
7147 A3(leftStep, lKey, lValue, result));
7148 rKey = $temp$rKey;
7149 rValue = $temp$rValue;
7150 _v0 = $temp$_v0;
7151 continue stepState;
7152 } else {
7153 if (_Utils_cmp(lKey, rKey) > 0) {
7154 return _Utils_Tuple2(
7155 list,
7156 A3(rightStep, rKey, rValue, result));
7157 } else {
7158 return _Utils_Tuple2(
7159 rest,
7160 A4(bothStep, lKey, lValue, rValue, result));
7161 }
7162 }
7163 }
7164 }
7165 });
7166 var _v3 = A3(
7167 $elm$core$Dict$foldl,
7168 stepState,
7169 _Utils_Tuple2(
7170 $elm$core$Dict$toList(leftDict),
7171 initialResult),
7172 rightDict);
7173 var leftovers = _v3.a;
7174 var intermediateResult = _v3.b;
7175 return A3(
7176 $elm$core$List$foldl,
7177 F2(
7178 function (_v4, result) {
7179 var k = _v4.a;
7180 var v = _v4.b;
7181 return A3(leftStep, k, v, result);
7182 }),
7183 intermediateResult,
7184 leftovers);
7185 });
7186var $elm$browser$Browser$Events$Event = F2(
7187 function (key, event) {
7188 return {c9: event, dl: key};
7189 });
7190var $elm$browser$Browser$Events$spawn = F3(
7191 function (router, key, _v0) {
7192 var node = _v0.a;
7193 var name = _v0.b;
7194 var actualNode = function () {
7195 if (!node) {
7196 return _Browser_doc;
7197 } else {
7198 return _Browser_window;
7199 }
7200 }();
7201 return A2(
7202 $elm$core$Task$map,
7203 function (value) {
7204 return _Utils_Tuple2(key, value);
7205 },
7206 A3(
7207 _Browser_on,
7208 actualNode,
7209 name,
7210 function (event) {
7211 return A2(
7212 $elm$core$Platform$sendToSelf,
7213 router,
7214 A2($elm$browser$Browser$Events$Event, key, event));
7215 }));
7216 });
7217var $elm$core$Dict$union = F2(
7218 function (t1, t2) {
7219 return A3($elm$core$Dict$foldl, $elm$core$Dict$insert, t2, t1);
7220 });
7221var $elm$browser$Browser$Events$onEffects = F3(
7222 function (router, subs, state) {
7223 var stepRight = F3(
7224 function (key, sub, _v6) {
7225 var deads = _v6.a;
7226 var lives = _v6.b;
7227 var news = _v6.c;
7228 return _Utils_Tuple3(
7229 deads,
7230 lives,
7231 A2(
7232 $elm$core$List$cons,
7233 A3($elm$browser$Browser$Events$spawn, router, key, sub),
7234 news));
7235 });
7236 var stepLeft = F3(
7237 function (_v4, pid, _v5) {
7238 var deads = _v5.a;
7239 var lives = _v5.b;
7240 var news = _v5.c;
7241 return _Utils_Tuple3(
7242 A2($elm$core$List$cons, pid, deads),
7243 lives,
7244 news);
7245 });
7246 var stepBoth = F4(
7247 function (key, pid, _v2, _v3) {
7248 var deads = _v3.a;
7249 var lives = _v3.b;
7250 var news = _v3.c;
7251 return _Utils_Tuple3(
7252 deads,
7253 A3($elm$core$Dict$insert, key, pid, lives),
7254 news);
7255 });
7256 var newSubs = A2($elm$core$List$map, $elm$browser$Browser$Events$addKey, subs);
7257 var _v0 = A6(
7258 $elm$core$Dict$merge,
7259 stepLeft,
7260 stepBoth,
7261 stepRight,
7262 state.dw,
7263 $elm$core$Dict$fromList(newSubs),
7264 _Utils_Tuple3(_List_Nil, $elm$core$Dict$empty, _List_Nil));
7265 var deadPids = _v0.a;
7266 var livePids = _v0.b;
7267 var makeNewPids = _v0.c;
7268 return A2(
7269 $elm$core$Task$andThen,
7270 function (pids) {
7271 return $elm$core$Task$succeed(
7272 A2(
7273 $elm$browser$Browser$Events$State,
7274 newSubs,
7275 A2(
7276 $elm$core$Dict$union,
7277 livePids,
7278 $elm$core$Dict$fromList(pids))));
7279 },
7280 A2(
7281 $elm$core$Task$andThen,
7282 function (_v1) {
7283 return $elm$core$Task$sequence(makeNewPids);
7284 },
7285 $elm$core$Task$sequence(
7286 A2($elm$core$List$map, $elm$core$Process$kill, deadPids))));
7287 });
7288var $elm$core$List$maybeCons = F3(
7289 function (f, mx, xs) {
7290 var _v0 = f(mx);
7291 if (!_v0.$) {
7292 var x = _v0.a;
7293 return A2($elm$core$List$cons, x, xs);
7294 } else {
7295 return xs;
7296 }
7297 });
7298var $elm$core$List$filterMap = F2(
7299 function (f, xs) {
7300 return A3(
7301 $elm$core$List$foldr,
7302 $elm$core$List$maybeCons(f),
7303 _List_Nil,
7304 xs);
7305 });
7306var $elm$browser$Browser$Events$onSelfMsg = F3(
7307 function (router, _v0, state) {
7308 var key = _v0.dl;
7309 var event = _v0.c9;
7310 var toMessage = function (_v2) {
7311 var subKey = _v2.a;
7312 var _v3 = _v2.b;
7313 var node = _v3.a;
7314 var name = _v3.b;
7315 var decoder = _v3.c;
7316 return _Utils_eq(subKey, key) ? A2(_Browser_decodeEvent, decoder, event) : $elm$core$Maybe$Nothing;
7317 };
7318 var messages = A2($elm$core$List$filterMap, toMessage, state.dL);
7319 return A2(
7320 $elm$core$Task$andThen,
7321 function (_v1) {
7322 return $elm$core$Task$succeed(state);
7323 },
7324 $elm$core$Task$sequence(
7325 A2(
7326 $elm$core$List$map,
7327 $elm$core$Platform$sendToApp(router),
7328 messages)));
7329 });
7330var $elm$browser$Browser$Events$subMap = F2(
7331 function (func, _v0) {
7332 var node = _v0.a;
7333 var name = _v0.b;
7334 var decoder = _v0.c;
7335 return A3(
7336 $elm$browser$Browser$Events$MySub,
7337 node,
7338 name,
7339 A2($elm$json$Json$Decode$map, func, decoder));
7340 });
7341_Platform_effectManagers['Browser.Events'] = _Platform_createManager($elm$browser$Browser$Events$init, $elm$browser$Browser$Events$onEffects, $elm$browser$Browser$Events$onSelfMsg, 0, $elm$browser$Browser$Events$subMap);
7342var $elm$browser$Browser$Events$subscription = _Platform_leaf('Browser.Events');
7343var $elm$browser$Browser$Events$on = F3(
7344 function (node, name, decoder) {
7345 return $elm$browser$Browser$Events$subscription(
7346 A3($elm$browser$Browser$Events$MySub, node, name, decoder));
7347 });
7348var $elm$browser$Browser$Events$onClick = A2($elm$browser$Browser$Events$on, 0, 'click');
7349var $rundis$elm_bootstrap$Bootstrap$Navbar$dropdownSubscriptions = F2(
7350 function (state, toMsg) {
7351 var dropdowns = state.O;
7352 var updDropdowns = A2(
7353 $elm$core$Dict$map,
7354 F2(
7355 function (_v2, status) {
7356 switch (status) {
7357 case 0:
7358 return 1;
7359 case 1:
7360 return 2;
7361 default:
7362 return 2;
7363 }
7364 }),
7365 dropdowns);
7366 var updState = A2(
7367 $rundis$elm_bootstrap$Bootstrap$Navbar$mapState,
7368 function (s) {
7369 return _Utils_update(
7370 s,
7371 {O: updDropdowns});
7372 },
7373 state);
7374 var needsSub = function (s) {
7375 return A2(
7376 $elm$core$List$any,
7377 function (_v1) {
7378 var status = _v1.b;
7379 return _Utils_eq(status, s);
7380 },
7381 $elm$core$Dict$toList(dropdowns));
7382 };
7383 return $elm$core$Platform$Sub$batch(
7384 _List_fromArray(
7385 [
7386 needsSub(0) ? $elm$browser$Browser$Events$onAnimationFrame(
7387 function (_v0) {
7388 return toMsg(updState);
7389 }) : $elm$core$Platform$Sub$none,
7390 needsSub(1) ? $elm$browser$Browser$Events$onClick(
7391 $elm$json$Json$Decode$succeed(
7392 toMsg(updState))) : $elm$core$Platform$Sub$none
7393 ]));
7394 });
7395var $elm$browser$Browser$Events$Window = 1;
7396var $elm$json$Json$Decode$field = _Json_decodeField;
7397var $elm$json$Json$Decode$int = _Json_decodeInt;
7398var $elm$browser$Browser$Events$onResize = function (func) {
7399 return A3(
7400 $elm$browser$Browser$Events$on,
7401 1,
7402 'resize',
7403 A2(
7404 $elm$json$Json$Decode$field,
7405 'target',
7406 A3(
7407 $elm$json$Json$Decode$map2,
7408 func,
7409 A2($elm$json$Json$Decode$field, 'innerWidth', $elm$json$Json$Decode$int),
7410 A2($elm$json$Json$Decode$field, 'innerHeight', $elm$json$Json$Decode$int))));
7411};
7412var $rundis$elm_bootstrap$Bootstrap$Navbar$subscriptions = F2(
7413 function (state, toMsg) {
7414 var visibility = state.j;
7415 var updState = function (v) {
7416 return A2(
7417 $rundis$elm_bootstrap$Bootstrap$Navbar$mapState,
7418 function (s) {
7419 return _Utils_update(
7420 s,
7421 {j: v});
7422 },
7423 state);
7424 };
7425 return $elm$core$Platform$Sub$batch(
7426 _List_fromArray(
7427 [
7428 function () {
7429 switch (visibility) {
7430 case 1:
7431 return $elm$browser$Browser$Events$onAnimationFrame(
7432 function (_v1) {
7433 return toMsg(
7434 updState(2));
7435 });
7436 case 3:
7437 return $elm$browser$Browser$Events$onAnimationFrame(
7438 function (_v2) {
7439 return toMsg(
7440 updState(4));
7441 });
7442 default:
7443 return $elm$core$Platform$Sub$none;
7444 }
7445 }(),
7446 $elm$browser$Browser$Events$onResize(
7447 F2(
7448 function (x, _v3) {
7449 return toMsg(
7450 A2(
7451 $rundis$elm_bootstrap$Bootstrap$Navbar$mapState,
7452 function (s) {
7453 return _Utils_update(
7454 s,
7455 {
7456 a_: $elm$core$Maybe$Just(x)
7457 });
7458 },
7459 state));
7460 })),
7461 A2($rundis$elm_bootstrap$Bootstrap$Navbar$dropdownSubscriptions, state, toMsg)
7462 ]));
7463 });
7464var $mdgriffith$elm_animator$Animator$toSubscription = F3(
7465 function (toMsg, model, _v0) {
7466 var isRunning = _v0.a;
7467 return isRunning(model) ? $elm$browser$Browser$Events$onAnimationFrame(toMsg) : $elm$core$Platform$Sub$none;
7468 });
7469var $author$project$Main$subscriptions = function (model) {
7470 return $elm$core$Platform$Sub$batch(
7471 _List_fromArray(
7472 [
7473 A3($mdgriffith$elm_animator$Animator$toSubscription, $author$project$Main$Tick, model, $author$project$Main$animator),
7474 A2($rundis$elm_bootstrap$Bootstrap$Navbar$subscriptions, model.aK, $author$project$Main$NavbarMsg),
7475 $author$project$Main$messageReceiver($author$project$Main$ReceivedDataFromJS)
7476 ]));
7477};
7478var $elm$browser$Browser$Navigation$load = _Browser_load;
7479var $elm$core$Platform$Cmd$batch = _Platform_batch;
7480var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil);
7481var $elm$browser$Browser$Navigation$pushUrl = _Browser_pushUrl;
7482var $elm$json$Json$Encode$string = _Json_wrap;
7483var $author$project$Main$sendMsg = _Platform_outgoingPort('sendMsg', $elm$json$Json$Encode$string);
7484var $mdgriffith$elm_animator$Animator$TransitionTo = F2(
7485 function (a, b) {
7486 return {$: 1, a: a, b: b};
7487 });
7488var $mdgriffith$elm_animator$Animator$event = $mdgriffith$elm_animator$Animator$TransitionTo;
7489var $mdgriffith$elm_animator$Animator$initializeSchedule = F2(
7490 function (waiting, steps) {
7491 initializeSchedule:
7492 while (true) {
7493 if (!steps.b) {
7494 return $elm$core$Maybe$Nothing;
7495 } else {
7496 if (!steps.a.$) {
7497 var additionalWait = steps.a.a;
7498 var moreSteps = steps.b;
7499 var $temp$waiting = A2($ianmackenzie$elm_units$Quantity$plus, waiting, additionalWait),
7500 $temp$steps = moreSteps;
7501 waiting = $temp$waiting;
7502 steps = $temp$steps;
7503 continue initializeSchedule;
7504 } else {
7505 var _v1 = steps.a;
7506 var dur = _v1.a;
7507 var checkpoint = _v1.b;
7508 var moreSteps = steps.b;
7509 return $elm$core$Maybe$Just(
7510 _Utils_Tuple2(
7511 A3(
7512 $mdgriffith$elm_animator$Internal$Timeline$Schedule,
7513 waiting,
7514 A3($mdgriffith$elm_animator$Internal$Timeline$Event, dur, checkpoint, $elm$core$Maybe$Nothing),
7515 _List_Nil),
7516 moreSteps));
7517 }
7518 }
7519 }
7520 });
7521var $ianmackenzie$elm_units$Duration$seconds = function (numSeconds) {
7522 return numSeconds;
7523};
7524var $ianmackenzie$elm_units$Duration$milliseconds = function (numMilliseconds) {
7525 return $ianmackenzie$elm_units$Duration$seconds(0.001 * numMilliseconds);
7526};
7527var $mdgriffith$elm_animator$Animator$millis = $ianmackenzie$elm_units$Duration$milliseconds;
7528var $mdgriffith$elm_animator$Internal$Timeline$addToDwell = F2(
7529 function (duration, maybeDwell) {
7530 if (!$ianmackenzie$elm_units$Duration$inMilliseconds(duration)) {
7531 return maybeDwell;
7532 } else {
7533 if (maybeDwell.$ === 1) {
7534 return $elm$core$Maybe$Just(duration);
7535 } else {
7536 var existing = maybeDwell.a;
7537 return $elm$core$Maybe$Just(
7538 A2($ianmackenzie$elm_units$Quantity$plus, duration, existing));
7539 }
7540 }
7541 });
7542var $mdgriffith$elm_animator$Internal$Timeline$extendEventDwell = F2(
7543 function (extendBy, thisEvent) {
7544 var at = thisEvent.a;
7545 var ev = thisEvent.b;
7546 var maybeDwell = thisEvent.c;
7547 return (!$ianmackenzie$elm_units$Duration$inMilliseconds(extendBy)) ? thisEvent : A3(
7548 $mdgriffith$elm_animator$Internal$Timeline$Event,
7549 at,
7550 ev,
7551 A2($mdgriffith$elm_animator$Internal$Timeline$addToDwell, extendBy, maybeDwell));
7552 });
7553var $mdgriffith$elm_animator$Animator$stepsToEvents = F2(
7554 function (currentStep, _v0) {
7555 var delay = _v0.a;
7556 var startEvent = _v0.b;
7557 var events = _v0.c;
7558 if (!events.b) {
7559 if (!currentStep.$) {
7560 var waiting = currentStep.a;
7561 return A3(
7562 $mdgriffith$elm_animator$Internal$Timeline$Schedule,
7563 delay,
7564 A2($mdgriffith$elm_animator$Internal$Timeline$extendEventDwell, waiting, startEvent),
7565 events);
7566 } else {
7567 var dur = currentStep.a;
7568 var checkpoint = currentStep.b;
7569 return A3(
7570 $mdgriffith$elm_animator$Internal$Timeline$Schedule,
7571 delay,
7572 startEvent,
7573 _List_fromArray(
7574 [
7575 A3($mdgriffith$elm_animator$Internal$Timeline$Event, dur, checkpoint, $elm$core$Maybe$Nothing)
7576 ]));
7577 }
7578 } else {
7579 var _v3 = events.a;
7580 var durationTo = _v3.a;
7581 var recentEvent = _v3.b;
7582 var maybeDwell = _v3.c;
7583 var remaining = events.b;
7584 if (!currentStep.$) {
7585 var dur = currentStep.a;
7586 return A3(
7587 $mdgriffith$elm_animator$Internal$Timeline$Schedule,
7588 delay,
7589 startEvent,
7590 A2(
7591 $elm$core$List$cons,
7592 A3(
7593 $mdgriffith$elm_animator$Internal$Timeline$Event,
7594 durationTo,
7595 recentEvent,
7596 A2($mdgriffith$elm_animator$Internal$Timeline$addToDwell, dur, maybeDwell)),
7597 remaining));
7598 } else {
7599 var dur = currentStep.a;
7600 var checkpoint = currentStep.b;
7601 return _Utils_eq(checkpoint, recentEvent) ? A3(
7602 $mdgriffith$elm_animator$Internal$Timeline$Schedule,
7603 delay,
7604 startEvent,
7605 A2(
7606 $elm$core$List$cons,
7607 A3(
7608 $mdgriffith$elm_animator$Internal$Timeline$Event,
7609 durationTo,
7610 recentEvent,
7611 A2($mdgriffith$elm_animator$Internal$Timeline$addToDwell, dur, maybeDwell)),
7612 remaining)) : A3(
7613 $mdgriffith$elm_animator$Internal$Timeline$Schedule,
7614 delay,
7615 startEvent,
7616 A2(
7617 $elm$core$List$cons,
7618 A3($mdgriffith$elm_animator$Internal$Timeline$Event, dur, checkpoint, $elm$core$Maybe$Nothing),
7619 events));
7620 }
7621 }
7622 });
7623var $mdgriffith$elm_animator$Animator$interrupt = F2(
7624 function (steps, _v0) {
7625 var tl = _v0;
7626 return _Utils_update(
7627 tl,
7628 {
7629 aC: function () {
7630 var _v1 = A2(
7631 $mdgriffith$elm_animator$Animator$initializeSchedule,
7632 $mdgriffith$elm_animator$Animator$millis(0),
7633 steps);
7634 if (_v1.$ === 1) {
7635 return tl.aC;
7636 } else {
7637 var _v2 = _v1.a;
7638 var schedule = _v2.a;
7639 var otherSteps = _v2.b;
7640 return A2(
7641 $elm$core$List$cons,
7642 A3($elm$core$List$foldl, $mdgriffith$elm_animator$Animator$stepsToEvents, schedule, otherSteps),
7643 tl.aC);
7644 }
7645 }(),
7646 b7: true
7647 });
7648 });
7649var $mdgriffith$elm_animator$Animator$go = F3(
7650 function (duration, ev, timeline) {
7651 return A2(
7652 $mdgriffith$elm_animator$Animator$interrupt,
7653 _List_fromArray(
7654 [
7655 A2($mdgriffith$elm_animator$Animator$event, duration, ev)
7656 ]),
7657 timeline);
7658 });
7659var $mdgriffith$elm_animator$Animator$verySlowly = $mdgriffith$elm_animator$Animator$millis(500);
7660var $author$project$Main$toNewPage = F2(
7661 function (url, model) {
7662 var newPage = A2(
7663 $elm$core$Maybe$withDefault,
7664 4,
7665 A2($elm$url$Url$Parser$parse, $author$project$Main$urlParser, url));
7666 return _Utils_update(
7667 model,
7668 {
7669 x: A3($mdgriffith$elm_animator$Animator$go, $mdgriffith$elm_animator$Animator$verySlowly, newPage, model.x)
7670 });
7671 });
7672var $elm$url$Url$addPort = F2(
7673 function (maybePort, starter) {
7674 if (maybePort.$ === 1) {
7675 return starter;
7676 } else {
7677 var port_ = maybePort.a;
7678 return starter + (':' + $elm$core$String$fromInt(port_));
7679 }
7680 });
7681var $elm$url$Url$addPrefixed = F3(
7682 function (prefix, maybeSegment, starter) {
7683 if (maybeSegment.$ === 1) {
7684 return starter;
7685 } else {
7686 var segment = maybeSegment.a;
7687 return _Utils_ap(
7688 starter,
7689 _Utils_ap(prefix, segment));
7690 }
7691 });
7692var $elm$url$Url$toString = function (url) {
7693 var http = function () {
7694 var _v0 = url.dB;
7695 if (!_v0) {
7696 return 'http://';
7697 } else {
7698 return 'https://';
7699 }
7700 }();
7701 return A3(
7702 $elm$url$Url$addPrefixed,
7703 '#',
7704 url.db,
7705 A3(
7706 $elm$url$Url$addPrefixed,
7707 '?',
7708 url.dC,
7709 _Utils_ap(
7710 A2(
7711 $elm$url$Url$addPort,
7712 url.dx,
7713 _Utils_ap(http, url.dd)),
7714 url.dv)));
7715};
7716var $mdgriffith$elm_animator$Animator$update = F3(
7717 function (newTime, _v0, model) {
7718 var updateModel = _v0.b;
7719 return A2(updateModel, newTime, model);
7720 });
7721var $author$project$Main$update = F2(
7722 function (msg, model) {
7723 switch (msg.$) {
7724 case 0:
7725 var newTime = msg.a;
7726 return _Utils_Tuple2(
7727 A3($mdgriffith$elm_animator$Animator$update, newTime, $author$project$Main$animator, model),
7728 $elm$core$Platform$Cmd$none);
7729 case 1:
7730 var urlRequest = msg.a;
7731 if (!urlRequest.$) {
7732 var url = urlRequest.a;
7733 return _Utils_Tuple2(
7734 A2($author$project$Main$toNewPage, url, model),
7735 A2(
7736 $elm$browser$Browser$Navigation$pushUrl,
7737 model.cD,
7738 $elm$url$Url$toString(url)));
7739 } else {
7740 var url = urlRequest.a;
7741 return _Utils_Tuple2(
7742 model,
7743 $elm$browser$Browser$Navigation$load(url));
7744 }
7745 case 2:
7746 var url = msg.a;
7747 return _Utils_Tuple2(
7748 A2($author$project$Main$toNewPage, url, model),
7749 $elm$core$Platform$Cmd$none);
7750 case 3:
7751 var barMsg = msg.a;
7752 return _Utils_Tuple2(
7753 _Utils_update(
7754 model,
7755 {aK: barMsg}),
7756 $elm$core$Platform$Cmd$none);
7757 case 4:
7758 return _Utils_Tuple2(
7759 model,
7760 $author$project$Main$sendMsg('Hey javascript!'));
7761 default:
7762 var data = msg.a;
7763 return _Utils_Tuple2(
7764 _Utils_update(
7765 model,
7766 {cA: data}),
7767 $elm$core$Platform$Cmd$none);
7768 }
7769 });
7770var $rundis$elm_bootstrap$Bootstrap$Navbar$Brand = $elm$core$Basics$identity;
7771var $elm$html$Html$a = _VirtualDom_node('a');
7772var $elm$html$Html$Attributes$stringProperty = F2(
7773 function (key, string) {
7774 return A2(
7775 _VirtualDom_property,
7776 key,
7777 $elm$json$Json$Encode$string(string));
7778 });
7779var $elm$html$Html$Attributes$class = $elm$html$Html$Attributes$stringProperty('className');
7780var $rundis$elm_bootstrap$Bootstrap$Navbar$Config = $elm$core$Basics$identity;
7781var $rundis$elm_bootstrap$Bootstrap$Navbar$updateConfig = F2(
7782 function (mapper, _v0) {
7783 var conf = _v0;
7784 return mapper(conf);
7785 });
7786var $rundis$elm_bootstrap$Bootstrap$Navbar$brand = F3(
7787 function (attributes, children, config_) {
7788 return A2(
7789 $rundis$elm_bootstrap$Bootstrap$Navbar$updateConfig,
7790 function (conf) {
7791 return _Utils_update(
7792 conf,
7793 {
7794 at: $elm$core$Maybe$Just(
7795 A2(
7796 $elm$html$Html$a,
7797 _Utils_ap(
7798 _List_fromArray(
7799 [
7800 $elm$html$Html$Attributes$class('navbar-brand')
7801 ]),
7802 attributes),
7803 children))
7804 });
7805 },
7806 config_);
7807 });
7808var $elm$html$Html$button = _VirtualDom_node('button');
7809var $elm$core$Maybe$andThen = F2(
7810 function (callback, maybeValue) {
7811 if (!maybeValue.$) {
7812 var value = maybeValue.a;
7813 return callback(value);
7814 } else {
7815 return $elm$core$Maybe$Nothing;
7816 }
7817 });
7818var $rundis$elm_bootstrap$Bootstrap$Internal$Button$applyModifier = F2(
7819 function (modifier, options) {
7820 switch (modifier.$) {
7821 case 0:
7822 var size = modifier.a;
7823 return _Utils_update(
7824 options,
7825 {
7826 cb: $elm$core$Maybe$Just(size)
7827 });
7828 case 1:
7829 var coloring = modifier.a;
7830 return _Utils_update(
7831 options,
7832 {
7833 F: $elm$core$Maybe$Just(coloring)
7834 });
7835 case 2:
7836 return _Utils_update(
7837 options,
7838 {bc: true});
7839 case 3:
7840 var val = modifier.a;
7841 return _Utils_update(
7842 options,
7843 {bm: val});
7844 default:
7845 var attrs = modifier.a;
7846 return _Utils_update(
7847 options,
7848 {
7849 a9: _Utils_ap(options.a9, attrs)
7850 });
7851 }
7852 });
7853var $elm$core$List$filter = F2(
7854 function (isGood, list) {
7855 return A3(
7856 $elm$core$List$foldr,
7857 F2(
7858 function (x, xs) {
7859 return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs;
7860 }),
7861 _List_Nil,
7862 list);
7863 });
7864var $elm$html$Html$Attributes$classList = function (classes) {
7865 return $elm$html$Html$Attributes$class(
7866 A2(
7867 $elm$core$String$join,
7868 ' ',
7869 A2(
7870 $elm$core$List$map,
7871 $elm$core$Tuple$first,
7872 A2($elm$core$List$filter, $elm$core$Tuple$second, classes))));
7873};
7874var $rundis$elm_bootstrap$Bootstrap$Internal$Button$defaultOptions = {a9: _List_Nil, bc: false, F: $elm$core$Maybe$Nothing, bm: false, cb: $elm$core$Maybe$Nothing};
7875var $elm$json$Json$Encode$bool = _Json_wrap;
7876var $elm$html$Html$Attributes$boolProperty = F2(
7877 function (key, bool) {
7878 return A2(
7879 _VirtualDom_property,
7880 key,
7881 $elm$json$Json$Encode$bool(bool));
7882 });
7883var $elm$html$Html$Attributes$disabled = $elm$html$Html$Attributes$boolProperty('disabled');
7884var $rundis$elm_bootstrap$Bootstrap$Internal$Button$roleClass = function (role) {
7885 switch (role) {
7886 case 0:
7887 return 'primary';
7888 case 1:
7889 return 'secondary';
7890 case 2:
7891 return 'success';
7892 case 3:
7893 return 'info';
7894 case 4:
7895 return 'warning';
7896 case 5:
7897 return 'danger';
7898 case 6:
7899 return 'dark';
7900 case 7:
7901 return 'light';
7902 default:
7903 return 'link';
7904 }
7905};
7906var $rundis$elm_bootstrap$Bootstrap$General$Internal$screenSizeOption = function (size) {
7907 switch (size) {
7908 case 0:
7909 return $elm$core$Maybe$Nothing;
7910 case 1:
7911 return $elm$core$Maybe$Just('sm');
7912 case 2:
7913 return $elm$core$Maybe$Just('md');
7914 case 3:
7915 return $elm$core$Maybe$Just('lg');
7916 default:
7917 return $elm$core$Maybe$Just('xl');
7918 }
7919};
7920var $rundis$elm_bootstrap$Bootstrap$Internal$Button$buttonAttributes = function (modifiers) {
7921 var options = A3($elm$core$List$foldl, $rundis$elm_bootstrap$Bootstrap$Internal$Button$applyModifier, $rundis$elm_bootstrap$Bootstrap$Internal$Button$defaultOptions, modifiers);
7922 return _Utils_ap(
7923 _List_fromArray(
7924 [
7925 $elm$html$Html$Attributes$classList(
7926 _List_fromArray(
7927 [
7928 _Utils_Tuple2('btn', true),
7929 _Utils_Tuple2('btn-block', options.bc),
7930 _Utils_Tuple2('disabled', options.bm)
7931 ])),
7932 $elm$html$Html$Attributes$disabled(options.bm)
7933 ]),
7934 _Utils_ap(
7935 function () {
7936 var _v0 = A2($elm$core$Maybe$andThen, $rundis$elm_bootstrap$Bootstrap$General$Internal$screenSizeOption, options.cb);
7937 if (!_v0.$) {
7938 var s = _v0.a;
7939 return _List_fromArray(
7940 [
7941 $elm$html$Html$Attributes$class('btn-' + s)
7942 ]);
7943 } else {
7944 return _List_Nil;
7945 }
7946 }(),
7947 _Utils_ap(
7948 function () {
7949 var _v1 = options.F;
7950 if (!_v1.$) {
7951 if (!_v1.a.$) {
7952 var role = _v1.a.a;
7953 return _List_fromArray(
7954 [
7955 $elm$html$Html$Attributes$class(
7956 'btn-' + $rundis$elm_bootstrap$Bootstrap$Internal$Button$roleClass(role))
7957 ]);
7958 } else {
7959 var role = _v1.a.a;
7960 return _List_fromArray(
7961 [
7962 $elm$html$Html$Attributes$class(
7963 'btn-outline-' + $rundis$elm_bootstrap$Bootstrap$Internal$Button$roleClass(role))
7964 ]);
7965 }
7966 } else {
7967 return _List_Nil;
7968 }
7969 }(),
7970 options.a9)));
7971};
7972var $rundis$elm_bootstrap$Bootstrap$Button$button = F2(
7973 function (options, children) {
7974 return A2(
7975 $elm$html$Html$button,
7976 $rundis$elm_bootstrap$Bootstrap$Internal$Button$buttonAttributes(options),
7977 children);
7978 });
7979var $rundis$elm_bootstrap$Bootstrap$Internal$Role$Light = 6;
7980var $rundis$elm_bootstrap$Bootstrap$Navbar$Light = 1;
7981var $rundis$elm_bootstrap$Bootstrap$Navbar$Roled = function (a) {
7982 return {$: 0, a: a};
7983};
7984var $rundis$elm_bootstrap$Bootstrap$General$Internal$XS = 0;
7985var $rundis$elm_bootstrap$Bootstrap$Navbar$config = function (toMsg) {
7986 return {
7987 at: $elm$core$Maybe$Nothing,
7988 bj: _List_Nil,
7989 dk: _List_Nil,
7990 cG: {
7991 a9: _List_Nil,
7992 ag: $elm$core$Maybe$Nothing,
7993 bw: false,
7994 b8: $elm$core$Maybe$Just(
7995 {
7996 bb: $rundis$elm_bootstrap$Bootstrap$Navbar$Roled(6),
7997 bC: 1
7998 }),
7999 aS: 0
8000 },
8001 cW: toMsg,
8002 V: false
8003 };
8004};
8005var $elm$html$Html$div = _VirtualDom_node('div');
8006var $elm$html$Html$Attributes$href = function (url) {
8007 return A2(
8008 $elm$html$Html$Attributes$stringProperty,
8009 'href',
8010 _VirtualDom_noJavaScriptUri(url));
8011};
8012var $elm$html$Html$Attributes$id = $elm$html$Html$Attributes$stringProperty('id');
8013var $rundis$elm_bootstrap$Bootstrap$Navbar$Item = function (a) {
8014 return {$: 0, a: a};
8015};
8016var $rundis$elm_bootstrap$Bootstrap$Navbar$itemLink = F2(
8017 function (attributes, children) {
8018 return $rundis$elm_bootstrap$Bootstrap$Navbar$Item(
8019 {a9: attributes, c2: children});
8020 });
8021var $rundis$elm_bootstrap$Bootstrap$Navbar$items = F2(
8022 function (items_, config_) {
8023 return A2(
8024 $rundis$elm_bootstrap$Bootstrap$Navbar$updateConfig,
8025 function (conf) {
8026 return _Utils_update(
8027 conf,
8028 {dk: items_});
8029 },
8030 config_);
8031 });
8032var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text;
8033var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text;
8034var $author$project$Main$loremIpsum = A2(
8035 $elm$html$Html$div,
8036 _List_Nil,
8037 _List_fromArray(
8038 [
8039 A2(
8040 $elm$html$Html$div,
8041 _List_Nil,
8042 _List_fromArray(
8043 [
8044 $elm$html$Html$text('Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry\'s standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.')
8045 ])),
8046 A2(
8047 $elm$html$Html$div,
8048 _List_Nil,
8049 _List_fromArray(
8050 [
8051 $elm$html$Html$text('Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from 45 BC, making it over 2000 years old. Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source. Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of \"de Finibus Bonorum et Malorum\" (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory of ethics, very popular during the Renaissance. The first line of Lorem Ipsum, \"Lorem ipsum dolor sit amet..\", comes from a line in section 1.10.32.')
8052 ])),
8053 A2(
8054 $elm$html$Html$div,
8055 _List_Nil,
8056 _List_fromArray(
8057 [
8058 $elm$html$Html$text('The standard chunk of Lorem Ipsum used since the 1500s is reproduced below for those interested. Sections 1.10.32 and 1.10.33 from \"de Finibus Bonorum et Malorum\" by Cicero are also reproduced in their exact original form, accompanied by English versions from the 1914 translation by H. Rackham. TEST-DEPLOY')
8059 ]))
8060 ]));
8061var $elm$url$Url$Builder$toQueryPair = function (_v0) {
8062 var key = _v0.a;
8063 var value = _v0.b;
8064 return key + ('=' + value);
8065};
8066var $elm$url$Url$Builder$toQuery = function (parameters) {
8067 if (!parameters.b) {
8068 return '';
8069 } else {
8070 return '?' + A2(
8071 $elm$core$String$join,
8072 '&',
8073 A2($elm$core$List$map, $elm$url$Url$Builder$toQueryPair, parameters));
8074 }
8075};
8076var $elm$url$Url$Builder$absolute = F2(
8077 function (pathSegments, parameters) {
8078 return '/' + (A2($elm$core$String$join, '/', pathSegments) + $elm$url$Url$Builder$toQuery(parameters));
8079 });
8080var $author$project$Main$pageToUrl = function (page) {
8081 switch (page) {
8082 case 0:
8083 return A2($elm$url$Url$Builder$absolute, _List_Nil, _List_Nil);
8084 case 1:
8085 return A2(
8086 $elm$url$Url$Builder$absolute,
8087 _List_fromArray(
8088 ['about']),
8089 _List_Nil);
8090 case 2:
8091 return A2(
8092 $elm$url$Url$Builder$absolute,
8093 _List_fromArray(
8094 ['blog']),
8095 _List_Nil);
8096 case 3:
8097 return A2(
8098 $elm$url$Url$Builder$absolute,
8099 _List_fromArray(
8100 ['login']),
8101 _List_Nil);
8102 default:
8103 return A2(
8104 $elm$url$Url$Builder$absolute,
8105 _List_fromArray(
8106 ['notfound']),
8107 _List_Nil);
8108 }
8109};
8110var $rundis$elm_bootstrap$Bootstrap$Internal$Button$Coloring = function (a) {
8111 return {$: 1, a: a};
8112};
8113var $rundis$elm_bootstrap$Bootstrap$Internal$Button$Primary = 0;
8114var $rundis$elm_bootstrap$Bootstrap$Internal$Button$Roled = function (a) {
8115 return {$: 0, a: a};
8116};
8117var $rundis$elm_bootstrap$Bootstrap$Button$primary = $rundis$elm_bootstrap$Bootstrap$Internal$Button$Coloring(
8118 $rundis$elm_bootstrap$Bootstrap$Internal$Button$Roled(0));
8119var $elm$virtual_dom$VirtualDom$node = function (tag) {
8120 return _VirtualDom_node(
8121 _VirtualDom_noScript(tag));
8122};
8123var $elm$html$Html$node = $elm$virtual_dom$VirtualDom$node;
8124var $author$project$Main$stylesheet = A3(
8125 $elm$html$Html$node,
8126 'style',
8127 _List_Nil,
8128 _List_fromArray(
8129 [
8130 $elm$html$Html$text('@import url(\'https://fonts.googleapis.com/css?family=Roboto&display=swap\');\n\na {\n text-decoration: none;\n color: black;\n}\n\na:visited {\n text-decoration: none;\n color: black;\n}\n.root {\n width: 100%;\n height: 1000px;\n font-size: 16px;\n user-select: none;\n padding: 50px;\n font-family: \'Roboto\', sans-serif;\n}\n.page-row {\n display: flex;\n flex-direction: row;\n align-items: center;\n justify-content: center;\n padding: 100px;\n transform: scale(0.2);\n}\n.page {\n width: 500px;\n padding: 48px;\n border: 1px solid black;\n border-radius: 2px;\n flex-shrink: 0;\n background-color: white;\n}\n\n')
8131 ]));
8132var $rundis$elm_bootstrap$Bootstrap$Navbar$maybeBrand = function (brand_) {
8133 if (!brand_.$) {
8134 var b = brand_.a;
8135 return _List_fromArray(
8136 [b]);
8137 } else {
8138 return _List_Nil;
8139 }
8140};
8141var $elm$core$Basics$not = _Basics_not;
8142var $elm$virtual_dom$VirtualDom$Normal = function (a) {
8143 return {$: 0, a: a};
8144};
8145var $elm$virtual_dom$VirtualDom$on = _VirtualDom_on;
8146var $elm$html$Html$Events$on = F2(
8147 function (event, decoder) {
8148 return A2(
8149 $elm$virtual_dom$VirtualDom$on,
8150 event,
8151 $elm$virtual_dom$VirtualDom$Normal(decoder));
8152 });
8153var $rundis$elm_bootstrap$Bootstrap$Navbar$sizeToComparable = function (size) {
8154 switch (size) {
8155 case 0:
8156 return 1;
8157 case 1:
8158 return 2;
8159 case 2:
8160 return 3;
8161 case 3:
8162 return 4;
8163 default:
8164 return 5;
8165 }
8166};
8167var $rundis$elm_bootstrap$Bootstrap$General$Internal$LG = 3;
8168var $rundis$elm_bootstrap$Bootstrap$General$Internal$MD = 2;
8169var $rundis$elm_bootstrap$Bootstrap$General$Internal$SM = 1;
8170var $rundis$elm_bootstrap$Bootstrap$General$Internal$XL = 4;
8171var $rundis$elm_bootstrap$Bootstrap$Navbar$toScreenSize = function (windowWidth) {
8172 return (windowWidth <= 576) ? 0 : ((windowWidth <= 768) ? 1 : ((windowWidth <= 992) ? 2 : ((windowWidth <= 1200) ? 3 : 4)));
8173};
8174var $rundis$elm_bootstrap$Bootstrap$Navbar$shouldHideMenu = F2(
8175 function (_v0, _v1) {
8176 var windowWidth = _v0.a_;
8177 var options = _v1.cG;
8178 var winMedia = function () {
8179 if (!windowWidth.$) {
8180 var s = windowWidth.a;
8181 return $rundis$elm_bootstrap$Bootstrap$Navbar$toScreenSize(s);
8182 } else {
8183 return 0;
8184 }
8185 }();
8186 return _Utils_cmp(
8187 $rundis$elm_bootstrap$Bootstrap$Navbar$sizeToComparable(winMedia),
8188 $rundis$elm_bootstrap$Bootstrap$Navbar$sizeToComparable(options.aS)) > 0;
8189 });
8190var $elm$virtual_dom$VirtualDom$style = _VirtualDom_style;
8191var $elm$html$Html$Attributes$style = $elm$virtual_dom$VirtualDom$style;
8192var $rundis$elm_bootstrap$Bootstrap$Navbar$Shown = 5;
8193var $rundis$elm_bootstrap$Bootstrap$Navbar$StartDown = 1;
8194var $rundis$elm_bootstrap$Bootstrap$Navbar$StartUp = 3;
8195var $rundis$elm_bootstrap$Bootstrap$Navbar$visibilityTransition = F2(
8196 function (withAnimation_, visibility) {
8197 var _v0 = _Utils_Tuple2(withAnimation_, visibility);
8198 if (_v0.a) {
8199 switch (_v0.b) {
8200 case 0:
8201 var _v1 = _v0.b;
8202 return 1;
8203 case 1:
8204 var _v2 = _v0.b;
8205 return 2;
8206 case 2:
8207 var _v3 = _v0.b;
8208 return 5;
8209 case 5:
8210 var _v4 = _v0.b;
8211 return 3;
8212 case 3:
8213 var _v5 = _v0.b;
8214 return 4;
8215 default:
8216 var _v6 = _v0.b;
8217 return 0;
8218 }
8219 } else {
8220 switch (_v0.b) {
8221 case 0:
8222 var _v7 = _v0.b;
8223 return 5;
8224 case 5:
8225 var _v8 = _v0.b;
8226 return 0;
8227 default:
8228 return 0;
8229 }
8230 }
8231 });
8232var $rundis$elm_bootstrap$Bootstrap$Navbar$transitionHandler = F2(
8233 function (state, configRec) {
8234 return $elm$json$Json$Decode$succeed(
8235 configRec.cW(
8236 A2(
8237 $rundis$elm_bootstrap$Bootstrap$Navbar$mapState,
8238 function (s) {
8239 return _Utils_update(
8240 s,
8241 {
8242 j: A2($rundis$elm_bootstrap$Bootstrap$Navbar$visibilityTransition, configRec.V, s.j)
8243 });
8244 },
8245 state)));
8246 });
8247var $elm$core$String$fromFloat = _String_fromNumber;
8248var $rundis$elm_bootstrap$Bootstrap$Navbar$transitionStyle = function (maybeHeight) {
8249 var pixelHeight = A2(
8250 $elm$core$Maybe$withDefault,
8251 '0',
8252 A2(
8253 $elm$core$Maybe$map,
8254 function (v) {
8255 return $elm$core$String$fromFloat(v) + 'px';
8256 },
8257 maybeHeight));
8258 return _List_fromArray(
8259 [
8260 A2($elm$html$Html$Attributes$style, 'position', 'relative'),
8261 A2($elm$html$Html$Attributes$style, 'height', pixelHeight),
8262 A2($elm$html$Html$Attributes$style, 'width', '100%'),
8263 A2($elm$html$Html$Attributes$style, 'overflow', 'hidden'),
8264 A2($elm$html$Html$Attributes$style, '-webkit-transition-timing-function', 'ease'),
8265 A2($elm$html$Html$Attributes$style, '-o-transition-timing-function', 'ease'),
8266 A2($elm$html$Html$Attributes$style, 'transition-timing-function', 'ease'),
8267 A2($elm$html$Html$Attributes$style, '-webkit-transition-duration', '0.35s'),
8268 A2($elm$html$Html$Attributes$style, '-o-transition-duration', '0.35s'),
8269 A2($elm$html$Html$Attributes$style, 'transition-duration', '0.35s'),
8270 A2($elm$html$Html$Attributes$style, '-webkit-transition-property', 'height'),
8271 A2($elm$html$Html$Attributes$style, '-o-transition-property', 'height'),
8272 A2($elm$html$Html$Attributes$style, 'transition-property', 'height')
8273 ]);
8274};
8275var $rundis$elm_bootstrap$Bootstrap$Navbar$menuAttributes = F2(
8276 function (state, configRec) {
8277 var visibility = state.j;
8278 var height = state.dc;
8279 var defaults = _List_fromArray(
8280 [
8281 $elm$html$Html$Attributes$class('collapse navbar-collapse')
8282 ]);
8283 switch (visibility) {
8284 case 0:
8285 if (height.$ === 1) {
8286 return ((!configRec.V) || A2($rundis$elm_bootstrap$Bootstrap$Navbar$shouldHideMenu, state, configRec)) ? defaults : _List_fromArray(
8287 [
8288 A2($elm$html$Html$Attributes$style, 'display', 'block'),
8289 A2($elm$html$Html$Attributes$style, 'height', '0'),
8290 A2($elm$html$Html$Attributes$style, 'overflow', 'hidden'),
8291 A2($elm$html$Html$Attributes$style, 'width', '100%')
8292 ]);
8293 } else {
8294 return defaults;
8295 }
8296 case 1:
8297 return $rundis$elm_bootstrap$Bootstrap$Navbar$transitionStyle($elm$core$Maybe$Nothing);
8298 case 2:
8299 return _Utils_ap(
8300 $rundis$elm_bootstrap$Bootstrap$Navbar$transitionStyle(height),
8301 _List_fromArray(
8302 [
8303 A2(
8304 $elm$html$Html$Events$on,
8305 'transitionend',
8306 A2($rundis$elm_bootstrap$Bootstrap$Navbar$transitionHandler, state, configRec))
8307 ]));
8308 case 4:
8309 return _Utils_ap(
8310 $rundis$elm_bootstrap$Bootstrap$Navbar$transitionStyle($elm$core$Maybe$Nothing),
8311 _List_fromArray(
8312 [
8313 A2(
8314 $elm$html$Html$Events$on,
8315 'transitionend',
8316 A2($rundis$elm_bootstrap$Bootstrap$Navbar$transitionHandler, state, configRec))
8317 ]));
8318 case 3:
8319 return $rundis$elm_bootstrap$Bootstrap$Navbar$transitionStyle(height);
8320 default:
8321 return _Utils_ap(
8322 defaults,
8323 _List_fromArray(
8324 [
8325 $elm$html$Html$Attributes$class('show')
8326 ]));
8327 }
8328 });
8329var $rundis$elm_bootstrap$Bootstrap$Navbar$menuWrapperAttributes = F2(
8330 function (state, confRec) {
8331 var visibility = state.j;
8332 var height = state.dc;
8333 var styleBlock = _List_fromArray(
8334 [
8335 A2($elm$html$Html$Attributes$style, 'display', 'block'),
8336 A2($elm$html$Html$Attributes$style, 'width', '100%')
8337 ]);
8338 var display = function () {
8339 if (height.$ === 1) {
8340 return ((!confRec.V) || A2($rundis$elm_bootstrap$Bootstrap$Navbar$shouldHideMenu, state, confRec)) ? 'flex' : 'block';
8341 } else {
8342 return 'flex';
8343 }
8344 }();
8345 switch (visibility) {
8346 case 0:
8347 return _List_fromArray(
8348 [
8349 A2($elm$html$Html$Attributes$style, 'display', display),
8350 A2($elm$html$Html$Attributes$style, 'width', '100%')
8351 ]);
8352 case 1:
8353 return styleBlock;
8354 case 2:
8355 return styleBlock;
8356 case 4:
8357 return styleBlock;
8358 case 3:
8359 return styleBlock;
8360 default:
8361 return ((!confRec.V) || A2($rundis$elm_bootstrap$Bootstrap$Navbar$shouldHideMenu, state, confRec)) ? _List_fromArray(
8362 [
8363 $elm$html$Html$Attributes$class('collapse navbar-collapse show')
8364 ]) : _List_fromArray(
8365 [
8366 A2($elm$html$Html$Attributes$style, 'display', 'block')
8367 ]);
8368 }
8369 });
8370var $elm$html$Html$nav = _VirtualDom_node('nav');
8371var $rundis$elm_bootstrap$Bootstrap$Navbar$expandOption = function (size) {
8372 var toClass = function (sz) {
8373 return $elm$html$Html$Attributes$class(
8374 'navbar-expand' + A2(
8375 $elm$core$Maybe$withDefault,
8376 '',
8377 A2(
8378 $elm$core$Maybe$map,
8379 function (s) {
8380 return '-' + s;
8381 },
8382 $rundis$elm_bootstrap$Bootstrap$General$Internal$screenSizeOption(sz))));
8383 };
8384 switch (size) {
8385 case 0:
8386 return _List_fromArray(
8387 [
8388 toClass(1)
8389 ]);
8390 case 1:
8391 return _List_fromArray(
8392 [
8393 toClass(2)
8394 ]);
8395 case 2:
8396 return _List_fromArray(
8397 [
8398 toClass(3)
8399 ]);
8400 case 3:
8401 return _List_fromArray(
8402 [
8403 toClass(4)
8404 ]);
8405 default:
8406 return _List_Nil;
8407 }
8408};
8409var $rundis$elm_bootstrap$Bootstrap$Navbar$fixOption = function (fix) {
8410 if (!fix) {
8411 return 'fixed-top';
8412 } else {
8413 return 'fixed-bottom';
8414 }
8415};
8416var $rundis$elm_bootstrap$Bootstrap$Internal$Role$toClass = F2(
8417 function (prefix, role) {
8418 return $elm$html$Html$Attributes$class(
8419 prefix + ('-' + function () {
8420 switch (role) {
8421 case 0:
8422 return 'primary';
8423 case 1:
8424 return 'secondary';
8425 case 2:
8426 return 'success';
8427 case 3:
8428 return 'info';
8429 case 4:
8430 return 'warning';
8431 case 5:
8432 return 'danger';
8433 case 6:
8434 return 'light';
8435 default:
8436 return 'dark';
8437 }
8438 }()));
8439 });
8440var $elm$core$String$concat = function (strings) {
8441 return A2($elm$core$String$join, '', strings);
8442};
8443var $elm$core$Basics$round = _Basics_round;
8444var $avh4$elm_color$Color$toCssString = function (_v0) {
8445 var r = _v0.a;
8446 var g = _v0.b;
8447 var b = _v0.c;
8448 var a = _v0.d;
8449 var roundTo = function (x) {
8450 return $elm$core$Basics$round(x * 1000) / 1000;
8451 };
8452 var pct = function (x) {
8453 return $elm$core$Basics$round(x * 10000) / 100;
8454 };
8455 return $elm$core$String$concat(
8456 _List_fromArray(
8457 [
8458 'rgba(',
8459 $elm$core$String$fromFloat(
8460 pct(r)),
8461 '%,',
8462 $elm$core$String$fromFloat(
8463 pct(g)),
8464 '%,',
8465 $elm$core$String$fromFloat(
8466 pct(b)),
8467 '%,',
8468 $elm$core$String$fromFloat(
8469 roundTo(a)),
8470 ')'
8471 ]));
8472};
8473var $rundis$elm_bootstrap$Bootstrap$Navbar$backgroundColorOption = function (bgClass) {
8474 switch (bgClass.$) {
8475 case 0:
8476 var role = bgClass.a;
8477 return A2($rundis$elm_bootstrap$Bootstrap$Internal$Role$toClass, 'bg', role);
8478 case 1:
8479 var color = bgClass.a;
8480 return A2(
8481 $elm$html$Html$Attributes$style,
8482 'background-color',
8483 $avh4$elm_color$Color$toCssString(color));
8484 default:
8485 var classString = bgClass.a;
8486 return $elm$html$Html$Attributes$class(classString);
8487 }
8488};
8489var $rundis$elm_bootstrap$Bootstrap$Navbar$linkModifierClass = function (modifier) {
8490 return $elm$html$Html$Attributes$class(
8491 function () {
8492 if (!modifier) {
8493 return 'navbar-dark';
8494 } else {
8495 return 'navbar-light';
8496 }
8497 }());
8498};
8499var $rundis$elm_bootstrap$Bootstrap$Navbar$schemeAttributes = function (_v0) {
8500 var modifier = _v0.bC;
8501 var bgColor = _v0.bb;
8502 return _List_fromArray(
8503 [
8504 $rundis$elm_bootstrap$Bootstrap$Navbar$linkModifierClass(modifier),
8505 $rundis$elm_bootstrap$Bootstrap$Navbar$backgroundColorOption(bgColor)
8506 ]);
8507};
8508var $rundis$elm_bootstrap$Bootstrap$Navbar$navbarAttributes = function (options) {
8509 return _Utils_ap(
8510 _List_fromArray(
8511 [
8512 $elm$html$Html$Attributes$classList(
8513 _List_fromArray(
8514 [
8515 _Utils_Tuple2('navbar', true),
8516 _Utils_Tuple2('container', options.bw)
8517 ]))
8518 ]),
8519 _Utils_ap(
8520 $rundis$elm_bootstrap$Bootstrap$Navbar$expandOption(options.aS),
8521 _Utils_ap(
8522 function () {
8523 var _v0 = options.b8;
8524 if (!_v0.$) {
8525 var scheme_ = _v0.a;
8526 return $rundis$elm_bootstrap$Bootstrap$Navbar$schemeAttributes(scheme_);
8527 } else {
8528 return _List_Nil;
8529 }
8530 }(),
8531 _Utils_ap(
8532 function () {
8533 var _v1 = options.ag;
8534 if (!_v1.$) {
8535 var fix = _v1.a;
8536 return _List_fromArray(
8537 [
8538 $elm$html$Html$Attributes$class(
8539 $rundis$elm_bootstrap$Bootstrap$Navbar$fixOption(fix))
8540 ]);
8541 } else {
8542 return _List_Nil;
8543 }
8544 }(),
8545 options.a9))));
8546};
8547var $rundis$elm_bootstrap$Bootstrap$Navbar$renderCustom = function (items_) {
8548 return A2(
8549 $elm$core$List$map,
8550 function (_v0) {
8551 var item = _v0;
8552 return item;
8553 },
8554 items_);
8555};
8556var $rundis$elm_bootstrap$Bootstrap$Navbar$getOrInitDropdownStatus = F2(
8557 function (id, _v0) {
8558 var dropdowns = _v0.O;
8559 return A2(
8560 $elm$core$Maybe$withDefault,
8561 2,
8562 A2($elm$core$Dict$get, id, dropdowns));
8563 });
8564var $elm$html$Html$li = _VirtualDom_node('li');
8565var $elm$core$Basics$neq = _Utils_notEqual;
8566var $elm$virtual_dom$VirtualDom$Custom = function (a) {
8567 return {$: 3, a: a};
8568};
8569var $elm$html$Html$Events$custom = F2(
8570 function (event, decoder) {
8571 return A2(
8572 $elm$virtual_dom$VirtualDom$on,
8573 event,
8574 $elm$virtual_dom$VirtualDom$Custom(decoder));
8575 });
8576var $rundis$elm_bootstrap$Bootstrap$Navbar$toggleOpen = F3(
8577 function (state, id, _v0) {
8578 var toMsg = _v0.cW;
8579 var currStatus = A2($rundis$elm_bootstrap$Bootstrap$Navbar$getOrInitDropdownStatus, id, state);
8580 var newStatus = function () {
8581 switch (currStatus) {
8582 case 0:
8583 return 2;
8584 case 1:
8585 return 2;
8586 default:
8587 return 0;
8588 }
8589 }();
8590 return toMsg(
8591 A2(
8592 $rundis$elm_bootstrap$Bootstrap$Navbar$mapState,
8593 function (s) {
8594 return _Utils_update(
8595 s,
8596 {
8597 O: A3($elm$core$Dict$insert, id, newStatus, s.O)
8598 });
8599 },
8600 state));
8601 });
8602var $rundis$elm_bootstrap$Bootstrap$Navbar$renderDropdownToggle = F4(
8603 function (state, id, configRec, _v0) {
8604 var attributes = _v0.a9;
8605 var children = _v0.c2;
8606 return A2(
8607 $elm$html$Html$a,
8608 _Utils_ap(
8609 _List_fromArray(
8610 [
8611 $elm$html$Html$Attributes$class('nav-link dropdown-toggle'),
8612 $elm$html$Html$Attributes$href('#'),
8613 A2(
8614 $elm$html$Html$Events$custom,
8615 'click',
8616 $elm$json$Json$Decode$succeed(
8617 {
8618 I: A3($rundis$elm_bootstrap$Bootstrap$Navbar$toggleOpen, state, id, configRec),
8619 cM: true,
8620 cS: false
8621 }))
8622 ]),
8623 attributes),
8624 children);
8625 });
8626var $rundis$elm_bootstrap$Bootstrap$Navbar$renderDropdown = F3(
8627 function (state, configRec, _v0) {
8628 var ddRec = _v0;
8629 var needsDropup = A2(
8630 $elm$core$Maybe$withDefault,
8631 false,
8632 A2(
8633 $elm$core$Maybe$map,
8634 function (fix) {
8635 if (fix === 1) {
8636 return true;
8637 } else {
8638 return false;
8639 }
8640 },
8641 configRec.cG.ag));
8642 var isShown = A2($rundis$elm_bootstrap$Bootstrap$Navbar$getOrInitDropdownStatus, ddRec.ek, state) !== 2;
8643 return A2(
8644 $elm$html$Html$li,
8645 _List_fromArray(
8646 [
8647 $elm$html$Html$Attributes$classList(
8648 _List_fromArray(
8649 [
8650 _Utils_Tuple2('nav-item', true),
8651 _Utils_Tuple2('dropdown', true),
8652 _Utils_Tuple2('shown', isShown),
8653 _Utils_Tuple2('dropup', needsDropup)
8654 ]))
8655 ]),
8656 _List_fromArray(
8657 [
8658 A4($rundis$elm_bootstrap$Bootstrap$Navbar$renderDropdownToggle, state, ddRec.ek, configRec, ddRec.dQ),
8659 A2(
8660 $elm$html$Html$div,
8661 _List_fromArray(
8662 [
8663 $elm$html$Html$Attributes$classList(
8664 _List_fromArray(
8665 [
8666 _Utils_Tuple2('dropdown-menu', true),
8667 _Utils_Tuple2('show', isShown)
8668 ]))
8669 ]),
8670 A2(
8671 $elm$core$List$map,
8672 function (_v1) {
8673 var item = _v1;
8674 return item;
8675 },
8676 ddRec.dk))
8677 ]));
8678 });
8679var $rundis$elm_bootstrap$Bootstrap$Navbar$renderItemLink = function (_v0) {
8680 var attributes = _v0.a9;
8681 var children = _v0.c2;
8682 return A2(
8683 $elm$html$Html$li,
8684 _List_fromArray(
8685 [
8686 $elm$html$Html$Attributes$class('nav-item')
8687 ]),
8688 _List_fromArray(
8689 [
8690 A2(
8691 $elm$html$Html$a,
8692 _Utils_ap(
8693 _List_fromArray(
8694 [
8695 $elm$html$Html$Attributes$class('nav-link')
8696 ]),
8697 attributes),
8698 children)
8699 ]));
8700};
8701var $elm$html$Html$ul = _VirtualDom_node('ul');
8702var $rundis$elm_bootstrap$Bootstrap$Navbar$renderNav = F3(
8703 function (state, configRec, navItems) {
8704 return A2(
8705 $elm$html$Html$ul,
8706 _List_fromArray(
8707 [
8708 $elm$html$Html$Attributes$class('navbar-nav mr-auto')
8709 ]),
8710 A2(
8711 $elm$core$List$map,
8712 function (item) {
8713 if (!item.$) {
8714 var item_ = item.a;
8715 return $rundis$elm_bootstrap$Bootstrap$Navbar$renderItemLink(item_);
8716 } else {
8717 var dropdown_ = item.a;
8718 return A3($rundis$elm_bootstrap$Bootstrap$Navbar$renderDropdown, state, configRec, dropdown_);
8719 }
8720 },
8721 navItems));
8722 });
8723var $elm$html$Html$span = _VirtualDom_node('span');
8724var $elm$json$Json$Decode$andThen = _Json_andThen;
8725var $elm$json$Json$Decode$at = F2(
8726 function (fields, decoder) {
8727 return A3($elm$core$List$foldr, $elm$json$Json$Decode$field, decoder, fields);
8728 });
8729var $elm$json$Json$Decode$decodeValue = _Json_run;
8730var $elm$json$Json$Decode$fail = _Json_fail;
8731var $elm$json$Json$Decode$float = _Json_decodeFloat;
8732var $elm$json$Json$Decode$oneOf = _Json_oneOf;
8733var $rundis$elm_bootstrap$Bootstrap$Utilities$DomHelper$parentElement = function (decoder) {
8734 return A2($elm$json$Json$Decode$field, 'parentElement', decoder);
8735};
8736var $rundis$elm_bootstrap$Bootstrap$Utilities$DomHelper$target = function (decoder) {
8737 return A2($elm$json$Json$Decode$field, 'target', decoder);
8738};
8739var $elm$json$Json$Decode$value = _Json_decodeValue;
8740var $rundis$elm_bootstrap$Bootstrap$Navbar$heightDecoder = function () {
8741 var tagDecoder = A3(
8742 $elm$json$Json$Decode$map2,
8743 F2(
8744 function (tag, val) {
8745 return _Utils_Tuple2(tag, val);
8746 }),
8747 A2($elm$json$Json$Decode$field, 'tagName', $elm$json$Json$Decode$string),
8748 $elm$json$Json$Decode$value);
8749 var resToDec = function (res) {
8750 if (!res.$) {
8751 var v = res.a;
8752 return $elm$json$Json$Decode$succeed(v);
8753 } else {
8754 var err = res.a;
8755 return $elm$json$Json$Decode$fail(
8756 $elm$json$Json$Decode$errorToString(err));
8757 }
8758 };
8759 var fromNavDec = $elm$json$Json$Decode$oneOf(
8760 _List_fromArray(
8761 [
8762 A2(
8763 $elm$json$Json$Decode$at,
8764 _List_fromArray(
8765 ['childNodes', '2', 'childNodes', '0', 'offsetHeight']),
8766 $elm$json$Json$Decode$float),
8767 A2(
8768 $elm$json$Json$Decode$at,
8769 _List_fromArray(
8770 ['childNodes', '1', 'childNodes', '0', 'offsetHeight']),
8771 $elm$json$Json$Decode$float)
8772 ]));
8773 var fromButtonDec = $rundis$elm_bootstrap$Bootstrap$Utilities$DomHelper$parentElement(fromNavDec);
8774 return A2(
8775 $elm$json$Json$Decode$andThen,
8776 function (_v0) {
8777 var tag = _v0.a;
8778 var val = _v0.b;
8779 switch (tag) {
8780 case 'NAV':
8781 return resToDec(
8782 A2($elm$json$Json$Decode$decodeValue, fromNavDec, val));
8783 case 'BUTTON':
8784 return resToDec(
8785 A2($elm$json$Json$Decode$decodeValue, fromButtonDec, val));
8786 default:
8787 return $elm$json$Json$Decode$succeed(0);
8788 }
8789 },
8790 $rundis$elm_bootstrap$Bootstrap$Utilities$DomHelper$target(
8791 $rundis$elm_bootstrap$Bootstrap$Utilities$DomHelper$parentElement(tagDecoder)));
8792}();
8793var $rundis$elm_bootstrap$Bootstrap$Navbar$toggleHandler = F2(
8794 function (state, configRec) {
8795 var height = state.dc;
8796 var updState = function (h) {
8797 return A2(
8798 $rundis$elm_bootstrap$Bootstrap$Navbar$mapState,
8799 function (s) {
8800 return _Utils_update(
8801 s,
8802 {
8803 dc: $elm$core$Maybe$Just(h),
8804 j: A2($rundis$elm_bootstrap$Bootstrap$Navbar$visibilityTransition, configRec.V, s.j)
8805 });
8806 },
8807 state);
8808 };
8809 return A2(
8810 $elm$html$Html$Events$on,
8811 'click',
8812 A2(
8813 $elm$json$Json$Decode$andThen,
8814 function (v) {
8815 return $elm$json$Json$Decode$succeed(
8816 configRec.cW(
8817 (v > 0) ? updState(v) : updState(
8818 A2($elm$core$Maybe$withDefault, 0, height))));
8819 },
8820 $rundis$elm_bootstrap$Bootstrap$Navbar$heightDecoder));
8821 });
8822var $elm$html$Html$Attributes$type_ = $elm$html$Html$Attributes$stringProperty('type');
8823var $rundis$elm_bootstrap$Bootstrap$Navbar$view = F2(
8824 function (state, conf) {
8825 var configRec = conf;
8826 return A2(
8827 $elm$html$Html$nav,
8828 $rundis$elm_bootstrap$Bootstrap$Navbar$navbarAttributes(configRec.cG),
8829 _Utils_ap(
8830 $rundis$elm_bootstrap$Bootstrap$Navbar$maybeBrand(configRec.at),
8831 _Utils_ap(
8832 _List_fromArray(
8833 [
8834 A2(
8835 $elm$html$Html$button,
8836 _List_fromArray(
8837 [
8838 $elm$html$Html$Attributes$class(
8839 'navbar-toggler' + A2(
8840 $elm$core$Maybe$withDefault,
8841 '',
8842 A2(
8843 $elm$core$Maybe$map,
8844 function (_v0) {
8845 return ' navbar-toggler-right';
8846 },
8847 configRec.at))),
8848 $elm$html$Html$Attributes$type_('button'),
8849 A2($rundis$elm_bootstrap$Bootstrap$Navbar$toggleHandler, state, configRec)
8850 ]),
8851 _List_fromArray(
8852 [
8853 A2(
8854 $elm$html$Html$span,
8855 _List_fromArray(
8856 [
8857 $elm$html$Html$Attributes$class('navbar-toggler-icon')
8858 ]),
8859 _List_Nil)
8860 ]))
8861 ]),
8862 _List_fromArray(
8863 [
8864 A2(
8865 $elm$html$Html$div,
8866 A2($rundis$elm_bootstrap$Bootstrap$Navbar$menuAttributes, state, configRec),
8867 _List_fromArray(
8868 [
8869 A2(
8870 $elm$html$Html$div,
8871 A2($rundis$elm_bootstrap$Bootstrap$Navbar$menuWrapperAttributes, state, configRec),
8872 _Utils_ap(
8873 _List_fromArray(
8874 [
8875 A3($rundis$elm_bootstrap$Bootstrap$Navbar$renderNav, state, configRec, configRec.dk)
8876 ]),
8877 $rundis$elm_bootstrap$Bootstrap$Navbar$renderCustom(configRec.bj)))
8878 ]))
8879 ]))));
8880 });
8881var $ianmackenzie$elm_units$Quantity$greaterThan = F2(
8882 function (_v0, _v1) {
8883 var y = _v0;
8884 var x = _v1;
8885 return _Utils_cmp(x, y) > 0;
8886 });
8887var $mdgriffith$elm_animator$Internal$Time$inMilliseconds = function (_v0) {
8888 var ms = _v0;
8889 return ms;
8890};
8891var $mdgriffith$elm_animator$Internal$Time$duration = F2(
8892 function (one, two) {
8893 return A2($ianmackenzie$elm_units$Quantity$greaterThan, two, one) ? $ianmackenzie$elm_units$Duration$milliseconds(
8894 A2(
8895 $elm$core$Basics$max,
8896 0,
8897 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(one) - $mdgriffith$elm_animator$Internal$Time$inMilliseconds(two))) : $ianmackenzie$elm_units$Duration$milliseconds(
8898 A2(
8899 $elm$core$Basics$max,
8900 0,
8901 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(two) - $mdgriffith$elm_animator$Internal$Time$inMilliseconds(one)));
8902 });
8903var $mdgriffith$elm_animator$Internal$Timeline$adjustTime = F4(
8904 function (lookup, getPersonality, unmodified, upcomingOccurring) {
8905 var event = unmodified.a;
8906 var start = unmodified.b;
8907 var eventEnd = unmodified.c;
8908 if (!upcomingOccurring.b) {
8909 return unmodified;
8910 } else {
8911 var _v1 = upcomingOccurring.a;
8912 var next = _v1.a;
8913 var nextStartTime = _v1.b;
8914 var personality = getPersonality(
8915 lookup(event));
8916 if (!(!personality.ea)) {
8917 var totalDuration = A2($mdgriffith$elm_animator$Internal$Time$duration, eventEnd, nextStartTime);
8918 var nextPersonality = getPersonality(
8919 lookup(next));
8920 var totalPortions = A2($elm$core$Basics$max, personality.ea + nextPersonality.d2, 1);
8921 var lateBy = A2($ianmackenzie$elm_units$Quantity$multiplyBy, personality.ea / totalPortions, totalDuration);
8922 return A3(
8923 $mdgriffith$elm_animator$Internal$Timeline$Occurring,
8924 event,
8925 start,
8926 A2($mdgriffith$elm_animator$Internal$Time$advanceBy, lateBy, eventEnd));
8927 } else {
8928 return unmodified;
8929 }
8930 }
8931 });
8932var $ianmackenzie$elm_units$Quantity$minus = F2(
8933 function (_v0, _v1) {
8934 var y = _v0;
8935 var x = _v1;
8936 return x - y;
8937 });
8938var $mdgriffith$elm_animator$Internal$Time$rollbackBy = F2(
8939 function (dur, time) {
8940 return A2(
8941 $ianmackenzie$elm_units$Quantity$minus,
8942 $ianmackenzie$elm_units$Duration$inMilliseconds(dur),
8943 time);
8944 });
8945var $mdgriffith$elm_animator$Internal$Time$zeroDuration = function (_v0) {
8946 var dur = _v0;
8947 return !dur;
8948};
8949var $mdgriffith$elm_animator$Internal$Timeline$adjustTimeWithPrevious = F5(
8950 function (lookup, getPersonality, _v0, unmodified, upcomingOccurring) {
8951 var prev = _v0.a;
8952 var prevStart = _v0.b;
8953 var prevEnd = _v0.c;
8954 var event = unmodified.a;
8955 var start = unmodified.b;
8956 var eventEnd = unmodified.c;
8957 var totalPrevDuration = A2($mdgriffith$elm_animator$Internal$Time$duration, prevEnd, start);
8958 var prevPersonality = getPersonality(
8959 lookup(prev));
8960 var personality = getPersonality(
8961 lookup(event));
8962 var totalPrevPortions = A2($elm$core$Basics$max, prevPersonality.ea + personality.d2, 1);
8963 var earlyBy = A2($ianmackenzie$elm_units$Quantity$multiplyBy, personality.d2 / totalPrevPortions, totalPrevDuration);
8964 if (!upcomingOccurring.b) {
8965 return $mdgriffith$elm_animator$Internal$Time$zeroDuration(earlyBy) ? unmodified : A3(
8966 $mdgriffith$elm_animator$Internal$Timeline$Occurring,
8967 event,
8968 A2($mdgriffith$elm_animator$Internal$Time$rollbackBy, earlyBy, start),
8969 eventEnd);
8970 } else {
8971 var _v2 = upcomingOccurring.a;
8972 var next = _v2.a;
8973 var nextStartTime = _v2.b;
8974 if (!(!personality.ea)) {
8975 var totalDuration = A2($mdgriffith$elm_animator$Internal$Time$duration, eventEnd, nextStartTime);
8976 var nextPersonality = getPersonality(
8977 lookup(next));
8978 var totalPortions = A2($elm$core$Basics$max, personality.ea + nextPersonality.d2, 1);
8979 var lateBy = A2($ianmackenzie$elm_units$Quantity$multiplyBy, personality.ea / totalPortions, totalDuration);
8980 return A3(
8981 $mdgriffith$elm_animator$Internal$Timeline$Occurring,
8982 event,
8983 A2($mdgriffith$elm_animator$Internal$Time$rollbackBy, earlyBy, start),
8984 A2($mdgriffith$elm_animator$Internal$Time$advanceBy, lateBy, eventEnd));
8985 } else {
8986 if ($mdgriffith$elm_animator$Internal$Time$zeroDuration(earlyBy)) {
8987 return unmodified;
8988 } else {
8989 return A3(
8990 $mdgriffith$elm_animator$Internal$Timeline$Occurring,
8991 event,
8992 A2($mdgriffith$elm_animator$Internal$Time$rollbackBy, earlyBy, start),
8993 eventEnd);
8994 }
8995 }
8996 }
8997 });
8998var $mdgriffith$elm_animator$Internal$Timeline$hasDwell = function (_v0) {
8999 var start = _v0.b;
9000 var end = _v0.c;
9001 return !(!(start - end));
9002};
9003var $mdgriffith$elm_animator$Internal$Timeline$createLookAhead = F4(
9004 function (fn, lookup, currentEvent, upcomingEvents) {
9005 if (!upcomingEvents.b) {
9006 return $elm$core$Maybe$Nothing;
9007 } else {
9008 var unadjustedUpcoming = upcomingEvents.a;
9009 var remain = upcomingEvents.b;
9010 var upcomingOccurring = A5($mdgriffith$elm_animator$Internal$Timeline$adjustTimeWithPrevious, lookup, fn.co, currentEvent, unadjustedUpcoming, remain);
9011 return $elm$core$Maybe$Just(
9012 {
9013 d0: lookup(
9014 $mdgriffith$elm_animator$Internal$Timeline$getEvent(upcomingOccurring)),
9015 eA: $mdgriffith$elm_animator$Internal$Timeline$hasDwell(upcomingOccurring),
9016 dP: $mdgriffith$elm_animator$Internal$Time$inMilliseconds(
9017 $mdgriffith$elm_animator$Internal$Timeline$startTime(upcomingOccurring))
9018 });
9019 }
9020 });
9021var $mdgriffith$elm_animator$Internal$Timeline$overLines = F7(
9022 function (fn, lookup, details, maybePreviousEvent, _v0, futureLines, state) {
9023 overLines:
9024 while (true) {
9025 var lineStart = _v0.a;
9026 var unadjustedStartEvent = _v0.b;
9027 var lineRemain = _v0.c;
9028 var transition = function (newState) {
9029 if (!futureLines.b) {
9030 return newState;
9031 } else {
9032 var future = futureLines.a;
9033 var futureStart = future.a;
9034 var futureStartEv = future.b;
9035 var futureRemain = future.c;
9036 var restOfFuture = futureLines.b;
9037 return A2($mdgriffith$elm_animator$Internal$Time$thisBeforeOrEqualThat, futureStart, details.ds) ? A7($mdgriffith$elm_animator$Internal$Timeline$overLines, fn, lookup, details, $elm$core$Maybe$Nothing, future, restOfFuture, newState) : newState;
9038 }
9039 };
9040 var now = function () {
9041 if (!futureLines.b) {
9042 return details.ds;
9043 } else {
9044 var _v5 = futureLines.a;
9045 var futureStart = _v5.a;
9046 var futureStartEv = _v5.b;
9047 var futureRemain = _v5.c;
9048 var restOfFuture = futureLines.b;
9049 return A2($mdgriffith$elm_animator$Internal$Time$thisBeforeThat, futureStart, details.ds) ? futureStart : details.ds;
9050 }
9051 }();
9052 var lineStartEv = function () {
9053 if (maybePreviousEvent.$ === 1) {
9054 return A4($mdgriffith$elm_animator$Internal$Timeline$adjustTime, lookup, fn.co, unadjustedStartEvent, lineRemain);
9055 } else {
9056 var prev = maybePreviousEvent.a;
9057 return A5($mdgriffith$elm_animator$Internal$Timeline$adjustTimeWithPrevious, lookup, fn.co, prev, unadjustedStartEvent, lineRemain);
9058 }
9059 }();
9060 if (A2(
9061 $mdgriffith$elm_animator$Internal$Time$thisBeforeThat,
9062 now,
9063 $mdgriffith$elm_animator$Internal$Timeline$startTime(lineStartEv))) {
9064 return transition(
9065 A7(
9066 fn.cB,
9067 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(lineStart),
9068 $elm$core$Maybe$Just(
9069 lookup(details.dh)),
9070 lookup(
9071 $mdgriffith$elm_animator$Internal$Timeline$getEvent(lineStartEv)),
9072 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(
9073 $mdgriffith$elm_animator$Internal$Timeline$startTime(lineStartEv)),
9074 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(now),
9075 A4($mdgriffith$elm_animator$Internal$Timeline$createLookAhead, fn, lookup, unadjustedStartEvent, lineRemain),
9076 state));
9077 } else {
9078 if (A2(
9079 $mdgriffith$elm_animator$Internal$Time$thisBeforeThat,
9080 now,
9081 $mdgriffith$elm_animator$Internal$Timeline$endTime(lineStartEv))) {
9082 return transition(
9083 A5(
9084 fn.cY,
9085 lookup,
9086 lineStartEv,
9087 now,
9088 A4($mdgriffith$elm_animator$Internal$Timeline$createLookAhead, fn, lookup, unadjustedStartEvent, lineRemain),
9089 state));
9090 } else {
9091 if (!lineRemain.b) {
9092 return transition(
9093 A5(fn.cY, lookup, lineStartEv, now, $elm$core$Maybe$Nothing, state));
9094 } else {
9095 var unadjustedNext = lineRemain.a;
9096 var lineRemain2 = lineRemain.b;
9097 var next = A5($mdgriffith$elm_animator$Internal$Timeline$adjustTimeWithPrevious, lookup, fn.co, unadjustedStartEvent, unadjustedNext, lineRemain2);
9098 if (A2(
9099 $mdgriffith$elm_animator$Internal$Time$thisBeforeThat,
9100 now,
9101 $mdgriffith$elm_animator$Internal$Timeline$startTime(next))) {
9102 return transition(
9103 A7(
9104 fn.cB,
9105 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(
9106 $mdgriffith$elm_animator$Internal$Timeline$endTime(lineStartEv)),
9107 $elm$core$Maybe$Just(
9108 lookup(
9109 $mdgriffith$elm_animator$Internal$Timeline$getEvent(lineStartEv))),
9110 lookup(
9111 $mdgriffith$elm_animator$Internal$Timeline$getEvent(next)),
9112 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(
9113 $mdgriffith$elm_animator$Internal$Timeline$startTime(next)),
9114 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(now),
9115 A4($mdgriffith$elm_animator$Internal$Timeline$createLookAhead, fn, lookup, unadjustedNext, lineRemain2),
9116 A5(
9117 fn.cY,
9118 lookup,
9119 lineStartEv,
9120 now,
9121 A4($mdgriffith$elm_animator$Internal$Timeline$createLookAhead, fn, lookup, unadjustedStartEvent, lineRemain),
9122 state)));
9123 } else {
9124 if (A2(
9125 $mdgriffith$elm_animator$Internal$Time$thisBeforeThat,
9126 now,
9127 $mdgriffith$elm_animator$Internal$Timeline$endTime(next))) {
9128 return transition(
9129 A5(
9130 fn.cY,
9131 lookup,
9132 next,
9133 now,
9134 A4($mdgriffith$elm_animator$Internal$Timeline$createLookAhead, fn, lookup, unadjustedNext, lineRemain2),
9135 state));
9136 } else {
9137 if (!lineRemain2.b) {
9138 return transition(
9139 A5(fn.cY, lookup, next, now, $elm$core$Maybe$Nothing, state));
9140 } else {
9141 var unadjustedNext2 = lineRemain2.a;
9142 var lineRemain3 = lineRemain2.b;
9143 var next2 = A5($mdgriffith$elm_animator$Internal$Timeline$adjustTimeWithPrevious, lookup, fn.co, unadjustedNext, unadjustedNext2, lineRemain3);
9144 if (A2(
9145 $mdgriffith$elm_animator$Internal$Time$thisBeforeThat,
9146 now,
9147 $mdgriffith$elm_animator$Internal$Timeline$startTime(next2))) {
9148 var after = A5(
9149 fn.cY,
9150 lookup,
9151 next,
9152 now,
9153 A4($mdgriffith$elm_animator$Internal$Timeline$createLookAhead, fn, lookup, unadjustedNext, lineRemain2),
9154 state);
9155 return transition(
9156 A7(
9157 fn.cB,
9158 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(
9159 $mdgriffith$elm_animator$Internal$Timeline$endTime(next)),
9160 $elm$core$Maybe$Just(
9161 lookup(
9162 $mdgriffith$elm_animator$Internal$Timeline$getEvent(next))),
9163 lookup(
9164 $mdgriffith$elm_animator$Internal$Timeline$getEvent(next2)),
9165 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(
9166 $mdgriffith$elm_animator$Internal$Timeline$startTime(next2)),
9167 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(now),
9168 A4($mdgriffith$elm_animator$Internal$Timeline$createLookAhead, fn, lookup, unadjustedNext2, lineRemain3),
9169 after));
9170 } else {
9171 if (A2(
9172 $mdgriffith$elm_animator$Internal$Time$thisBeforeThat,
9173 now,
9174 $mdgriffith$elm_animator$Internal$Timeline$endTime(next2))) {
9175 return transition(
9176 A5(
9177 fn.cY,
9178 lookup,
9179 next2,
9180 now,
9181 A4($mdgriffith$elm_animator$Internal$Timeline$createLookAhead, fn, lookup, unadjustedNext2, lineRemain3),
9182 state));
9183 } else {
9184 var after = A5(
9185 fn.cY,
9186 lookup,
9187 next2,
9188 now,
9189 A4($mdgriffith$elm_animator$Internal$Timeline$createLookAhead, fn, lookup, unadjustedNext2, lineRemain3),
9190 state);
9191 var $temp$fn = fn,
9192 $temp$lookup = lookup,
9193 $temp$details = details,
9194 $temp$maybePreviousEvent = $elm$core$Maybe$Just(next),
9195 $temp$_v0 = A3(
9196 $mdgriffith$elm_animator$Internal$Timeline$Line,
9197 $mdgriffith$elm_animator$Internal$Timeline$endTime(next),
9198 unadjustedNext2,
9199 lineRemain3),
9200 $temp$futureLines = futureLines,
9201 $temp$state = after;
9202 fn = $temp$fn;
9203 lookup = $temp$lookup;
9204 details = $temp$details;
9205 maybePreviousEvent = $temp$maybePreviousEvent;
9206 _v0 = $temp$_v0;
9207 futureLines = $temp$futureLines;
9208 state = $temp$state;
9209 continue overLines;
9210 }
9211 }
9212 }
9213 }
9214 }
9215 }
9216 }
9217 }
9218 }
9219 });
9220var $mdgriffith$elm_animator$Internal$Timeline$foldp = F3(
9221 function (lookup, fn, _v0) {
9222 var timelineDetails = _v0;
9223 var _v1 = timelineDetails.da;
9224 var timetable = _v1;
9225 var start = fn.cQ(
9226 lookup(timelineDetails.dh));
9227 if (!timetable.b) {
9228 return start;
9229 } else {
9230 var firstLine = timetable.a;
9231 var remainingLines = timetable.b;
9232 return A7($mdgriffith$elm_animator$Internal$Timeline$overLines, fn, lookup, timelineDetails, $elm$core$Maybe$Nothing, firstLine, remainingLines, start);
9233 }
9234 });
9235var $mdgriffith$elm_animator$Internal$Timeline$linearDefault = {d2: 0, d3: 0, ea: 0, eb: 0, eR: 0};
9236var $mdgriffith$elm_animator$Internal$Timeline$current = function (timeline) {
9237 var details = timeline;
9238 return A3(
9239 $mdgriffith$elm_animator$Internal$Timeline$foldp,
9240 $elm$core$Basics$identity,
9241 {
9242 co: function (_v0) {
9243 return $mdgriffith$elm_animator$Internal$Timeline$linearDefault;
9244 },
9245 cu: function (_v1) {
9246 return $elm$core$Maybe$Nothing;
9247 },
9248 cB: F7(
9249 function (_v2, _v3, target, _v4, _v5, _v6, _v7) {
9250 return target;
9251 }),
9252 cQ: function (_v8) {
9253 return details.dh;
9254 },
9255 cY: F5(
9256 function (lookup, target, targetTime, maybeLookAhead, state) {
9257 return $mdgriffith$elm_animator$Internal$Timeline$getEvent(target);
9258 })
9259 },
9260 timeline);
9261};
9262var $mdgriffith$elm_animator$Animator$current = $mdgriffith$elm_animator$Internal$Timeline$current;
9263var $mdgriffith$elm_animator$Animator$Css$Center = {$: 0};
9264var $mdgriffith$elm_animator$Animator$Css$defaultTransformOptions = {
9265 bT: $mdgriffith$elm_animator$Animator$Css$Center,
9266 aP: {dY: 0, dZ: 0, d$: 1}
9267};
9268var $mdgriffith$elm_animator$Animator$Css$explainActive = function (attrs) {
9269 explainActive:
9270 while (true) {
9271 if (!attrs.b) {
9272 return false;
9273 } else {
9274 if (attrs.a.$ === 4) {
9275 var on = attrs.a.a;
9276 var others = attrs.b;
9277 return on;
9278 } else {
9279 var skip = attrs.a;
9280 var others = attrs.b;
9281 var $temp$attrs = others;
9282 attrs = $temp$attrs;
9283 continue explainActive;
9284 }
9285 }
9286 }
9287};
9288var $elm$core$Tuple$pair = F2(
9289 function (a, b) {
9290 return _Utils_Tuple2(a, b);
9291 });
9292var $mdgriffith$elm_animator$Animator$Css$viewAxes = function (options) {
9293 var _v0 = function () {
9294 var _v1 = options.bT;
9295 if (!_v1.$) {
9296 return A2($elm$core$Tuple$pair, 0, 0);
9297 } else {
9298 var ox = _v1.a;
9299 var oy = _v1.b;
9300 return A2($elm$core$Tuple$pair, ox, oy);
9301 }
9302 }();
9303 var x = _v0.a;
9304 var y = _v0.b;
9305 return A2(
9306 $elm$html$Html$div,
9307 _List_fromArray(
9308 [
9309 A2($elm$html$Html$Attributes$style, 'position', 'absolute'),
9310 A2($elm$html$Html$Attributes$style, 'width', '0px'),
9311 A2($elm$html$Html$Attributes$style, 'height', '0px'),
9312 A2(
9313 $elm$html$Html$Attributes$style,
9314 'left',
9315 'calc(50% + ' + ($elm$core$String$fromFloat(x) + 'px - 3px)')),
9316 A2(
9317 $elm$html$Html$Attributes$style,
9318 'top',
9319 'calc(50% + ' + ($elm$core$String$fromFloat(y) + 'px - 3px)'))
9320 ]),
9321 _List_fromArray(
9322 [
9323 A2(
9324 $elm$html$Html$div,
9325 _List_fromArray(
9326 [
9327 A2($elm$html$Html$Attributes$style, 'position', 'absolute'),
9328 A2($elm$html$Html$Attributes$style, 'top', '10px'),
9329 A2($elm$html$Html$Attributes$style, 'left', '-1px'),
9330 A2($elm$html$Html$Attributes$style, 'width', '2px'),
9331 A2($elm$html$Html$Attributes$style, 'height', '50px'),
9332 A2($elm$html$Html$Attributes$style, 'background-color', 'black')
9333 ]),
9334 _List_fromArray(
9335 [
9336 A2(
9337 $elm$html$Html$div,
9338 _List_fromArray(
9339 [
9340 A2($elm$html$Html$Attributes$style, 'position', 'absolute'),
9341 A2($elm$html$Html$Attributes$style, 'bottom', '-5px'),
9342 A2($elm$html$Html$Attributes$style, 'left', '-3px'),
9343 A2($elm$html$Html$Attributes$style, 'width', '0'),
9344 A2($elm$html$Html$Attributes$style, 'height', '0'),
9345 A2($elm$html$Html$Attributes$style, 'border-left', '4px solid transparent'),
9346 A2($elm$html$Html$Attributes$style, 'border-right', '4px solid transparent'),
9347 A2($elm$html$Html$Attributes$style, 'border-top', '8px solid black')
9348 ]),
9349 _List_Nil),
9350 A2(
9351 $elm$html$Html$div,
9352 _List_fromArray(
9353 [
9354 A2($elm$html$Html$Attributes$style, 'position', 'absolute'),
9355 A2($elm$html$Html$Attributes$style, 'right', '-3px'),
9356 A2($elm$html$Html$Attributes$style, 'bottom', '-22px'),
9357 A2($elm$html$Html$Attributes$style, 'font-size', '12px')
9358 ]),
9359 _List_fromArray(
9360 [
9361 $elm$html$Html$text('Y')
9362 ]))
9363 ])),
9364 A2(
9365 $elm$html$Html$div,
9366 _List_fromArray(
9367 [
9368 A2($elm$html$Html$Attributes$style, 'position', 'absolute'),
9369 A2($elm$html$Html$Attributes$style, 'top', '-1px'),
9370 A2($elm$html$Html$Attributes$style, 'left', '10px'),
9371 A2($elm$html$Html$Attributes$style, 'width', '50px'),
9372 A2($elm$html$Html$Attributes$style, 'height', '2px'),
9373 A2($elm$html$Html$Attributes$style, 'background-color', 'black')
9374 ]),
9375 _List_fromArray(
9376 [
9377 A2(
9378 $elm$html$Html$div,
9379 _List_fromArray(
9380 [
9381 A2($elm$html$Html$Attributes$style, 'position', 'absolute'),
9382 A2($elm$html$Html$Attributes$style, 'right', '-5px'),
9383 A2($elm$html$Html$Attributes$style, 'top', '-3px'),
9384 A2($elm$html$Html$Attributes$style, 'width', '0'),
9385 A2($elm$html$Html$Attributes$style, 'height', '0'),
9386 A2($elm$html$Html$Attributes$style, 'border-top', '4px solid transparent'),
9387 A2($elm$html$Html$Attributes$style, 'border-bottom', '4px solid transparent'),
9388 A2($elm$html$Html$Attributes$style, 'border-left', '8px solid black')
9389 ]),
9390 _List_Nil),
9391 A2(
9392 $elm$html$Html$div,
9393 _List_fromArray(
9394 [
9395 A2($elm$html$Html$Attributes$style, 'position', 'absolute'),
9396 A2($elm$html$Html$Attributes$style, 'right', '-14px'),
9397 A2($elm$html$Html$Attributes$style, 'top', '-6px'),
9398 A2($elm$html$Html$Attributes$style, 'font-size', '12px')
9399 ]),
9400 _List_fromArray(
9401 [
9402 $elm$html$Html$text('X')
9403 ]))
9404 ])),
9405 A2(
9406 $elm$html$Html$div,
9407 _List_fromArray(
9408 [
9409 A2($elm$html$Html$Attributes$style, 'position', 'absolute'),
9410 A2($elm$html$Html$Attributes$style, 'width', '6px'),
9411 A2($elm$html$Html$Attributes$style, 'height', '6px'),
9412 A2($elm$html$Html$Attributes$style, 'left', '-3px'),
9413 A2($elm$html$Html$Attributes$style, 'top', '-3px'),
9414 A2($elm$html$Html$Attributes$style, 'background-color', 'red'),
9415 A2($elm$html$Html$Attributes$style, 'border-radius', '3px')
9416 ]),
9417 _List_Nil),
9418 A2(
9419 $elm$html$Html$div,
9420 _List_fromArray(
9421 [
9422 A2($elm$html$Html$Attributes$style, 'position', 'absolute'),
9423 A2($elm$html$Html$Attributes$style, 'width', '12px'),
9424 A2($elm$html$Html$Attributes$style, 'height', '12px'),
9425 A2($elm$html$Html$Attributes$style, 'left', '-7px'),
9426 A2($elm$html$Html$Attributes$style, 'top', '-7px'),
9427 A2($elm$html$Html$Attributes$style, 'background-color', 'transparent'),
9428 A2($elm$html$Html$Attributes$style, 'border-radius', '7px'),
9429 A2($elm$html$Html$Attributes$style, 'border', '1px solid red')
9430 ]),
9431 _List_Nil)
9432 ]));
9433};
9434var $mdgriffith$elm_animator$Animator$Css$explainElement = function (transformOptions) {
9435 return A2(
9436 $elm$html$Html$div,
9437 _List_fromArray(
9438 [
9439 A2($elm$html$Html$Attributes$style, 'position', 'absolute'),
9440 A2($elm$html$Html$Attributes$style, 'width', '100%'),
9441 A2($elm$html$Html$Attributes$style, 'height', '100%'),
9442 A2($elm$html$Html$Attributes$style, 'background-color', 'rgba(238, 238, 238, 0.4)'),
9443 A2($elm$html$Html$Attributes$style, 'border', '2px solid #DDD'),
9444 A2($elm$html$Html$Attributes$style, 'z-index', '10')
9445 ]),
9446 _List_fromArray(
9447 [
9448 $mdgriffith$elm_animator$Animator$Css$viewAxes(transformOptions)
9449 ]));
9450};
9451var $mdgriffith$elm_animator$Animator$Css$getTransformOptions = function (attrs) {
9452 getTransformOptions:
9453 while (true) {
9454 if (!attrs.b) {
9455 return $elm$core$Maybe$Nothing;
9456 } else {
9457 if (attrs.a.$ === 3) {
9458 var _v1 = attrs.a;
9459 var opts = _v1.a;
9460 return $elm$core$Maybe$Just(opts);
9461 } else {
9462 var rest = attrs.b;
9463 var $temp$attrs = rest;
9464 attrs = $temp$attrs;
9465 continue getTransformOptions;
9466 }
9467 }
9468 }
9469};
9470var $mdgriffith$elm_animator$Animator$Css$renderClassName = F2(
9471 function (str, anim) {
9472 renderClassName:
9473 while (true) {
9474 if (!anim.b) {
9475 return str;
9476 } else {
9477 if (!anim.b.b) {
9478 var top = anim.a;
9479 return (str === '') ? top.er : _Utils_ap(str, top.er);
9480 } else {
9481 var top = anim.a;
9482 var _v1 = anim.b;
9483 var next = _v1.a;
9484 var remaining = _v1.b;
9485 var $temp$str = str + (top.er + '-'),
9486 $temp$anim = A2($elm$core$List$cons, next, remaining);
9487 str = $temp$str;
9488 anim = $temp$anim;
9489 continue renderClassName;
9490 }
9491 }
9492 }
9493 });
9494var $mdgriffith$elm_animator$Animator$Css$renderDelay = F2(
9495 function (str, anim) {
9496 renderDelay:
9497 while (true) {
9498 if (!anim.b) {
9499 return str;
9500 } else {
9501 if (!anim.b.b) {
9502 var top = anim.a;
9503 return (str === '') ? ($elm$core$String$fromFloat(top.ab) + 'ms') : (str + ($elm$core$String$fromFloat(top.ab) + 'ms'));
9504 } else {
9505 var top = anim.a;
9506 var _v1 = anim.b;
9507 var next = _v1.a;
9508 var remaining = _v1.b;
9509 var $temp$str = str + ($elm$core$String$fromFloat(top.ab) + 'ms, '),
9510 $temp$anim = A2($elm$core$List$cons, next, remaining);
9511 str = $temp$str;
9512 anim = $temp$anim;
9513 continue renderDelay;
9514 }
9515 }
9516 }
9517 });
9518var $mdgriffith$elm_animator$Animator$Css$renderDuration = F2(
9519 function (str, anim) {
9520 renderDuration:
9521 while (true) {
9522 if (!anim.b) {
9523 return str;
9524 } else {
9525 if (!anim.b.b) {
9526 var top = anim.a;
9527 return (str === '') ? ($elm$core$String$fromFloat(top.y) + 'ms') : (str + ($elm$core$String$fromFloat(top.y) + 'ms'));
9528 } else {
9529 var top = anim.a;
9530 var _v1 = anim.b;
9531 var next = _v1.a;
9532 var remaining = _v1.b;
9533 var $temp$str = str + ($elm$core$String$fromFloat(top.y) + 'ms, '),
9534 $temp$anim = A2($elm$core$List$cons, next, remaining);
9535 str = $temp$str;
9536 anim = $temp$anim;
9537 continue renderDuration;
9538 }
9539 }
9540 }
9541 });
9542var $mdgriffith$elm_animator$Animator$Css$repeatToString = function (rep) {
9543 if (!rep.$) {
9544 return 'infinite';
9545 } else {
9546 var n = rep.a;
9547 return $elm$core$String$fromInt(n);
9548 }
9549};
9550var $mdgriffith$elm_animator$Animator$Css$renderIterations = F2(
9551 function (str, anim) {
9552 renderIterations:
9553 while (true) {
9554 if (!anim.b) {
9555 return str;
9556 } else {
9557 if (!anim.b.b) {
9558 var top = anim.a;
9559 return (str === '') ? $mdgriffith$elm_animator$Animator$Css$repeatToString(top.al) : _Utils_ap(
9560 str,
9561 $mdgriffith$elm_animator$Animator$Css$repeatToString(top.al));
9562 } else {
9563 var top = anim.a;
9564 var _v1 = anim.b;
9565 var next = _v1.a;
9566 var remaining = _v1.b;
9567 var $temp$str = str + ($mdgriffith$elm_animator$Animator$Css$repeatToString(top.al) + ', '),
9568 $temp$anim = A2($elm$core$List$cons, next, remaining);
9569 str = $temp$str;
9570 anim = $temp$anim;
9571 continue renderIterations;
9572 }
9573 }
9574 }
9575 });
9576var $mdgriffith$elm_animator$Animator$Css$renderKeyframes = F2(
9577 function (str, anim) {
9578 renderKeyframes:
9579 while (true) {
9580 if (!anim.b) {
9581 return str;
9582 } else {
9583 var top = anim.a;
9584 var remain = anim.b;
9585 var $temp$str = str + ('\n' + top.by),
9586 $temp$anim = remain;
9587 str = $temp$str;
9588 anim = $temp$anim;
9589 continue renderKeyframes;
9590 }
9591 }
9592 });
9593var $mdgriffith$elm_animator$Animator$Css$renderName = F2(
9594 function (str, anim) {
9595 renderName:
9596 while (true) {
9597 if (!anim.b) {
9598 return str;
9599 } else {
9600 if (!anim.b.b) {
9601 var top = anim.a;
9602 return (str === '') ? top.er : _Utils_ap(str, top.er);
9603 } else {
9604 var top = anim.a;
9605 var _v1 = anim.b;
9606 var next = _v1.a;
9607 var remaining = _v1.b;
9608 var $temp$str = str + (top.er + ', '),
9609 $temp$anim = A2($elm$core$List$cons, next, remaining);
9610 str = $temp$str;
9611 anim = $temp$anim;
9612 continue renderName;
9613 }
9614 }
9615 }
9616 });
9617var $mdgriffith$elm_animator$Animator$Css$timingFnName = function (fn) {
9618 return 'linear';
9619};
9620var $mdgriffith$elm_animator$Animator$Css$renderTiming = F2(
9621 function (str, anim) {
9622 renderTiming:
9623 while (true) {
9624 if (!anim.b) {
9625 return str;
9626 } else {
9627 if (!anim.b.b) {
9628 var top = anim.a;
9629 return (str === '') ? $mdgriffith$elm_animator$Animator$Css$timingFnName(top.ao) : _Utils_ap(
9630 str,
9631 $mdgriffith$elm_animator$Animator$Css$timingFnName(top.ao));
9632 } else {
9633 var top = anim.a;
9634 var _v1 = anim.b;
9635 var next = _v1.a;
9636 var remaining = _v1.b;
9637 var $temp$str = str + ($mdgriffith$elm_animator$Animator$Css$timingFnName(top.ao) + ', '),
9638 $temp$anim = A2($elm$core$List$cons, next, remaining);
9639 str = $temp$str;
9640 anim = $temp$anim;
9641 continue renderTiming;
9642 }
9643 }
9644 }
9645 });
9646var $mdgriffith$elm_animator$Animator$Css$renderAnimations = function (animations) {
9647 return A2($mdgriffith$elm_animator$Animator$Css$renderKeyframes, '', animations) + ('\n.' + (A2($mdgriffith$elm_animator$Animator$Css$renderClassName, '', animations) + ('{\n animation-name: ' + (A2($mdgriffith$elm_animator$Animator$Css$renderName, '', animations) + (';\n animation-delay: ' + (A2($mdgriffith$elm_animator$Animator$Css$renderDelay, '', animations) + (';\n animation-duration: ' + (A2($mdgriffith$elm_animator$Animator$Css$renderDuration, '', animations) + (';\n animation-timing-function: ' + (A2($mdgriffith$elm_animator$Animator$Css$renderTiming, '', animations) + (';\n animation-fill-mode: forwards;\n animation-iteration-count: ' + (A2($mdgriffith$elm_animator$Animator$Css$renderIterations, '', animations) + ';\n }\n '))))))))))));
9648};
9649var $mdgriffith$elm_animator$Internal$Timeline$Frame = F2(
9650 function (a, b) {
9651 return {$: 0, a: a, b: b};
9652 });
9653var $mdgriffith$elm_animator$Internal$Timeline$getLastEvent = F2(
9654 function (head, rest) {
9655 getLastEvent:
9656 while (true) {
9657 if (!rest.b) {
9658 return head;
9659 } else {
9660 var top = rest.a;
9661 var tail = rest.b;
9662 var $temp$head = top,
9663 $temp$rest = tail;
9664 head = $temp$head;
9665 rest = $temp$rest;
9666 continue getLastEvent;
9667 }
9668 }
9669 });
9670var $mdgriffith$elm_animator$Internal$Timeline$findLastEventInLines = F2(
9671 function (first, remaining) {
9672 findLastEventInLines:
9673 while (true) {
9674 if (!remaining.b) {
9675 var startEv = first.b;
9676 var rem = first.c;
9677 return A2($mdgriffith$elm_animator$Internal$Timeline$getLastEvent, startEv, rem);
9678 } else {
9679 var r1 = remaining.a;
9680 var r1Remain = remaining.b;
9681 var $temp$first = r1,
9682 $temp$remaining = r1Remain;
9683 first = $temp$first;
9684 remaining = $temp$remaining;
9685 continue findLastEventInLines;
9686 }
9687 }
9688 });
9689var $mdgriffith$elm_animator$Internal$Timeline$getFrames = F4(
9690 function (currentTime, config, fn, newFrames) {
9691 getFrames:
9692 while (true) {
9693 if (A2($mdgriffith$elm_animator$Internal$Time$thisBeforeOrEqualThat, currentTime, config.B)) {
9694 if (!newFrames.b) {
9695 return _List_fromArray(
9696 [
9697 A2(
9698 $mdgriffith$elm_animator$Internal$Timeline$Frame,
9699 0,
9700 fn(config.B)),
9701 A2(
9702 $mdgriffith$elm_animator$Internal$Timeline$Frame,
9703 1,
9704 fn(config.bn))
9705 ]);
9706 } else {
9707 return A2(
9708 $elm$core$List$cons,
9709 A2(
9710 $mdgriffith$elm_animator$Internal$Timeline$Frame,
9711 0,
9712 fn(config.B)),
9713 newFrames);
9714 }
9715 } else {
9716 var _new = A2(
9717 $mdgriffith$elm_animator$Internal$Timeline$Frame,
9718 A3($mdgriffith$elm_animator$Internal$Time$progress, config.B, config.bn, currentTime),
9719 fn(currentTime));
9720 var $temp$currentTime = A2($mdgriffith$elm_animator$Internal$Time$rollbackBy, config.cJ, currentTime),
9721 $temp$config = config,
9722 $temp$fn = fn,
9723 $temp$newFrames = A2($elm$core$List$cons, _new, newFrames);
9724 currentTime = $temp$currentTime;
9725 config = $temp$config;
9726 fn = $temp$fn;
9727 newFrames = $temp$newFrames;
9728 continue getFrames;
9729 }
9730 }
9731 });
9732var $mdgriffith$elm_animator$Internal$Time$numberOfFrames = F4(
9733 function (fps, lastFrameTime, startAt, endAt) {
9734 var totalDurationInMs = $ianmackenzie$elm_units$Duration$inMilliseconds(
9735 A2($mdgriffith$elm_animator$Internal$Time$duration, startAt, endAt));
9736 var millisecondsPerFrame = 1000 / fps;
9737 var framesSinceLastFrame = A2(
9738 $elm$core$Basics$max,
9739 0,
9740 $ianmackenzie$elm_units$Duration$inMilliseconds(
9741 A2($mdgriffith$elm_animator$Internal$Time$duration, lastFrameTime, startAt))) / millisecondsPerFrame;
9742 var offset = 1 - (framesSinceLastFrame - $elm$core$Basics$floor(framesSinceLastFrame));
9743 return _Utils_Tuple2(
9744 offset * millisecondsPerFrame,
9745 A2(
9746 $elm$core$Basics$max,
9747 1,
9748 $elm$core$Basics$round(totalDurationInMs / millisecondsPerFrame)));
9749 });
9750var $mdgriffith$elm_animator$Internal$Timeline$zeroDuration = $ianmackenzie$elm_units$Duration$milliseconds(0);
9751var $mdgriffith$elm_animator$Internal$Timeline$capture = F4(
9752 function (fps, lookup, fn, _v0) {
9753 var timelineDetails = _v0;
9754 var _v1 = timelineDetails.da;
9755 var timetable = _v1;
9756 var start = fn.cQ(
9757 lookup(timelineDetails.dh));
9758 if (!timetable.b) {
9759 return {
9760 y: $mdgriffith$elm_animator$Internal$Timeline$zeroDuration,
9761 ct: $elm$core$Maybe$Nothing,
9762 a: _List_fromArray(
9763 [
9764 A2($mdgriffith$elm_animator$Internal$Timeline$Frame, 1, start)
9765 ])
9766 };
9767 } else {
9768 var firstLine = timetable.a;
9769 var remainingLines = timetable.b;
9770 var millisecondsPerFrame = 1000 / fps;
9771 var lastEvent = A2($mdgriffith$elm_animator$Internal$Timeline$findLastEventInLines, firstLine, remainingLines);
9772 var frames = A4(
9773 $mdgriffith$elm_animator$Internal$Timeline$getFrames,
9774 $mdgriffith$elm_animator$Internal$Timeline$startTime(lastEvent),
9775 {
9776 bn: $mdgriffith$elm_animator$Internal$Timeline$startTime(lastEvent),
9777 dt: 0,
9778 cJ: $ianmackenzie$elm_units$Duration$milliseconds(millisecondsPerFrame),
9779 B: timelineDetails.ds
9780 },
9781 function (currentTime) {
9782 return A7(
9783 $mdgriffith$elm_animator$Internal$Timeline$overLines,
9784 fn,
9785 lookup,
9786 _Utils_update(
9787 timelineDetails,
9788 {ds: currentTime}),
9789 $elm$core$Maybe$Nothing,
9790 firstLine,
9791 remainingLines,
9792 start);
9793 },
9794 _List_Nil);
9795 var _v3 = A2(
9796 $mdgriffith$elm_animator$Internal$Time$thisAfterThat,
9797 timelineDetails.ds,
9798 $mdgriffith$elm_animator$Internal$Timeline$startTime(lastEvent)) ? _Utils_Tuple2(0, 1) : A4(
9799 $mdgriffith$elm_animator$Internal$Time$numberOfFrames,
9800 fps,
9801 timelineDetails.ds,
9802 timelineDetails.ds,
9803 $mdgriffith$elm_animator$Internal$Timeline$startTime(lastEvent));
9804 var numberOfFrames = _v3.b;
9805 return {
9806 y: A2(
9807 $mdgriffith$elm_animator$Internal$Time$thisAfterThat,
9808 timelineDetails.ds,
9809 $mdgriffith$elm_animator$Internal$Timeline$startTime(lastEvent)) ? $mdgriffith$elm_animator$Internal$Timeline$zeroDuration : A2(
9810 $mdgriffith$elm_animator$Internal$Time$duration,
9811 timelineDetails.ds,
9812 $mdgriffith$elm_animator$Internal$Timeline$startTime(lastEvent)),
9813 ct: function () {
9814 var _v4 = fn.cu(
9815 lookup(
9816 $mdgriffith$elm_animator$Internal$Timeline$getEvent(lastEvent)));
9817 if (_v4.$ === 1) {
9818 return $elm$core$Maybe$Nothing;
9819 } else {
9820 var period = _v4.a;
9821 var lastEventEv = lookup(
9822 $mdgriffith$elm_animator$Internal$Timeline$getEvent(lastEvent));
9823 var dwellStartTime = $mdgriffith$elm_animator$Internal$Timeline$startTime(lastEvent);
9824 var endAt = function () {
9825 if (period.$ === 1) {
9826 var n = period.a;
9827 var totalDur = period.b;
9828 return A2($mdgriffith$elm_animator$Internal$Time$advanceBy, totalDur, dwellStartTime);
9829 } else {
9830 var totalDur = period.a;
9831 return A2($mdgriffith$elm_animator$Internal$Time$advanceBy, totalDur, dwellStartTime);
9832 }
9833 }();
9834 var lastConcreteState = A7(
9835 $mdgriffith$elm_animator$Internal$Timeline$overLines,
9836 fn,
9837 lookup,
9838 _Utils_update(
9839 timelineDetails,
9840 {ds: dwellStartTime}),
9841 $elm$core$Maybe$Nothing,
9842 firstLine,
9843 remainingLines,
9844 start);
9845 var _v5 = A4($mdgriffith$elm_animator$Internal$Time$numberOfFrames, fps, dwellStartTime, dwellStartTime, endAt);
9846 var dwellOffset = _v5.a;
9847 var numberOfDwellFrames = _v5.b;
9848 var dwellFrames = A4(
9849 $mdgriffith$elm_animator$Internal$Timeline$getFrames,
9850 endAt,
9851 {
9852 bn: endAt,
9853 dt: dwellOffset,
9854 cJ: $ianmackenzie$elm_units$Duration$milliseconds(millisecondsPerFrame),
9855 B: dwellStartTime
9856 },
9857 function (currentTime) {
9858 return A5(fn.cY, lookup, lastEvent, currentTime, $elm$core$Maybe$Nothing, lastConcreteState);
9859 },
9860 _List_Nil);
9861 return $elm$core$Maybe$Just(
9862 {a: dwellFrames, bU: period});
9863 }
9864 }(),
9865 a: frames
9866 };
9867 }
9868 });
9869var $elm$core$Basics$sqrt = _Basics_sqrt;
9870var $mdgriffith$elm_animator$Internal$Interpolate$average = F3(
9871 function (x, y, progress) {
9872 return $elm$core$Basics$sqrt(((x * x) * (1 - progress)) + ((y * y) * progress));
9873 });
9874var $mdgriffith$elm_animator$Internal$Time$millis = function (ms) {
9875 return ms;
9876};
9877var $avh4$elm_color$Color$RgbaSpace = F4(
9878 function (a, b, c, d) {
9879 return {$: 0, a: a, b: b, c: c, d: d};
9880 });
9881var $avh4$elm_color$Color$rgba = F4(
9882 function (r, g, b, a) {
9883 return A4($avh4$elm_color$Color$RgbaSpace, r, g, b, a);
9884 });
9885var $avh4$elm_color$Color$toRgba = function (_v0) {
9886 var r = _v0.a;
9887 var g = _v0.b;
9888 var b = _v0.c;
9889 var a = _v0.d;
9890 return {W: a, cq: b, cw: g, cO: r};
9891};
9892var $mdgriffith$elm_animator$Internal$Interpolate$lerpColor = F7(
9893 function (prevEndTime, maybePrev, target, targetTime, now, maybeLookAhead, state) {
9894 var two = $avh4$elm_color$Color$toRgba(target);
9895 var progress = A3(
9896 $mdgriffith$elm_animator$Internal$Time$progress,
9897 $mdgriffith$elm_animator$Internal$Time$millis(prevEndTime),
9898 $mdgriffith$elm_animator$Internal$Time$millis(targetTime),
9899 $mdgriffith$elm_animator$Internal$Time$millis(now));
9900 var one = $avh4$elm_color$Color$toRgba(state);
9901 return A4(
9902 $avh4$elm_color$Color$rgba,
9903 A3($mdgriffith$elm_animator$Internal$Interpolate$average, one.cO, two.cO, progress),
9904 A3($mdgriffith$elm_animator$Internal$Interpolate$average, one.cw, two.cw, progress),
9905 A3($mdgriffith$elm_animator$Internal$Interpolate$average, one.cq, two.cq, progress),
9906 A3($mdgriffith$elm_animator$Internal$Interpolate$average, one.W, two.W, progress));
9907 });
9908var $mdgriffith$elm_animator$Internal$Interpolate$linearDefault = {d2: 0, d3: 0, ea: 0, eb: 0, eR: 0};
9909var $mdgriffith$elm_animator$Internal$Interpolate$coloring = {
9910 co: function (_v0) {
9911 return $mdgriffith$elm_animator$Internal$Interpolate$linearDefault;
9912 },
9913 cu: function (_v1) {
9914 return $elm$core$Maybe$Nothing;
9915 },
9916 cB: $mdgriffith$elm_animator$Internal$Interpolate$lerpColor,
9917 cQ: $elm$core$Basics$identity,
9918 cY: F5(
9919 function (lookup, target, targetTime, maybeLookAhead, state) {
9920 return lookup(
9921 $mdgriffith$elm_animator$Internal$Timeline$getEvent(target));
9922 })
9923};
9924var $elm$core$Basics$composeR = F3(
9925 function (f, g, x) {
9926 return g(
9927 f(x));
9928 });
9929var $ianmackenzie$elm_units$Pixels$inPixels = function (_v0) {
9930 var numPixels = _v0;
9931 return numPixels;
9932};
9933var $mdgriffith$elm_animator$Animator$Css$expand = F2(
9934 function (_v0, _v1) {
9935 var lastFrame = _v0.b;
9936 var percent = _v1.a;
9937 var rotation = _v1.b;
9938 return A2(
9939 $mdgriffith$elm_animator$Internal$Timeline$Frame,
9940 percent,
9941 {X: lastFrame.X, Y: lastFrame.Y, Z: lastFrame.Z, ae: lastFrame.ae, af: lastFrame.af, H: lastFrame.H, aO: rotation, f: lastFrame.f, g: lastFrame.g, h: lastFrame.h, dY: lastFrame.dY, dZ: lastFrame.dZ, d$: lastFrame.d$});
9942 });
9943var $ianmackenzie$elm_units$Pixels$pixels = function (numPixels) {
9944 return numPixels;
9945};
9946var $ianmackenzie$elm_units$Pixels$pixelsPerSecond = function (numPixelsPerSecond) {
9947 return numPixelsPerSecond;
9948};
9949var $mdgriffith$elm_animator$Animator$Css$mapDwellFrames = F2(
9950 function (combinedFrames, dwell) {
9951 var lastFrame = function () {
9952 if (!combinedFrames.b) {
9953 return A2(
9954 $mdgriffith$elm_animator$Internal$Timeline$Frame,
9955 1,
9956 {
9957 X: 0,
9958 Y: 0,
9959 Z: 1,
9960 ae: {
9961 A: $ianmackenzie$elm_units$Pixels$pixels(0),
9962 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
9963 },
9964 af: {
9965 A: $ianmackenzie$elm_units$Pixels$pixels(0),
9966 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
9967 },
9968 H: {
9969 A: $ianmackenzie$elm_units$Pixels$pixels(1),
9970 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
9971 },
9972 aO: {
9973 A: $ianmackenzie$elm_units$Pixels$pixels(0),
9974 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
9975 },
9976 f: {
9977 A: $ianmackenzie$elm_units$Pixels$pixels(1),
9978 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
9979 },
9980 g: {
9981 A: $ianmackenzie$elm_units$Pixels$pixels(1),
9982 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
9983 },
9984 h: {
9985 A: $ianmackenzie$elm_units$Pixels$pixels(1),
9986 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
9987 },
9988 dY: {
9989 A: $ianmackenzie$elm_units$Pixels$pixels(0),
9990 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
9991 },
9992 dZ: {
9993 A: $ianmackenzie$elm_units$Pixels$pixels(0),
9994 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
9995 },
9996 d$: {
9997 A: $ianmackenzie$elm_units$Pixels$pixels(0),
9998 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
9999 }
10000 });
10001 } else {
10002 var last = combinedFrames.a;
10003 return last;
10004 }
10005 }();
10006 return {
10007 a: A2(
10008 $elm$core$List$map,
10009 $mdgriffith$elm_animator$Animator$Css$expand(lastFrame),
10010 dwell.a),
10011 bU: dwell.bU
10012 };
10013 });
10014var $mdgriffith$elm_animator$Internal$Interpolate$dwellPeriod = function (movement) {
10015 if (movement.$ === 1) {
10016 return $elm$core$Maybe$Nothing;
10017 } else {
10018 var period = movement.b;
10019 return $elm$core$Maybe$Just(period);
10020 }
10021};
10022var $mdgriffith$elm_animator$Internal$Interpolate$getPersonality = function (m) {
10023 if (!m.$) {
10024 var personality = m.a;
10025 return personality;
10026 } else {
10027 var personality = m.a;
10028 return personality;
10029 }
10030};
10031var $ianmackenzie$elm_units$Pixels$inPixelsPerSecond = function (_v0) {
10032 var numPixelsPerSecond = _v0;
10033 return numPixelsPerSecond;
10034};
10035var $mdgriffith$elm_animator$Internal$Interpolate$Spline = F4(
10036 function (a, b, c, d) {
10037 return {$: 0, a: a, b: b, c: c, d: d};
10038 });
10039var $mdgriffith$elm_animator$Internal$Interpolate$zeroPoint = {dY: 0, dZ: 0};
10040var $mdgriffith$elm_animator$Internal$Interpolate$createSpline = function (config) {
10041 var totalX = config.c8.dY - config.cQ.dY;
10042 var startVelScale = 1 / (config.an.dY / totalX);
10043 var startVelocity = (!config.ax.eb) ? {dY: 0, dZ: 0} : (((!(config.an.dY - $mdgriffith$elm_animator$Internal$Interpolate$zeroPoint.dY)) && (!(config.an.dZ - $mdgriffith$elm_animator$Internal$Interpolate$zeroPoint.dZ))) ? {dY: totalX * (config.ax.eb * 3), dZ: 0} : {dY: (startVelScale * config.an.dY) * (config.ax.eb * 3), dZ: (startVelScale * config.an.dZ) * (config.ax.eb * 3)});
10044 var endVelScale = 1 / (config.ad.dY / totalX);
10045 var endVelocity = (!config.as.d3) ? {dY: 0, dZ: 0} : (((!(config.ad.dY - $mdgriffith$elm_animator$Internal$Interpolate$zeroPoint.dY)) && (!(config.ad.dZ - $mdgriffith$elm_animator$Internal$Interpolate$zeroPoint.dZ))) ? {dY: totalX * (config.as.d3 * 3), dZ: 0} : {dY: (endVelScale * config.ad.dY) * (config.as.d3 * 3), dZ: (endVelScale * config.ad.dZ) * (config.as.d3 * 3)});
10046 return A4(
10047 $mdgriffith$elm_animator$Internal$Interpolate$Spline,
10048 config.cQ,
10049 {dY: config.cQ.dY + ((1 / 3) * startVelocity.dY), dZ: config.cQ.dZ + ((1 / 3) * startVelocity.dZ)},
10050 {dY: config.c8.dY + (((-1) / 3) * endVelocity.dY), dZ: config.c8.dZ + (((-1) / 3) * endVelocity.dZ)},
10051 config.c8);
10052};
10053var $mdgriffith$elm_animator$Internal$Interpolate$findAtXOnSpline = F6(
10054 function (spline, desiredX, tolerance, jumpSize, t, depth) {
10055 findAtXOnSpline:
10056 while (true) {
10057 var p1 = spline.a;
10058 var p2 = spline.b;
10059 var p3 = spline.c;
10060 var p4 = spline.d;
10061 var point = function () {
10062 if (t <= 0.5) {
10063 var q3 = {dY: p3.dY + (t * (p4.dY - p3.dY)), dZ: p3.dZ + (t * (p4.dZ - p3.dZ))};
10064 var q2 = {dY: p2.dY + (t * (p3.dY - p2.dY)), dZ: p2.dZ + (t * (p3.dZ - p2.dZ))};
10065 var r2 = {dY: q2.dY + (t * (q3.dY - q2.dY)), dZ: q2.dZ + (t * (q3.dZ - q2.dZ))};
10066 var q1 = {dY: p1.dY + (t * (p2.dY - p1.dY)), dZ: p1.dZ + (t * (p2.dZ - p1.dZ))};
10067 var r1 = {dY: q1.dY + (t * (q2.dY - q1.dY)), dZ: q1.dZ + (t * (q2.dZ - q1.dZ))};
10068 return {dY: r1.dY + (t * (r2.dY - r1.dY)), dZ: r1.dZ + (t * (r2.dZ - r1.dZ))};
10069 } else {
10070 var q3 = {dY: p4.dY + ((1 - t) * (p3.dY - p4.dY)), dZ: p4.dZ + ((1 - t) * (p3.dZ - p4.dZ))};
10071 var q2 = {dY: p3.dY + ((1 - t) * (p2.dY - p3.dY)), dZ: p3.dZ + ((1 - t) * (p2.dZ - p3.dZ))};
10072 var r2 = {dY: q3.dY + ((1 - t) * (q2.dY - q3.dY)), dZ: q3.dZ + ((1 - t) * (q2.dZ - q3.dZ))};
10073 var q1 = {dY: p2.dY + ((1 - t) * (p1.dY - p2.dY)), dZ: p2.dZ + ((1 - t) * (p1.dZ - p2.dZ))};
10074 var r1 = {dY: q2.dY + ((1 - t) * (q1.dY - q2.dY)), dZ: q2.dZ + ((1 - t) * (q1.dZ - q2.dZ))};
10075 return {dY: r2.dY + ((1 - t) * (r1.dY - r2.dY)), dZ: r2.dZ + ((1 - t) * (r1.dZ - r2.dZ))};
10076 }
10077 }();
10078 if (depth === 10) {
10079 return {cK: point, cV: t};
10080 } else {
10081 if (($elm$core$Basics$abs(point.dY - desiredX) < 1) && ($elm$core$Basics$abs(point.dY - desiredX) >= 0)) {
10082 return {cK: point, cV: t};
10083 } else {
10084 if ((point.dY - desiredX) > 0) {
10085 var $temp$spline = spline,
10086 $temp$desiredX = desiredX,
10087 $temp$tolerance = tolerance,
10088 $temp$jumpSize = jumpSize / 2,
10089 $temp$t = t - jumpSize,
10090 $temp$depth = depth + 1;
10091 spline = $temp$spline;
10092 desiredX = $temp$desiredX;
10093 tolerance = $temp$tolerance;
10094 jumpSize = $temp$jumpSize;
10095 t = $temp$t;
10096 depth = $temp$depth;
10097 continue findAtXOnSpline;
10098 } else {
10099 var $temp$spline = spline,
10100 $temp$desiredX = desiredX,
10101 $temp$tolerance = tolerance,
10102 $temp$jumpSize = jumpSize / 2,
10103 $temp$t = t + jumpSize,
10104 $temp$depth = depth + 1;
10105 spline = $temp$spline;
10106 desiredX = $temp$desiredX;
10107 tolerance = $temp$tolerance;
10108 jumpSize = $temp$jumpSize;
10109 t = $temp$t;
10110 depth = $temp$depth;
10111 continue findAtXOnSpline;
10112 }
10113 }
10114 }
10115 }
10116 });
10117var $mdgriffith$elm_animator$Internal$Interpolate$interpolateValue = F3(
10118 function (start, end, t) {
10119 return (t <= 0.5) ? (start + (t * (end - start))) : (end + ((1 - t) * (start - end)));
10120 });
10121var $mdgriffith$elm_animator$Internal$Interpolate$firstDerivativeOnSpline = F2(
10122 function (_v0, proportion) {
10123 var p1 = _v0.a;
10124 var p2 = _v0.b;
10125 var p3 = _v0.c;
10126 var p4 = _v0.d;
10127 var vy3 = p4.dZ - p3.dZ;
10128 var vy2 = p3.dZ - p2.dZ;
10129 var wy2 = A3($mdgriffith$elm_animator$Internal$Interpolate$interpolateValue, vy2, vy3, proportion);
10130 var vy1 = p2.dZ - p1.dZ;
10131 var wy1 = A3($mdgriffith$elm_animator$Internal$Interpolate$interpolateValue, vy1, vy2, proportion);
10132 var vx3 = p4.dY - p3.dY;
10133 var vx2 = p3.dY - p2.dY;
10134 var wx2 = A3($mdgriffith$elm_animator$Internal$Interpolate$interpolateValue, vx2, vx3, proportion);
10135 var vx1 = p2.dY - p1.dY;
10136 var wx1 = A3($mdgriffith$elm_animator$Internal$Interpolate$interpolateValue, vx1, vx2, proportion);
10137 return {
10138 dY: 3 * A3($mdgriffith$elm_animator$Internal$Interpolate$interpolateValue, wx1, wx2, proportion),
10139 dZ: 3 * A3($mdgriffith$elm_animator$Internal$Interpolate$interpolateValue, wy1, wy2, proportion)
10140 };
10141 });
10142var $mdgriffith$elm_animator$Internal$Interpolate$guessTime = F2(
10143 function (now, _v0) {
10144 var one = _v0.a;
10145 var two = _v0.b;
10146 var three = _v0.c;
10147 var four = _v0.d;
10148 return (!(four.dY - one.dY)) ? 0.5 : ((now - one.dY) / (four.dY - one.dY));
10149 });
10150var $ianmackenzie$elm_units$Quantity$divideBy = F2(
10151 function (divisor, _v0) {
10152 var value = _v0;
10153 return value / divisor;
10154 });
10155var $ianmackenzie$elm_units$Quantity$per = F2(
10156 function (_v0, _v1) {
10157 var independentValue = _v0;
10158 var dependentValue = _v1;
10159 return dependentValue / independentValue;
10160 });
10161var $mdgriffith$elm_animator$Internal$Interpolate$derivativeOfEasing = F3(
10162 function (ease, period, target) {
10163 var targetPixels = $ianmackenzie$elm_units$Pixels$pixels(
10164 ease(target));
10165 var sampleSize = 16;
10166 var deltaSample = sampleSize / $ianmackenzie$elm_units$Duration$inMilliseconds(period);
10167 var next = $ianmackenzie$elm_units$Pixels$pixels(
10168 ease(target + deltaSample));
10169 var dx2 = A2($ianmackenzie$elm_units$Quantity$minus, targetPixels, next);
10170 var prev = $ianmackenzie$elm_units$Pixels$pixels(
10171 ease(target - deltaSample));
10172 var dx1 = A2($ianmackenzie$elm_units$Quantity$minus, prev, targetPixels);
10173 var dx = A2(
10174 $ianmackenzie$elm_units$Quantity$divideBy,
10175 2,
10176 A2($ianmackenzie$elm_units$Quantity$plus, dx1, dx2));
10177 return A2(
10178 $ianmackenzie$elm_units$Quantity$per,
10179 $ianmackenzie$elm_units$Duration$milliseconds(sampleSize),
10180 dx);
10181 });
10182var $elm$core$Basics$isInfinite = _Basics_isInfinite;
10183var $ianmackenzie$elm_units$Quantity$isInfinite = function (_v0) {
10184 var value = _v0;
10185 return $elm$core$Basics$isInfinite(value);
10186};
10187var $elm$core$Basics$isNaN = _Basics_isNaN;
10188var $ianmackenzie$elm_units$Quantity$isNaN = function (_v0) {
10189 var value = _v0;
10190 return $elm$core$Basics$isNaN(value);
10191};
10192var $ianmackenzie$elm_units$Quantity$zero = 0;
10193var $mdgriffith$elm_animator$Internal$Interpolate$velocityBetween = F4(
10194 function (one, oneTime, two, twoTime) {
10195 var duration = A2($mdgriffith$elm_animator$Internal$Time$duration, oneTime, twoTime);
10196 var distance = A2($ianmackenzie$elm_units$Quantity$minus, one, two);
10197 var vel = A2($ianmackenzie$elm_units$Quantity$per, duration, distance);
10198 return ($ianmackenzie$elm_units$Quantity$isNaN(vel) || $ianmackenzie$elm_units$Quantity$isInfinite(vel)) ? $ianmackenzie$elm_units$Quantity$zero : vel;
10199 });
10200var $mdgriffith$elm_animator$Internal$Interpolate$newVelocityAtTarget = F3(
10201 function (target, targetTime, maybeLookAhead) {
10202 if (maybeLookAhead.$ === 1) {
10203 if (target.$ === 1) {
10204 return $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0);
10205 } else {
10206 var period = target.b;
10207 var toX = target.c;
10208 if (!period.$) {
10209 var periodDuration = period.a;
10210 return A3($mdgriffith$elm_animator$Internal$Interpolate$derivativeOfEasing, toX, periodDuration, 0);
10211 } else {
10212 var n = period.a;
10213 var periodDuration = period.b;
10214 return A3($mdgriffith$elm_animator$Internal$Interpolate$derivativeOfEasing, toX, periodDuration, 0);
10215 }
10216 }
10217 } else {
10218 var lookAhead = maybeLookAhead.a;
10219 var targetPosition = function () {
10220 if (!target.$) {
10221 var toX = target.c;
10222 return $ianmackenzie$elm_units$Pixels$pixels(
10223 toX(0));
10224 } else {
10225 var x = target.b;
10226 return $ianmackenzie$elm_units$Pixels$pixels(x);
10227 }
10228 }();
10229 var _v3 = lookAhead.d0;
10230 if (_v3.$ === 1) {
10231 var aheadPosition = _v3.b;
10232 return A4(
10233 $mdgriffith$elm_animator$Internal$Interpolate$velocityBetween,
10234 targetPosition,
10235 $mdgriffith$elm_animator$Internal$Time$millis(targetTime),
10236 $ianmackenzie$elm_units$Pixels$pixels(aheadPosition),
10237 $mdgriffith$elm_animator$Internal$Time$millis(lookAhead.dP));
10238 } else {
10239 var period = _v3.b;
10240 var toX = _v3.c;
10241 if (lookAhead.eA) {
10242 if (!period.$) {
10243 var periodDuration = period.a;
10244 return A3($mdgriffith$elm_animator$Internal$Interpolate$derivativeOfEasing, toX, periodDuration, 0);
10245 } else {
10246 var n = period.a;
10247 var periodDuration = period.b;
10248 return A3($mdgriffith$elm_animator$Internal$Interpolate$derivativeOfEasing, toX, periodDuration, 0);
10249 }
10250 } else {
10251 return A4(
10252 $mdgriffith$elm_animator$Internal$Interpolate$velocityBetween,
10253 targetPosition,
10254 $mdgriffith$elm_animator$Internal$Time$millis(targetTime),
10255 $ianmackenzie$elm_units$Pixels$pixels(
10256 toX(0)),
10257 $mdgriffith$elm_animator$Internal$Time$millis(lookAhead.dP));
10258 }
10259 }
10260 }
10261 });
10262var $mdgriffith$elm_animator$Internal$Interpolate$interpolateBetween = F7(
10263 function (startTimeInMs, maybePrevious, target, targetTimeInMs, now, maybeLookAhead, state) {
10264 var targetVelocity = $ianmackenzie$elm_units$Pixels$inPixelsPerSecond(
10265 A3($mdgriffith$elm_animator$Internal$Interpolate$newVelocityAtTarget, target, targetTimeInMs, maybeLookAhead));
10266 var targetPosition = function () {
10267 if (!target.$) {
10268 var toX = target.c;
10269 return $ianmackenzie$elm_units$Pixels$pixels(
10270 toX(0));
10271 } else {
10272 var x = target.b;
10273 return $ianmackenzie$elm_units$Pixels$pixels(x);
10274 }
10275 }();
10276 var curve = $mdgriffith$elm_animator$Internal$Interpolate$createSpline(
10277 {
10278 as: function () {
10279 if (target.$ === 1) {
10280 var personality = target.a;
10281 return personality;
10282 } else {
10283 var personality = target.a;
10284 return personality;
10285 }
10286 }(),
10287 ax: function () {
10288 if (maybePrevious.$ === 1) {
10289 return $mdgriffith$elm_animator$Internal$Interpolate$linearDefault;
10290 } else {
10291 if (maybePrevious.a.$ === 1) {
10292 var _v2 = maybePrevious.a;
10293 var personality = _v2.a;
10294 return personality;
10295 } else {
10296 var _v3 = maybePrevious.a;
10297 var personality = _v3.a;
10298 return personality;
10299 }
10300 }
10301 }(),
10302 c8: {
10303 dY: targetTimeInMs,
10304 dZ: $ianmackenzie$elm_units$Pixels$inPixels(targetPosition)
10305 },
10306 ad: {dY: 1000, dZ: targetVelocity},
10307 cQ: {
10308 dY: startTimeInMs,
10309 dZ: $ianmackenzie$elm_units$Pixels$inPixels(state.A)
10310 },
10311 an: {
10312 dY: 1000,
10313 dZ: $ianmackenzie$elm_units$Pixels$inPixelsPerSecond(state.dV)
10314 }
10315 });
10316 var current = A6(
10317 $mdgriffith$elm_animator$Internal$Interpolate$findAtXOnSpline,
10318 curve,
10319 now,
10320 1,
10321 0.25,
10322 A2($mdgriffith$elm_animator$Internal$Interpolate$guessTime, now, curve),
10323 0);
10324 var firstDerivative = A2($mdgriffith$elm_animator$Internal$Interpolate$firstDerivativeOnSpline, curve, current.cV);
10325 return {
10326 A: $ianmackenzie$elm_units$Pixels$pixels(current.cK.dZ),
10327 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(1000 * (firstDerivative.dZ / firstDerivative.dY))
10328 };
10329 });
10330var $mdgriffith$elm_animator$Internal$Spring$criticalDamping = F2(
10331 function (k, m) {
10332 return 2 * $elm$core$Basics$sqrt(k * m);
10333 });
10334var $elm$core$Basics$e = _Basics_e;
10335var $mdgriffith$elm_animator$Internal$Spring$toleranceForSpringSettleTimeCalculation = (-1) * A2($elm$core$Basics$logBase, $elm$core$Basics$e, 0.005);
10336var $mdgriffith$elm_animator$Internal$Spring$settlesAt = function (_v0) {
10337 var stiffness = _v0.aQ;
10338 var damping = _v0.aw;
10339 var mass = _v0.aH;
10340 var m = mass;
10341 var k = stiffness;
10342 var springAspect = $elm$core$Basics$sqrt(k / m);
10343 var cCritical = A2($mdgriffith$elm_animator$Internal$Spring$criticalDamping, k, m);
10344 var c = damping;
10345 if (_Utils_eq(
10346 $elm$core$Basics$round(c),
10347 $elm$core$Basics$round(cCritical))) {
10348 return 1000 * (8.5 / springAspect);
10349 } else {
10350 if ((c - cCritical) > 0) {
10351 var dampingAspect = c / cCritical;
10352 return 1000 * ($mdgriffith$elm_animator$Internal$Spring$toleranceForSpringSettleTimeCalculation / (dampingAspect * springAspect));
10353 } else {
10354 var dampingAspect = c / cCritical;
10355 return 1000 * ($mdgriffith$elm_animator$Internal$Spring$toleranceForSpringSettleTimeCalculation / (dampingAspect * springAspect));
10356 }
10357 }
10358};
10359var $mdgriffith$elm_animator$Internal$Spring$mapToRange = F3(
10360 function (minimum, maximum, x) {
10361 var total = maximum - minimum;
10362 return minimum + (x * total);
10363 });
10364var $mdgriffith$elm_animator$Internal$Spring$wobble2Ratio = F2(
10365 function (wobble, duration) {
10366 var ms = $ianmackenzie$elm_units$Duration$inMilliseconds(duration);
10367 var scalingBelowDur = ms / 350;
10368 var top = A2(
10369 $elm$core$Basics$max,
10370 0.43,
10371 0.8 * A2($elm$core$Basics$min, 1, scalingBelowDur));
10372 var bounded = A2(
10373 $elm$core$Basics$min,
10374 1,
10375 A2($elm$core$Basics$max, 0, wobble));
10376 return A3($mdgriffith$elm_animator$Internal$Spring$mapToRange, 0.43, top, 1 - bounded);
10377 });
10378var $mdgriffith$elm_animator$Internal$Spring$wobble2Damping = F4(
10379 function (wobble, k, m, duration) {
10380 return A2($mdgriffith$elm_animator$Internal$Spring$wobble2Ratio, wobble, duration) * A2($mdgriffith$elm_animator$Internal$Spring$criticalDamping, k, m);
10381 });
10382var $mdgriffith$elm_animator$Internal$Spring$select = F2(
10383 function (wobbliness, duration) {
10384 var k = 150;
10385 var durMS = $ianmackenzie$elm_units$Duration$inMilliseconds(duration);
10386 var damping = A4($mdgriffith$elm_animator$Internal$Spring$wobble2Damping, wobbliness, k, 1, duration);
10387 var initiallySettlesAt = $mdgriffith$elm_animator$Internal$Spring$settlesAt(
10388 {aw: damping, aH: 1, aQ: k});
10389 var newCritical = A2($mdgriffith$elm_animator$Internal$Spring$criticalDamping, k, durMS / initiallySettlesAt);
10390 return {aw: damping, aH: durMS / initiallySettlesAt, aQ: k};
10391 });
10392var $elm$core$List$repeatHelp = F3(
10393 function (result, n, value) {
10394 repeatHelp:
10395 while (true) {
10396 if (n <= 0) {
10397 return result;
10398 } else {
10399 var $temp$result = A2($elm$core$List$cons, value, result),
10400 $temp$n = n - 1,
10401 $temp$value = value;
10402 result = $temp$result;
10403 n = $temp$n;
10404 value = $temp$value;
10405 continue repeatHelp;
10406 }
10407 }
10408 });
10409var $elm$core$List$repeat = F2(
10410 function (n, value) {
10411 return A3($elm$core$List$repeatHelp, _List_Nil, n, value);
10412 });
10413var $mdgriffith$elm_animator$Internal$Spring$step = F4(
10414 function (target, _v0, dtms, motion) {
10415 var stiffness = _v0.aQ;
10416 var damping = _v0.aw;
10417 var mass = _v0.aH;
10418 var fspring = stiffness * (target - motion.A);
10419 var fdamper = ((-1) * damping) * motion.dV;
10420 var dt = dtms / 1000;
10421 var a = (fspring + fdamper) / mass;
10422 var newVelocity = motion.dV + (a * dt);
10423 var newPos = motion.A + (newVelocity * dt);
10424 return {A: newPos, dV: newVelocity};
10425 });
10426var $mdgriffith$elm_animator$Internal$Spring$stepOver = F4(
10427 function (duration, params, target, state) {
10428 var durMS = $ianmackenzie$elm_units$Duration$inMilliseconds(duration);
10429 var frames = durMS / 16;
10430 var remainder = 16 * (frames - $elm$core$Basics$floor(frames));
10431 var steps = (remainder > 0) ? A2(
10432 $elm$core$List$cons,
10433 remainder,
10434 A2(
10435 $elm$core$List$repeat,
10436 ($elm$core$Basics$floor(durMS) / 16) | 0,
10437 16)) : A2(
10438 $elm$core$List$repeat,
10439 ($elm$core$Basics$floor(durMS) / 16) | 0,
10440 16);
10441 return A3(
10442 $elm$core$List$foldl,
10443 A2($mdgriffith$elm_animator$Internal$Spring$step, target, params),
10444 state,
10445 steps);
10446 });
10447var $mdgriffith$elm_animator$Internal$Interpolate$springInterpolation = F7(
10448 function (prevEndTime, _v0, target, targetTime, now, _v1, state) {
10449 var wobble = function () {
10450 if (!target.$) {
10451 var personality = target.a;
10452 return personality.eR;
10453 } else {
10454 var personality = target.a;
10455 return personality.eR;
10456 }
10457 }();
10458 var targetPos = function () {
10459 if (!target.$) {
10460 var toX = target.c;
10461 return toX(0);
10462 } else {
10463 var x = target.b;
10464 return x;
10465 }
10466 }();
10467 var duration = A2(
10468 $mdgriffith$elm_animator$Internal$Time$duration,
10469 $mdgriffith$elm_animator$Internal$Time$millis(prevEndTime),
10470 $mdgriffith$elm_animator$Internal$Time$millis(targetTime));
10471 var params = A2($mdgriffith$elm_animator$Internal$Spring$select, wobble, duration);
10472 var _new = A4(
10473 $mdgriffith$elm_animator$Internal$Spring$stepOver,
10474 A2(
10475 $mdgriffith$elm_animator$Internal$Time$duration,
10476 $mdgriffith$elm_animator$Internal$Time$millis(prevEndTime),
10477 $mdgriffith$elm_animator$Internal$Time$millis(now)),
10478 params,
10479 targetPos,
10480 {
10481 A: $ianmackenzie$elm_units$Pixels$inPixels(state.A),
10482 dV: $ianmackenzie$elm_units$Pixels$inPixelsPerSecond(state.dV)
10483 });
10484 return {
10485 A: $ianmackenzie$elm_units$Pixels$pixels(_new.A),
10486 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(_new.dV)
10487 };
10488 });
10489var $mdgriffith$elm_animator$Internal$Interpolate$lerp = F7(
10490 function (prevEndTime, maybePrev, target, targetTime, now, maybeLookAhead, state) {
10491 var wobble = function () {
10492 if (!target.$) {
10493 var personality = target.a;
10494 return personality.eR;
10495 } else {
10496 var personality = target.a;
10497 return personality.eR;
10498 }
10499 }();
10500 var nothingHappened = function () {
10501 if (!target.$) {
10502 return false;
10503 } else {
10504 var x = target.b;
10505 return _Utils_eq(
10506 x,
10507 $ianmackenzie$elm_units$Pixels$inPixels(state.A)) && (!$ianmackenzie$elm_units$Pixels$inPixelsPerSecond(state.dV));
10508 }
10509 }();
10510 if (nothingHappened) {
10511 return state;
10512 } else {
10513 if (maybeLookAhead.$ === 1) {
10514 return (!(!wobble)) ? A7($mdgriffith$elm_animator$Internal$Interpolate$springInterpolation, prevEndTime, maybePrev, target, targetTime, now, maybeLookAhead, state) : A7($mdgriffith$elm_animator$Internal$Interpolate$interpolateBetween, prevEndTime, maybePrev, target, targetTime, now, maybeLookAhead, state);
10515 } else {
10516 return A7($mdgriffith$elm_animator$Internal$Interpolate$interpolateBetween, prevEndTime, maybePrev, target, targetTime, now, maybeLookAhead, state);
10517 }
10518 }
10519 });
10520var $mdgriffith$elm_animator$Internal$Interpolate$startMoving = function (movement) {
10521 return {
10522 A: function () {
10523 if (!movement.$) {
10524 var toX = movement.c;
10525 return $ianmackenzie$elm_units$Pixels$pixels(
10526 toX(0));
10527 } else {
10528 var x = movement.b;
10529 return $ianmackenzie$elm_units$Pixels$pixels(x);
10530 }
10531 }(),
10532 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
10533 };
10534};
10535var $mdgriffith$elm_animator$Internal$Time$earliest = F2(
10536 function (oneQty, twoQty) {
10537 var one = oneQty;
10538 var two = twoQty;
10539 return ((one - two) >= 0) ? twoQty : oneQty;
10540 });
10541var $elm$core$Basics$modBy = _Basics_modBy;
10542var $mdgriffith$elm_animator$Internal$Interpolate$wrapUnitAfter = F2(
10543 function (dur, total) {
10544 var totalDuration = $elm$core$Basics$round(
10545 $ianmackenzie$elm_units$Duration$inMilliseconds(total));
10546 var periodDuration = $elm$core$Basics$round(
10547 $ianmackenzie$elm_units$Duration$inMilliseconds(dur));
10548 if ((!periodDuration) || (!totalDuration)) {
10549 return 0;
10550 } else {
10551 var remaining = A2($elm$core$Basics$modBy, periodDuration, totalDuration);
10552 return (!remaining) ? 1 : (remaining / periodDuration);
10553 }
10554 });
10555var $mdgriffith$elm_animator$Internal$Interpolate$visit = F5(
10556 function (lookup, occurring, now, maybeLookAhead, state) {
10557 var event = occurring.a;
10558 var start = occurring.b;
10559 var eventEnd = occurring.c;
10560 var dwellTime = function () {
10561 if (maybeLookAhead.$ === 1) {
10562 return A2($mdgriffith$elm_animator$Internal$Time$duration, start, now);
10563 } else {
10564 return A2(
10565 $mdgriffith$elm_animator$Internal$Time$duration,
10566 start,
10567 A2($mdgriffith$elm_animator$Internal$Time$earliest, now, eventEnd));
10568 }
10569 }();
10570 if ($mdgriffith$elm_animator$Internal$Time$zeroDuration(dwellTime)) {
10571 return {
10572 A: function () {
10573 var _v0 = lookup(event);
10574 if (!_v0.$) {
10575 var period = _v0.b;
10576 var toX = _v0.c;
10577 return $ianmackenzie$elm_units$Pixels$pixels(
10578 toX(0));
10579 } else {
10580 var x = _v0.b;
10581 return $ianmackenzie$elm_units$Pixels$pixels(x);
10582 }
10583 }(),
10584 dV: A3(
10585 $mdgriffith$elm_animator$Internal$Interpolate$newVelocityAtTarget,
10586 lookup(event),
10587 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(start),
10588 maybeLookAhead)
10589 };
10590 } else {
10591 var _v1 = lookup(event);
10592 if (_v1.$ === 1) {
10593 var pos = _v1.b;
10594 return {
10595 A: $ianmackenzie$elm_units$Pixels$pixels(pos),
10596 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
10597 };
10598 } else {
10599 var period = _v1.b;
10600 var toX = _v1.c;
10601 if (!period.$) {
10602 var periodDuration = period.a;
10603 var progress = A2($mdgriffith$elm_animator$Internal$Interpolate$wrapUnitAfter, periodDuration, dwellTime);
10604 return {
10605 A: $ianmackenzie$elm_units$Pixels$pixels(
10606 toX(progress)),
10607 dV: A3($mdgriffith$elm_animator$Internal$Interpolate$derivativeOfEasing, toX, periodDuration, progress)
10608 };
10609 } else {
10610 var n = period.a;
10611 var periodDuration = period.b;
10612 var totalMS = $ianmackenzie$elm_units$Duration$inMilliseconds(dwellTime);
10613 var iterationTimeMS = $ianmackenzie$elm_units$Duration$inMilliseconds(periodDuration);
10614 var iteration = $elm$core$Basics$floor(totalMS / iterationTimeMS);
10615 if (_Utils_cmp(iteration, n) > -1) {
10616 return {
10617 A: $ianmackenzie$elm_units$Pixels$pixels(
10618 toX(1)),
10619 dV: $ianmackenzie$elm_units$Pixels$pixelsPerSecond(0)
10620 };
10621 } else {
10622 var progress = A2($mdgriffith$elm_animator$Internal$Interpolate$wrapUnitAfter, periodDuration, dwellTime);
10623 return {
10624 A: $ianmackenzie$elm_units$Pixels$pixels(
10625 toX(progress)),
10626 dV: A3($mdgriffith$elm_animator$Internal$Interpolate$derivativeOfEasing, toX, periodDuration, progress)
10627 };
10628 }
10629 }
10630 }
10631 }
10632 });
10633var $mdgriffith$elm_animator$Internal$Interpolate$moving = {co: $mdgriffith$elm_animator$Internal$Interpolate$getPersonality, cu: $mdgriffith$elm_animator$Internal$Interpolate$dwellPeriod, cB: $mdgriffith$elm_animator$Internal$Interpolate$lerp, cQ: $mdgriffith$elm_animator$Internal$Interpolate$startMoving, cY: $mdgriffith$elm_animator$Internal$Interpolate$visit};
10634var $mdgriffith$elm_animator$Animator$Css$LinearTiming = 0;
10635var $mdgriffith$elm_animator$Animator$Css$LoopAnim = {$: 0};
10636var $mdgriffith$elm_animator$Animator$Css$RepeatAnim = function (a) {
10637 return {$: 1, a: a};
10638};
10639var $mdgriffith$elm_animator$Animator$Css$renderFrame = F8(
10640 function (i, total, name, frames, renderer, stubber, rendered, stub) {
10641 renderFrame:
10642 while (true) {
10643 if (!frames.b) {
10644 return {a: rendered, cX: stub};
10645 } else {
10646 var _v1 = frames.a;
10647 var percent = _v1.a;
10648 var frm = _v1.b;
10649 var remain = frames.b;
10650 if (total === 1) {
10651 var keyframe = ('0% {' + (name + (': ' + (renderer(frm) + ';}\n')))) + ('100% {' + (name + (': ' + (renderer(frm) + ';}\n'))));
10652 return {
10653 a: keyframe,
10654 cX: stubber(frm)
10655 };
10656 } else {
10657 var keyframe = $elm$core$String$fromFloat(100 * percent) + ('% {' + (name + (': ' + (renderer(frm) + ';}\n'))));
10658 var $temp$i = i + 1,
10659 $temp$total = total,
10660 $temp$name = name,
10661 $temp$frames = remain,
10662 $temp$renderer = renderer,
10663 $temp$stubber = stubber,
10664 $temp$rendered = _Utils_ap(rendered, keyframe),
10665 $temp$stub = _Utils_ap(
10666 stub,
10667 stubber(frm));
10668 i = $temp$i;
10669 total = $temp$total;
10670 name = $temp$name;
10671 frames = $temp$frames;
10672 renderer = $temp$renderer;
10673 stubber = $temp$stubber;
10674 rendered = $temp$rendered;
10675 stub = $temp$stub;
10676 continue renderFrame;
10677 }
10678 }
10679 }
10680 });
10681var $mdgriffith$elm_animator$Animator$Css$renderAnimation = F6(
10682 function (now, attrName, frames, renderer, stubber, anims) {
10683 var rendered = A8(
10684 $mdgriffith$elm_animator$Animator$Css$renderFrame,
10685 0,
10686 $elm$core$List$length(frames.a),
10687 attrName,
10688 frames.a,
10689 renderer,
10690 stubber,
10691 '',
10692 '');
10693 var name = attrName + ('-' + ($elm$core$String$fromInt(
10694 $elm$core$Basics$floor(
10695 $mdgriffith$elm_animator$Internal$Time$inMilliseconds(now))) + ('-' + rendered.cX)));
10696 var newKeyFrames = '@keyframes ' + (name + (' {\n' + (rendered.a + '\n}')));
10697 var duration = $ianmackenzie$elm_units$Duration$inMilliseconds(frames.y);
10698 var anim = {
10699 ab: 0,
10700 y: duration,
10701 by: newKeyFrames,
10702 er: name,
10703 al: $mdgriffith$elm_animator$Animator$Css$RepeatAnim(1),
10704 ao: 0
10705 };
10706 var _v0 = frames.ct;
10707 if (_v0.$ === 1) {
10708 return A2($elm$core$List$cons, anim, anims);
10709 } else {
10710 var details = _v0.a;
10711 var dwellFrames = A8(
10712 $mdgriffith$elm_animator$Animator$Css$renderFrame,
10713 0,
10714 $elm$core$List$length(details.a),
10715 attrName,
10716 details.a,
10717 renderer,
10718 stubber,
10719 '',
10720 '');
10721 var dwell = {
10722 ab: duration,
10723 y: function () {
10724 var _v1 = details.bU;
10725 if (_v1.$ === 1) {
10726 var dwellDur = _v1.b;
10727 return $ianmackenzie$elm_units$Duration$inMilliseconds(dwellDur);
10728 } else {
10729 var dwellDur = _v1.a;
10730 return $ianmackenzie$elm_units$Duration$inMilliseconds(dwellDur);
10731 }
10732 }(),
10733 by: '@keyframes ' + (name + ('-dwell' + (' {\n' + (dwellFrames.a + '\n}')))),
10734 er: name + '-dwell',
10735 al: function () {
10736 var _v2 = details.bU;
10737 if (_v2.$ === 1) {
10738 var n = _v2.a;
10739 return $mdgriffith$elm_animator$Animator$Css$RepeatAnim(n);
10740 } else {
10741 return $mdgriffith$elm_animator$Animator$Css$LoopAnim;
10742 }
10743 }(),
10744 ao: 0
10745 };
10746 return A2(
10747 $elm$core$List$cons,
10748 dwell,
10749 A2($elm$core$List$cons, anim, anims));
10750 }
10751 });
10752var $mdgriffith$elm_animator$Animator$Css$stubFloat = function (f) {
10753 return $elm$core$String$fromInt(
10754 $elm$core$Basics$round(f * 1000));
10755};
10756var $mdgriffith$elm_animator$Animator$Css$stubColor = function (clr) {
10757 var _v0 = $avh4$elm_color$Color$toRgba(clr);
10758 var red = _v0.cO;
10759 var green = _v0.cw;
10760 var blue = _v0.cq;
10761 var alpha = _v0.W;
10762 return _Utils_ap(
10763 $mdgriffith$elm_animator$Animator$Css$stubFloat(red) + '-',
10764 _Utils_ap(
10765 $mdgriffith$elm_animator$Animator$Css$stubFloat(green) + '-',
10766 _Utils_ap(
10767 $mdgriffith$elm_animator$Animator$Css$stubFloat(blue) + '-',
10768 $mdgriffith$elm_animator$Animator$Css$stubFloat(alpha))));
10769};
10770var $mdgriffith$elm_animator$Animator$Css$toTransform = function (options) {
10771 return function (rendered) {
10772 return function (x) {
10773 return function (y) {
10774 return function (z) {
10775 return function (rotation) {
10776 return function (scaleX) {
10777 return function (scaleY) {
10778 return function (scaleZ) {
10779 return function (facingX) {
10780 return function (facingY) {
10781 return function (facingZ) {
10782 toTransform:
10783 while (true) {
10784 if (!x.b) {
10785 return rendered;
10786 } else {
10787 var _v1 = x.a;
10788 var percent = _v1.a;
10789 var topX = _v1.b;
10790 var rX = x.b;
10791 if (!y.b) {
10792 return rendered;
10793 } else {
10794 var _v3 = y.a;
10795 var topY = _v3.b;
10796 var rY = y.b;
10797 if (!z.b) {
10798 return rendered;
10799 } else {
10800 var _v5 = z.a;
10801 var topZ = _v5.b;
10802 var rZ = z.b;
10803 if (!rotation.b) {
10804 return rendered;
10805 } else {
10806 var _v7 = rotation.a;
10807 var topR = _v7.b;
10808 var rR = rotation.b;
10809 if (!scaleX.b) {
10810 return rendered;
10811 } else {
10812 var _v9 = scaleX.a;
10813 var topSx = _v9.b;
10814 var rsx = scaleX.b;
10815 if (!scaleY.b) {
10816 return rendered;
10817 } else {
10818 var _v11 = scaleY.a;
10819 var topSy = _v11.b;
10820 var rsy = scaleY.b;
10821 if (!scaleZ.b) {
10822 return rendered;
10823 } else {
10824 var _v13 = scaleZ.a;
10825 var topSz = _v13.b;
10826 var rsz = scaleZ.b;
10827 if (!facingX.b) {
10828 return rendered;
10829 } else {
10830 var _v15 = facingX.a;
10831 var topFx = _v15.b;
10832 var rfx = facingX.b;
10833 if (!facingY.b) {
10834 return rendered;
10835 } else {
10836 var _v17 = facingY.a;
10837 var topFy = _v17.b;
10838 var rfy = facingY.b;
10839 if (!facingZ.b) {
10840 return rendered;
10841 } else {
10842 var _v19 = facingZ.a;
10843 var topFz = _v19.b;
10844 var rfz = facingZ.b;
10845 var $temp$options = options,
10846 $temp$rendered = A2(
10847 $elm$core$List$cons,
10848 A2(
10849 $mdgriffith$elm_animator$Internal$Timeline$Frame,
10850 percent,
10851 {X: options.aP.dY, Y: options.aP.dZ, Z: options.aP.d$, ae: topFx, af: topFy, H: topFz, aO: topR, f: topSx, g: topSy, h: topSz, dY: topX, dZ: topY, d$: topZ}),
10852 rendered),
10853 $temp$x = rX,
10854 $temp$y = rY,
10855 $temp$z = rZ,
10856 $temp$rotation = rR,
10857 $temp$scaleX = rsx,
10858 $temp$scaleY = rsy,
10859 $temp$scaleZ = rsz,
10860 $temp$facingX = rfx,
10861 $temp$facingY = rfy,
10862 $temp$facingZ = rfz;
10863 options = $temp$options;
10864 rendered = $temp$rendered;
10865 x = $temp$x;
10866 y = $temp$y;
10867 z = $temp$z;
10868 rotation = $temp$rotation;
10869 scaleX = $temp$scaleX;
10870 scaleY = $temp$scaleY;
10871 scaleZ = $temp$scaleZ;
10872 facingX = $temp$facingX;
10873 facingY = $temp$facingY;
10874 facingZ = $temp$facingZ;
10875 continue toTransform;
10876 }
10877 }
10878 }
10879 }
10880 }
10881 }
10882 }
10883 }
10884 }
10885 }
10886 }
10887 };
10888 };
10889 };
10890 };
10891 };
10892 };
10893 };
10894 };
10895 };
10896 };
10897 };
10898};
10899var $elm$core$Basics$atan2 = _Basics_atan2;
10900var $elm$core$Basics$toPolar = function (_v0) {
10901 var x = _v0.a;
10902 var y = _v0.b;
10903 return _Utils_Tuple2(
10904 $elm$core$Basics$sqrt((x * x) + (y * y)),
10905 A2($elm$core$Basics$atan2, y, x));
10906};
10907var $mdgriffith$elm_animator$Animator$Css$transformToString = function (details) {
10908 var _v0 = $elm$core$Basics$toPolar(
10909 _Utils_Tuple2(
10910 $ianmackenzie$elm_units$Pixels$inPixels(details.H.A),
10911 $ianmackenzie$elm_units$Pixels$inPixels(details.ae.A)));
10912 var rotationAroundY = _v0.b;
10913 var _v1 = $elm$core$Basics$toPolar(
10914 _Utils_Tuple2(
10915 $ianmackenzie$elm_units$Pixels$inPixels(details.H.A),
10916 $ianmackenzie$elm_units$Pixels$inPixels(details.af.A)));
10917 var rotationAroundX = _v1.b;
10918 return ('translate3d(' + ($elm$core$String$fromFloat(
10919 $ianmackenzie$elm_units$Pixels$inPixels(details.dY.A)) + ('px, ' + ($elm$core$String$fromFloat(
10920 $ianmackenzie$elm_units$Pixels$inPixels(details.dZ.A)) + ('px, ' + ($elm$core$String$fromFloat(
10921 $ianmackenzie$elm_units$Pixels$inPixels(details.d$.A)) + 'px)')))))) + ((' rotate3d(0, 1, 0, ' + ($elm$core$String$fromFloat(rotationAroundY) + 'rad)')) + ((' rotate3d(1, 0, 0, ' + ($elm$core$String$fromFloat(rotationAroundX) + 'rad)')) + ((' rotate3d(' + ($elm$core$String$fromFloat(details.X) + (', ' + ($elm$core$String$fromFloat(details.Y) + (', ' + ($elm$core$String$fromFloat(details.Z) + (', ' + ($elm$core$String$fromFloat(
10922 $ianmackenzie$elm_units$Pixels$inPixels(details.aO.A)) + 'rad)')))))))) + (' scale3d(' + ($elm$core$String$fromFloat(
10923 $ianmackenzie$elm_units$Pixels$inPixels(details.f.A)) + (', ' + ($elm$core$String$fromFloat(
10924 $ianmackenzie$elm_units$Pixels$inPixels(details.g.A)) + (', ' + ($elm$core$String$fromFloat(
10925 $ianmackenzie$elm_units$Pixels$inPixels(details.h.A)) + ')')))))))));
10926};
10927var $mdgriffith$elm_animator$Animator$Css$transformToStub = function (details) {
10928 var _v0 = $elm$core$Basics$toPolar(
10929 _Utils_Tuple2(
10930 $ianmackenzie$elm_units$Pixels$inPixels(details.H.A),
10931 $ianmackenzie$elm_units$Pixels$inPixels(details.ae.A)));
10932 var rotationAroundY = _v0.b;
10933 var _v1 = $elm$core$Basics$toPolar(
10934 _Utils_Tuple2(
10935 $ianmackenzie$elm_units$Pixels$inPixels(details.H.A),
10936 $ianmackenzie$elm_units$Pixels$inPixels(details.af.A)));
10937 var rotationAroundX = _v1.b;
10938 return $mdgriffith$elm_animator$Animator$Css$stubFloat(
10939 $ianmackenzie$elm_units$Pixels$inPixels(details.dY.A)) + ('-' + ($mdgriffith$elm_animator$Animator$Css$stubFloat(
10940 $ianmackenzie$elm_units$Pixels$inPixels(details.dZ.A)) + ('-' + ($mdgriffith$elm_animator$Animator$Css$stubFloat(
10941 $ianmackenzie$elm_units$Pixels$inPixels(details.d$.A)) + ('-' + ($mdgriffith$elm_animator$Animator$Css$stubFloat(rotationAroundY) + ('-' + ($mdgriffith$elm_animator$Animator$Css$stubFloat(rotationAroundX) + ('-' + ($mdgriffith$elm_animator$Animator$Css$stubFloat(details.X) + ('-' + ($mdgriffith$elm_animator$Animator$Css$stubFloat(details.Y) + ('-' + ($mdgriffith$elm_animator$Animator$Css$stubFloat(details.Z) + ('-' + ($mdgriffith$elm_animator$Animator$Css$stubFloat(
10942 $ianmackenzie$elm_units$Pixels$inPixels(details.aO.A)) + ('-' + ($mdgriffith$elm_animator$Animator$Css$stubFloat(
10943 $ianmackenzie$elm_units$Pixels$inPixels(details.f.A)) + ('-' + ($mdgriffith$elm_animator$Animator$Css$stubFloat(
10944 $ianmackenzie$elm_units$Pixels$inPixels(details.g.A)) + ('-' + $mdgriffith$elm_animator$Animator$Css$stubFloat(
10945 $ianmackenzie$elm_units$Pixels$inPixels(details.h.A)))))))))))))))))))))));
10946};
10947var $mdgriffith$elm_animator$Internal$Interpolate$Osc = F3(
10948 function (a, b, c) {
10949 return {$: 0, a: a, b: b, c: c};
10950 });
10951var $mdgriffith$elm_animator$Internal$Interpolate$Pos = F2(
10952 function (a, b) {
10953 return {$: 1, a: a, b: b};
10954 });
10955var $mdgriffith$elm_animator$Internal$Interpolate$withDefault = F2(
10956 function (def, defaultOr) {
10957 if (!defaultOr.$) {
10958 return def;
10959 } else {
10960 var specified = defaultOr.a;
10961 return specified;
10962 }
10963 });
10964var $mdgriffith$elm_animator$Internal$Interpolate$fillDefaults = F2(
10965 function (builtInDefault, specified) {
10966 if (!specified.$) {
10967 return builtInDefault;
10968 } else {
10969 var partial = specified.a;
10970 return {
10971 d2: A2($mdgriffith$elm_animator$Internal$Interpolate$withDefault, builtInDefault.d2, partial.d2),
10972 d3: A2($mdgriffith$elm_animator$Internal$Interpolate$withDefault, builtInDefault.d3, partial.d3),
10973 ea: A2($mdgriffith$elm_animator$Internal$Interpolate$withDefault, builtInDefault.ea, partial.ea),
10974 eb: A2($mdgriffith$elm_animator$Internal$Interpolate$withDefault, builtInDefault.eb, partial.eb),
10975 eR: A2($mdgriffith$elm_animator$Internal$Interpolate$withDefault, builtInDefault.eR, partial.eR)
10976 };
10977 }
10978 });
10979var $mdgriffith$elm_animator$Internal$Interpolate$withLinearDefault = function (defMovement) {
10980 if (!defMovement.$) {
10981 var specifiedPersonality = defMovement.a;
10982 var period = defMovement.b;
10983 var fn = defMovement.c;
10984 var personality = A2($mdgriffith$elm_animator$Internal$Interpolate$fillDefaults, $mdgriffith$elm_animator$Internal$Interpolate$linearDefault, specifiedPersonality);
10985 return A3($mdgriffith$elm_animator$Internal$Interpolate$Osc, personality, period, fn);
10986 } else {
10987 var specifiedPersonality = defMovement.a;
10988 var p = defMovement.b;
10989 var personality = A2($mdgriffith$elm_animator$Internal$Interpolate$fillDefaults, $mdgriffith$elm_animator$Internal$Interpolate$linearDefault, specifiedPersonality);
10990 return A2($mdgriffith$elm_animator$Internal$Interpolate$Pos, personality, p);
10991 }
10992};
10993var $mdgriffith$elm_animator$Internal$Interpolate$standardDefault = {d2: 0, d3: 0.8, ea: 0, eb: 0.4, eR: 0};
10994var $mdgriffith$elm_animator$Internal$Interpolate$withStandardDefault = function (defMovement) {
10995 if (!defMovement.$) {
10996 var specifiedPersonality = defMovement.a;
10997 var period = defMovement.b;
10998 var fn = defMovement.c;
10999 var personality = A2($mdgriffith$elm_animator$Internal$Interpolate$fillDefaults, $mdgriffith$elm_animator$Internal$Interpolate$standardDefault, specifiedPersonality);
11000 return A3($mdgriffith$elm_animator$Internal$Interpolate$Osc, personality, period, fn);
11001 } else {
11002 var specifiedPersonality = defMovement.a;
11003 var p = defMovement.b;
11004 var personality = A2($mdgriffith$elm_animator$Internal$Interpolate$fillDefaults, $mdgriffith$elm_animator$Internal$Interpolate$standardDefault, specifiedPersonality);
11005 return A2($mdgriffith$elm_animator$Internal$Interpolate$Pos, personality, p);
11006 }
11007};
11008var $mdgriffith$elm_animator$Animator$Css$renderAttrs = F3(
11009 function (timeline, attr, anim) {
11010 var details = timeline;
11011 switch (attr.$) {
11012 case 4:
11013 return anim;
11014 case 0:
11015 var attrName = attr.a;
11016 var lookup = attr.b;
11017 return A6(
11018 $mdgriffith$elm_animator$Animator$Css$renderAnimation,
11019 details.ds,
11020 attrName,
11021 A4($mdgriffith$elm_animator$Internal$Timeline$capture, 60, lookup, $mdgriffith$elm_animator$Internal$Interpolate$coloring, timeline),
11022 $avh4$elm_color$Color$toCssString,
11023 $mdgriffith$elm_animator$Animator$Css$stubColor,
11024 anim);
11025 case 1:
11026 var attrName = attr.a;
11027 var lookup = attr.b;
11028 var toString = attr.c;
11029 return A6(
11030 $mdgriffith$elm_animator$Animator$Css$renderAnimation,
11031 details.ds,
11032 attrName,
11033 A4(
11034 $mdgriffith$elm_animator$Internal$Timeline$capture,
11035 60,
11036 A2($elm$core$Basics$composeR, lookup, $mdgriffith$elm_animator$Internal$Interpolate$withLinearDefault),
11037 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11038 timeline),
11039 A2(
11040 $elm$core$Basics$composeR,
11041 function ($) {
11042 return $.A;
11043 },
11044 A2($elm$core$Basics$composeR, $ianmackenzie$elm_units$Pixels$inPixels, toString)),
11045 A2(
11046 $elm$core$Basics$composeR,
11047 function ($) {
11048 return $.A;
11049 },
11050 A2($elm$core$Basics$composeR, $ianmackenzie$elm_units$Pixels$inPixels, $mdgriffith$elm_animator$Animator$Css$stubFloat)),
11051 anim);
11052 case 2:
11053 var attrName = attr.a;
11054 var lookup = attr.b;
11055 var toString = attr.c;
11056 return A6(
11057 $mdgriffith$elm_animator$Animator$Css$renderAnimation,
11058 details.ds,
11059 attrName,
11060 A4(
11061 $mdgriffith$elm_animator$Internal$Timeline$capture,
11062 60,
11063 A2($elm$core$Basics$composeR, lookup, $mdgriffith$elm_animator$Internal$Interpolate$withStandardDefault),
11064 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11065 timeline),
11066 A2(
11067 $elm$core$Basics$composeR,
11068 function ($) {
11069 return $.A;
11070 },
11071 A2($elm$core$Basics$composeR, $ianmackenzie$elm_units$Pixels$inPixels, toString)),
11072 A2(
11073 $elm$core$Basics$composeR,
11074 function ($) {
11075 return $.A;
11076 },
11077 A2($elm$core$Basics$composeR, $ianmackenzie$elm_units$Pixels$inPixels, $mdgriffith$elm_animator$Animator$Css$stubFloat)),
11078 anim);
11079 default:
11080 var options = attr.a;
11081 var lookupTransform = attr.b;
11082 var lookup = function (state) {
11083 var _v1 = lookupTransform(state);
11084 var deets = _v1;
11085 return deets;
11086 };
11087 var rotation = A4(
11088 $mdgriffith$elm_animator$Internal$Timeline$capture,
11089 60,
11090 A2(
11091 $elm$core$Basics$composeR,
11092 lookup,
11093 A2(
11094 $elm$core$Basics$composeR,
11095 function ($) {
11096 return $.s;
11097 },
11098 $mdgriffith$elm_animator$Internal$Interpolate$withLinearDefault)),
11099 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11100 timeline);
11101 var scaleX = A4(
11102 $mdgriffith$elm_animator$Internal$Timeline$capture,
11103 60,
11104 A2(
11105 $elm$core$Basics$composeR,
11106 lookup,
11107 A2(
11108 $elm$core$Basics$composeR,
11109 function ($) {
11110 return $.f;
11111 },
11112 $mdgriffith$elm_animator$Internal$Interpolate$withStandardDefault)),
11113 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11114 timeline);
11115 var scaleY = A4(
11116 $mdgriffith$elm_animator$Internal$Timeline$capture,
11117 60,
11118 A2(
11119 $elm$core$Basics$composeR,
11120 lookup,
11121 A2(
11122 $elm$core$Basics$composeR,
11123 function ($) {
11124 return $.g;
11125 },
11126 $mdgriffith$elm_animator$Internal$Interpolate$withStandardDefault)),
11127 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11128 timeline);
11129 var scaleZ = A4(
11130 $mdgriffith$elm_animator$Internal$Timeline$capture,
11131 60,
11132 A2(
11133 $elm$core$Basics$composeR,
11134 lookup,
11135 A2(
11136 $elm$core$Basics$composeR,
11137 function ($) {
11138 return $.h;
11139 },
11140 $mdgriffith$elm_animator$Internal$Interpolate$withStandardDefault)),
11141 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11142 timeline);
11143 var x = A4(
11144 $mdgriffith$elm_animator$Internal$Timeline$capture,
11145 60,
11146 A2(
11147 $elm$core$Basics$composeR,
11148 lookup,
11149 A2(
11150 $elm$core$Basics$composeR,
11151 function ($) {
11152 return $.dY;
11153 },
11154 $mdgriffith$elm_animator$Internal$Interpolate$withStandardDefault)),
11155 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11156 timeline);
11157 var y = A4(
11158 $mdgriffith$elm_animator$Internal$Timeline$capture,
11159 60,
11160 A2(
11161 $elm$core$Basics$composeR,
11162 lookup,
11163 A2(
11164 $elm$core$Basics$composeR,
11165 function ($) {
11166 return $.dZ;
11167 },
11168 $mdgriffith$elm_animator$Internal$Interpolate$withStandardDefault)),
11169 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11170 timeline);
11171 var z = A4(
11172 $mdgriffith$elm_animator$Internal$Timeline$capture,
11173 60,
11174 A2(
11175 $elm$core$Basics$composeR,
11176 lookup,
11177 A2(
11178 $elm$core$Basics$composeR,
11179 function ($) {
11180 return $.d$;
11181 },
11182 $mdgriffith$elm_animator$Internal$Interpolate$withStandardDefault)),
11183 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11184 timeline);
11185 var facingZ = A4(
11186 $mdgriffith$elm_animator$Internal$Timeline$capture,
11187 60,
11188 A2(
11189 $elm$core$Basics$composeR,
11190 lookup,
11191 A2(
11192 $elm$core$Basics$composeR,
11193 function ($) {
11194 return $.q;
11195 },
11196 A2(
11197 $elm$core$Basics$composeR,
11198 function ($) {
11199 return $.d$;
11200 },
11201 $mdgriffith$elm_animator$Internal$Interpolate$withStandardDefault))),
11202 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11203 timeline);
11204 var facingY = A4(
11205 $mdgriffith$elm_animator$Internal$Timeline$capture,
11206 60,
11207 A2(
11208 $elm$core$Basics$composeR,
11209 lookup,
11210 A2(
11211 $elm$core$Basics$composeR,
11212 function ($) {
11213 return $.q;
11214 },
11215 A2(
11216 $elm$core$Basics$composeR,
11217 function ($) {
11218 return $.dZ;
11219 },
11220 $mdgriffith$elm_animator$Internal$Interpolate$withStandardDefault))),
11221 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11222 timeline);
11223 var facingX = A4(
11224 $mdgriffith$elm_animator$Internal$Timeline$capture,
11225 60,
11226 A2(
11227 $elm$core$Basics$composeR,
11228 lookup,
11229 A2(
11230 $elm$core$Basics$composeR,
11231 function ($) {
11232 return $.q;
11233 },
11234 A2(
11235 $elm$core$Basics$composeR,
11236 function ($) {
11237 return $.dY;
11238 },
11239 $mdgriffith$elm_animator$Internal$Interpolate$withStandardDefault))),
11240 $mdgriffith$elm_animator$Internal$Interpolate$moving,
11241 timeline);
11242 var combined = $mdgriffith$elm_animator$Animator$Css$toTransform(options)(_List_Nil)(x.a)(y.a)(z.a)(rotation.a)(scaleX.a)(scaleY.a)(scaleZ.a)(facingX.a)(facingY.a)(facingZ.a);
11243 return A6(
11244 $mdgriffith$elm_animator$Animator$Css$renderAnimation,
11245 details.ds,
11246 'transform',
11247 {
11248 y: x.y,
11249 ct: A2(
11250 $elm$core$Maybe$map,
11251 $mdgriffith$elm_animator$Animator$Css$mapDwellFrames(combined),
11252 rotation.ct),
11253 a: $elm$core$List$reverse(combined)
11254 },
11255 $mdgriffith$elm_animator$Animator$Css$transformToString,
11256 $mdgriffith$elm_animator$Animator$Css$transformToStub,
11257 anim);
11258 }
11259 });
11260var $mdgriffith$elm_animator$Animator$Css$renderTransformOptions = function (opts) {
11261 return A2(
11262 $elm$html$Html$Attributes$style,
11263 'transform-origin',
11264 function () {
11265 var _v0 = opts.bT;
11266 if (!_v0.$) {
11267 return 'center';
11268 } else {
11269 var x = _v0.a;
11270 var y = _v0.b;
11271 return ('calc(50% + ' + ($elm$core$String$fromFloat(x) + 'px) calc(50% + ')) + ($elm$core$String$fromFloat(y) + 'px)');
11272 }
11273 }());
11274};
11275var $mdgriffith$elm_animator$Animator$Css$stylesheet = function (str) {
11276 return A3(
11277 $elm$html$Html$node,
11278 'style',
11279 _List_Nil,
11280 _List_fromArray(
11281 [
11282 $elm$html$Html$text(str)
11283 ]));
11284};
11285var $mdgriffith$elm_animator$Animator$Css$node = F5(
11286 function (name, timeline, divAttrs, attrs, children) {
11287 var transformOptions = A2(
11288 $elm$core$Maybe$withDefault,
11289 $mdgriffith$elm_animator$Animator$Css$defaultTransformOptions,
11290 $mdgriffith$elm_animator$Animator$Css$getTransformOptions(divAttrs));
11291 var explainIsOn = $mdgriffith$elm_animator$Animator$Css$explainActive(divAttrs);
11292 var possiblyExplainAttr = explainIsOn ? A2($elm$html$Html$Attributes$style, 'position', 'relative') : A2($elm$html$Html$Attributes$style, '', '');
11293 var animations = $elm$core$List$reverse(
11294 A3(
11295 $elm$core$List$foldl,
11296 $mdgriffith$elm_animator$Animator$Css$renderAttrs(timeline),
11297 _List_Nil,
11298 divAttrs));
11299 return A3(
11300 $elm$html$Html$node,
11301 name,
11302 A2(
11303 $elm$core$List$cons,
11304 $elm$html$Html$Attributes$class(
11305 A2($mdgriffith$elm_animator$Animator$Css$renderClassName, '', animations)),
11306 A2(
11307 $elm$core$List$cons,
11308 possiblyExplainAttr,
11309 A2(
11310 $elm$core$List$cons,
11311 $mdgriffith$elm_animator$Animator$Css$renderTransformOptions(transformOptions),
11312 attrs))),
11313 A2(
11314 $elm$core$List$cons,
11315 $mdgriffith$elm_animator$Animator$Css$stylesheet(
11316 $mdgriffith$elm_animator$Animator$Css$renderAnimations(animations)),
11317 A2(
11318 $elm$core$List$cons,
11319 explainIsOn ? $mdgriffith$elm_animator$Animator$Css$explainElement(transformOptions) : $elm$html$Html$text(''),
11320 children)));
11321 });
11322var $mdgriffith$elm_animator$Animator$Css$div = $mdgriffith$elm_animator$Animator$Css$node('div');
11323var $elm$html$Html$h2 = _VirtualDom_node('h2');
11324var $mdgriffith$elm_animator$Internal$Interpolate$FullDefault = {$: 0};
11325var $mdgriffith$elm_animator$Internal$Interpolate$Position = F2(
11326 function (a, b) {
11327 return {$: 1, a: a, b: b};
11328 });
11329var $mdgriffith$elm_animator$Animator$at = $mdgriffith$elm_animator$Internal$Interpolate$Position($mdgriffith$elm_animator$Internal$Interpolate$FullDefault);
11330var $mdgriffith$elm_animator$Animator$Css$Linear = F3(
11331 function (a, b, c) {
11332 return {$: 1, a: a, b: b, c: c};
11333 });
11334var $mdgriffith$elm_animator$Animator$Css$opacity = function (lookup) {
11335 return A3($mdgriffith$elm_animator$Animator$Css$Linear, 'opacity', lookup, $elm$core$String$fromFloat);
11336};
11337var $mdgriffith$elm_animator$Animator$Css$Transform = $elm$core$Basics$identity;
11338var $mdgriffith$elm_animator$Animator$Css$scale = function (movement) {
11339 return {
11340 q: {
11341 dY: $mdgriffith$elm_animator$Animator$at(0),
11342 dZ: $mdgriffith$elm_animator$Animator$at(0),
11343 d$: $mdgriffith$elm_animator$Animator$at(0)
11344 },
11345 s: $mdgriffith$elm_animator$Animator$at(0),
11346 f: $mdgriffith$elm_animator$Animator$at(movement),
11347 g: $mdgriffith$elm_animator$Animator$at(movement),
11348 h: $mdgriffith$elm_animator$Animator$at(1),
11349 dY: $mdgriffith$elm_animator$Animator$at(0),
11350 dZ: $mdgriffith$elm_animator$Animator$at(0),
11351 d$: $mdgriffith$elm_animator$Animator$at(0)
11352 };
11353};
11354var $mdgriffith$elm_animator$Animator$Css$Movement = F3(
11355 function (a, b, c) {
11356 return {$: 2, a: a, b: b, c: c};
11357 });
11358var $mdgriffith$elm_animator$Animator$Css$style = F3(
11359 function (name, toString, lookup) {
11360 return A3($mdgriffith$elm_animator$Animator$Css$Movement, name, lookup, toString);
11361 });
11362var $mdgriffith$elm_animator$Animator$Css$TransformAttr = F2(
11363 function (a, b) {
11364 return {$: 3, a: a, b: b};
11365 });
11366var $mdgriffith$elm_animator$Animator$Css$transform = $mdgriffith$elm_animator$Animator$Css$TransformAttr($mdgriffith$elm_animator$Animator$Css$defaultTransformOptions);
11367var $author$project$Main$pageAnimation = function (page) {
11368 return _List_fromArray(
11369 [
11370 $mdgriffith$elm_animator$Animator$Css$opacity(
11371 function (currentPage) {
11372 return _Utils_eq(currentPage, page) ? $mdgriffith$elm_animator$Animator$at(1) : $mdgriffith$elm_animator$Animator$at(0.4);
11373 }),
11374 $mdgriffith$elm_animator$Animator$Css$transform(
11375 function (currentPage) {
11376 return _Utils_eq(currentPage, page) ? $mdgriffith$elm_animator$Animator$Css$scale(5) : $mdgriffith$elm_animator$Animator$Css$scale(1);
11377 }),
11378 A3(
11379 $mdgriffith$elm_animator$Animator$Css$style,
11380 'margin',
11381 function (_float) {
11382 var str = $elm$core$String$fromFloat(_float);
11383 return '0px ' + (str + 'px');
11384 },
11385 function (currentPage) {
11386 return _Utils_eq(currentPage, page) ? $mdgriffith$elm_animator$Animator$at(1800) : $mdgriffith$elm_animator$Animator$at(0);
11387 }),
11388 A3(
11389 $mdgriffith$elm_animator$Animator$Css$style,
11390 'border-width',
11391 function (_float) {
11392 return $elm$core$String$fromFloat(_float) + 'px';
11393 },
11394 function (currentPage) {
11395 return _Utils_eq(currentPage, page) ? $mdgriffith$elm_animator$Animator$at(1) : $mdgriffith$elm_animator$Animator$at(5);
11396 })
11397 ]);
11398};
11399var $author$project$Main$viewPage = F3(
11400 function (timeline, page, _v0) {
11401 var title = _v0.ap;
11402 var content = _v0.av;
11403 var wrapInLink = function (html) {
11404 return _Utils_eq(
11405 $mdgriffith$elm_animator$Animator$current(timeline),
11406 page) ? html : A2(
11407 $elm$html$Html$a,
11408 _List_fromArray(
11409 [
11410 $elm$html$Html$Attributes$href(
11411 $author$project$Main$pageToUrl(page)),
11412 A2($elm$html$Html$Attributes$style, 'cursor', 'pointer')
11413 ]),
11414 _List_fromArray(
11415 [html]));
11416 };
11417 return wrapInLink(
11418 A4(
11419 $mdgriffith$elm_animator$Animator$Css$div,
11420 timeline,
11421 $author$project$Main$pageAnimation(page),
11422 _List_fromArray(
11423 [
11424 $elm$html$Html$Attributes$class('page')
11425 ]),
11426 _List_fromArray(
11427 [
11428 A2(
11429 $elm$html$Html$h2,
11430 _List_Nil,
11431 _List_fromArray(
11432 [
11433 $elm$html$Html$text(title)
11434 ])),
11435 content
11436 ])));
11437 });
11438var $rundis$elm_bootstrap$Bootstrap$Navbar$withAnimation = function (config_) {
11439 return A2(
11440 $rundis$elm_bootstrap$Bootstrap$Navbar$updateConfig,
11441 function (conf) {
11442 return _Utils_update(
11443 conf,
11444 {V: true});
11445 },
11446 config_);
11447};
11448var $author$project$Main$view = function (model) {
11449 return {
11450 d4: _List_fromArray(
11451 [
11452 $author$project$Main$stylesheet,
11453 A2(
11454 $elm$html$Html$div,
11455 _List_fromArray(
11456 [
11457 $elm$html$Html$Attributes$class('root')
11458 ]),
11459 _List_fromArray(
11460 [
11461 A2(
11462 $rundis$elm_bootstrap$Bootstrap$Navbar$view,
11463 model.aK,
11464 A2(
11465 $rundis$elm_bootstrap$Bootstrap$Navbar$items,
11466 _List_fromArray(
11467 [
11468 A2(
11469 $rundis$elm_bootstrap$Bootstrap$Navbar$itemLink,
11470 _List_fromArray(
11471 [
11472 $elm$html$Html$Attributes$href(
11473 $author$project$Main$pageToUrl(0))
11474 ]),
11475 _List_fromArray(
11476 [
11477 $elm$html$Html$text('Home')
11478 ])),
11479 A2(
11480 $rundis$elm_bootstrap$Bootstrap$Navbar$itemLink,
11481 _List_fromArray(
11482 [
11483 $elm$html$Html$Attributes$href(
11484 $author$project$Main$pageToUrl(2))
11485 ]),
11486 _List_fromArray(
11487 [
11488 $elm$html$Html$text('Blog')
11489 ])),
11490 A2(
11491 $rundis$elm_bootstrap$Bootstrap$Navbar$itemLink,
11492 _List_fromArray(
11493 [
11494 $elm$html$Html$Attributes$href(
11495 $author$project$Main$pageToUrl(1))
11496 ]),
11497 _List_fromArray(
11498 [
11499 $elm$html$Html$text('About')
11500 ])),
11501 A2(
11502 $rundis$elm_bootstrap$Bootstrap$Navbar$itemLink,
11503 _List_fromArray(
11504 [
11505 $elm$html$Html$Attributes$href(
11506 $author$project$Main$pageToUrl(3))
11507 ]),
11508 _List_fromArray(
11509 [
11510 $elm$html$Html$text('Login')
11511 ]))
11512 ]),
11513 A3(
11514 $rundis$elm_bootstrap$Bootstrap$Navbar$brand,
11515 _List_fromArray(
11516 [
11517 $elm$html$Html$Attributes$href('#')
11518 ]),
11519 _List_fromArray(
11520 [
11521 $elm$html$Html$text('MBSPA')
11522 ]),
11523 $rundis$elm_bootstrap$Bootstrap$Navbar$withAnimation(
11524 $rundis$elm_bootstrap$Bootstrap$Navbar$config($author$project$Main$NavbarMsg))))),
11525 A2(
11526 $elm$html$Html$div,
11527 _List_fromArray(
11528 [
11529 $elm$html$Html$Attributes$class('page-row')
11530 ]),
11531 _List_fromArray(
11532 [
11533 A3(
11534 $author$project$Main$viewPage,
11535 model.x,
11536 0,
11537 {av: $author$project$Main$loremIpsum, ap: 'The home page'}),
11538 A3(
11539 $author$project$Main$viewPage,
11540 model.x,
11541 2,
11542 {av: $author$project$Main$loremIpsum, ap: 'Blog'}),
11543 A3(
11544 $author$project$Main$viewPage,
11545 model.x,
11546 1,
11547 {av: $author$project$Main$loremIpsum, ap: 'About'}),
11548 A3(
11549 $author$project$Main$viewPage,
11550 model.x,
11551 3,
11552 {
11553 av: A2(
11554 $elm$html$Html$div,
11555 _List_Nil,
11556 _List_fromArray(
11557 [
11558 A2(
11559 $elm$html$Html$div,
11560 _List_Nil,
11561 _List_fromArray(
11562 [
11563 $elm$html$Html$text('Just a placeholder for now')
11564 ])),
11565 A2(
11566 $elm$html$Html$div,
11567 _List_Nil,
11568 _List_fromArray(
11569 [
11570 A2(
11571 $rundis$elm_bootstrap$Bootstrap$Button$button,
11572 _List_fromArray(
11573 [$rundis$elm_bootstrap$Bootstrap$Button$primary]),
11574 _List_fromArray(
11575 [
11576 $elm$html$Html$text('Testing bootstrap buttons!')
11577 ]))
11578 ]))
11579 ])),
11580 ap: 'Login'
11581 })
11582 ])),
11583 A2(
11584 $elm$html$Html$div,
11585 _List_fromArray(
11586 [
11587 $elm$html$Html$Attributes$id('firebaseui-auth-container')
11588 ]),
11589 _List_Nil)
11590 ]))
11591 ]),
11592 ap: 'Animator - Page Transitions'
11593 };
11594};
11595var $author$project$Main$main = $elm$browser$Browser$application(
11596 {en: $author$project$Main$init, ev: $author$project$Main$UrlChanged, ew: $author$project$Main$ClickedLink, eI: $author$project$Main$subscriptions, eO: $author$project$Main$update, eP: $author$project$Main$view});
11597_Platform_export({'Main':{'init':$author$project$Main$main(
11598 $elm$json$Json$Decode$succeed(0))(0)}});}(this));