· 6 years ago · Dec 05, 2019, 12:36 AM
1<!DOCTYPE HTML>
2<html>
3<head>
4 <meta charset="UTF-8">
5 <title>Main</title>
6 <style>body { padding: 0; margin: 0; }</style>
7</head>
8
9<body>
10
11<pre id="elm"></pre>
12
13<script>
14try {
15(function(scope){
16'use strict';
17
18function F(arity, fun, wrapper) {
19 wrapper.a = arity;
20 wrapper.f = fun;
21 return wrapper;
22}
23
24function F2(fun) {
25 return F(2, fun, function(a) { return function(b) { return fun(a,b); }; })
26}
27function F3(fun) {
28 return F(3, fun, function(a) {
29 return function(b) { return function(c) { return fun(a, b, c); }; };
30 });
31}
32function F4(fun) {
33 return F(4, fun, function(a) { return function(b) { return function(c) {
34 return function(d) { return fun(a, b, c, d); }; }; };
35 });
36}
37function F5(fun) {
38 return F(5, fun, function(a) { return function(b) { return function(c) {
39 return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };
40 });
41}
42function F6(fun) {
43 return F(6, fun, function(a) { return function(b) { return function(c) {
44 return function(d) { return function(e) { return function(f) {
45 return fun(a, b, c, d, e, f); }; }; }; }; };
46 });
47}
48function F7(fun) {
49 return F(7, fun, function(a) { return function(b) { return function(c) {
50 return function(d) { return function(e) { return function(f) {
51 return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };
52 });
53}
54function F8(fun) {
55 return F(8, fun, function(a) { return function(b) { return function(c) {
56 return function(d) { return function(e) { return function(f) {
57 return function(g) { return function(h) {
58 return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };
59 });
60}
61function F9(fun) {
62 return F(9, fun, function(a) { return function(b) { return function(c) {
63 return function(d) { return function(e) { return function(f) {
64 return function(g) { return function(h) { return function(i) {
65 return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };
66 });
67}
68
69function A2(fun, a, b) {
70 return fun.a === 2 ? fun.f(a, b) : fun(a)(b);
71}
72function A3(fun, a, b, c) {
73 return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c);
74}
75function A4(fun, a, b, c, d) {
76 return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d);
77}
78function A5(fun, a, b, c, d, e) {
79 return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e);
80}
81function A6(fun, a, b, c, d, e, f) {
82 return fun.a === 6 ? fun.f(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f);
83}
84function A7(fun, a, b, c, d, e, f, g) {
85 return fun.a === 7 ? fun.f(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g);
86}
87function A8(fun, a, b, c, d, e, f, g, h) {
88 return fun.a === 8 ? fun.f(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h);
89}
90function A9(fun, a, b, c, d, e, f, g, h, i) {
91 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);
92}
93
94console.warn('Compiled in DEV mode. Follow the advice at https://elm-lang.org/0.19.1/optimize for better performance and smaller assets.');
95
96
97// EQUALITY
98
99function _Utils_eq(x, y)
100{
101 for (
102 var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);
103 isEqual && (pair = stack.pop());
104 isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack)
105 )
106 {}
107
108 return isEqual;
109}
110
111function _Utils_eqHelp(x, y, depth, stack)
112{
113 if (depth > 100)
114 {
115 stack.push(_Utils_Tuple2(x,y));
116 return true;
117 }
118
119 if (x === y)
120 {
121 return true;
122 }
123
124 if (typeof x !== 'object' || x === null || y === null)
125 {
126 typeof x === 'function' && _Debug_crash(5);
127 return false;
128 }
129
130 /**/
131 if (x.$ === 'Set_elm_builtin')
132 {
133 x = $elm$core$Set$toList(x);
134 y = $elm$core$Set$toList(y);
135 }
136 if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')
137 {
138 x = $elm$core$Dict$toList(x);
139 y = $elm$core$Dict$toList(y);
140 }
141 //*/
142
143 /**_UNUSED/
144 if (x.$ < 0)
145 {
146 x = $elm$core$Dict$toList(x);
147 y = $elm$core$Dict$toList(y);
148 }
149 //*/
150
151 for (var key in x)
152 {
153 if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))
154 {
155 return false;
156 }
157 }
158 return true;
159}
160
161var _Utils_equal = F2(_Utils_eq);
162var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); });
163
164
165
166// COMPARISONS
167
168// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
169// the particular integer values assigned to LT, EQ, and GT.
170
171function _Utils_cmp(x, y, ord)
172{
173 if (typeof x !== 'object')
174 {
175 return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1;
176 }
177
178 /**/
179 if (x instanceof String)
180 {
181 var a = x.valueOf();
182 var b = y.valueOf();
183 return a === b ? 0 : a < b ? -1 : 1;
184 }
185 //*/
186
187 /**_UNUSED/
188 if (typeof x.$ === 'undefined')
189 //*/
190 /**/
191 if (x.$[0] === '#')
192 //*/
193 {
194 return (ord = _Utils_cmp(x.a, y.a))
195 ? ord
196 : (ord = _Utils_cmp(x.b, y.b))
197 ? ord
198 : _Utils_cmp(x.c, y.c);
199 }
200
201 // traverse conses until end of a list or a mismatch
202 for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES
203 return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);
204}
205
206var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; });
207var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; });
208var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; });
209var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; });
210
211var _Utils_compare = F2(function(x, y)
212{
213 var n = _Utils_cmp(x, y);
214 return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ;
215});
216
217
218// COMMON VALUES
219
220var _Utils_Tuple0_UNUSED = 0;
221var _Utils_Tuple0 = { $: '#0' };
222
223function _Utils_Tuple2_UNUSED(a, b) { return { a: a, b: b }; }
224function _Utils_Tuple2(a, b) { return { $: '#2', a: a, b: b }; }
225
226function _Utils_Tuple3_UNUSED(a, b, c) { return { a: a, b: b, c: c }; }
227function _Utils_Tuple3(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }
228
229function _Utils_chr_UNUSED(c) { return c; }
230function _Utils_chr(c) { return new String(c); }
231
232
233// RECORDS
234
235function _Utils_update(oldRecord, updatedFields)
236{
237 var newRecord = {};
238
239 for (var key in oldRecord)
240 {
241 newRecord[key] = oldRecord[key];
242 }
243
244 for (var key in updatedFields)
245 {
246 newRecord[key] = updatedFields[key];
247 }
248
249 return newRecord;
250}
251
252
253// APPEND
254
255var _Utils_append = F2(_Utils_ap);
256
257function _Utils_ap(xs, ys)
258{
259 // append Strings
260 if (typeof xs === 'string')
261 {
262 return xs + ys;
263 }
264
265 // append Lists
266 if (!xs.b)
267 {
268 return ys;
269 }
270 var root = _List_Cons(xs.a, ys);
271 xs = xs.b
272 for (var curr = root; xs.b; xs = xs.b) // WHILE_CONS
273 {
274 curr = curr.b = _List_Cons(xs.a, ys);
275 }
276 return root;
277}
278
279
280
281var _List_Nil_UNUSED = { $: 0 };
282var _List_Nil = { $: '[]' };
283
284function _List_Cons_UNUSED(hd, tl) { return { $: 1, a: hd, b: tl }; }
285function _List_Cons(hd, tl) { return { $: '::', a: hd, b: tl }; }
286
287
288var _List_cons = F2(_List_Cons);
289
290function _List_fromArray(arr)
291{
292 var out = _List_Nil;
293 for (var i = arr.length; i--; )
294 {
295 out = _List_Cons(arr[i], out);
296 }
297 return out;
298}
299
300function _List_toArray(xs)
301{
302 for (var out = []; xs.b; xs = xs.b) // WHILE_CONS
303 {
304 out.push(xs.a);
305 }
306 return out;
307}
308
309var _List_map2 = F3(function(f, xs, ys)
310{
311 for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES
312 {
313 arr.push(A2(f, xs.a, ys.a));
314 }
315 return _List_fromArray(arr);
316});
317
318var _List_map3 = F4(function(f, xs, ys, zs)
319{
320 for (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
321 {
322 arr.push(A3(f, xs.a, ys.a, zs.a));
323 }
324 return _List_fromArray(arr);
325});
326
327var _List_map4 = F5(function(f, ws, xs, ys, zs)
328{
329 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
330 {
331 arr.push(A4(f, ws.a, xs.a, ys.a, zs.a));
332 }
333 return _List_fromArray(arr);
334});
335
336var _List_map5 = F6(function(f, vs, ws, xs, ys, zs)
337{
338 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
339 {
340 arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a));
341 }
342 return _List_fromArray(arr);
343});
344
345var _List_sortBy = F2(function(f, xs)
346{
347 return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
348 return _Utils_cmp(f(a), f(b));
349 }));
350});
351
352var _List_sortWith = F2(function(f, xs)
353{
354 return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
355 var ord = A2(f, a, b);
356 return ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1;
357 }));
358});
359
360
361
362var _JsArray_empty = [];
363
364function _JsArray_singleton(value)
365{
366 return [value];
367}
368
369function _JsArray_length(array)
370{
371 return array.length;
372}
373
374var _JsArray_initialize = F3(function(size, offset, func)
375{
376 var result = new Array(size);
377
378 for (var i = 0; i < size; i++)
379 {
380 result[i] = func(offset + i);
381 }
382
383 return result;
384});
385
386var _JsArray_initializeFromList = F2(function (max, ls)
387{
388 var result = new Array(max);
389
390 for (var i = 0; i < max && ls.b; i++)
391 {
392 result[i] = ls.a;
393 ls = ls.b;
394 }
395
396 result.length = i;
397 return _Utils_Tuple2(result, ls);
398});
399
400var _JsArray_unsafeGet = F2(function(index, array)
401{
402 return array[index];
403});
404
405var _JsArray_unsafeSet = F3(function(index, value, array)
406{
407 var length = array.length;
408 var result = new Array(length);
409
410 for (var i = 0; i < length; i++)
411 {
412 result[i] = array[i];
413 }
414
415 result[index] = value;
416 return result;
417});
418
419var _JsArray_push = F2(function(value, array)
420{
421 var length = array.length;
422 var result = new Array(length + 1);
423
424 for (var i = 0; i < length; i++)
425 {
426 result[i] = array[i];
427 }
428
429 result[length] = value;
430 return result;
431});
432
433var _JsArray_foldl = F3(function(func, acc, array)
434{
435 var length = array.length;
436
437 for (var i = 0; i < length; i++)
438 {
439 acc = A2(func, array[i], acc);
440 }
441
442 return acc;
443});
444
445var _JsArray_foldr = F3(function(func, acc, array)
446{
447 for (var i = array.length - 1; i >= 0; i--)
448 {
449 acc = A2(func, array[i], acc);
450 }
451
452 return acc;
453});
454
455var _JsArray_map = F2(function(func, array)
456{
457 var length = array.length;
458 var result = new Array(length);
459
460 for (var i = 0; i < length; i++)
461 {
462 result[i] = func(array[i]);
463 }
464
465 return result;
466});
467
468var _JsArray_indexedMap = F3(function(func, offset, array)
469{
470 var length = array.length;
471 var result = new Array(length);
472
473 for (var i = 0; i < length; i++)
474 {
475 result[i] = A2(func, offset + i, array[i]);
476 }
477
478 return result;
479});
480
481var _JsArray_slice = F3(function(from, to, array)
482{
483 return array.slice(from, to);
484});
485
486var _JsArray_appendN = F3(function(n, dest, source)
487{
488 var destLen = dest.length;
489 var itemsToCopy = n - destLen;
490
491 if (itemsToCopy > source.length)
492 {
493 itemsToCopy = source.length;
494 }
495
496 var size = destLen + itemsToCopy;
497 var result = new Array(size);
498
499 for (var i = 0; i < destLen; i++)
500 {
501 result[i] = dest[i];
502 }
503
504 for (var i = 0; i < itemsToCopy; i++)
505 {
506 result[i + destLen] = source[i];
507 }
508
509 return result;
510});
511
512
513
514// LOG
515
516var _Debug_log_UNUSED = F2(function(tag, value)
517{
518 return value;
519});
520
521var _Debug_log = F2(function(tag, value)
522{
523 console.log(tag + ': ' + _Debug_toString(value));
524 return value;
525});
526
527
528// TODOS
529
530function _Debug_todo(moduleName, region)
531{
532 return function(message) {
533 _Debug_crash(8, moduleName, region, message);
534 };
535}
536
537function _Debug_todoCase(moduleName, region, value)
538{
539 return function(message) {
540 _Debug_crash(9, moduleName, region, value, message);
541 };
542}
543
544
545// TO STRING
546
547function _Debug_toString_UNUSED(value)
548{
549 return '<internals>';
550}
551
552function _Debug_toString(value)
553{
554 return _Debug_toAnsiString(false, value);
555}
556
557function _Debug_toAnsiString(ansi, value)
558{
559 if (typeof value === 'function')
560 {
561 return _Debug_internalColor(ansi, '<function>');
562 }
563
564 if (typeof value === 'boolean')
565 {
566 return _Debug_ctorColor(ansi, value ? 'True' : 'False');
567 }
568
569 if (typeof value === 'number')
570 {
571 return _Debug_numberColor(ansi, value + '');
572 }
573
574 if (value instanceof String)
575 {
576 return _Debug_charColor(ansi, "'" + _Debug_addSlashes(value, true) + "'");
577 }
578
579 if (typeof value === 'string')
580 {
581 return _Debug_stringColor(ansi, '"' + _Debug_addSlashes(value, false) + '"');
582 }
583
584 if (typeof value === 'object' && '$' in value)
585 {
586 var tag = value.$;
587
588 if (typeof tag === 'number')
589 {
590 return _Debug_internalColor(ansi, '<internals>');
591 }
592
593 if (tag[0] === '#')
594 {
595 var output = [];
596 for (var k in value)
597 {
598 if (k === '$') continue;
599 output.push(_Debug_toAnsiString(ansi, value[k]));
600 }
601 return '(' + output.join(',') + ')';
602 }
603
604 if (tag === 'Set_elm_builtin')
605 {
606 return _Debug_ctorColor(ansi, 'Set')
607 + _Debug_fadeColor(ansi, '.fromList') + ' '
608 + _Debug_toAnsiString(ansi, $elm$core$Set$toList(value));
609 }
610
611 if (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin')
612 {
613 return _Debug_ctorColor(ansi, 'Dict')
614 + _Debug_fadeColor(ansi, '.fromList') + ' '
615 + _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value));
616 }
617
618 if (tag === 'Array_elm_builtin')
619 {
620 return _Debug_ctorColor(ansi, 'Array')
621 + _Debug_fadeColor(ansi, '.fromList') + ' '
622 + _Debug_toAnsiString(ansi, $elm$core$Array$toList(value));
623 }
624
625 if (tag === '::' || tag === '[]')
626 {
627 var output = '[';
628
629 value.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b)
630
631 for (; value.b; value = value.b) // WHILE_CONS
632 {
633 output += ',' + _Debug_toAnsiString(ansi, value.a);
634 }
635 return output + ']';
636 }
637
638 var output = '';
639 for (var i in value)
640 {
641 if (i === '$') continue;
642 var str = _Debug_toAnsiString(ansi, value[i]);
643 var c0 = str[0];
644 var parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
645 output += ' ' + (parenless ? str : '(' + str + ')');
646 }
647 return _Debug_ctorColor(ansi, tag) + output;
648 }
649
650 if (typeof DataView === 'function' && value instanceof DataView)
651 {
652 return _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>');
653 }
654
655 if (typeof File === 'function' && value instanceof File)
656 {
657 return _Debug_internalColor(ansi, '<' + value.name + '>');
658 }
659
660 if (typeof value === 'object')
661 {
662 var output = [];
663 for (var key in value)
664 {
665 var field = key[0] === '_' ? key.slice(1) : key;
666 output.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key]));
667 }
668 if (output.length === 0)
669 {
670 return '{}';
671 }
672 return '{ ' + output.join(', ') + ' }';
673 }
674
675 return _Debug_internalColor(ansi, '<internals>');
676}
677
678function _Debug_addSlashes(str, isChar)
679{
680 var s = str
681 .replace(/\\/g, '\\\\')
682 .replace(/\n/g, '\\n')
683 .replace(/\t/g, '\\t')
684 .replace(/\r/g, '\\r')
685 .replace(/\v/g, '\\v')
686 .replace(/\0/g, '\\0');
687
688 if (isChar)
689 {
690 return s.replace(/\'/g, '\\\'');
691 }
692 else
693 {
694 return s.replace(/\"/g, '\\"');
695 }
696}
697
698function _Debug_ctorColor(ansi, string)
699{
700 return ansi ? '\x1b[96m' + string + '\x1b[0m' : string;
701}
702
703function _Debug_numberColor(ansi, string)
704{
705 return ansi ? '\x1b[95m' + string + '\x1b[0m' : string;
706}
707
708function _Debug_stringColor(ansi, string)
709{
710 return ansi ? '\x1b[93m' + string + '\x1b[0m' : string;
711}
712
713function _Debug_charColor(ansi, string)
714{
715 return ansi ? '\x1b[92m' + string + '\x1b[0m' : string;
716}
717
718function _Debug_fadeColor(ansi, string)
719{
720 return ansi ? '\x1b[37m' + string + '\x1b[0m' : string;
721}
722
723function _Debug_internalColor(ansi, string)
724{
725 return ansi ? '\x1b[94m' + string + '\x1b[0m' : string;
726}
727
728function _Debug_toHexDigit(n)
729{
730 return String.fromCharCode(n < 10 ? 48 + n : 55 + n);
731}
732
733
734// CRASH
735
736
737function _Debug_crash_UNUSED(identifier)
738{
739 throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');
740}
741
742
743function _Debug_crash(identifier, fact1, fact2, fact3, fact4)
744{
745 switch(identifier)
746 {
747 case 0:
748 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.');
749
750 case 1:
751 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.');
752
753 case 2:
754 var jsonErrorString = fact1;
755 throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString);
756
757 case 3:
758 var portName = fact1;
759 throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.');
760
761 case 4:
762 var portName = fact1;
763 var problem = fact2;
764 throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem);
765
766 case 5:
767 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.');
768
769 case 6:
770 var moduleName = fact1;
771 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!');
772
773 case 8:
774 var moduleName = fact1;
775 var region = fact2;
776 var message = fact3;
777 throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message);
778
779 case 9:
780 var moduleName = fact1;
781 var region = fact2;
782 var value = fact3;
783 var message = fact4;
784 throw new Error(
785 'TODO in module `' + moduleName + '` from the `case` expression '
786 + _Debug_regionToString(region) + '\n\nIt received the following value:\n\n '
787 + _Debug_toString(value).replace('\n', '\n ')
788 + '\n\nBut the branch that handles it says:\n\n ' + message.replace('\n', '\n ')
789 );
790
791 case 10:
792 throw new Error('Bug in https://github.com/elm/virtual-dom/issues');
793
794 case 11:
795 throw new Error('Cannot perform mod 0. Division by zero error.');
796 }
797}
798
799function _Debug_regionToString(region)
800{
801 if (region.start.line === region.end.line)
802 {
803 return 'on line ' + region.start.line;
804 }
805 return 'on lines ' + region.start.line + ' through ' + region.end.line;
806}
807
808
809
810// MATH
811
812var _Basics_add = F2(function(a, b) { return a + b; });
813var _Basics_sub = F2(function(a, b) { return a - b; });
814var _Basics_mul = F2(function(a, b) { return a * b; });
815var _Basics_fdiv = F2(function(a, b) { return a / b; });
816var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; });
817var _Basics_pow = F2(Math.pow);
818
819var _Basics_remainderBy = F2(function(b, a) { return a % b; });
820
821// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
822var _Basics_modBy = F2(function(modulus, x)
823{
824 var answer = x % modulus;
825 return modulus === 0
826 ? _Debug_crash(11)
827 :
828 ((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0))
829 ? answer + modulus
830 : answer;
831});
832
833
834// TRIGONOMETRY
835
836var _Basics_pi = Math.PI;
837var _Basics_e = Math.E;
838var _Basics_cos = Math.cos;
839var _Basics_sin = Math.sin;
840var _Basics_tan = Math.tan;
841var _Basics_acos = Math.acos;
842var _Basics_asin = Math.asin;
843var _Basics_atan = Math.atan;
844var _Basics_atan2 = F2(Math.atan2);
845
846
847// MORE MATH
848
849function _Basics_toFloat(x) { return x; }
850function _Basics_truncate(n) { return n | 0; }
851function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; }
852
853var _Basics_ceiling = Math.ceil;
854var _Basics_floor = Math.floor;
855var _Basics_round = Math.round;
856var _Basics_sqrt = Math.sqrt;
857var _Basics_log = Math.log;
858var _Basics_isNaN = isNaN;
859
860
861// BOOLEANS
862
863function _Basics_not(bool) { return !bool; }
864var _Basics_and = F2(function(a, b) { return a && b; });
865var _Basics_or = F2(function(a, b) { return a || b; });
866var _Basics_xor = F2(function(a, b) { return a !== b; });
867
868
869
870var _String_cons = F2(function(chr, str)
871{
872 return chr + str;
873});
874
875function _String_uncons(string)
876{
877 var word = string.charCodeAt(0);
878 return word
879 ? $elm$core$Maybe$Just(
880 0xD800 <= word && word <= 0xDBFF
881 ? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))
882 : _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))
883 )
884 : $elm$core$Maybe$Nothing;
885}
886
887var _String_append = F2(function(a, b)
888{
889 return a + b;
890});
891
892function _String_length(str)
893{
894 return str.length;
895}
896
897var _String_map = F2(function(func, string)
898{
899 var len = string.length;
900 var array = new Array(len);
901 var i = 0;
902 while (i < len)
903 {
904 var word = string.charCodeAt(i);
905 if (0xD800 <= word && word <= 0xDBFF)
906 {
907 array[i] = func(_Utils_chr(string[i] + string[i+1]));
908 i += 2;
909 continue;
910 }
911 array[i] = func(_Utils_chr(string[i]));
912 i++;
913 }
914 return array.join('');
915});
916
917var _String_filter = F2(function(isGood, str)
918{
919 var arr = [];
920 var len = str.length;
921 var i = 0;
922 while (i < len)
923 {
924 var char = str[i];
925 var word = str.charCodeAt(i);
926 i++;
927 if (0xD800 <= word && word <= 0xDBFF)
928 {
929 char += str[i];
930 i++;
931 }
932
933 if (isGood(_Utils_chr(char)))
934 {
935 arr.push(char);
936 }
937 }
938 return arr.join('');
939});
940
941function _String_reverse(str)
942{
943 var len = str.length;
944 var arr = new Array(len);
945 var i = 0;
946 while (i < len)
947 {
948 var word = str.charCodeAt(i);
949 if (0xD800 <= word && word <= 0xDBFF)
950 {
951 arr[len - i] = str[i + 1];
952 i++;
953 arr[len - i] = str[i - 1];
954 i++;
955 }
956 else
957 {
958 arr[len - i] = str[i];
959 i++;
960 }
961 }
962 return arr.join('');
963}
964
965var _String_foldl = F3(function(func, state, string)
966{
967 var len = string.length;
968 var i = 0;
969 while (i < len)
970 {
971 var char = string[i];
972 var word = string.charCodeAt(i);
973 i++;
974 if (0xD800 <= word && word <= 0xDBFF)
975 {
976 char += string[i];
977 i++;
978 }
979 state = A2(func, _Utils_chr(char), state);
980 }
981 return state;
982});
983
984var _String_foldr = F3(function(func, state, string)
985{
986 var i = string.length;
987 while (i--)
988 {
989 var char = string[i];
990 var word = string.charCodeAt(i);
991 if (0xDC00 <= word && word <= 0xDFFF)
992 {
993 i--;
994 char = string[i] + char;
995 }
996 state = A2(func, _Utils_chr(char), state);
997 }
998 return state;
999});
1000
1001var _String_split = F2(function(sep, str)
1002{
1003 return str.split(sep);
1004});
1005
1006var _String_join = F2(function(sep, strs)
1007{
1008 return strs.join(sep);
1009});
1010
1011var _String_slice = F3(function(start, end, str) {
1012 return str.slice(start, end);
1013});
1014
1015function _String_trim(str)
1016{
1017 return str.trim();
1018}
1019
1020function _String_trimLeft(str)
1021{
1022 return str.replace(/^\s+/, '');
1023}
1024
1025function _String_trimRight(str)
1026{
1027 return str.replace(/\s+$/, '');
1028}
1029
1030function _String_words(str)
1031{
1032 return _List_fromArray(str.trim().split(/\s+/g));
1033}
1034
1035function _String_lines(str)
1036{
1037 return _List_fromArray(str.split(/\r\n|\r|\n/g));
1038}
1039
1040function _String_toUpper(str)
1041{
1042 return str.toUpperCase();
1043}
1044
1045function _String_toLower(str)
1046{
1047 return str.toLowerCase();
1048}
1049
1050var _String_any = F2(function(isGood, string)
1051{
1052 var i = string.length;
1053 while (i--)
1054 {
1055 var char = string[i];
1056 var word = string.charCodeAt(i);
1057 if (0xDC00 <= word && word <= 0xDFFF)
1058 {
1059 i--;
1060 char = string[i] + char;
1061 }
1062 if (isGood(_Utils_chr(char)))
1063 {
1064 return true;
1065 }
1066 }
1067 return false;
1068});
1069
1070var _String_all = F2(function(isGood, string)
1071{
1072 var i = string.length;
1073 while (i--)
1074 {
1075 var char = string[i];
1076 var word = string.charCodeAt(i);
1077 if (0xDC00 <= word && word <= 0xDFFF)
1078 {
1079 i--;
1080 char = string[i] + char;
1081 }
1082 if (!isGood(_Utils_chr(char)))
1083 {
1084 return false;
1085 }
1086 }
1087 return true;
1088});
1089
1090var _String_contains = F2(function(sub, str)
1091{
1092 return str.indexOf(sub) > -1;
1093});
1094
1095var _String_startsWith = F2(function(sub, str)
1096{
1097 return str.indexOf(sub) === 0;
1098});
1099
1100var _String_endsWith = F2(function(sub, str)
1101{
1102 return str.length >= sub.length &&
1103 str.lastIndexOf(sub) === str.length - sub.length;
1104});
1105
1106var _String_indexes = F2(function(sub, str)
1107{
1108 var subLen = sub.length;
1109
1110 if (subLen < 1)
1111 {
1112 return _List_Nil;
1113 }
1114
1115 var i = 0;
1116 var is = [];
1117
1118 while ((i = str.indexOf(sub, i)) > -1)
1119 {
1120 is.push(i);
1121 i = i + subLen;
1122 }
1123
1124 return _List_fromArray(is);
1125});
1126
1127
1128// TO STRING
1129
1130function _String_fromNumber(number)
1131{
1132 return number + '';
1133}
1134
1135
1136// INT CONVERSIONS
1137
1138function _String_toInt(str)
1139{
1140 var total = 0;
1141 var code0 = str.charCodeAt(0);
1142 var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;
1143
1144 for (var i = start; i < str.length; ++i)
1145 {
1146 var code = str.charCodeAt(i);
1147 if (code < 0x30 || 0x39 < code)
1148 {
1149 return $elm$core$Maybe$Nothing;
1150 }
1151 total = 10 * total + code - 0x30;
1152 }
1153
1154 return i == start
1155 ? $elm$core$Maybe$Nothing
1156 : $elm$core$Maybe$Just(code0 == 0x2D ? -total : total);
1157}
1158
1159
1160// FLOAT CONVERSIONS
1161
1162function _String_toFloat(s)
1163{
1164 // check if it is a hex, octal, or binary number
1165 if (s.length === 0 || /[\sxbo]/.test(s))
1166 {
1167 return $elm$core$Maybe$Nothing;
1168 }
1169 var n = +s;
1170 // faster isNaN check
1171 return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing;
1172}
1173
1174function _String_fromList(chars)
1175{
1176 return _List_toArray(chars).join('');
1177}
1178
1179
1180
1181
1182function _Char_toCode(char)
1183{
1184 var code = char.charCodeAt(0);
1185 if (0xD800 <= code && code <= 0xDBFF)
1186 {
1187 return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000
1188 }
1189 return code;
1190}
1191
1192function _Char_fromCode(code)
1193{
1194 return _Utils_chr(
1195 (code < 0 || 0x10FFFF < code)
1196 ? '\uFFFD'
1197 :
1198 (code <= 0xFFFF)
1199 ? String.fromCharCode(code)
1200 :
1201 (code -= 0x10000,
1202 String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)
1203 )
1204 );
1205}
1206
1207function _Char_toUpper(char)
1208{
1209 return _Utils_chr(char.toUpperCase());
1210}
1211
1212function _Char_toLower(char)
1213{
1214 return _Utils_chr(char.toLowerCase());
1215}
1216
1217function _Char_toLocaleUpper(char)
1218{
1219 return _Utils_chr(char.toLocaleUpperCase());
1220}
1221
1222function _Char_toLocaleLower(char)
1223{
1224 return _Utils_chr(char.toLocaleLowerCase());
1225}
1226
1227
1228
1229/**/
1230function _Json_errorToString(error)
1231{
1232 return $elm$json$Json$Decode$errorToString(error);
1233}
1234//*/
1235
1236
1237// CORE DECODERS
1238
1239function _Json_succeed(msg)
1240{
1241 return {
1242 $: 0,
1243 a: msg
1244 };
1245}
1246
1247function _Json_fail(msg)
1248{
1249 return {
1250 $: 1,
1251 a: msg
1252 };
1253}
1254
1255function _Json_decodePrim(decoder)
1256{
1257 return { $: 2, b: decoder };
1258}
1259
1260var _Json_decodeInt = _Json_decodePrim(function(value) {
1261 return (typeof value !== 'number')
1262 ? _Json_expecting('an INT', value)
1263 :
1264 (-2147483647 < value && value < 2147483647 && (value | 0) === value)
1265 ? $elm$core$Result$Ok(value)
1266 :
1267 (isFinite(value) && !(value % 1))
1268 ? $elm$core$Result$Ok(value)
1269 : _Json_expecting('an INT', value);
1270});
1271
1272var _Json_decodeBool = _Json_decodePrim(function(value) {
1273 return (typeof value === 'boolean')
1274 ? $elm$core$Result$Ok(value)
1275 : _Json_expecting('a BOOL', value);
1276});
1277
1278var _Json_decodeFloat = _Json_decodePrim(function(value) {
1279 return (typeof value === 'number')
1280 ? $elm$core$Result$Ok(value)
1281 : _Json_expecting('a FLOAT', value);
1282});
1283
1284var _Json_decodeValue = _Json_decodePrim(function(value) {
1285 return $elm$core$Result$Ok(_Json_wrap(value));
1286});
1287
1288var _Json_decodeString = _Json_decodePrim(function(value) {
1289 return (typeof value === 'string')
1290 ? $elm$core$Result$Ok(value)
1291 : (value instanceof String)
1292 ? $elm$core$Result$Ok(value + '')
1293 : _Json_expecting('a STRING', value);
1294});
1295
1296function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }
1297function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }
1298
1299function _Json_decodeNull(value) { return { $: 5, c: value }; }
1300
1301var _Json_decodeField = F2(function(field, decoder)
1302{
1303 return {
1304 $: 6,
1305 d: field,
1306 b: decoder
1307 };
1308});
1309
1310var _Json_decodeIndex = F2(function(index, decoder)
1311{
1312 return {
1313 $: 7,
1314 e: index,
1315 b: decoder
1316 };
1317});
1318
1319function _Json_decodeKeyValuePairs(decoder)
1320{
1321 return {
1322 $: 8,
1323 b: decoder
1324 };
1325}
1326
1327function _Json_mapMany(f, decoders)
1328{
1329 return {
1330 $: 9,
1331 f: f,
1332 g: decoders
1333 };
1334}
1335
1336var _Json_andThen = F2(function(callback, decoder)
1337{
1338 return {
1339 $: 10,
1340 b: decoder,
1341 h: callback
1342 };
1343});
1344
1345function _Json_oneOf(decoders)
1346{
1347 return {
1348 $: 11,
1349 g: decoders
1350 };
1351}
1352
1353
1354// DECODING OBJECTS
1355
1356var _Json_map1 = F2(function(f, d1)
1357{
1358 return _Json_mapMany(f, [d1]);
1359});
1360
1361var _Json_map2 = F3(function(f, d1, d2)
1362{
1363 return _Json_mapMany(f, [d1, d2]);
1364});
1365
1366var _Json_map3 = F4(function(f, d1, d2, d3)
1367{
1368 return _Json_mapMany(f, [d1, d2, d3]);
1369});
1370
1371var _Json_map4 = F5(function(f, d1, d2, d3, d4)
1372{
1373 return _Json_mapMany(f, [d1, d2, d3, d4]);
1374});
1375
1376var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)
1377{
1378 return _Json_mapMany(f, [d1, d2, d3, d4, d5]);
1379});
1380
1381var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)
1382{
1383 return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);
1384});
1385
1386var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)
1387{
1388 return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
1389});
1390
1391var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)
1392{
1393 return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
1394});
1395
1396
1397// DECODE
1398
1399var _Json_runOnString = F2(function(decoder, string)
1400{
1401 try
1402 {
1403 var value = JSON.parse(string);
1404 return _Json_runHelp(decoder, value);
1405 }
1406 catch (e)
1407 {
1408 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string)));
1409 }
1410});
1411
1412var _Json_run = F2(function(decoder, value)
1413{
1414 return _Json_runHelp(decoder, _Json_unwrap(value));
1415});
1416
1417function _Json_runHelp(decoder, value)
1418{
1419 switch (decoder.$)
1420 {
1421 case 2:
1422 return decoder.b(value);
1423
1424 case 5:
1425 return (value === null)
1426 ? $elm$core$Result$Ok(decoder.c)
1427 : _Json_expecting('null', value);
1428
1429 case 3:
1430 if (!_Json_isArray(value))
1431 {
1432 return _Json_expecting('a LIST', value);
1433 }
1434 return _Json_runArrayDecoder(decoder.b, value, _List_fromArray);
1435
1436 case 4:
1437 if (!_Json_isArray(value))
1438 {
1439 return _Json_expecting('an ARRAY', value);
1440 }
1441 return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);
1442
1443 case 6:
1444 var field = decoder.d;
1445 if (typeof value !== 'object' || value === null || !(field in value))
1446 {
1447 return _Json_expecting('an OBJECT with a field named `' + field + '`', value);
1448 }
1449 var result = _Json_runHelp(decoder.b, value[field]);
1450 return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a));
1451
1452 case 7:
1453 var index = decoder.e;
1454 if (!_Json_isArray(value))
1455 {
1456 return _Json_expecting('an ARRAY', value);
1457 }
1458 if (index >= value.length)
1459 {
1460 return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);
1461 }
1462 var result = _Json_runHelp(decoder.b, value[index]);
1463 return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a));
1464
1465 case 8:
1466 if (typeof value !== 'object' || value === null || _Json_isArray(value))
1467 {
1468 return _Json_expecting('an OBJECT', value);
1469 }
1470
1471 var keyValuePairs = _List_Nil;
1472 // TODO test perf of Object.keys and switch when support is good enough
1473 for (var key in value)
1474 {
1475 if (value.hasOwnProperty(key))
1476 {
1477 var result = _Json_runHelp(decoder.b, value[key]);
1478 if (!$elm$core$Result$isOk(result))
1479 {
1480 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a));
1481 }
1482 keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);
1483 }
1484 }
1485 return $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs));
1486
1487 case 9:
1488 var answer = decoder.f;
1489 var decoders = decoder.g;
1490 for (var i = 0; i < decoders.length; i++)
1491 {
1492 var result = _Json_runHelp(decoders[i], value);
1493 if (!$elm$core$Result$isOk(result))
1494 {
1495 return result;
1496 }
1497 answer = answer(result.a);
1498 }
1499 return $elm$core$Result$Ok(answer);
1500
1501 case 10:
1502 var result = _Json_runHelp(decoder.b, value);
1503 return (!$elm$core$Result$isOk(result))
1504 ? result
1505 : _Json_runHelp(decoder.h(result.a), value);
1506
1507 case 11:
1508 var errors = _List_Nil;
1509 for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS
1510 {
1511 var result = _Json_runHelp(temp.a, value);
1512 if ($elm$core$Result$isOk(result))
1513 {
1514 return result;
1515 }
1516 errors = _List_Cons(result.a, errors);
1517 }
1518 return $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)));
1519
1520 case 1:
1521 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));
1522
1523 case 0:
1524 return $elm$core$Result$Ok(decoder.a);
1525 }
1526}
1527
1528function _Json_runArrayDecoder(decoder, value, toElmValue)
1529{
1530 var len = value.length;
1531 var array = new Array(len);
1532 for (var i = 0; i < len; i++)
1533 {
1534 var result = _Json_runHelp(decoder, value[i]);
1535 if (!$elm$core$Result$isOk(result))
1536 {
1537 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a));
1538 }
1539 array[i] = result.a;
1540 }
1541 return $elm$core$Result$Ok(toElmValue(array));
1542}
1543
1544function _Json_isArray(value)
1545{
1546 return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);
1547}
1548
1549function _Json_toElmArray(array)
1550{
1551 return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; });
1552}
1553
1554function _Json_expecting(type, value)
1555{
1556 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));
1557}
1558
1559
1560// EQUALITY
1561
1562function _Json_equality(x, y)
1563{
1564 if (x === y)
1565 {
1566 return true;
1567 }
1568
1569 if (x.$ !== y.$)
1570 {
1571 return false;
1572 }
1573
1574 switch (x.$)
1575 {
1576 case 0:
1577 case 1:
1578 return x.a === y.a;
1579
1580 case 2:
1581 return x.b === y.b;
1582
1583 case 5:
1584 return x.c === y.c;
1585
1586 case 3:
1587 case 4:
1588 case 8:
1589 return _Json_equality(x.b, y.b);
1590
1591 case 6:
1592 return x.d === y.d && _Json_equality(x.b, y.b);
1593
1594 case 7:
1595 return x.e === y.e && _Json_equality(x.b, y.b);
1596
1597 case 9:
1598 return x.f === y.f && _Json_listEquality(x.g, y.g);
1599
1600 case 10:
1601 return x.h === y.h && _Json_equality(x.b, y.b);
1602
1603 case 11:
1604 return _Json_listEquality(x.g, y.g);
1605 }
1606}
1607
1608function _Json_listEquality(aDecoders, bDecoders)
1609{
1610 var len = aDecoders.length;
1611 if (len !== bDecoders.length)
1612 {
1613 return false;
1614 }
1615 for (var i = 0; i < len; i++)
1616 {
1617 if (!_Json_equality(aDecoders[i], bDecoders[i]))
1618 {
1619 return false;
1620 }
1621 }
1622 return true;
1623}
1624
1625
1626// ENCODE
1627
1628var _Json_encode = F2(function(indentLevel, value)
1629{
1630 return JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';
1631});
1632
1633function _Json_wrap(value) { return { $: 0, a: value }; }
1634function _Json_unwrap(value) { return value.a; }
1635
1636function _Json_wrap_UNUSED(value) { return value; }
1637function _Json_unwrap_UNUSED(value) { return value; }
1638
1639function _Json_emptyArray() { return []; }
1640function _Json_emptyObject() { return {}; }
1641
1642var _Json_addField = F3(function(key, value, object)
1643{
1644 object[key] = _Json_unwrap(value);
1645 return object;
1646});
1647
1648function _Json_addEntry(func)
1649{
1650 return F2(function(entry, array)
1651 {
1652 array.push(_Json_unwrap(func(entry)));
1653 return array;
1654 });
1655}
1656
1657var _Json_encodeNull = _Json_wrap(null);
1658
1659
1660
1661// TASKS
1662
1663function _Scheduler_succeed(value)
1664{
1665 return {
1666 $: 0,
1667 a: value
1668 };
1669}
1670
1671function _Scheduler_fail(error)
1672{
1673 return {
1674 $: 1,
1675 a: error
1676 };
1677}
1678
1679function _Scheduler_binding(callback)
1680{
1681 return {
1682 $: 2,
1683 b: callback,
1684 c: null
1685 };
1686}
1687
1688var _Scheduler_andThen = F2(function(callback, task)
1689{
1690 return {
1691 $: 3,
1692 b: callback,
1693 d: task
1694 };
1695});
1696
1697var _Scheduler_onError = F2(function(callback, task)
1698{
1699 return {
1700 $: 4,
1701 b: callback,
1702 d: task
1703 };
1704});
1705
1706function _Scheduler_receive(callback)
1707{
1708 return {
1709 $: 5,
1710 b: callback
1711 };
1712}
1713
1714
1715// PROCESSES
1716
1717var _Scheduler_guid = 0;
1718
1719function _Scheduler_rawSpawn(task)
1720{
1721 var proc = {
1722 $: 0,
1723 e: _Scheduler_guid++,
1724 f: task,
1725 g: null,
1726 h: []
1727 };
1728
1729 _Scheduler_enqueue(proc);
1730
1731 return proc;
1732}
1733
1734function _Scheduler_spawn(task)
1735{
1736 return _Scheduler_binding(function(callback) {
1737 callback(_Scheduler_succeed(_Scheduler_rawSpawn(task)));
1738 });
1739}
1740
1741function _Scheduler_rawSend(proc, msg)
1742{
1743 proc.h.push(msg);
1744 _Scheduler_enqueue(proc);
1745}
1746
1747var _Scheduler_send = F2(function(proc, msg)
1748{
1749 return _Scheduler_binding(function(callback) {
1750 _Scheduler_rawSend(proc, msg);
1751 callback(_Scheduler_succeed(_Utils_Tuple0));
1752 });
1753});
1754
1755function _Scheduler_kill(proc)
1756{
1757 return _Scheduler_binding(function(callback) {
1758 var task = proc.f;
1759 if (task.$ === 2 && task.c)
1760 {
1761 task.c();
1762 }
1763
1764 proc.f = null;
1765
1766 callback(_Scheduler_succeed(_Utils_Tuple0));
1767 });
1768}
1769
1770
1771/* STEP PROCESSES
1772
1773type alias Process =
1774 { $ : tag
1775 , id : unique_id
1776 , root : Task
1777 , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack }
1778 , mailbox : [msg]
1779 }
1780
1781*/
1782
1783
1784var _Scheduler_working = false;
1785var _Scheduler_queue = [];
1786
1787
1788function _Scheduler_enqueue(proc)
1789{
1790 _Scheduler_queue.push(proc);
1791 if (_Scheduler_working)
1792 {
1793 return;
1794 }
1795 _Scheduler_working = true;
1796 while (proc = _Scheduler_queue.shift())
1797 {
1798 _Scheduler_step(proc);
1799 }
1800 _Scheduler_working = false;
1801}
1802
1803
1804function _Scheduler_step(proc)
1805{
1806 while (proc.f)
1807 {
1808 var rootTag = proc.f.$;
1809 if (rootTag === 0 || rootTag === 1)
1810 {
1811 while (proc.g && proc.g.$ !== rootTag)
1812 {
1813 proc.g = proc.g.i;
1814 }
1815 if (!proc.g)
1816 {
1817 return;
1818 }
1819 proc.f = proc.g.b(proc.f.a);
1820 proc.g = proc.g.i;
1821 }
1822 else if (rootTag === 2)
1823 {
1824 proc.f.c = proc.f.b(function(newRoot) {
1825 proc.f = newRoot;
1826 _Scheduler_enqueue(proc);
1827 });
1828 return;
1829 }
1830 else if (rootTag === 5)
1831 {
1832 if (proc.h.length === 0)
1833 {
1834 return;
1835 }
1836 proc.f = proc.f.b(proc.h.shift());
1837 }
1838 else // if (rootTag === 3 || rootTag === 4)
1839 {
1840 proc.g = {
1841 $: rootTag === 3 ? 0 : 1,
1842 b: proc.f.b,
1843 i: proc.g
1844 };
1845 proc.f = proc.f.d;
1846 }
1847 }
1848}
1849
1850
1851
1852function _Process_sleep(time)
1853{
1854 return _Scheduler_binding(function(callback) {
1855 var id = setTimeout(function() {
1856 callback(_Scheduler_succeed(_Utils_Tuple0));
1857 }, time);
1858
1859 return function() { clearTimeout(id); };
1860 });
1861}
1862
1863
1864
1865
1866// PROGRAMS
1867
1868
1869var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args)
1870{
1871 return _Platform_initialize(
1872 flagDecoder,
1873 args,
1874 impl.init,
1875 impl.update,
1876 impl.subscriptions,
1877 function() { return function() {} }
1878 );
1879});
1880
1881
1882
1883// INITIALIZE A PROGRAM
1884
1885
1886function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder)
1887{
1888 var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined));
1889 $elm$core$Result$isOk(result) || _Debug_crash(2 /**/, _Json_errorToString(result.a) /**/);
1890 var managers = {};
1891 result = init(result.a);
1892 var model = result.a;
1893 var stepper = stepperBuilder(sendToApp, model);
1894 var ports = _Platform_setupEffects(managers, sendToApp);
1895
1896 function sendToApp(msg, viewMetadata)
1897 {
1898 result = A2(update, msg, model);
1899 stepper(model = result.a, viewMetadata);
1900 _Platform_dispatchEffects(managers, result.b, subscriptions(model));
1901 }
1902
1903 _Platform_dispatchEffects(managers, result.b, subscriptions(model));
1904
1905 return ports ? { ports: ports } : {};
1906}
1907
1908
1909
1910// TRACK PRELOADS
1911//
1912// This is used by code in elm/browser and elm/http
1913// to register any HTTP requests that are triggered by init.
1914//
1915
1916
1917var _Platform_preload;
1918
1919
1920function _Platform_registerPreload(url)
1921{
1922 _Platform_preload.add(url);
1923}
1924
1925
1926
1927// EFFECT MANAGERS
1928
1929
1930var _Platform_effectManagers = {};
1931
1932
1933function _Platform_setupEffects(managers, sendToApp)
1934{
1935 var ports;
1936
1937 // setup all necessary effect managers
1938 for (var key in _Platform_effectManagers)
1939 {
1940 var manager = _Platform_effectManagers[key];
1941
1942 if (manager.a)
1943 {
1944 ports = ports || {};
1945 ports[key] = manager.a(key, sendToApp);
1946 }
1947
1948 managers[key] = _Platform_instantiateManager(manager, sendToApp);
1949 }
1950
1951 return ports;
1952}
1953
1954
1955function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap)
1956{
1957 return {
1958 b: init,
1959 c: onEffects,
1960 d: onSelfMsg,
1961 e: cmdMap,
1962 f: subMap
1963 };
1964}
1965
1966
1967function _Platform_instantiateManager(info, sendToApp)
1968{
1969 var router = {
1970 g: sendToApp,
1971 h: undefined
1972 };
1973
1974 var onEffects = info.c;
1975 var onSelfMsg = info.d;
1976 var cmdMap = info.e;
1977 var subMap = info.f;
1978
1979 function loop(state)
1980 {
1981 return A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg)
1982 {
1983 var value = msg.a;
1984
1985 if (msg.$ === 0)
1986 {
1987 return A3(onSelfMsg, router, value, state);
1988 }
1989
1990 return cmdMap && subMap
1991 ? A4(onEffects, router, value.i, value.j, state)
1992 : A3(onEffects, router, cmdMap ? value.i : value.j, state);
1993 }));
1994 }
1995
1996 return router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b));
1997}
1998
1999
2000
2001// ROUTING
2002
2003
2004var _Platform_sendToApp = F2(function(router, msg)
2005{
2006 return _Scheduler_binding(function(callback)
2007 {
2008 router.g(msg);
2009 callback(_Scheduler_succeed(_Utils_Tuple0));
2010 });
2011});
2012
2013
2014var _Platform_sendToSelf = F2(function(router, msg)
2015{
2016 return A2(_Scheduler_send, router.h, {
2017 $: 0,
2018 a: msg
2019 });
2020});
2021
2022
2023
2024// BAGS
2025
2026
2027function _Platform_leaf(home)
2028{
2029 return function(value)
2030 {
2031 return {
2032 $: 1,
2033 k: home,
2034 l: value
2035 };
2036 };
2037}
2038
2039
2040function _Platform_batch(list)
2041{
2042 return {
2043 $: 2,
2044 m: list
2045 };
2046}
2047
2048
2049var _Platform_map = F2(function(tagger, bag)
2050{
2051 return {
2052 $: 3,
2053 n: tagger,
2054 o: bag
2055 }
2056});
2057
2058
2059
2060// PIPE BAGS INTO EFFECT MANAGERS
2061
2062
2063function _Platform_dispatchEffects(managers, cmdBag, subBag)
2064{
2065 var effectsDict = {};
2066 _Platform_gatherEffects(true, cmdBag, effectsDict, null);
2067 _Platform_gatherEffects(false, subBag, effectsDict, null);
2068
2069 for (var home in managers)
2070 {
2071 _Scheduler_rawSend(managers[home], {
2072 $: 'fx',
2073 a: effectsDict[home] || { i: _List_Nil, j: _List_Nil }
2074 });
2075 }
2076}
2077
2078
2079function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers)
2080{
2081 switch (bag.$)
2082 {
2083 case 1:
2084 var home = bag.k;
2085 var effect = _Platform_toEffect(isCmd, home, taggers, bag.l);
2086 effectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]);
2087 return;
2088
2089 case 2:
2090 for (var list = bag.m; list.b; list = list.b) // WHILE_CONS
2091 {
2092 _Platform_gatherEffects(isCmd, list.a, effectsDict, taggers);
2093 }
2094 return;
2095
2096 case 3:
2097 _Platform_gatherEffects(isCmd, bag.o, effectsDict, {
2098 p: bag.n,
2099 q: taggers
2100 });
2101 return;
2102 }
2103}
2104
2105
2106function _Platform_toEffect(isCmd, home, taggers, value)
2107{
2108 function applyTaggers(x)
2109 {
2110 for (var temp = taggers; temp; temp = temp.q)
2111 {
2112 x = temp.p(x);
2113 }
2114 return x;
2115 }
2116
2117 var map = isCmd
2118 ? _Platform_effectManagers[home].e
2119 : _Platform_effectManagers[home].f;
2120
2121 return A2(map, applyTaggers, value)
2122}
2123
2124
2125function _Platform_insert(isCmd, newEffect, effects)
2126{
2127 effects = effects || { i: _List_Nil, j: _List_Nil };
2128
2129 isCmd
2130 ? (effects.i = _List_Cons(newEffect, effects.i))
2131 : (effects.j = _List_Cons(newEffect, effects.j));
2132
2133 return effects;
2134}
2135
2136
2137
2138// PORTS
2139
2140
2141function _Platform_checkPortName(name)
2142{
2143 if (_Platform_effectManagers[name])
2144 {
2145 _Debug_crash(3, name)
2146 }
2147}
2148
2149
2150
2151// OUTGOING PORTS
2152
2153
2154function _Platform_outgoingPort(name, converter)
2155{
2156 _Platform_checkPortName(name);
2157 _Platform_effectManagers[name] = {
2158 e: _Platform_outgoingPortMap,
2159 r: converter,
2160 a: _Platform_setupOutgoingPort
2161 };
2162 return _Platform_leaf(name);
2163}
2164
2165
2166var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; });
2167
2168
2169function _Platform_setupOutgoingPort(name)
2170{
2171 var subs = [];
2172 var converter = _Platform_effectManagers[name].r;
2173
2174 // CREATE MANAGER
2175
2176 var init = _Process_sleep(0);
2177
2178 _Platform_effectManagers[name].b = init;
2179 _Platform_effectManagers[name].c = F3(function(router, cmdList, state)
2180 {
2181 for ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS
2182 {
2183 // grab a separate reference to subs in case unsubscribe is called
2184 var currentSubs = subs;
2185 var value = _Json_unwrap(converter(cmdList.a));
2186 for (var i = 0; i < currentSubs.length; i++)
2187 {
2188 currentSubs[i](value);
2189 }
2190 }
2191 return init;
2192 });
2193
2194 // PUBLIC API
2195
2196 function subscribe(callback)
2197 {
2198 subs.push(callback);
2199 }
2200
2201 function unsubscribe(callback)
2202 {
2203 // copy subs into a new array in case unsubscribe is called within a
2204 // subscribed callback
2205 subs = subs.slice();
2206 var index = subs.indexOf(callback);
2207 if (index >= 0)
2208 {
2209 subs.splice(index, 1);
2210 }
2211 }
2212
2213 return {
2214 subscribe: subscribe,
2215 unsubscribe: unsubscribe
2216 };
2217}
2218
2219
2220
2221// INCOMING PORTS
2222
2223
2224function _Platform_incomingPort(name, converter)
2225{
2226 _Platform_checkPortName(name);
2227 _Platform_effectManagers[name] = {
2228 f: _Platform_incomingPortMap,
2229 r: converter,
2230 a: _Platform_setupIncomingPort
2231 };
2232 return _Platform_leaf(name);
2233}
2234
2235
2236var _Platform_incomingPortMap = F2(function(tagger, finalTagger)
2237{
2238 return function(value)
2239 {
2240 return tagger(finalTagger(value));
2241 };
2242});
2243
2244
2245function _Platform_setupIncomingPort(name, sendToApp)
2246{
2247 var subs = _List_Nil;
2248 var converter = _Platform_effectManagers[name].r;
2249
2250 // CREATE MANAGER
2251
2252 var init = _Scheduler_succeed(null);
2253
2254 _Platform_effectManagers[name].b = init;
2255 _Platform_effectManagers[name].c = F3(function(router, subList, state)
2256 {
2257 subs = subList;
2258 return init;
2259 });
2260
2261 // PUBLIC API
2262
2263 function send(incomingValue)
2264 {
2265 var result = A2(_Json_run, converter, _Json_wrap(incomingValue));
2266
2267 $elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a);
2268
2269 var value = result.a;
2270 for (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS
2271 {
2272 sendToApp(temp.a(value));
2273 }
2274 }
2275
2276 return { send: send };
2277}
2278
2279
2280
2281// EXPORT ELM MODULES
2282//
2283// Have DEBUG and PROD versions so that we can (1) give nicer errors in
2284// debug mode and (2) not pay for the bits needed for that in prod mode.
2285//
2286
2287
2288function _Platform_export_UNUSED(exports)
2289{
2290 scope['Elm']
2291 ? _Platform_mergeExportsProd(scope['Elm'], exports)
2292 : scope['Elm'] = exports;
2293}
2294
2295
2296function _Platform_mergeExportsProd(obj, exports)
2297{
2298 for (var name in exports)
2299 {
2300 (name in obj)
2301 ? (name == 'init')
2302 ? _Debug_crash(6)
2303 : _Platform_mergeExportsProd(obj[name], exports[name])
2304 : (obj[name] = exports[name]);
2305 }
2306}
2307
2308
2309function _Platform_export(exports)
2310{
2311 scope['Elm']
2312 ? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports)
2313 : scope['Elm'] = exports;
2314}
2315
2316
2317function _Platform_mergeExportsDebug(moduleName, obj, exports)
2318{
2319 for (var name in exports)
2320 {
2321 (name in obj)
2322 ? (name == 'init')
2323 ? _Debug_crash(6, moduleName)
2324 : _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name])
2325 : (obj[name] = exports[name]);
2326 }
2327}
2328
2329
2330
2331
2332// HELPERS
2333
2334
2335var _VirtualDom_divertHrefToApp;
2336
2337var _VirtualDom_doc = typeof document !== 'undefined' ? document : {};
2338
2339
2340function _VirtualDom_appendChild(parent, child)
2341{
2342 parent.appendChild(child);
2343}
2344
2345var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args)
2346{
2347 // NOTE: this function needs _Platform_export available to work
2348
2349 /**_UNUSED/
2350 var node = args['node'];
2351 //*/
2352 /**/
2353 var node = args && args['node'] ? args['node'] : _Debug_crash(0);
2354 //*/
2355
2356 node.parentNode.replaceChild(
2357 _VirtualDom_render(virtualNode, function() {}),
2358 node
2359 );
2360
2361 return {};
2362});
2363
2364
2365
2366// TEXT
2367
2368
2369function _VirtualDom_text(string)
2370{
2371 return {
2372 $: 0,
2373 a: string
2374 };
2375}
2376
2377
2378
2379// NODE
2380
2381
2382var _VirtualDom_nodeNS = F2(function(namespace, tag)
2383{
2384 return F2(function(factList, kidList)
2385 {
2386 for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
2387 {
2388 var kid = kidList.a;
2389 descendantsCount += (kid.b || 0);
2390 kids.push(kid);
2391 }
2392 descendantsCount += kids.length;
2393
2394 return {
2395 $: 1,
2396 c: tag,
2397 d: _VirtualDom_organizeFacts(factList),
2398 e: kids,
2399 f: namespace,
2400 b: descendantsCount
2401 };
2402 });
2403});
2404
2405
2406var _VirtualDom_node = _VirtualDom_nodeNS(undefined);
2407
2408
2409
2410// KEYED NODE
2411
2412
2413var _VirtualDom_keyedNodeNS = 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.b || 0);
2421 kids.push(kid);
2422 }
2423 descendantsCount += kids.length;
2424
2425 return {
2426 $: 2,
2427 c: tag,
2428 d: _VirtualDom_organizeFacts(factList),
2429 e: kids,
2430 f: namespace,
2431 b: descendantsCount
2432 };
2433 });
2434});
2435
2436
2437var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined);
2438
2439
2440
2441// CUSTOM
2442
2443
2444function _VirtualDom_custom(factList, model, render, diff)
2445{
2446 return {
2447 $: 3,
2448 d: _VirtualDom_organizeFacts(factList),
2449 g: model,
2450 h: render,
2451 i: diff
2452 };
2453}
2454
2455
2456
2457// MAP
2458
2459
2460var _VirtualDom_map = F2(function(tagger, node)
2461{
2462 return {
2463 $: 4,
2464 j: tagger,
2465 k: node,
2466 b: 1 + (node.b || 0)
2467 };
2468});
2469
2470
2471
2472// LAZY
2473
2474
2475function _VirtualDom_thunk(refs, thunk)
2476{
2477 return {
2478 $: 5,
2479 l: refs,
2480 m: thunk,
2481 k: undefined
2482 };
2483}
2484
2485var _VirtualDom_lazy = F2(function(func, a)
2486{
2487 return _VirtualDom_thunk([func, a], function() {
2488 return func(a);
2489 });
2490});
2491
2492var _VirtualDom_lazy2 = F3(function(func, a, b)
2493{
2494 return _VirtualDom_thunk([func, a, b], function() {
2495 return A2(func, a, b);
2496 });
2497});
2498
2499var _VirtualDom_lazy3 = F4(function(func, a, b, c)
2500{
2501 return _VirtualDom_thunk([func, a, b, c], function() {
2502 return A3(func, a, b, c);
2503 });
2504});
2505
2506var _VirtualDom_lazy4 = F5(function(func, a, b, c, d)
2507{
2508 return _VirtualDom_thunk([func, a, b, c, d], function() {
2509 return A4(func, a, b, c, d);
2510 });
2511});
2512
2513var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e)
2514{
2515 return _VirtualDom_thunk([func, a, b, c, d, e], function() {
2516 return A5(func, a, b, c, d, e);
2517 });
2518});
2519
2520var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f)
2521{
2522 return _VirtualDom_thunk([func, a, b, c, d, e, f], function() {
2523 return A6(func, a, b, c, d, e, f);
2524 });
2525});
2526
2527var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g)
2528{
2529 return _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() {
2530 return A7(func, a, b, c, d, e, f, g);
2531 });
2532});
2533
2534var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h)
2535{
2536 return _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() {
2537 return A8(func, a, b, c, d, e, f, g, h);
2538 });
2539});
2540
2541
2542
2543// FACTS
2544
2545
2546var _VirtualDom_on = F2(function(key, handler)
2547{
2548 return {
2549 $: 'a0',
2550 n: key,
2551 o: handler
2552 };
2553});
2554var _VirtualDom_style = F2(function(key, value)
2555{
2556 return {
2557 $: 'a1',
2558 n: key,
2559 o: value
2560 };
2561});
2562var _VirtualDom_property = F2(function(key, value)
2563{
2564 return {
2565 $: 'a2',
2566 n: key,
2567 o: value
2568 };
2569});
2570var _VirtualDom_attribute = F2(function(key, value)
2571{
2572 return {
2573 $: 'a3',
2574 n: key,
2575 o: value
2576 };
2577});
2578var _VirtualDom_attributeNS = F3(function(namespace, key, value)
2579{
2580 return {
2581 $: 'a4',
2582 n: key,
2583 o: { f: namespace, o: value }
2584 };
2585});
2586
2587
2588
2589// XSS ATTACK VECTOR CHECKS
2590
2591
2592function _VirtualDom_noScript(tag)
2593{
2594 return tag == 'script' ? 'p' : tag;
2595}
2596
2597function _VirtualDom_noOnOrFormAction(key)
2598{
2599 return /^(on|formAction$)/i.test(key) ? 'data-' + key : key;
2600}
2601
2602function _VirtualDom_noInnerHtmlOrFormAction(key)
2603{
2604 return key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key;
2605}
2606
2607function _VirtualDom_noJavaScriptUri_UNUSED(value)
2608{
2609 return /^javascript:/i.test(value.replace(/\s/g,'')) ? '' : value;
2610}
2611
2612function _VirtualDom_noJavaScriptUri(value)
2613{
2614 return /^javascript:/i.test(value.replace(/\s/g,''))
2615 ? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'
2616 : value;
2617}
2618
2619function _VirtualDom_noJavaScriptOrHtmlUri_UNUSED(value)
2620{
2621 return /^\s*(javascript:|data:text\/html)/i.test(value) ? '' : value;
2622}
2623
2624function _VirtualDom_noJavaScriptOrHtmlUri(value)
2625{
2626 return /^\s*(javascript:|data:text\/html)/i.test(value)
2627 ? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'
2628 : value;
2629}
2630
2631
2632
2633// MAP FACTS
2634
2635
2636var _VirtualDom_mapAttribute = F2(function(func, attr)
2637{
2638 return (attr.$ === 'a0')
2639 ? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o))
2640 : attr;
2641});
2642
2643function _VirtualDom_mapHandler(func, handler)
2644{
2645 var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2646
2647 // 0 = Normal
2648 // 1 = MayStopPropagation
2649 // 2 = MayPreventDefault
2650 // 3 = Custom
2651
2652 return {
2653 $: handler.$,
2654 a:
2655 !tag
2656 ? A2($elm$json$Json$Decode$map, func, handler.a)
2657 :
2658 A3($elm$json$Json$Decode$map2,
2659 tag < 3
2660 ? _VirtualDom_mapEventTuple
2661 : _VirtualDom_mapEventRecord,
2662 $elm$json$Json$Decode$succeed(func),
2663 handler.a
2664 )
2665 };
2666}
2667
2668var _VirtualDom_mapEventTuple = F2(function(func, tuple)
2669{
2670 return _Utils_Tuple2(func(tuple.a), tuple.b);
2671});
2672
2673var _VirtualDom_mapEventRecord = F2(function(func, record)
2674{
2675 return {
2676 message: func(record.message),
2677 stopPropagation: record.stopPropagation,
2678 preventDefault: record.preventDefault
2679 }
2680});
2681
2682
2683
2684// ORGANIZE FACTS
2685
2686
2687function _VirtualDom_organizeFacts(factList)
2688{
2689 for (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS
2690 {
2691 var entry = factList.a;
2692
2693 var tag = entry.$;
2694 var key = entry.n;
2695 var value = entry.o;
2696
2697 if (tag === 'a2')
2698 {
2699 (key === 'className')
2700 ? _VirtualDom_addClass(facts, key, _Json_unwrap(value))
2701 : facts[key] = _Json_unwrap(value);
2702
2703 continue;
2704 }
2705
2706 var subFacts = facts[tag] || (facts[tag] = {});
2707 (tag === 'a3' && key === 'class')
2708 ? _VirtualDom_addClass(subFacts, key, value)
2709 : subFacts[key] = value;
2710 }
2711
2712 return facts;
2713}
2714
2715function _VirtualDom_addClass(object, key, newClass)
2716{
2717 var classes = object[key];
2718 object[key] = classes ? classes + ' ' + newClass : newClass;
2719}
2720
2721
2722
2723// RENDER
2724
2725
2726function _VirtualDom_render(vNode, eventNode)
2727{
2728 var tag = vNode.$;
2729
2730 if (tag === 5)
2731 {
2732 return _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode);
2733 }
2734
2735 if (tag === 0)
2736 {
2737 return _VirtualDom_doc.createTextNode(vNode.a);
2738 }
2739
2740 if (tag === 4)
2741 {
2742 var subNode = vNode.k;
2743 var tagger = vNode.j;
2744
2745 while (subNode.$ === 4)
2746 {
2747 typeof tagger !== 'object'
2748 ? tagger = [tagger, subNode.j]
2749 : tagger.push(subNode.j);
2750
2751 subNode = subNode.k;
2752 }
2753
2754 var subEventRoot = { j: tagger, p: eventNode };
2755 var domNode = _VirtualDom_render(subNode, subEventRoot);
2756 domNode.elm_event_node_ref = subEventRoot;
2757 return domNode;
2758 }
2759
2760 if (tag === 3)
2761 {
2762 var domNode = vNode.h(vNode.g);
2763 _VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2764 return domNode;
2765 }
2766
2767 // at this point `tag` must be 1 or 2
2768
2769 var domNode = vNode.f
2770 ? _VirtualDom_doc.createElementNS(vNode.f, vNode.c)
2771 : _VirtualDom_doc.createElement(vNode.c);
2772
2773 if (_VirtualDom_divertHrefToApp && vNode.c == 'a')
2774 {
2775 domNode.addEventListener('click', _VirtualDom_divertHrefToApp(domNode));
2776 }
2777
2778 _VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2779
2780 for (var kids = vNode.e, i = 0; i < kids.length; i++)
2781 {
2782 _VirtualDom_appendChild(domNode, _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode));
2783 }
2784
2785 return domNode;
2786}
2787
2788
2789
2790// APPLY FACTS
2791
2792
2793function _VirtualDom_applyFacts(domNode, eventNode, facts)
2794{
2795 for (var key in facts)
2796 {
2797 var value = facts[key];
2798
2799 key === 'a1'
2800 ? _VirtualDom_applyStyles(domNode, value)
2801 :
2802 key === 'a0'
2803 ? _VirtualDom_applyEvents(domNode, eventNode, value)
2804 :
2805 key === 'a3'
2806 ? _VirtualDom_applyAttrs(domNode, value)
2807 :
2808 key === 'a4'
2809 ? _VirtualDom_applyAttrsNS(domNode, value)
2810 :
2811 ((key !== 'value' && key !== 'checked') || domNode[key] !== value) && (domNode[key] = value);
2812 }
2813}
2814
2815
2816
2817// APPLY STYLES
2818
2819
2820function _VirtualDom_applyStyles(domNode, styles)
2821{
2822 var domNodeStyle = domNode.style;
2823
2824 for (var key in styles)
2825 {
2826 domNodeStyle[key] = styles[key];
2827 }
2828}
2829
2830
2831
2832// APPLY ATTRS
2833
2834
2835function _VirtualDom_applyAttrs(domNode, attrs)
2836{
2837 for (var key in attrs)
2838 {
2839 var value = attrs[key];
2840 typeof value !== 'undefined'
2841 ? domNode.setAttribute(key, value)
2842 : domNode.removeAttribute(key);
2843 }
2844}
2845
2846
2847
2848// APPLY NAMESPACED ATTRS
2849
2850
2851function _VirtualDom_applyAttrsNS(domNode, nsAttrs)
2852{
2853 for (var key in nsAttrs)
2854 {
2855 var pair = nsAttrs[key];
2856 var namespace = pair.f;
2857 var value = pair.o;
2858
2859 typeof value !== 'undefined'
2860 ? domNode.setAttributeNS(namespace, key, value)
2861 : domNode.removeAttributeNS(namespace, key);
2862 }
2863}
2864
2865
2866
2867// APPLY EVENTS
2868
2869
2870function _VirtualDom_applyEvents(domNode, eventNode, events)
2871{
2872 var allCallbacks = domNode.elmFs || (domNode.elmFs = {});
2873
2874 for (var key in events)
2875 {
2876 var newHandler = events[key];
2877 var oldCallback = allCallbacks[key];
2878
2879 if (!newHandler)
2880 {
2881 domNode.removeEventListener(key, oldCallback);
2882 allCallbacks[key] = undefined;
2883 continue;
2884 }
2885
2886 if (oldCallback)
2887 {
2888 var oldHandler = oldCallback.q;
2889 if (oldHandler.$ === newHandler.$)
2890 {
2891 oldCallback.q = newHandler;
2892 continue;
2893 }
2894 domNode.removeEventListener(key, oldCallback);
2895 }
2896
2897 oldCallback = _VirtualDom_makeCallback(eventNode, newHandler);
2898 domNode.addEventListener(key, oldCallback,
2899 _VirtualDom_passiveSupported
2900 && { passive: $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 }
2901 );
2902 allCallbacks[key] = oldCallback;
2903 }
2904}
2905
2906
2907
2908// PASSIVE EVENTS
2909
2910
2911var _VirtualDom_passiveSupported;
2912
2913try
2914{
2915 window.addEventListener('t', null, Object.defineProperty({}, 'passive', {
2916 get: function() { _VirtualDom_passiveSupported = true; }
2917 }));
2918}
2919catch(e) {}
2920
2921
2922
2923// EVENT HANDLERS
2924
2925
2926function _VirtualDom_makeCallback(eventNode, initialHandler)
2927{
2928 function callback(event)
2929 {
2930 var handler = callback.q;
2931 var result = _Json_runHelp(handler.a, event);
2932
2933 if (!$elm$core$Result$isOk(result))
2934 {
2935 return;
2936 }
2937
2938 var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2939
2940 // 0 = Normal
2941 // 1 = MayStopPropagation
2942 // 2 = MayPreventDefault
2943 // 3 = Custom
2944
2945 var value = result.a;
2946 var message = !tag ? value : tag < 3 ? value.a : value.message;
2947 var stopPropagation = tag == 1 ? value.b : tag == 3 && value.stopPropagation;
2948 var currentEventNode = (
2949 stopPropagation && event.stopPropagation(),
2950 (tag == 2 ? value.b : tag == 3 && value.preventDefault) && event.preventDefault(),
2951 eventNode
2952 );
2953 var tagger;
2954 var i;
2955 while (tagger = currentEventNode.j)
2956 {
2957 if (typeof tagger == 'function')
2958 {
2959 message = tagger(message);
2960 }
2961 else
2962 {
2963 for (var i = tagger.length; i--; )
2964 {
2965 message = tagger[i](message);
2966 }
2967 }
2968 currentEventNode = currentEventNode.p;
2969 }
2970 currentEventNode(message, stopPropagation); // stopPropagation implies isSync
2971 }
2972
2973 callback.q = initialHandler;
2974
2975 return callback;
2976}
2977
2978function _VirtualDom_equalEvents(x, y)
2979{
2980 return x.$ == y.$ && _Json_equality(x.a, y.a);
2981}
2982
2983
2984
2985// DIFF
2986
2987
2988// TODO: Should we do patches like in iOS?
2989//
2990// type Patch
2991// = At Int Patch
2992// | Batch (List Patch)
2993// | Change ...
2994//
2995// How could it not be better?
2996//
2997function _VirtualDom_diff(x, y)
2998{
2999 var patches = [];
3000 _VirtualDom_diffHelp(x, y, patches, 0);
3001 return patches;
3002}
3003
3004
3005function _VirtualDom_pushPatch(patches, type, index, data)
3006{
3007 var patch = {
3008 $: type,
3009 r: index,
3010 s: data,
3011 t: undefined,
3012 u: undefined
3013 };
3014 patches.push(patch);
3015 return patch;
3016}
3017
3018
3019function _VirtualDom_diffHelp(x, y, patches, index)
3020{
3021 if (x === y)
3022 {
3023 return;
3024 }
3025
3026 var xType = x.$;
3027 var yType = y.$;
3028
3029 // Bail if you run into different types of nodes. Implies that the
3030 // structure has changed significantly and it's not worth a diff.
3031 if (xType !== yType)
3032 {
3033 if (xType === 1 && yType === 2)
3034 {
3035 y = _VirtualDom_dekey(y);
3036 yType = 1;
3037 }
3038 else
3039 {
3040 _VirtualDom_pushPatch(patches, 0, index, y);
3041 return;
3042 }
3043 }
3044
3045 // Now we know that both nodes are the same $.
3046 switch (yType)
3047 {
3048 case 5:
3049 var xRefs = x.l;
3050 var yRefs = y.l;
3051 var i = xRefs.length;
3052 var same = i === yRefs.length;
3053 while (same && i--)
3054 {
3055 same = xRefs[i] === yRefs[i];
3056 }
3057 if (same)
3058 {
3059 y.k = x.k;
3060 return;
3061 }
3062 y.k = y.m();
3063 var subPatches = [];
3064 _VirtualDom_diffHelp(x.k, y.k, subPatches, 0);
3065 subPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches);
3066 return;
3067
3068 case 4:
3069 // gather nested taggers
3070 var xTaggers = x.j;
3071 var yTaggers = y.j;
3072 var nesting = false;
3073
3074 var xSubNode = x.k;
3075 while (xSubNode.$ === 4)
3076 {
3077 nesting = true;
3078
3079 typeof xTaggers !== 'object'
3080 ? xTaggers = [xTaggers, xSubNode.j]
3081 : xTaggers.push(xSubNode.j);
3082
3083 xSubNode = xSubNode.k;
3084 }
3085
3086 var ySubNode = y.k;
3087 while (ySubNode.$ === 4)
3088 {
3089 nesting = true;
3090
3091 typeof yTaggers !== 'object'
3092 ? yTaggers = [yTaggers, ySubNode.j]
3093 : yTaggers.push(ySubNode.j);
3094
3095 ySubNode = ySubNode.k;
3096 }
3097
3098 // Just bail if different numbers of taggers. This implies the
3099 // structure of the virtual DOM has changed.
3100 if (nesting && xTaggers.length !== yTaggers.length)
3101 {
3102 _VirtualDom_pushPatch(patches, 0, index, y);
3103 return;
3104 }
3105
3106 // check if taggers are "the same"
3107 if (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers)
3108 {
3109 _VirtualDom_pushPatch(patches, 2, index, yTaggers);
3110 }
3111
3112 // diff everything below the taggers
3113 _VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1);
3114 return;
3115
3116 case 0:
3117 if (x.a !== y.a)
3118 {
3119 _VirtualDom_pushPatch(patches, 3, index, y.a);
3120 }
3121 return;
3122
3123 case 1:
3124 _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids);
3125 return;
3126
3127 case 2:
3128 _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids);
3129 return;
3130
3131 case 3:
3132 if (x.h !== y.h)
3133 {
3134 _VirtualDom_pushPatch(patches, 0, index, y);
3135 return;
3136 }
3137
3138 var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3139 factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3140
3141 var patch = y.i(x.g, y.g);
3142 patch && _VirtualDom_pushPatch(patches, 5, index, patch);
3143
3144 return;
3145 }
3146}
3147
3148// assumes the incoming arrays are the same length
3149function _VirtualDom_pairwiseRefEqual(as, bs)
3150{
3151 for (var i = 0; i < as.length; i++)
3152 {
3153 if (as[i] !== bs[i])
3154 {
3155 return false;
3156 }
3157 }
3158
3159 return true;
3160}
3161
3162function _VirtualDom_diffNodes(x, y, patches, index, diffKids)
3163{
3164 // Bail if obvious indicators have changed. Implies more serious
3165 // structural changes such that it's not worth it to diff.
3166 if (x.c !== y.c || x.f !== y.f)
3167 {
3168 _VirtualDom_pushPatch(patches, 0, index, y);
3169 return;
3170 }
3171
3172 var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3173 factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3174
3175 diffKids(x, y, patches, index);
3176}
3177
3178
3179
3180// DIFF FACTS
3181
3182
3183// TODO Instead of creating a new diff object, it's possible to just test if
3184// there *is* a diff. During the actual patch, do the diff again and make the
3185// modifications directly. This way, there's no new allocations. Worth it?
3186function _VirtualDom_diffFacts(x, y, category)
3187{
3188 var diff;
3189
3190 // look for changes and removals
3191 for (var xKey in x)
3192 {
3193 if (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4')
3194 {
3195 var subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey);
3196 if (subDiff)
3197 {
3198 diff = diff || {};
3199 diff[xKey] = subDiff;
3200 }
3201 continue;
3202 }
3203
3204 // remove if not in the new facts
3205 if (!(xKey in y))
3206 {
3207 diff = diff || {};
3208 diff[xKey] =
3209 !category
3210 ? (typeof x[xKey] === 'string' ? '' : null)
3211 :
3212 (category === 'a1')
3213 ? ''
3214 :
3215 (category === 'a0' || category === 'a3')
3216 ? undefined
3217 :
3218 { f: x[xKey].f, o: undefined };
3219
3220 continue;
3221 }
3222
3223 var xValue = x[xKey];
3224 var yValue = y[xKey];
3225
3226 // reference equal, so don't worry about it
3227 if (xValue === yValue && xKey !== 'value' && xKey !== 'checked'
3228 || category === 'a0' && _VirtualDom_equalEvents(xValue, yValue))
3229 {
3230 continue;
3231 }
3232
3233 diff = diff || {};
3234 diff[xKey] = yValue;
3235 }
3236
3237 // add new stuff
3238 for (var yKey in y)
3239 {
3240 if (!(yKey in x))
3241 {
3242 diff = diff || {};
3243 diff[yKey] = y[yKey];
3244 }
3245 }
3246
3247 return diff;
3248}
3249
3250
3251
3252// DIFF KIDS
3253
3254
3255function _VirtualDom_diffKids(xParent, yParent, patches, index)
3256{
3257 var xKids = xParent.e;
3258 var yKids = yParent.e;
3259
3260 var xLen = xKids.length;
3261 var yLen = yKids.length;
3262
3263 // FIGURE OUT IF THERE ARE INSERTS OR REMOVALS
3264
3265 if (xLen > yLen)
3266 {
3267 _VirtualDom_pushPatch(patches, 6, index, {
3268 v: yLen,
3269 i: xLen - yLen
3270 });
3271 }
3272 else if (xLen < yLen)
3273 {
3274 _VirtualDom_pushPatch(patches, 7, index, {
3275 v: xLen,
3276 e: yKids
3277 });
3278 }
3279
3280 // PAIRWISE DIFF EVERYTHING ELSE
3281
3282 for (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++)
3283 {
3284 var xKid = xKids[i];
3285 _VirtualDom_diffHelp(xKid, yKids[i], patches, ++index);
3286 index += xKid.b || 0;
3287 }
3288}
3289
3290
3291
3292// KEYED DIFF
3293
3294
3295function _VirtualDom_diffKeyedKids(xParent, yParent, patches, rootIndex)
3296{
3297 var localPatches = [];
3298
3299 var changes = {}; // Dict String Entry
3300 var inserts = []; // Array { index : Int, entry : Entry }
3301 // type Entry = { tag : String, vnode : VNode, index : Int, data : _ }
3302
3303 var xKids = xParent.e;
3304 var yKids = yParent.e;
3305 var xLen = xKids.length;
3306 var yLen = yKids.length;
3307 var xIndex = 0;
3308 var yIndex = 0;
3309
3310 var index = rootIndex;
3311
3312 while (xIndex < xLen && yIndex < yLen)
3313 {
3314 var x = xKids[xIndex];
3315 var y = yKids[yIndex];
3316
3317 var xKey = x.a;
3318 var yKey = y.a;
3319 var xNode = x.b;
3320 var yNode = y.b;
3321
3322 var newMatch = undefined;
3323 var oldMatch = undefined;
3324
3325 // check if keys match
3326
3327 if (xKey === yKey)
3328 {
3329 index++;
3330 _VirtualDom_diffHelp(xNode, yNode, localPatches, index);
3331 index += xNode.b || 0;
3332
3333 xIndex++;
3334 yIndex++;
3335 continue;
3336 }
3337
3338 // look ahead 1 to detect insertions and removals.
3339
3340 var xNext = xKids[xIndex + 1];
3341 var yNext = yKids[yIndex + 1];
3342
3343 if (xNext)
3344 {
3345 var xNextKey = xNext.a;
3346 var xNextNode = xNext.b;
3347 oldMatch = yKey === xNextKey;
3348 }
3349
3350 if (yNext)
3351 {
3352 var yNextKey = yNext.a;
3353 var yNextNode = yNext.b;
3354 newMatch = xKey === yNextKey;
3355 }
3356
3357
3358 // swap x and y
3359 if (newMatch && oldMatch)
3360 {
3361 index++;
3362 _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3363 _VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts);
3364 index += xNode.b || 0;
3365
3366 index++;
3367 _VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index);
3368 index += xNextNode.b || 0;
3369
3370 xIndex += 2;
3371 yIndex += 2;
3372 continue;
3373 }
3374
3375 // insert y
3376 if (newMatch)
3377 {
3378 index++;
3379 _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3380 _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3381 index += xNode.b || 0;
3382
3383 xIndex += 1;
3384 yIndex += 2;
3385 continue;
3386 }
3387
3388 // remove x
3389 if (oldMatch)
3390 {
3391 index++;
3392 _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3393 index += xNode.b || 0;
3394
3395 index++;
3396 _VirtualDom_diffHelp(xNextNode, yNode, localPatches, index);
3397 index += xNextNode.b || 0;
3398
3399 xIndex += 2;
3400 yIndex += 1;
3401 continue;
3402 }
3403
3404 // remove x, insert y
3405 if (xNext && xNextKey === yNextKey)
3406 {
3407 index++;
3408 _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3409 _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3410 index += xNode.b || 0;
3411
3412 index++;
3413 _VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index);
3414 index += xNextNode.b || 0;
3415
3416 xIndex += 2;
3417 yIndex += 2;
3418 continue;
3419 }
3420
3421 break;
3422 }
3423
3424 // eat up any remaining nodes with removeNode and insertNode
3425
3426 while (xIndex < xLen)
3427 {
3428 index++;
3429 var x = xKids[xIndex];
3430 var xNode = x.b;
3431 _VirtualDom_removeNode(changes, localPatches, x.a, xNode, index);
3432 index += xNode.b || 0;
3433 xIndex++;
3434 }
3435
3436 while (yIndex < yLen)
3437 {
3438 var endInserts = endInserts || [];
3439 var y = yKids[yIndex];
3440 _VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts);
3441 yIndex++;
3442 }
3443
3444 if (localPatches.length > 0 || inserts.length > 0 || endInserts)
3445 {
3446 _VirtualDom_pushPatch(patches, 8, rootIndex, {
3447 w: localPatches,
3448 x: inserts,
3449 y: endInserts
3450 });
3451 }
3452}
3453
3454
3455
3456// CHANGES FROM KEYED DIFF
3457
3458
3459var _VirtualDom_POSTFIX = '_elmW6BL';
3460
3461
3462function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts)
3463{
3464 var entry = changes[key];
3465
3466 // never seen this key before
3467 if (!entry)
3468 {
3469 entry = {
3470 c: 0,
3471 z: vnode,
3472 r: yIndex,
3473 s: undefined
3474 };
3475
3476 inserts.push({ r: yIndex, A: entry });
3477 changes[key] = entry;
3478
3479 return;
3480 }
3481
3482 // this key was removed earlier, a match!
3483 if (entry.c === 1)
3484 {
3485 inserts.push({ r: yIndex, A: entry });
3486
3487 entry.c = 2;
3488 var subPatches = [];
3489 _VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r);
3490 entry.r = yIndex;
3491 entry.s.s = {
3492 w: subPatches,
3493 A: entry
3494 };
3495
3496 return;
3497 }
3498
3499 // this key has already been inserted or moved, a duplicate!
3500 _VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts);
3501}
3502
3503
3504function _VirtualDom_removeNode(changes, localPatches, key, vnode, index)
3505{
3506 var entry = changes[key];
3507
3508 // never seen this key before
3509 if (!entry)
3510 {
3511 var patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined);
3512
3513 changes[key] = {
3514 c: 1,
3515 z: vnode,
3516 r: index,
3517 s: patch
3518 };
3519
3520 return;
3521 }
3522
3523 // this key was inserted earlier, a match!
3524 if (entry.c === 0)
3525 {
3526 entry.c = 2;
3527 var subPatches = [];
3528 _VirtualDom_diffHelp(vnode, entry.z, subPatches, index);
3529
3530 _VirtualDom_pushPatch(localPatches, 9, index, {
3531 w: subPatches,
3532 A: entry
3533 });
3534
3535 return;
3536 }
3537
3538 // this key has already been removed or moved, a duplicate!
3539 _VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, index);
3540}
3541
3542
3543
3544// ADD DOM NODES
3545//
3546// Each DOM node has an "index" assigned in order of traversal. It is important
3547// to minimize our crawl over the actual DOM, so these indexes (along with the
3548// descendantsCount of virtual nodes) let us skip touching entire subtrees of
3549// the DOM if we know there are no patches there.
3550
3551
3552function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode)
3553{
3554 _VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode);
3555}
3556
3557
3558// assumes `patches` is non-empty and indexes increase monotonically.
3559function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode)
3560{
3561 var patch = patches[i];
3562 var index = patch.r;
3563
3564 while (index === low)
3565 {
3566 var patchType = patch.$;
3567
3568 if (patchType === 1)
3569 {
3570 _VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode);
3571 }
3572 else if (patchType === 8)
3573 {
3574 patch.t = domNode;
3575 patch.u = eventNode;
3576
3577 var subPatches = patch.s.w;
3578 if (subPatches.length > 0)
3579 {
3580 _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3581 }
3582 }
3583 else if (patchType === 9)
3584 {
3585 patch.t = domNode;
3586 patch.u = eventNode;
3587
3588 var data = patch.s;
3589 if (data)
3590 {
3591 data.A.s = domNode;
3592 var subPatches = data.w;
3593 if (subPatches.length > 0)
3594 {
3595 _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3596 }
3597 }
3598 }
3599 else
3600 {
3601 patch.t = domNode;
3602 patch.u = eventNode;
3603 }
3604
3605 i++;
3606
3607 if (!(patch = patches[i]) || (index = patch.r) > high)
3608 {
3609 return i;
3610 }
3611 }
3612
3613 var tag = vNode.$;
3614
3615 if (tag === 4)
3616 {
3617 var subNode = vNode.k;
3618
3619 while (subNode.$ === 4)
3620 {
3621 subNode = subNode.k;
3622 }
3623
3624 return _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);
3625 }
3626
3627 // tag must be 1 or 2 at this point
3628
3629 var vKids = vNode.e;
3630 var childNodes = domNode.childNodes;
3631 for (var j = 0; j < vKids.length; j++)
3632 {
3633 low++;
3634 var vKid = tag === 1 ? vKids[j] : vKids[j].b;
3635 var nextLow = low + (vKid.b || 0);
3636 if (low <= index && index <= nextLow)
3637 {
3638 i = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode);
3639 if (!(patch = patches[i]) || (index = patch.r) > high)
3640 {
3641 return i;
3642 }
3643 }
3644 low = nextLow;
3645 }
3646 return i;
3647}
3648
3649
3650
3651// APPLY PATCHES
3652
3653
3654function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode)
3655{
3656 if (patches.length === 0)
3657 {
3658 return rootDomNode;
3659 }
3660
3661 _VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);
3662 return _VirtualDom_applyPatchesHelp(rootDomNode, patches);
3663}
3664
3665function _VirtualDom_applyPatchesHelp(rootDomNode, patches)
3666{
3667 for (var i = 0; i < patches.length; i++)
3668 {
3669 var patch = patches[i];
3670 var localDomNode = patch.t
3671 var newNode = _VirtualDom_applyPatch(localDomNode, patch);
3672 if (localDomNode === rootDomNode)
3673 {
3674 rootDomNode = newNode;
3675 }
3676 }
3677 return rootDomNode;
3678}
3679
3680function _VirtualDom_applyPatch(domNode, patch)
3681{
3682 switch (patch.$)
3683 {
3684 case 0:
3685 return _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u);
3686
3687 case 4:
3688 _VirtualDom_applyFacts(domNode, patch.u, patch.s);
3689 return domNode;
3690
3691 case 3:
3692 domNode.replaceData(0, domNode.length, patch.s);
3693 return domNode;
3694
3695 case 1:
3696 return _VirtualDom_applyPatchesHelp(domNode, patch.s);
3697
3698 case 2:
3699 if (domNode.elm_event_node_ref)
3700 {
3701 domNode.elm_event_node_ref.j = patch.s;
3702 }
3703 else
3704 {
3705 domNode.elm_event_node_ref = { j: patch.s, p: patch.u };
3706 }
3707 return domNode;
3708
3709 case 6:
3710 var data = patch.s;
3711 for (var i = 0; i < data.i; i++)
3712 {
3713 domNode.removeChild(domNode.childNodes[data.v]);
3714 }
3715 return domNode;
3716
3717 case 7:
3718 var data = patch.s;
3719 var kids = data.e;
3720 var i = data.v;
3721 var theEnd = domNode.childNodes[i];
3722 for (; i < kids.length; i++)
3723 {
3724 domNode.insertBefore(_VirtualDom_render(kids[i], patch.u), theEnd);
3725 }
3726 return domNode;
3727
3728 case 9:
3729 var data = patch.s;
3730 if (!data)
3731 {
3732 domNode.parentNode.removeChild(domNode);
3733 return domNode;
3734 }
3735 var entry = data.A;
3736 if (typeof entry.r !== 'undefined')
3737 {
3738 domNode.parentNode.removeChild(domNode);
3739 }
3740 entry.s = _VirtualDom_applyPatchesHelp(domNode, data.w);
3741 return domNode;
3742
3743 case 8:
3744 return _VirtualDom_applyPatchReorder(domNode, patch);
3745
3746 case 5:
3747 return patch.s(domNode);
3748
3749 default:
3750 _Debug_crash(10); // 'Ran into an unknown patch!'
3751 }
3752}
3753
3754
3755function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode)
3756{
3757 var parentNode = domNode.parentNode;
3758 var newNode = _VirtualDom_render(vNode, eventNode);
3759
3760 if (!newNode.elm_event_node_ref)
3761 {
3762 newNode.elm_event_node_ref = domNode.elm_event_node_ref;
3763 }
3764
3765 if (parentNode && newNode !== domNode)
3766 {
3767 parentNode.replaceChild(newNode, domNode);
3768 }
3769 return newNode;
3770}
3771
3772
3773function _VirtualDom_applyPatchReorder(domNode, patch)
3774{
3775 var data = patch.s;
3776
3777 // remove end inserts
3778 var frag = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch);
3779
3780 // removals
3781 domNode = _VirtualDom_applyPatchesHelp(domNode, data.w);
3782
3783 // inserts
3784 var inserts = data.x;
3785 for (var i = 0; i < inserts.length; i++)
3786 {
3787 var insert = inserts[i];
3788 var entry = insert.A;
3789 var node = entry.c === 2
3790 ? entry.s
3791 : _VirtualDom_render(entry.z, patch.u);
3792 domNode.insertBefore(node, domNode.childNodes[insert.r]);
3793 }
3794
3795 // add end inserts
3796 if (frag)
3797 {
3798 _VirtualDom_appendChild(domNode, frag);
3799 }
3800
3801 return domNode;
3802}
3803
3804
3805function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch)
3806{
3807 if (!endInserts)
3808 {
3809 return;
3810 }
3811
3812 var frag = _VirtualDom_doc.createDocumentFragment();
3813 for (var i = 0; i < endInserts.length; i++)
3814 {
3815 var insert = endInserts[i];
3816 var entry = insert.A;
3817 _VirtualDom_appendChild(frag, entry.c === 2
3818 ? entry.s
3819 : _VirtualDom_render(entry.z, patch.u)
3820 );
3821 }
3822 return frag;
3823}
3824
3825
3826function _VirtualDom_virtualize(node)
3827{
3828 // TEXT NODES
3829
3830 if (node.nodeType === 3)
3831 {
3832 return _VirtualDom_text(node.textContent);
3833 }
3834
3835
3836 // WEIRD NODES
3837
3838 if (node.nodeType !== 1)
3839 {
3840 return _VirtualDom_text('');
3841 }
3842
3843
3844 // ELEMENT NODES
3845
3846 var attrList = _List_Nil;
3847 var attrs = node.attributes;
3848 for (var i = attrs.length; i--; )
3849 {
3850 var attr = attrs[i];
3851 var name = attr.name;
3852 var value = attr.value;
3853 attrList = _List_Cons( A2(_VirtualDom_attribute, name, value), attrList );
3854 }
3855
3856 var tag = node.tagName.toLowerCase();
3857 var kidList = _List_Nil;
3858 var kids = node.childNodes;
3859
3860 for (var i = kids.length; i--; )
3861 {
3862 kidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList);
3863 }
3864 return A3(_VirtualDom_node, tag, attrList, kidList);
3865}
3866
3867function _VirtualDom_dekey(keyedNode)
3868{
3869 var keyedKids = keyedNode.e;
3870 var len = keyedKids.length;
3871 var kids = new Array(len);
3872 for (var i = 0; i < len; i++)
3873 {
3874 kids[i] = keyedKids[i].b;
3875 }
3876
3877 return {
3878 $: 1,
3879 c: keyedNode.c,
3880 d: keyedNode.d,
3881 e: kids,
3882 f: keyedNode.f,
3883 b: keyedNode.b
3884 };
3885}
3886
3887
3888
3889
3890// ELEMENT
3891
3892
3893var _Debugger_element;
3894
3895var _Browser_element = _Debugger_element || F4(function(impl, flagDecoder, debugMetadata, args)
3896{
3897 return _Platform_initialize(
3898 flagDecoder,
3899 args,
3900 impl.init,
3901 impl.update,
3902 impl.subscriptions,
3903 function(sendToApp, initialModel) {
3904 var view = impl.view;
3905 /**_UNUSED/
3906 var domNode = args['node'];
3907 //*/
3908 /**/
3909 var domNode = args && args['node'] ? args['node'] : _Debug_crash(0);
3910 //*/
3911 var currNode = _VirtualDom_virtualize(domNode);
3912
3913 return _Browser_makeAnimator(initialModel, function(model)
3914 {
3915 var nextNode = view(model);
3916 var patches = _VirtualDom_diff(currNode, nextNode);
3917 domNode = _VirtualDom_applyPatches(domNode, currNode, patches, sendToApp);
3918 currNode = nextNode;
3919 });
3920 }
3921 );
3922});
3923
3924
3925
3926// DOCUMENT
3927
3928
3929var _Debugger_document;
3930
3931var _Browser_document = _Debugger_document || F4(function(impl, flagDecoder, debugMetadata, args)
3932{
3933 return _Platform_initialize(
3934 flagDecoder,
3935 args,
3936 impl.init,
3937 impl.update,
3938 impl.subscriptions,
3939 function(sendToApp, initialModel) {
3940 var divertHrefToApp = impl.setup && impl.setup(sendToApp)
3941 var view = impl.view;
3942 var title = _VirtualDom_doc.title;
3943 var bodyNode = _VirtualDom_doc.body;
3944 var currNode = _VirtualDom_virtualize(bodyNode);
3945 return _Browser_makeAnimator(initialModel, function(model)
3946 {
3947 _VirtualDom_divertHrefToApp = divertHrefToApp;
3948 var doc = view(model);
3949 var nextNode = _VirtualDom_node('body')(_List_Nil)(doc.body);
3950 var patches = _VirtualDom_diff(currNode, nextNode);
3951 bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp);
3952 currNode = nextNode;
3953 _VirtualDom_divertHrefToApp = 0;
3954 (title !== doc.title) && (_VirtualDom_doc.title = title = doc.title);
3955 });
3956 }
3957 );
3958});
3959
3960
3961
3962// ANIMATION
3963
3964
3965var _Browser_cancelAnimationFrame =
3966 typeof cancelAnimationFrame !== 'undefined'
3967 ? cancelAnimationFrame
3968 : function(id) { clearTimeout(id); };
3969
3970var _Browser_requestAnimationFrame =
3971 typeof requestAnimationFrame !== 'undefined'
3972 ? requestAnimationFrame
3973 : function(callback) { return setTimeout(callback, 1000 / 60); };
3974
3975
3976function _Browser_makeAnimator(model, draw)
3977{
3978 draw(model);
3979
3980 var state = 0;
3981
3982 function updateIfNeeded()
3983 {
3984 state = state === 1
3985 ? 0
3986 : ( _Browser_requestAnimationFrame(updateIfNeeded), draw(model), 1 );
3987 }
3988
3989 return function(nextModel, isSync)
3990 {
3991 model = nextModel;
3992
3993 isSync
3994 ? ( draw(model),
3995 state === 2 && (state = 1)
3996 )
3997 : ( state === 0 && _Browser_requestAnimationFrame(updateIfNeeded),
3998 state = 2
3999 );
4000 };
4001}
4002
4003
4004
4005// APPLICATION
4006
4007
4008function _Browser_application(impl)
4009{
4010 var onUrlChange = impl.onUrlChange;
4011 var onUrlRequest = impl.onUrlRequest;
4012 var key = function() { key.a(onUrlChange(_Browser_getUrl())); };
4013
4014 return _Browser_document({
4015 setup: function(sendToApp)
4016 {
4017 key.a = sendToApp;
4018 _Browser_window.addEventListener('popstate', key);
4019 _Browser_window.navigator.userAgent.indexOf('Trident') < 0 || _Browser_window.addEventListener('hashchange', key);
4020
4021 return F2(function(domNode, event)
4022 {
4023 if (!event.ctrlKey && !event.metaKey && !event.shiftKey && event.button < 1 && !domNode.target && !domNode.hasAttribute('download'))
4024 {
4025 event.preventDefault();
4026 var href = domNode.href;
4027 var curr = _Browser_getUrl();
4028 var next = $elm$url$Url$fromString(href).a;
4029 sendToApp(onUrlRequest(
4030 (next
4031 && curr.protocol === next.protocol
4032 && curr.host === next.host
4033 && curr.port_.a === next.port_.a
4034 )
4035 ? $elm$browser$Browser$Internal(next)
4036 : $elm$browser$Browser$External(href)
4037 ));
4038 }
4039 });
4040 },
4041 init: function(flags)
4042 {
4043 return A3(impl.init, flags, _Browser_getUrl(), key);
4044 },
4045 view: impl.view,
4046 update: impl.update,
4047 subscriptions: impl.subscriptions
4048 });
4049}
4050
4051function _Browser_getUrl()
4052{
4053 return $elm$url$Url$fromString(_VirtualDom_doc.location.href).a || _Debug_crash(1);
4054}
4055
4056var _Browser_go = F2(function(key, n)
4057{
4058 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4059 n && history.go(n);
4060 key();
4061 }));
4062});
4063
4064var _Browser_pushUrl = F2(function(key, url)
4065{
4066 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4067 history.pushState({}, '', url);
4068 key();
4069 }));
4070});
4071
4072var _Browser_replaceUrl = F2(function(key, url)
4073{
4074 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4075 history.replaceState({}, '', url);
4076 key();
4077 }));
4078});
4079
4080
4081
4082// GLOBAL EVENTS
4083
4084
4085var _Browser_fakeNode = { addEventListener: function() {}, removeEventListener: function() {} };
4086var _Browser_doc = typeof document !== 'undefined' ? document : _Browser_fakeNode;
4087var _Browser_window = typeof window !== 'undefined' ? window : _Browser_fakeNode;
4088
4089var _Browser_on = F3(function(node, eventName, sendToSelf)
4090{
4091 return _Scheduler_spawn(_Scheduler_binding(function(callback)
4092 {
4093 function handler(event) { _Scheduler_rawSpawn(sendToSelf(event)); }
4094 node.addEventListener(eventName, handler, _VirtualDom_passiveSupported && { passive: true });
4095 return function() { node.removeEventListener(eventName, handler); };
4096 }));
4097});
4098
4099var _Browser_decodeEvent = F2(function(decoder, event)
4100{
4101 var result = _Json_runHelp(decoder, event);
4102 return $elm$core$Result$isOk(result) ? $elm$core$Maybe$Just(result.a) : $elm$core$Maybe$Nothing;
4103});
4104
4105
4106
4107// PAGE VISIBILITY
4108
4109
4110function _Browser_visibilityInfo()
4111{
4112 return (typeof _VirtualDom_doc.hidden !== 'undefined')
4113 ? { hidden: 'hidden', change: 'visibilitychange' }
4114 :
4115 (typeof _VirtualDom_doc.mozHidden !== 'undefined')
4116 ? { hidden: 'mozHidden', change: 'mozvisibilitychange' }
4117 :
4118 (typeof _VirtualDom_doc.msHidden !== 'undefined')
4119 ? { hidden: 'msHidden', change: 'msvisibilitychange' }
4120 :
4121 (typeof _VirtualDom_doc.webkitHidden !== 'undefined')
4122 ? { hidden: 'webkitHidden', change: 'webkitvisibilitychange' }
4123 : { hidden: 'hidden', change: 'visibilitychange' };
4124}
4125
4126
4127
4128// ANIMATION FRAMES
4129
4130
4131function _Browser_rAF()
4132{
4133 return _Scheduler_binding(function(callback)
4134 {
4135 var id = _Browser_requestAnimationFrame(function() {
4136 callback(_Scheduler_succeed(Date.now()));
4137 });
4138
4139 return function() {
4140 _Browser_cancelAnimationFrame(id);
4141 };
4142 });
4143}
4144
4145
4146function _Browser_now()
4147{
4148 return _Scheduler_binding(function(callback)
4149 {
4150 callback(_Scheduler_succeed(Date.now()));
4151 });
4152}
4153
4154
4155
4156// DOM STUFF
4157
4158
4159function _Browser_withNode(id, doStuff)
4160{
4161 return _Scheduler_binding(function(callback)
4162 {
4163 _Browser_requestAnimationFrame(function() {
4164 var node = document.getElementById(id);
4165 callback(node
4166 ? _Scheduler_succeed(doStuff(node))
4167 : _Scheduler_fail($elm$browser$Browser$Dom$NotFound(id))
4168 );
4169 });
4170 });
4171}
4172
4173
4174function _Browser_withWindow(doStuff)
4175{
4176 return _Scheduler_binding(function(callback)
4177 {
4178 _Browser_requestAnimationFrame(function() {
4179 callback(_Scheduler_succeed(doStuff()));
4180 });
4181 });
4182}
4183
4184
4185// FOCUS and BLUR
4186
4187
4188var _Browser_call = F2(function(functionName, id)
4189{
4190 return _Browser_withNode(id, function(node) {
4191 node[functionName]();
4192 return _Utils_Tuple0;
4193 });
4194});
4195
4196
4197
4198// WINDOW VIEWPORT
4199
4200
4201function _Browser_getViewport()
4202{
4203 return {
4204 scene: _Browser_getScene(),
4205 viewport: {
4206 x: _Browser_window.pageXOffset,
4207 y: _Browser_window.pageYOffset,
4208 width: _Browser_doc.documentElement.clientWidth,
4209 height: _Browser_doc.documentElement.clientHeight
4210 }
4211 };
4212}
4213
4214function _Browser_getScene()
4215{
4216 var body = _Browser_doc.body;
4217 var elem = _Browser_doc.documentElement;
4218 return {
4219 width: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth),
4220 height: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight)
4221 };
4222}
4223
4224var _Browser_setViewport = F2(function(x, y)
4225{
4226 return _Browser_withWindow(function()
4227 {
4228 _Browser_window.scroll(x, y);
4229 return _Utils_Tuple0;
4230 });
4231});
4232
4233
4234
4235// ELEMENT VIEWPORT
4236
4237
4238function _Browser_getViewportOf(id)
4239{
4240 return _Browser_withNode(id, function(node)
4241 {
4242 return {
4243 scene: {
4244 width: node.scrollWidth,
4245 height: node.scrollHeight
4246 },
4247 viewport: {
4248 x: node.scrollLeft,
4249 y: node.scrollTop,
4250 width: node.clientWidth,
4251 height: node.clientHeight
4252 }
4253 };
4254 });
4255}
4256
4257
4258var _Browser_setViewportOf = F3(function(id, x, y)
4259{
4260 return _Browser_withNode(id, function(node)
4261 {
4262 node.scrollLeft = x;
4263 node.scrollTop = y;
4264 return _Utils_Tuple0;
4265 });
4266});
4267
4268
4269
4270// ELEMENT
4271
4272
4273function _Browser_getElement(id)
4274{
4275 return _Browser_withNode(id, function(node)
4276 {
4277 var rect = node.getBoundingClientRect();
4278 var x = _Browser_window.pageXOffset;
4279 var y = _Browser_window.pageYOffset;
4280 return {
4281 scene: _Browser_getScene(),
4282 viewport: {
4283 x: x,
4284 y: y,
4285 width: _Browser_doc.documentElement.clientWidth,
4286 height: _Browser_doc.documentElement.clientHeight
4287 },
4288 element: {
4289 x: x + rect.left,
4290 y: y + rect.top,
4291 width: rect.width,
4292 height: rect.height
4293 }
4294 };
4295 });
4296}
4297
4298
4299
4300// LOAD and RELOAD
4301
4302
4303function _Browser_reload(skipCache)
4304{
4305 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4306 {
4307 _VirtualDom_doc.location.reload(skipCache);
4308 }));
4309}
4310
4311function _Browser_load(url)
4312{
4313 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4314 {
4315 try
4316 {
4317 _Browser_window.location = url;
4318 }
4319 catch(err)
4320 {
4321 // Only Firefox can throw a NS_ERROR_MALFORMED_URI exception here.
4322 // Other browsers reload the page, so let's be consistent about that.
4323 _VirtualDom_doc.location.reload(false);
4324 }
4325 }));
4326}
4327var $author$project$Main$init = 1;
4328var $elm$core$Basics$EQ = {$: 'EQ'};
4329var $elm$core$Basics$GT = {$: 'GT'};
4330var $elm$core$Basics$LT = {$: 'LT'};
4331var $elm$core$List$cons = _List_cons;
4332var $elm$core$Dict$foldr = F3(
4333 function (func, acc, t) {
4334 foldr:
4335 while (true) {
4336 if (t.$ === 'RBEmpty_elm_builtin') {
4337 return acc;
4338 } else {
4339 var key = t.b;
4340 var value = t.c;
4341 var left = t.d;
4342 var right = t.e;
4343 var $temp$func = func,
4344 $temp$acc = A3(
4345 func,
4346 key,
4347 value,
4348 A3($elm$core$Dict$foldr, func, acc, right)),
4349 $temp$t = left;
4350 func = $temp$func;
4351 acc = $temp$acc;
4352 t = $temp$t;
4353 continue foldr;
4354 }
4355 }
4356 });
4357var $elm$core$Dict$toList = function (dict) {
4358 return A3(
4359 $elm$core$Dict$foldr,
4360 F3(
4361 function (key, value, list) {
4362 return A2(
4363 $elm$core$List$cons,
4364 _Utils_Tuple2(key, value),
4365 list);
4366 }),
4367 _List_Nil,
4368 dict);
4369};
4370var $elm$core$Dict$keys = function (dict) {
4371 return A3(
4372 $elm$core$Dict$foldr,
4373 F3(
4374 function (key, value, keyList) {
4375 return A2($elm$core$List$cons, key, keyList);
4376 }),
4377 _List_Nil,
4378 dict);
4379};
4380var $elm$core$Set$toList = function (_v0) {
4381 var dict = _v0.a;
4382 return $elm$core$Dict$keys(dict);
4383};
4384var $elm$core$Elm$JsArray$foldr = _JsArray_foldr;
4385var $elm$core$Array$foldr = F3(
4386 function (func, baseCase, _v0) {
4387 var tree = _v0.c;
4388 var tail = _v0.d;
4389 var helper = F2(
4390 function (node, acc) {
4391 if (node.$ === 'SubTree') {
4392 var subTree = node.a;
4393 return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);
4394 } else {
4395 var values = node.a;
4396 return A3($elm$core$Elm$JsArray$foldr, func, acc, values);
4397 }
4398 });
4399 return A3(
4400 $elm$core$Elm$JsArray$foldr,
4401 helper,
4402 A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail),
4403 tree);
4404 });
4405var $elm$core$Array$toList = function (array) {
4406 return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array);
4407};
4408var $elm$core$Result$Err = function (a) {
4409 return {$: 'Err', a: a};
4410};
4411var $elm$json$Json$Decode$Failure = F2(
4412 function (a, b) {
4413 return {$: 'Failure', a: a, b: b};
4414 });
4415var $elm$json$Json$Decode$Field = F2(
4416 function (a, b) {
4417 return {$: 'Field', a: a, b: b};
4418 });
4419var $elm$json$Json$Decode$Index = F2(
4420 function (a, b) {
4421 return {$: 'Index', a: a, b: b};
4422 });
4423var $elm$core$Result$Ok = function (a) {
4424 return {$: 'Ok', a: a};
4425};
4426var $elm$json$Json$Decode$OneOf = function (a) {
4427 return {$: 'OneOf', a: a};
4428};
4429var $elm$core$Basics$False = {$: 'False'};
4430var $elm$core$Basics$add = _Basics_add;
4431var $elm$core$Maybe$Just = function (a) {
4432 return {$: 'Just', a: a};
4433};
4434var $elm$core$Maybe$Nothing = {$: 'Nothing'};
4435var $elm$core$String$all = _String_all;
4436var $elm$core$Basics$and = _Basics_and;
4437var $elm$core$Basics$append = _Utils_append;
4438var $elm$json$Json$Encode$encode = _Json_encode;
4439var $elm$core$String$fromInt = _String_fromNumber;
4440var $elm$core$String$join = F2(
4441 function (sep, chunks) {
4442 return A2(
4443 _String_join,
4444 sep,
4445 _List_toArray(chunks));
4446 });
4447var $elm$core$String$split = F2(
4448 function (sep, string) {
4449 return _List_fromArray(
4450 A2(_String_split, sep, string));
4451 });
4452var $elm$json$Json$Decode$indent = function (str) {
4453 return A2(
4454 $elm$core$String$join,
4455 '\n ',
4456 A2($elm$core$String$split, '\n', str));
4457};
4458var $elm$core$List$foldl = F3(
4459 function (func, acc, list) {
4460 foldl:
4461 while (true) {
4462 if (!list.b) {
4463 return acc;
4464 } else {
4465 var x = list.a;
4466 var xs = list.b;
4467 var $temp$func = func,
4468 $temp$acc = A2(func, x, acc),
4469 $temp$list = xs;
4470 func = $temp$func;
4471 acc = $temp$acc;
4472 list = $temp$list;
4473 continue foldl;
4474 }
4475 }
4476 });
4477var $elm$core$List$length = function (xs) {
4478 return A3(
4479 $elm$core$List$foldl,
4480 F2(
4481 function (_v0, i) {
4482 return i + 1;
4483 }),
4484 0,
4485 xs);
4486};
4487var $elm$core$List$map2 = _List_map2;
4488var $elm$core$Basics$le = _Utils_le;
4489var $elm$core$Basics$sub = _Basics_sub;
4490var $elm$core$List$rangeHelp = F3(
4491 function (lo, hi, list) {
4492 rangeHelp:
4493 while (true) {
4494 if (_Utils_cmp(lo, hi) < 1) {
4495 var $temp$lo = lo,
4496 $temp$hi = hi - 1,
4497 $temp$list = A2($elm$core$List$cons, hi, list);
4498 lo = $temp$lo;
4499 hi = $temp$hi;
4500 list = $temp$list;
4501 continue rangeHelp;
4502 } else {
4503 return list;
4504 }
4505 }
4506 });
4507var $elm$core$List$range = F2(
4508 function (lo, hi) {
4509 return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil);
4510 });
4511var $elm$core$List$indexedMap = F2(
4512 function (f, xs) {
4513 return A3(
4514 $elm$core$List$map2,
4515 f,
4516 A2(
4517 $elm$core$List$range,
4518 0,
4519 $elm$core$List$length(xs) - 1),
4520 xs);
4521 });
4522var $elm$core$Char$toCode = _Char_toCode;
4523var $elm$core$Char$isLower = function (_char) {
4524 var code = $elm$core$Char$toCode(_char);
4525 return (97 <= code) && (code <= 122);
4526};
4527var $elm$core$Char$isUpper = function (_char) {
4528 var code = $elm$core$Char$toCode(_char);
4529 return (code <= 90) && (65 <= code);
4530};
4531var $elm$core$Basics$or = _Basics_or;
4532var $elm$core$Char$isAlpha = function (_char) {
4533 return $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char);
4534};
4535var $elm$core$Char$isDigit = function (_char) {
4536 var code = $elm$core$Char$toCode(_char);
4537 return (code <= 57) && (48 <= code);
4538};
4539var $elm$core$Char$isAlphaNum = function (_char) {
4540 return $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char));
4541};
4542var $elm$core$List$reverse = function (list) {
4543 return A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list);
4544};
4545var $elm$core$String$uncons = _String_uncons;
4546var $elm$json$Json$Decode$errorOneOf = F2(
4547 function (i, error) {
4548 return '\n\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent(
4549 $elm$json$Json$Decode$errorToString(error))));
4550 });
4551var $elm$json$Json$Decode$errorToString = function (error) {
4552 return A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);
4553};
4554var $elm$json$Json$Decode$errorToStringHelp = F2(
4555 function (error, context) {
4556 errorToStringHelp:
4557 while (true) {
4558 switch (error.$) {
4559 case 'Field':
4560 var f = error.a;
4561 var err = error.b;
4562 var isSimple = function () {
4563 var _v1 = $elm$core$String$uncons(f);
4564 if (_v1.$ === 'Nothing') {
4565 return false;
4566 } else {
4567 var _v2 = _v1.a;
4568 var _char = _v2.a;
4569 var rest = _v2.b;
4570 return $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest);
4571 }
4572 }();
4573 var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']'));
4574 var $temp$error = err,
4575 $temp$context = A2($elm$core$List$cons, fieldName, context);
4576 error = $temp$error;
4577 context = $temp$context;
4578 continue errorToStringHelp;
4579 case 'Index':
4580 var i = error.a;
4581 var err = error.b;
4582 var indexName = '[' + ($elm$core$String$fromInt(i) + ']');
4583 var $temp$error = err,
4584 $temp$context = A2($elm$core$List$cons, indexName, context);
4585 error = $temp$error;
4586 context = $temp$context;
4587 continue errorToStringHelp;
4588 case 'OneOf':
4589 var errors = error.a;
4590 if (!errors.b) {
4591 return 'Ran into a Json.Decode.oneOf with no possibilities' + function () {
4592 if (!context.b) {
4593 return '!';
4594 } else {
4595 return ' at json' + A2(
4596 $elm$core$String$join,
4597 '',
4598 $elm$core$List$reverse(context));
4599 }
4600 }();
4601 } else {
4602 if (!errors.b.b) {
4603 var err = errors.a;
4604 var $temp$error = err,
4605 $temp$context = context;
4606 error = $temp$error;
4607 context = $temp$context;
4608 continue errorToStringHelp;
4609 } else {
4610 var starter = function () {
4611 if (!context.b) {
4612 return 'Json.Decode.oneOf';
4613 } else {
4614 return 'The Json.Decode.oneOf at json' + A2(
4615 $elm$core$String$join,
4616 '',
4617 $elm$core$List$reverse(context));
4618 }
4619 }();
4620 var introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt(
4621 $elm$core$List$length(errors)) + ' ways:'));
4622 return A2(
4623 $elm$core$String$join,
4624 '\n\n',
4625 A2(
4626 $elm$core$List$cons,
4627 introduction,
4628 A2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors)));
4629 }
4630 }
4631 default:
4632 var msg = error.a;
4633 var json = error.b;
4634 var introduction = function () {
4635 if (!context.b) {
4636 return 'Problem with the given value:\n\n';
4637 } else {
4638 return 'Problem with the value at json' + (A2(
4639 $elm$core$String$join,
4640 '',
4641 $elm$core$List$reverse(context)) + ':\n\n ');
4642 }
4643 }();
4644 return introduction + ($elm$json$Json$Decode$indent(
4645 A2($elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg));
4646 }
4647 }
4648 });
4649var $elm$core$Array$branchFactor = 32;
4650var $elm$core$Array$Array_elm_builtin = F4(
4651 function (a, b, c, d) {
4652 return {$: 'Array_elm_builtin', a: a, b: b, c: c, d: d};
4653 });
4654var $elm$core$Elm$JsArray$empty = _JsArray_empty;
4655var $elm$core$Basics$ceiling = _Basics_ceiling;
4656var $elm$core$Basics$fdiv = _Basics_fdiv;
4657var $elm$core$Basics$logBase = F2(
4658 function (base, number) {
4659 return _Basics_log(number) / _Basics_log(base);
4660 });
4661var $elm$core$Basics$toFloat = _Basics_toFloat;
4662var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling(
4663 A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor));
4664var $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);
4665var $elm$core$Elm$JsArray$initialize = _JsArray_initialize;
4666var $elm$core$Array$Leaf = function (a) {
4667 return {$: 'Leaf', a: a};
4668};
4669var $elm$core$Basics$apL = F2(
4670 function (f, x) {
4671 return f(x);
4672 });
4673var $elm$core$Basics$apR = F2(
4674 function (x, f) {
4675 return f(x);
4676 });
4677var $elm$core$Basics$eq = _Utils_equal;
4678var $elm$core$Basics$floor = _Basics_floor;
4679var $elm$core$Elm$JsArray$length = _JsArray_length;
4680var $elm$core$Basics$gt = _Utils_gt;
4681var $elm$core$Basics$max = F2(
4682 function (x, y) {
4683 return (_Utils_cmp(x, y) > 0) ? x : y;
4684 });
4685var $elm$core$Basics$mul = _Basics_mul;
4686var $elm$core$Array$SubTree = function (a) {
4687 return {$: 'SubTree', a: a};
4688};
4689var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;
4690var $elm$core$Array$compressNodes = F2(
4691 function (nodes, acc) {
4692 compressNodes:
4693 while (true) {
4694 var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes);
4695 var node = _v0.a;
4696 var remainingNodes = _v0.b;
4697 var newAcc = A2(
4698 $elm$core$List$cons,
4699 $elm$core$Array$SubTree(node),
4700 acc);
4701 if (!remainingNodes.b) {
4702 return $elm$core$List$reverse(newAcc);
4703 } else {
4704 var $temp$nodes = remainingNodes,
4705 $temp$acc = newAcc;
4706 nodes = $temp$nodes;
4707 acc = $temp$acc;
4708 continue compressNodes;
4709 }
4710 }
4711 });
4712var $elm$core$Tuple$first = function (_v0) {
4713 var x = _v0.a;
4714 return x;
4715};
4716var $elm$core$Array$treeFromBuilder = F2(
4717 function (nodeList, nodeListSize) {
4718 treeFromBuilder:
4719 while (true) {
4720 var newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor);
4721 if (newNodeSize === 1) {
4722 return A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a;
4723 } else {
4724 var $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil),
4725 $temp$nodeListSize = newNodeSize;
4726 nodeList = $temp$nodeList;
4727 nodeListSize = $temp$nodeListSize;
4728 continue treeFromBuilder;
4729 }
4730 }
4731 });
4732var $elm$core$Array$builderToArray = F2(
4733 function (reverseNodeList, builder) {
4734 if (!builder.nodeListSize) {
4735 return A4(
4736 $elm$core$Array$Array_elm_builtin,
4737 $elm$core$Elm$JsArray$length(builder.tail),
4738 $elm$core$Array$shiftStep,
4739 $elm$core$Elm$JsArray$empty,
4740 builder.tail);
4741 } else {
4742 var treeLen = builder.nodeListSize * $elm$core$Array$branchFactor;
4743 var depth = $elm$core$Basics$floor(
4744 A2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1));
4745 var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.nodeList) : builder.nodeList;
4746 var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.nodeListSize);
4747 return A4(
4748 $elm$core$Array$Array_elm_builtin,
4749 $elm$core$Elm$JsArray$length(builder.tail) + treeLen,
4750 A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep),
4751 tree,
4752 builder.tail);
4753 }
4754 });
4755var $elm$core$Basics$idiv = _Basics_idiv;
4756var $elm$core$Basics$lt = _Utils_lt;
4757var $elm$core$Array$initializeHelp = F5(
4758 function (fn, fromIndex, len, nodeList, tail) {
4759 initializeHelp:
4760 while (true) {
4761 if (fromIndex < 0) {
4762 return A2(
4763 $elm$core$Array$builderToArray,
4764 false,
4765 {nodeList: nodeList, nodeListSize: (len / $elm$core$Array$branchFactor) | 0, tail: tail});
4766 } else {
4767 var leaf = $elm$core$Array$Leaf(
4768 A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn));
4769 var $temp$fn = fn,
4770 $temp$fromIndex = fromIndex - $elm$core$Array$branchFactor,
4771 $temp$len = len,
4772 $temp$nodeList = A2($elm$core$List$cons, leaf, nodeList),
4773 $temp$tail = tail;
4774 fn = $temp$fn;
4775 fromIndex = $temp$fromIndex;
4776 len = $temp$len;
4777 nodeList = $temp$nodeList;
4778 tail = $temp$tail;
4779 continue initializeHelp;
4780 }
4781 }
4782 });
4783var $elm$core$Basics$remainderBy = _Basics_remainderBy;
4784var $elm$core$Array$initialize = F2(
4785 function (len, fn) {
4786 if (len <= 0) {
4787 return $elm$core$Array$empty;
4788 } else {
4789 var tailLen = len % $elm$core$Array$branchFactor;
4790 var tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn);
4791 var initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor;
4792 return A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);
4793 }
4794 });
4795var $elm$core$Basics$True = {$: 'True'};
4796var $elm$core$Result$isOk = function (result) {
4797 if (result.$ === 'Ok') {
4798 return true;
4799 } else {
4800 return false;
4801 }
4802};
4803var $elm$json$Json$Decode$map = _Json_map1;
4804var $elm$json$Json$Decode$map2 = _Json_map2;
4805var $elm$json$Json$Decode$succeed = _Json_succeed;
4806var $elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) {
4807 switch (handler.$) {
4808 case 'Normal':
4809 return 0;
4810 case 'MayStopPropagation':
4811 return 1;
4812 case 'MayPreventDefault':
4813 return 2;
4814 default:
4815 return 3;
4816 }
4817};
4818var $elm$browser$Browser$External = function (a) {
4819 return {$: 'External', a: a};
4820};
4821var $elm$browser$Browser$Internal = function (a) {
4822 return {$: 'Internal', a: a};
4823};
4824var $elm$core$Basics$identity = function (x) {
4825 return x;
4826};
4827var $elm$browser$Browser$Dom$NotFound = function (a) {
4828 return {$: 'NotFound', a: a};
4829};
4830var $elm$url$Url$Http = {$: 'Http'};
4831var $elm$url$Url$Https = {$: 'Https'};
4832var $elm$url$Url$Url = F6(
4833 function (protocol, host, port_, path, query, fragment) {
4834 return {fragment: fragment, host: host, path: path, port_: port_, protocol: protocol, query: query};
4835 });
4836var $elm$core$String$contains = _String_contains;
4837var $elm$core$String$length = _String_length;
4838var $elm$core$String$slice = _String_slice;
4839var $elm$core$String$dropLeft = F2(
4840 function (n, string) {
4841 return (n < 1) ? string : A3(
4842 $elm$core$String$slice,
4843 n,
4844 $elm$core$String$length(string),
4845 string);
4846 });
4847var $elm$core$String$indexes = _String_indexes;
4848var $elm$core$String$isEmpty = function (string) {
4849 return string === '';
4850};
4851var $elm$core$String$left = F2(
4852 function (n, string) {
4853 return (n < 1) ? '' : A3($elm$core$String$slice, 0, n, string);
4854 });
4855var $elm$core$String$toInt = _String_toInt;
4856var $elm$url$Url$chompBeforePath = F5(
4857 function (protocol, path, params, frag, str) {
4858 if ($elm$core$String$isEmpty(str) || A2($elm$core$String$contains, '@', str)) {
4859 return $elm$core$Maybe$Nothing;
4860 } else {
4861 var _v0 = A2($elm$core$String$indexes, ':', str);
4862 if (!_v0.b) {
4863 return $elm$core$Maybe$Just(
4864 A6($elm$url$Url$Url, protocol, str, $elm$core$Maybe$Nothing, path, params, frag));
4865 } else {
4866 if (!_v0.b.b) {
4867 var i = _v0.a;
4868 var _v1 = $elm$core$String$toInt(
4869 A2($elm$core$String$dropLeft, i + 1, str));
4870 if (_v1.$ === 'Nothing') {
4871 return $elm$core$Maybe$Nothing;
4872 } else {
4873 var port_ = _v1;
4874 return $elm$core$Maybe$Just(
4875 A6(
4876 $elm$url$Url$Url,
4877 protocol,
4878 A2($elm$core$String$left, i, str),
4879 port_,
4880 path,
4881 params,
4882 frag));
4883 }
4884 } else {
4885 return $elm$core$Maybe$Nothing;
4886 }
4887 }
4888 }
4889 });
4890var $elm$url$Url$chompBeforeQuery = F4(
4891 function (protocol, params, frag, str) {
4892 if ($elm$core$String$isEmpty(str)) {
4893 return $elm$core$Maybe$Nothing;
4894 } else {
4895 var _v0 = A2($elm$core$String$indexes, '/', str);
4896 if (!_v0.b) {
4897 return A5($elm$url$Url$chompBeforePath, protocol, '/', params, frag, str);
4898 } else {
4899 var i = _v0.a;
4900 return A5(
4901 $elm$url$Url$chompBeforePath,
4902 protocol,
4903 A2($elm$core$String$dropLeft, i, str),
4904 params,
4905 frag,
4906 A2($elm$core$String$left, i, str));
4907 }
4908 }
4909 });
4910var $elm$url$Url$chompBeforeFragment = F3(
4911 function (protocol, frag, str) {
4912 if ($elm$core$String$isEmpty(str)) {
4913 return $elm$core$Maybe$Nothing;
4914 } else {
4915 var _v0 = A2($elm$core$String$indexes, '?', str);
4916 if (!_v0.b) {
4917 return A4($elm$url$Url$chompBeforeQuery, protocol, $elm$core$Maybe$Nothing, frag, str);
4918 } else {
4919 var i = _v0.a;
4920 return A4(
4921 $elm$url$Url$chompBeforeQuery,
4922 protocol,
4923 $elm$core$Maybe$Just(
4924 A2($elm$core$String$dropLeft, i + 1, str)),
4925 frag,
4926 A2($elm$core$String$left, i, str));
4927 }
4928 }
4929 });
4930var $elm$url$Url$chompAfterProtocol = F2(
4931 function (protocol, str) {
4932 if ($elm$core$String$isEmpty(str)) {
4933 return $elm$core$Maybe$Nothing;
4934 } else {
4935 var _v0 = A2($elm$core$String$indexes, '#', str);
4936 if (!_v0.b) {
4937 return A3($elm$url$Url$chompBeforeFragment, protocol, $elm$core$Maybe$Nothing, str);
4938 } else {
4939 var i = _v0.a;
4940 return A3(
4941 $elm$url$Url$chompBeforeFragment,
4942 protocol,
4943 $elm$core$Maybe$Just(
4944 A2($elm$core$String$dropLeft, i + 1, str)),
4945 A2($elm$core$String$left, i, str));
4946 }
4947 }
4948 });
4949var $elm$core$String$startsWith = _String_startsWith;
4950var $elm$url$Url$fromString = function (str) {
4951 return A2($elm$core$String$startsWith, 'http://', str) ? A2(
4952 $elm$url$Url$chompAfterProtocol,
4953 $elm$url$Url$Http,
4954 A2($elm$core$String$dropLeft, 7, str)) : (A2($elm$core$String$startsWith, 'https://', str) ? A2(
4955 $elm$url$Url$chompAfterProtocol,
4956 $elm$url$Url$Https,
4957 A2($elm$core$String$dropLeft, 8, str)) : $elm$core$Maybe$Nothing);
4958};
4959var $elm$core$Basics$never = function (_v0) {
4960 never:
4961 while (true) {
4962 var nvr = _v0.a;
4963 var $temp$_v0 = nvr;
4964 _v0 = $temp$_v0;
4965 continue never;
4966 }
4967};
4968var $elm$core$Task$Perform = function (a) {
4969 return {$: 'Perform', a: a};
4970};
4971var $elm$core$Task$succeed = _Scheduler_succeed;
4972var $elm$core$Task$init = $elm$core$Task$succeed(_Utils_Tuple0);
4973var $elm$core$List$foldrHelper = F4(
4974 function (fn, acc, ctr, ls) {
4975 if (!ls.b) {
4976 return acc;
4977 } else {
4978 var a = ls.a;
4979 var r1 = ls.b;
4980 if (!r1.b) {
4981 return A2(fn, a, acc);
4982 } else {
4983 var b = r1.a;
4984 var r2 = r1.b;
4985 if (!r2.b) {
4986 return A2(
4987 fn,
4988 a,
4989 A2(fn, b, acc));
4990 } else {
4991 var c = r2.a;
4992 var r3 = r2.b;
4993 if (!r3.b) {
4994 return A2(
4995 fn,
4996 a,
4997 A2(
4998 fn,
4999 b,
5000 A2(fn, c, acc)));
5001 } else {
5002 var d = r3.a;
5003 var r4 = r3.b;
5004 var res = (ctr > 500) ? A3(
5005 $elm$core$List$foldl,
5006 fn,
5007 acc,
5008 $elm$core$List$reverse(r4)) : A4($elm$core$List$foldrHelper, fn, acc, ctr + 1, r4);
5009 return A2(
5010 fn,
5011 a,
5012 A2(
5013 fn,
5014 b,
5015 A2(
5016 fn,
5017 c,
5018 A2(fn, d, res))));
5019 }
5020 }
5021 }
5022 }
5023 });
5024var $elm$core$List$foldr = F3(
5025 function (fn, acc, ls) {
5026 return A4($elm$core$List$foldrHelper, fn, acc, 0, ls);
5027 });
5028var $elm$core$List$map = F2(
5029 function (f, xs) {
5030 return A3(
5031 $elm$core$List$foldr,
5032 F2(
5033 function (x, acc) {
5034 return A2(
5035 $elm$core$List$cons,
5036 f(x),
5037 acc);
5038 }),
5039 _List_Nil,
5040 xs);
5041 });
5042var $elm$core$Task$andThen = _Scheduler_andThen;
5043var $elm$core$Task$map = F2(
5044 function (func, taskA) {
5045 return A2(
5046 $elm$core$Task$andThen,
5047 function (a) {
5048 return $elm$core$Task$succeed(
5049 func(a));
5050 },
5051 taskA);
5052 });
5053var $elm$core$Task$map2 = F3(
5054 function (func, taskA, taskB) {
5055 return A2(
5056 $elm$core$Task$andThen,
5057 function (a) {
5058 return A2(
5059 $elm$core$Task$andThen,
5060 function (b) {
5061 return $elm$core$Task$succeed(
5062 A2(func, a, b));
5063 },
5064 taskB);
5065 },
5066 taskA);
5067 });
5068var $elm$core$Task$sequence = function (tasks) {
5069 return A3(
5070 $elm$core$List$foldr,
5071 $elm$core$Task$map2($elm$core$List$cons),
5072 $elm$core$Task$succeed(_List_Nil),
5073 tasks);
5074};
5075var $elm$core$Platform$sendToApp = _Platform_sendToApp;
5076var $elm$core$Task$spawnCmd = F2(
5077 function (router, _v0) {
5078 var task = _v0.a;
5079 return _Scheduler_spawn(
5080 A2(
5081 $elm$core$Task$andThen,
5082 $elm$core$Platform$sendToApp(router),
5083 task));
5084 });
5085var $elm$core$Task$onEffects = F3(
5086 function (router, commands, state) {
5087 return A2(
5088 $elm$core$Task$map,
5089 function (_v0) {
5090 return _Utils_Tuple0;
5091 },
5092 $elm$core$Task$sequence(
5093 A2(
5094 $elm$core$List$map,
5095 $elm$core$Task$spawnCmd(router),
5096 commands)));
5097 });
5098var $elm$core$Task$onSelfMsg = F3(
5099 function (_v0, _v1, _v2) {
5100 return $elm$core$Task$succeed(_Utils_Tuple0);
5101 });
5102var $elm$core$Task$cmdMap = F2(
5103 function (tagger, _v0) {
5104 var task = _v0.a;
5105 return $elm$core$Task$Perform(
5106 A2($elm$core$Task$map, tagger, task));
5107 });
5108_Platform_effectManagers['Task'] = _Platform_createManager($elm$core$Task$init, $elm$core$Task$onEffects, $elm$core$Task$onSelfMsg, $elm$core$Task$cmdMap);
5109var $elm$core$Task$command = _Platform_leaf('Task');
5110var $elm$core$Task$perform = F2(
5111 function (toMessage, task) {
5112 return $elm$core$Task$command(
5113 $elm$core$Task$Perform(
5114 A2($elm$core$Task$map, toMessage, task)));
5115 });
5116var $elm$core$Platform$Cmd$batch = _Platform_batch;
5117var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil);
5118var $elm$core$Platform$Sub$batch = _Platform_batch;
5119var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil);
5120var $elm$browser$Browser$sandbox = function (impl) {
5121 return _Browser_element(
5122 {
5123 init: function (_v0) {
5124 return _Utils_Tuple2(impl.init, $elm$core$Platform$Cmd$none);
5125 },
5126 subscriptions: function (_v1) {
5127 return $elm$core$Platform$Sub$none;
5128 },
5129 update: F2(
5130 function (msg, model) {
5131 return _Utils_Tuple2(
5132 A2(impl.update, msg, model),
5133 $elm$core$Platform$Cmd$none);
5134 }),
5135 view: impl.view
5136 });
5137};
5138var $author$project$Main$update = F2(
5139 function (change, model) {
5140 if (change.$ === 'Times2') {
5141 return model * 2;
5142 } else {
5143 return ((model - 1) / 3) | 0;
5144 }
5145 });
5146var $elm$html$Html$div = _VirtualDom_node('div');
5147var $elm$html$Html$h1 = _VirtualDom_node('h1');
5148var $elm$html$Html$h2 = _VirtualDom_node('h2');
5149var $elm$virtual_dom$VirtualDom$style = _VirtualDom_style;
5150var $elm$html$Html$Attributes$style = $elm$virtual_dom$VirtualDom$style;
5151var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text;
5152var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text;
5153var $author$project$Main$Minus1Div3 = {$: 'Minus1Div3'};
5154var $author$project$Main$Times2 = {$: 'Times2'};
5155var $elm$html$Html$button = _VirtualDom_node('button');
5156var $elm$virtual_dom$VirtualDom$Normal = function (a) {
5157 return {$: 'Normal', a: a};
5158};
5159var $elm$virtual_dom$VirtualDom$on = _VirtualDom_on;
5160var $elm$html$Html$Events$on = F2(
5161 function (event, decoder) {
5162 return A2(
5163 $elm$virtual_dom$VirtualDom$on,
5164 event,
5165 $elm$virtual_dom$VirtualDom$Normal(decoder));
5166 });
5167var $elm$html$Html$Events$onClick = function (msg) {
5168 return A2(
5169 $elm$html$Html$Events$on,
5170 'click',
5171 $elm$json$Json$Decode$succeed(msg));
5172};
5173var $author$project$Main$validate = function (model) {
5174 return (model < 1) ? A2(
5175 $elm$html$Html$div,
5176 _List_fromArray(
5177 [
5178 A2($elm$html$Html$Attributes$style, 'color', 'red')
5179 ]),
5180 _List_fromArray(
5181 [
5182 $elm$html$Html$text('YOU MADE A BIG OOPSIE!!!!')
5183 ])) : A2(
5184 $elm$html$Html$div,
5185 _List_fromArray(
5186 [
5187 A2($elm$html$Html$Attributes$style, 'color', 'cyan')
5188 ]),
5189 _List_fromArray(
5190 [
5191 A2(
5192 $elm$html$Html$button,
5193 _List_fromArray(
5194 [
5195 A2($elm$html$Html$Attributes$style, 'color', 'orange'),
5196 $elm$html$Html$Events$onClick($author$project$Main$Times2)
5197 ]),
5198 _List_fromArray(
5199 [
5200 $elm$html$Html$text('inverse of y=x/2')
5201 ])),
5202 A2(
5203 $elm$html$Html$div,
5204 _List_Nil,
5205 _List_fromArray(
5206 [
5207 $elm$html$Html$text(
5208 $elm$core$String$fromInt(model))
5209 ])),
5210 A2(
5211 $elm$html$Html$button,
5212 _List_fromArray(
5213 [
5214 A2($elm$html$Html$Attributes$style, 'color', 'orange'),
5215 $elm$html$Html$Events$onClick($author$project$Main$Minus1Div3)
5216 ]),
5217 _List_fromArray(
5218 [
5219 $elm$html$Html$text('inverse of y=3x+1')
5220 ]))
5221 ]));
5222};
5223var $author$project$Main$view = function (model) {
5224 return A2(
5225 $elm$html$Html$div,
5226 _List_Nil,
5227 _List_fromArray(
5228 [
5229 A2(
5230 $elm$html$Html$div,
5231 _List_fromArray(
5232 [
5233 A2($elm$html$Html$Attributes$style, 'color', 'green')
5234 ]),
5235 _List_fromArray(
5236 [
5237 A2(
5238 $elm$html$Html$h1,
5239 _List_Nil,
5240 _List_fromArray(
5241 [
5242 $elm$html$Html$text('Enter Your Birthday in yy/dd/mm format')
5243 ])),
5244 A2(
5245 $elm$html$Html$h2,
5246 _List_Nil,
5247 _List_fromArray(
5248 [
5249 $elm$html$Html$text('It\'s easy! Any number is theoretically possible, assuming the Collatz conjecture...')
5250 ]))
5251 ])),
5252 $author$project$Main$validate(model)
5253 ]));
5254};
5255var $author$project$Main$main = $elm$browser$Browser$sandbox(
5256 {init: $author$project$Main$init, update: $author$project$Main$update, view: $author$project$Main$view});
5257_Platform_export({'Main':{'init':$author$project$Main$main(
5258 $elm$json$Json$Decode$succeed(_Utils_Tuple0))(0)}});}(this));
5259
5260 var app = Elm.Main.init({ node: document.getElementById("elm") });
5261}
5262catch (e)
5263{
5264 // display initialization errors (e.g. bad flags, infinite recursion)
5265 var header = document.createElement("h1");
5266 header.style.fontFamily = "monospace";
5267 header.innerText = "Initialization Error";
5268 var pre = document.getElementById("elm");
5269 document.body.insertBefore(header, pre);
5270 pre.innerText = e;
5271 throw e;
5272}
5273</script>
5274
5275</body>
5276</html>