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

Binary file not shown.

examples/counter/src/Main.elmnew file+105
@@ -0,0 +1,105 @@
1+module Main exposing (main)
2+
3+{-| Phase 2-4 verification: TEA with events.
4+Counter app with increment/decrement via tap events.
5+-}
6+
7+import Browser
8+import Lynx
9+import Lynx.Attributes as Attr
10+import Lynx.Events exposing (onTap)
11+import VirtualDom exposing (Node)
12+
13+
14+
15+-- MAIN
16+
17+
18+main : Program () Model Msg
19+main =
20+ Browser.sandbox
21+ { init = init
22+ , view = view
23+ , update = update
24+ }
25+
26+
27+
28+-- MODEL
29+
30+
31+type alias Model =
32+ { count : Int
33+ }
34+
35+
36+init : Model
37+init =
38+ { count = 0
39+ }
40+
41+
42+
43+-- UPDATE
44+
45+
46+type Msg
47+ = Increment
48+ | Decrement
49+
50+
51+update : Msg -> Model -> Model
52+update msg model =
53+ case msg of
54+ Increment ->
55+ { model | count = model.count + 1 }
56+
57+ Decrement ->
58+ { model | count = model.count - 1 }
59+
60+
61+
62+-- VIEW
63+
64+
65+view : Model -> Node Msg
66+view model =
67+ Lynx.view
68+ [ Attr.flexDirection "column"
69+ , Attr.alignItems "center"
70+ , Attr.justifyContent "center"
71+ , Attr.flex 1
72+ ]
73+ [ Lynx.view
74+ [ Attr.flexDirection "row"
75+ , Attr.alignItems "center"
76+ ]
77+ [ button Decrement "-"
78+ , Lynx.text
79+ [ Attr.fontSize 32
80+ , Attr.marginLeft 20
81+ , Attr.marginRight 20
82+ ]
83+ [ Lynx.textContent (String.fromInt model.count) ]
84+ , button Increment "+"
85+ ]
86+ ]
87+
88+
89+button : Msg -> String -> Node Msg
90+button msg label =
91+ Lynx.view
92+ [ onTap msg
93+ , Attr.backgroundColor "#4a90d9"
94+ , Attr.borderRadius 8
95+ , Attr.paddingTop 12
96+ , Attr.paddingBottom 12
97+ , Attr.paddingLeft 24
98+ , Attr.paddingRight 24
99+ ]
100+ [ Lynx.text
101+ [ Attr.color "#ffffff"
102+ , Attr.fontSize 24
103+ ]
104+ [ Lynx.textContent label ]
105+ ]
examples/hello-world/elm.jsnew file+3697
@@ -0,0 +1,3697 @@
1+(function(scope){
2+'use strict';
3+
4+function F(arity, fun, wrapper) {
5+ wrapper.a = arity;
6+ wrapper.f = fun;
7+ return wrapper;
8+}
9+
10+function F2(fun) {
11+ return F(2, fun, function(a) { return function(b) { return fun(a,b); }; })
12+}
13+function F3(fun) {
14+ return F(3, fun, function(a) {
15+ return function(b) { return function(c) { return fun(a, b, c); }; };
16+ });
17+}
18+function F4(fun) {
19+ return F(4, fun, function(a) { return function(b) { return function(c) {
20+ return function(d) { return fun(a, b, c, d); }; }; };
21+ });
22+}
23+function F5(fun) {
24+ return F(5, fun, function(a) { return function(b) { return function(c) {
25+ return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };
26+ });
27+}
28+function F6(fun) {
29+ return F(6, fun, function(a) { return function(b) { return function(c) {
30+ return function(d) { return function(e) { return function(f) {
31+ return fun(a, b, c, d, e, f); }; }; }; }; };
32+ });
33+}
34+function F7(fun) {
35+ return F(7, fun, function(a) { return function(b) { return function(c) {
36+ return function(d) { return function(e) { return function(f) {
37+ return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };
38+ });
39+}
40+function F8(fun) {
41+ return F(8, fun, function(a) { return function(b) { return function(c) {
42+ return function(d) { return function(e) { return function(f) {
43+ return function(g) { return function(h) {
44+ return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };
45+ });
46+}
47+function F9(fun) {
48+ return F(9, fun, function(a) { return function(b) { return function(c) {
49+ return function(d) { return function(e) { return function(f) {
50+ return function(g) { return function(h) { return function(i) {
51+ return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };
52+ });
53+}
54+
55+function A2(fun, a, b) {
56+ return fun.a === 2 ? fun.f(a, b) : fun(a)(b);
57+}
58+function A3(fun, a, b, c) {
59+ return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c);
60+}
61+function A4(fun, a, b, c, d) {
62+ return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d);
63+}
64+function A5(fun, a, b, c, d, e) {
65+ return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e);
66+}
67+function A6(fun, a, b, c, d, e, f) {
68+ return fun.a === 6 ? fun.f(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f);
69+}
70+function A7(fun, a, b, c, d, e, f, g) {
71+ return fun.a === 7 ? fun.f(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g);
72+}
73+function A8(fun, a, b, c, d, e, f, g, h) {
74+ return fun.a === 8 ? fun.f(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h);
75+}
76+function A9(fun, a, b, c, d, e, f, g, h, i) {
77+ return fun.a === 9 ? fun.f(a, b, c, d, e, f, g, h, i) : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
78+}
79+
80+console.warn('Compiled in DEV mode. Follow the advice at https://elm-lang.org/0.19.1/optimize for better performance and smaller assets.');
81+
82+
83+var _JsArray_empty = [];
84+
85+function _JsArray_singleton(value)
86+{
87+ return [value];
88+}
89+
90+function _JsArray_length(array)
91+{
92+ return array.length;
93+}
94+
95+var _JsArray_initialize = F3(function(size, offset, func)
96+{
97+ var result = new Array(size);
98+
99+ for (var i = 0; i < size; i++)
100+ {
101+ result[i] = func(offset + i);
102+ }
103+
104+ return result;
105+});
106+
107+var _JsArray_initializeFromList = F2(function (max, ls)
108+{
109+ var result = new Array(max);
110+
111+ for (var i = 0; i < max && ls.b; i++)
112+ {
113+ result[i] = ls.a;
114+ ls = ls.b;
115+ }
116+
117+ result.length = i;
118+ return _Utils_Tuple2(result, ls);
119+});
120+
121+var _JsArray_unsafeGet = F2(function(index, array)
122+{
123+ return array[index];
124+});
125+
126+var _JsArray_unsafeSet = F3(function(index, value, array)
127+{
128+ var length = array.length;
129+ var result = new Array(length);
130+
131+ for (var i = 0; i < length; i++)
132+ {
133+ result[i] = array[i];
134+ }
135+
136+ result[index] = value;
137+ return result;
138+});
139+
140+var _JsArray_push = F2(function(value, array)
141+{
142+ var length = array.length;
143+ var result = new Array(length + 1);
144+
145+ for (var i = 0; i < length; i++)
146+ {
147+ result[i] = array[i];
148+ }
149+
150+ result[length] = value;
151+ return result;
152+});
153+
154+var _JsArray_foldl = F3(function(func, acc, array)
155+{
156+ var length = array.length;
157+
158+ for (var i = 0; i < length; i++)
159+ {
160+ acc = A2(func, array[i], acc);
161+ }
162+
163+ return acc;
164+});
165+
166+var _JsArray_foldr = F3(function(func, acc, array)
167+{
168+ for (var i = array.length - 1; i >= 0; i--)
169+ {
170+ acc = A2(func, array[i], acc);
171+ }
172+
173+ return acc;
174+});
175+
176+var _JsArray_map = F2(function(func, array)
177+{
178+ var length = array.length;
179+ var result = new Array(length);
180+
181+ for (var i = 0; i < length; i++)
182+ {
183+ result[i] = func(array[i]);
184+ }
185+
186+ return result;
187+});
188+
189+var _JsArray_indexedMap = F3(function(func, offset, array)
190+{
191+ var length = array.length;
192+ var result = new Array(length);
193+
194+ for (var i = 0; i < length; i++)
195+ {
196+ result[i] = A2(func, offset + i, array[i]);
197+ }
198+
199+ return result;
200+});
201+
202+var _JsArray_slice = F3(function(from, to, array)
203+{
204+ return array.slice(from, to);
205+});
206+
207+var _JsArray_appendN = F3(function(n, dest, source)
208+{
209+ var destLen = dest.length;
210+ var itemsToCopy = n - destLen;
211+
212+ if (itemsToCopy > source.length)
213+ {
214+ itemsToCopy = source.length;
215+ }
216+
217+ var size = destLen + itemsToCopy;
218+ var result = new Array(size);
219+
220+ for (var i = 0; i < destLen; i++)
221+ {
222+ result[i] = dest[i];
223+ }
224+
225+ for (var i = 0; i < itemsToCopy; i++)
226+ {
227+ result[i + destLen] = source[i];
228+ }
229+
230+ return result;
231+});
232+
233+
234+
235+// LOG
236+
237+var _Debug_log_UNUSED = F2(function(tag, value)
238+{
239+ return value;
240+});
241+
242+var _Debug_log = F2(function(tag, value)
243+{
244+ console.log(tag + ': ' + _Debug_toString(value));
245+ return value;
246+});
247+
248+
249+// TODOS
250+
251+function _Debug_todo(moduleName, region)
252+{
253+ return function(message) {
254+ _Debug_crash(8, moduleName, region, message);
255+ };
256+}
257+
258+function _Debug_todoCase(moduleName, region, value)
259+{
260+ return function(message) {
261+ _Debug_crash(9, moduleName, region, value, message);
262+ };
263+}
264+
265+
266+// TO STRING
267+
268+function _Debug_toString_UNUSED(value)
269+{
270+ return '<internals>';
271+}
272+
273+function _Debug_toString(value)
274+{
275+ return _Debug_toAnsiString(false, value);
276+}
277+
278+function _Debug_toAnsiString(ansi, value)
279+{
280+ if (typeof value === 'function')
281+ {
282+ return _Debug_internalColor(ansi, '<function>');
283+ }
284+
285+ if (typeof value === 'boolean')
286+ {
287+ return _Debug_ctorColor(ansi, value ? 'True' : 'False');
288+ }
289+
290+ if (typeof value === 'number')
291+ {
292+ return _Debug_numberColor(ansi, value + '');
293+ }
294+
295+ if (value instanceof String)
296+ {
297+ return _Debug_charColor(ansi, "'" + _Debug_addSlashes(value, true) + "'");
298+ }
299+
300+ if (typeof value === 'string')
301+ {
302+ return _Debug_stringColor(ansi, '"' + _Debug_addSlashes(value, false) + '"');
303+ }
304+
305+ if (typeof value === 'object' && '$' in value)
306+ {
307+ var tag = value.$;
308+
309+ if (typeof tag === 'number')
310+ {
311+ return _Debug_internalColor(ansi, '<internals>');
312+ }
313+
314+ if (tag[0] === '#')
315+ {
316+ var output = [];
317+ for (var k in value)
318+ {
319+ if (k === '$') continue;
320+ output.push(_Debug_toAnsiString(ansi, value[k]));
321+ }
322+ return '(' + output.join(',') + ')';
323+ }
324+
325+ if (tag === 'Set_elm_builtin')
326+ {
327+ return _Debug_ctorColor(ansi, 'Set')
328+ + _Debug_fadeColor(ansi, '.fromList') + ' '
329+ + _Debug_toAnsiString(ansi, $elm$core$Set$toList(value));
330+ }
331+
332+ if (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin')
333+ {
334+ return _Debug_ctorColor(ansi, 'Dict')
335+ + _Debug_fadeColor(ansi, '.fromList') + ' '
336+ + _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value));
337+ }
338+
339+ if (tag === 'Array_elm_builtin')
340+ {
341+ return _Debug_ctorColor(ansi, 'Array')
342+ + _Debug_fadeColor(ansi, '.fromList') + ' '
343+ + _Debug_toAnsiString(ansi, $elm$core$Array$toList(value));
344+ }
345+
346+ if (tag === '::' || tag === '[]')
347+ {
348+ var output = '[';
349+
350+ value.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b)
351+
352+ for (; value.b; value = value.b) // WHILE_CONS
353+ {
354+ output += ',' + _Debug_toAnsiString(ansi, value.a);
355+ }
356+ return output + ']';
357+ }
358+
359+ var output = '';
360+ for (var i in value)
361+ {
362+ if (i === '$') continue;
363+ var str = _Debug_toAnsiString(ansi, value[i]);
364+ var c0 = str[0];
365+ var parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
366+ output += ' ' + (parenless ? str : '(' + str + ')');
367+ }
368+ return _Debug_ctorColor(ansi, tag) + output;
369+ }
370+
371+ if (typeof DataView === 'function' && value instanceof DataView)
372+ {
373+ return _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>');
374+ }
375+
376+ if (typeof File !== 'undefined' && value instanceof File)
377+ {
378+ return _Debug_internalColor(ansi, '<' + value.name + '>');
379+ }
380+
381+ if (typeof value === 'object')
382+ {
383+ var output = [];
384+ for (var key in value)
385+ {
386+ var field = key[0] === '_' ? key.slice(1) : key;
387+ output.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key]));
388+ }
389+ if (output.length === 0)
390+ {
391+ return '{}';
392+ }
393+ return '{ ' + output.join(', ') + ' }';
394+ }
395+
396+ return _Debug_internalColor(ansi, '<internals>');
397+}
398+
399+function _Debug_addSlashes(str, isChar)
400+{
401+ var s = str
402+ .replace(/\\/g, '\\\\')
403+ .replace(/\n/g, '\\n')
404+ .replace(/\t/g, '\\t')
405+ .replace(/\r/g, '\\r')
406+ .replace(/\v/g, '\\v')
407+ .replace(/\0/g, '\\0');
408+
409+ if (isChar)
410+ {
411+ return s.replace(/\'/g, '\\\'');
412+ }
413+ else
414+ {
415+ return s.replace(/\"/g, '\\"');
416+ }
417+}
418+
419+function _Debug_ctorColor(ansi, string)
420+{
421+ return ansi ? '\x1b[96m' + string + '\x1b[0m' : string;
422+}
423+
424+function _Debug_numberColor(ansi, string)
425+{
426+ return ansi ? '\x1b[95m' + string + '\x1b[0m' : string;
427+}
428+
429+function _Debug_stringColor(ansi, string)
430+{
431+ return ansi ? '\x1b[93m' + string + '\x1b[0m' : string;
432+}
433+
434+function _Debug_charColor(ansi, string)
435+{
436+ return ansi ? '\x1b[92m' + string + '\x1b[0m' : string;
437+}
438+
439+function _Debug_fadeColor(ansi, string)
440+{
441+ return ansi ? '\x1b[37m' + string + '\x1b[0m' : string;
442+}
443+
444+function _Debug_internalColor(ansi, string)
445+{
446+ return ansi ? '\x1b[36m' + string + '\x1b[0m' : string;
447+}
448+
449+function _Debug_toHexDigit(n)
450+{
451+ return String.fromCharCode(n < 10 ? 48 + n : 55 + n);
452+}
453+
454+
455+// CRASH
456+
457+
458+function _Debug_crash_UNUSED(identifier)
459+{
460+ throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');
461+}
462+
463+
464+function _Debug_crash(identifier, fact1, fact2, fact3, fact4)
465+{
466+ switch(identifier)
467+ {
468+ case 0:
469+ 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.');
470+
471+ case 1:
472+ 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.');
473+
474+ case 2:
475+ var jsonErrorString = fact1;
476+ throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString);
477+
478+ case 3:
479+ var portName = fact1;
480+ throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.');
481+
482+ case 4:
483+ var portName = fact1;
484+ var problem = fact2;
485+ throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem);
486+
487+ case 5:
488+ 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.');
489+
490+ case 6:
491+ var moduleName = fact1;
492+ 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!');
493+
494+ case 8:
495+ var moduleName = fact1;
496+ var region = fact2;
497+ var message = fact3;
498+ throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message);
499+
500+ case 9:
501+ var moduleName = fact1;
502+ var region = fact2;
503+ var value = fact3;
504+ var message = fact4;
505+ throw new Error(
506+ 'TODO in module `' + moduleName + '` from the `case` expression '
507+ + _Debug_regionToString(region) + '\n\nIt received the following value:\n\n '
508+ + _Debug_toString(value).replace('\n', '\n ')
509+ + '\n\nBut the branch that handles it says:\n\n ' + message.replace('\n', '\n ')
510+ );
511+
512+ case 10:
513+ throw new Error('Bug in https://github.com/elm/virtual-dom/issues');
514+
515+ case 11:
516+ throw new Error('Cannot perform mod 0. Division by zero error.');
517+ }
518+}
519+
520+function _Debug_regionToString(region)
521+{
522+ if (region.start.line === region.end.line)
523+ {
524+ return 'on line ' + region.start.line;
525+ }
526+ return 'on lines ' + region.start.line + ' through ' + region.end.line;
527+}
528+
529+
530+
531+// EQUALITY
532+
533+function _Utils_eq(x, y)
534+{
535+ for (
536+ var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);
537+ isEqual && (pair = stack.pop());
538+ isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack)
539+ )
540+ {}
541+
542+ return isEqual;
543+}
544+
545+function _Utils_eqHelp(x, y, depth, stack)
546+{
547+ if (x === y)
548+ {
549+ return true;
550+ }
551+
552+ if (typeof x !== 'object' || x === null || y === null)
553+ {
554+ typeof x === 'function' && _Debug_crash(5);
555+ return false;
556+ }
557+
558+ if (depth > 100)
559+ {
560+ stack.push(_Utils_Tuple2(x,y));
561+ return true;
562+ }
563+
564+ /**/
565+ if (x.$ === 'Set_elm_builtin')
566+ {
567+ x = $elm$core$Set$toList(x);
568+ y = $elm$core$Set$toList(y);
569+ }
570+ if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')
571+ {
572+ x = $elm$core$Dict$toList(x);
573+ y = $elm$core$Dict$toList(y);
574+ }
575+ //*/
576+
577+ /**_UNUSED/
578+ if (x.$ < 0)
579+ {
580+ x = $elm$core$Dict$toList(x);
581+ y = $elm$core$Dict$toList(y);
582+ }
583+ //*/
584+
585+ for (var key in x)
586+ {
587+ if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))
588+ {
589+ return false;
590+ }
591+ }
592+ return true;
593+}
594+
595+var _Utils_equal = F2(_Utils_eq);
596+var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); });
597+
598+
599+
600+// COMPARISONS
601+
602+// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
603+// the particular integer values assigned to LT, EQ, and GT.
604+
605+function _Utils_cmp(x, y, ord)
606+{
607+ if (typeof x !== 'object')
608+ {
609+ return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1;
610+ }
611+
612+ /**/
613+ if (x instanceof String)
614+ {
615+ var a = x.valueOf();
616+ var b = y.valueOf();
617+ return a === b ? 0 : a < b ? -1 : 1;
618+ }
619+ //*/
620+
621+ /**_UNUSED/
622+ if (typeof x.$ === 'undefined')
623+ //*/
624+ /**/
625+ if (x.$[0] === '#')
626+ //*/
627+ {
628+ return (ord = _Utils_cmp(x.a, y.a))
629+ ? ord
630+ : (ord = _Utils_cmp(x.b, y.b))
631+ ? ord
632+ : _Utils_cmp(x.c, y.c);
633+ }
634+
635+ // traverse conses until end of a list or a mismatch
636+ for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES
637+ return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);
638+}
639+
640+var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; });
641+var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; });
642+var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; });
643+var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; });
644+
645+var _Utils_compare = F2(function(x, y)
646+{
647+ var n = _Utils_cmp(x, y);
648+ return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ;
649+});
650+
651+
652+// COMMON VALUES
653+
654+var _Utils_Tuple0_UNUSED = 0;
655+var _Utils_Tuple0 = { $: '#0' };
656+
657+function _Utils_Tuple2_UNUSED(a, b) { return { a: a, b: b }; }
658+function _Utils_Tuple2(a, b) { return { $: '#2', a: a, b: b }; }
659+
660+function _Utils_Tuple3_UNUSED(a, b, c) { return { a: a, b: b, c: c }; }
661+function _Utils_Tuple3(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }
662+
663+function _Utils_chr_UNUSED(c) { return c; }
664+function _Utils_chr(c) { return new String(c); }
665+
666+
667+// RECORDS
668+
669+function _Utils_update(oldRecord, updatedFields)
670+{
671+ var newRecord = {};
672+
673+ for (var key in oldRecord)
674+ {
675+ newRecord[key] = oldRecord[key];
676+ }
677+
678+ for (var key in updatedFields)
679+ {
680+ newRecord[key] = updatedFields[key];
681+ }
682+
683+ return newRecord;
684+}
685+
686+
687+// APPEND
688+
689+var _Utils_append = F2(_Utils_ap);
690+
691+function _Utils_ap(xs, ys)
692+{
693+ // append Strings
694+ if (typeof xs === 'string')
695+ {
696+ return xs + ys;
697+ }
698+
699+ // append Lists
700+ if (!xs.b)
701+ {
702+ return ys;
703+ }
704+ var root = _List_Cons(xs.a, ys);
705+ xs = xs.b
706+ for (var curr = root; xs.b; xs = xs.b) // WHILE_CONS
707+ {
708+ curr = curr.b = _List_Cons(xs.a, ys);
709+ }
710+ return root;
711+}
712+
713+
714+
715+var _List_Nil_UNUSED = { $: 0 };
716+var _List_Nil = { $: '[]' };
717+
718+function _List_Cons_UNUSED(hd, tl) { return { $: 1, a: hd, b: tl }; }
719+function _List_Cons(hd, tl) { return { $: '::', a: hd, b: tl }; }
720+
721+
722+var _List_cons = F2(_List_Cons);
723+
724+function _List_fromArray(arr)
725+{
726+ var out = _List_Nil;
727+ for (var i = arr.length; i--; )
728+ {
729+ out = _List_Cons(arr[i], out);
730+ }
731+ return out;
732+}
733+
734+function _List_toArray(xs)
735+{
736+ for (var out = []; xs.b; xs = xs.b) // WHILE_CONS
737+ {
738+ out.push(xs.a);
739+ }
740+ return out;
741+}
742+
743+var _List_map2 = F3(function(f, xs, ys)
744+{
745+ for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES
746+ {
747+ arr.push(A2(f, xs.a, ys.a));
748+ }
749+ return _List_fromArray(arr);
750+});
751+
752+var _List_map3 = F4(function(f, xs, ys, zs)
753+{
754+ for (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
755+ {
756+ arr.push(A3(f, xs.a, ys.a, zs.a));
757+ }
758+ return _List_fromArray(arr);
759+});
760+
761+var _List_map4 = F5(function(f, ws, xs, ys, zs)
762+{
763+ 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
764+ {
765+ arr.push(A4(f, ws.a, xs.a, ys.a, zs.a));
766+ }
767+ return _List_fromArray(arr);
768+});
769+
770+var _List_map5 = F6(function(f, vs, ws, xs, ys, zs)
771+{
772+ 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
773+ {
774+ arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a));
775+ }
776+ return _List_fromArray(arr);
777+});
778+
779+var _List_sortBy = F2(function(f, xs)
780+{
781+ return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
782+ return _Utils_cmp(f(a), f(b));
783+ }));
784+});
785+
786+var _List_sortWith = F2(function(f, xs)
787+{
788+ return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
789+ var ord = A2(f, a, b);
790+ return ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1;
791+ }));
792+});
793+
794+
795+
796+// MATH
797+
798+var _Basics_add = F2(function(a, b) { return a + b; });
799+var _Basics_sub = F2(function(a, b) { return a - b; });
800+var _Basics_mul = F2(function(a, b) { return a * b; });
801+var _Basics_fdiv = F2(function(a, b) { return a / b; });
802+var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; });
803+var _Basics_pow = F2(Math.pow);
804+
805+var _Basics_remainderBy = F2(function(b, a) { return a % b; });
806+
807+// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
808+var _Basics_modBy = F2(function(modulus, x)
809+{
810+ var answer = x % modulus;
811+ return modulus === 0
812+ ? _Debug_crash(11)
813+ :
814+ ((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0))
815+ ? answer + modulus
816+ : answer;
817+});
818+
819+
820+// TRIGONOMETRY
821+
822+var _Basics_pi = Math.PI;
823+var _Basics_e = Math.E;
824+var _Basics_cos = Math.cos;
825+var _Basics_sin = Math.sin;
826+var _Basics_tan = Math.tan;
827+var _Basics_acos = Math.acos;
828+var _Basics_asin = Math.asin;
829+var _Basics_atan = Math.atan;
830+var _Basics_atan2 = F2(Math.atan2);
831+
832+
833+// MORE MATH
834+
835+function _Basics_toFloat(x) { return x; }
836+function _Basics_truncate(n) { return n | 0; }
837+function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; }
838+
839+var _Basics_ceiling = Math.ceil;
840+var _Basics_floor = Math.floor;
841+var _Basics_round = Math.round;
842+var _Basics_sqrt = Math.sqrt;
843+var _Basics_log = Math.log;
844+var _Basics_isNaN = isNaN;
845+
846+
847+// BOOLEANS
848+
849+function _Basics_not(bool) { return !bool; }
850+var _Basics_and = F2(function(a, b) { return a && b; });
851+var _Basics_or = F2(function(a, b) { return a || b; });
852+var _Basics_xor = F2(function(a, b) { return a !== b; });
853+
854+
855+
856+var _String_cons = F2(function(chr, str)
857+{
858+ return chr + str;
859+});
860+
861+function _String_uncons(string)
862+{
863+ var word = string.charCodeAt(0);
864+ return !isNaN(word)
865+ ? $elm$core$Maybe$Just(
866+ 0xD800 <= word && word <= 0xDBFF
867+ ? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))
868+ : _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))
869+ )
870+ : $elm$core$Maybe$Nothing;
871+}
872+
873+var _String_append = F2(function(a, b)
874+{
875+ return a + b;
876+});
877+
878+function _String_length(str)
879+{
880+ return str.length;
881+}
882+
883+var _String_map = F2(function(func, string)
884+{
885+ var len = string.length;
886+ var array = new Array(len);
887+ var i = 0;
888+ while (i < len)
889+ {
890+ var word = string.charCodeAt(i);
891+ if (0xD800 <= word && word <= 0xDBFF)
892+ {
893+ array[i] = func(_Utils_chr(string[i] + string[i+1]));
894+ i += 2;
895+ continue;
896+ }
897+ array[i] = func(_Utils_chr(string[i]));
898+ i++;
899+ }
900+ return array.join('');
901+});
902+
903+var _String_filter = F2(function(isGood, str)
904+{
905+ var arr = [];
906+ var len = str.length;
907+ var i = 0;
908+ while (i < len)
909+ {
910+ var char = str[i];
911+ var word = str.charCodeAt(i);
912+ i++;
913+ if (0xD800 <= word && word <= 0xDBFF)
914+ {
915+ char += str[i];
916+ i++;
917+ }
918+
919+ if (isGood(_Utils_chr(char)))
920+ {
921+ arr.push(char);
922+ }
923+ }
924+ return arr.join('');
925+});
926+
927+function _String_reverse(str)
928+{
929+ var len = str.length;
930+ var arr = new Array(len);
931+ var i = 0;
932+ while (i < len)
933+ {
934+ var word = str.charCodeAt(i);
935+ if (0xD800 <= word && word <= 0xDBFF)
936+ {
937+ arr[len - i] = str[i + 1];
938+ i++;
939+ arr[len - i] = str[i - 1];
940+ i++;
941+ }
942+ else
943+ {
944+ arr[len - i] = str[i];
945+ i++;
946+ }
947+ }
948+ return arr.join('');
949+}
950+
951+var _String_foldl = F3(function(func, state, string)
952+{
953+ var len = string.length;
954+ var i = 0;
955+ while (i < len)
956+ {
957+ var char = string[i];
958+ var word = string.charCodeAt(i);
959+ i++;
960+ if (0xD800 <= word && word <= 0xDBFF)
961+ {
962+ char += string[i];
963+ i++;
964+ }
965+ state = A2(func, _Utils_chr(char), state);
966+ }
967+ return state;
968+});
969+
970+var _String_foldr = F3(function(func, state, string)
971+{
972+ var i = string.length;
973+ while (i--)
974+ {
975+ var char = string[i];
976+ var word = string.charCodeAt(i);
977+ if (0xDC00 <= word && word <= 0xDFFF)
978+ {
979+ i--;
980+ char = string[i] + char;
981+ }
982+ state = A2(func, _Utils_chr(char), state);
983+ }
984+ return state;
985+});
986+
987+var _String_split = F2(function(sep, str)
988+{
989+ return str.split(sep);
990+});
991+
992+var _String_join = F2(function(sep, strs)
993+{
994+ return strs.join(sep);
995+});
996+
997+var _String_slice = F3(function(start, end, str) {
998+ return str.slice(start, end);
999+});
1000+
1001+function _String_trim(str)
1002+{
1003+ return str.trim();
1004+}
1005+
1006+function _String_trimLeft(str)
1007+{
1008+ return str.replace(/^\s+/, '');
1009+}
1010+
1011+function _String_trimRight(str)
1012+{
1013+ return str.replace(/\s+$/, '');
1014+}
1015+
1016+function _String_words(str)
1017+{
1018+ return _List_fromArray(str.trim().split(/\s+/g));
1019+}
1020+
1021+function _String_lines(str)
1022+{
1023+ return _List_fromArray(str.split(/\r\n|\r|\n/g));
1024+}
1025+
1026+function _String_toUpper(str)
1027+{
1028+ return str.toUpperCase();
1029+}
1030+
1031+function _String_toLower(str)
1032+{
1033+ return str.toLowerCase();
1034+}
1035+
1036+var _String_any = F2(function(isGood, string)
1037+{
1038+ var i = string.length;
1039+ while (i--)
1040+ {
1041+ var char = string[i];
1042+ var word = string.charCodeAt(i);
1043+ if (0xDC00 <= word && word <= 0xDFFF)
1044+ {
1045+ i--;
1046+ char = string[i] + char;
1047+ }
1048+ if (isGood(_Utils_chr(char)))
1049+ {
1050+ return true;
1051+ }
1052+ }
1053+ return false;
1054+});
1055+
1056+var _String_all = F2(function(isGood, string)
1057+{
1058+ var i = string.length;
1059+ while (i--)
1060+ {
1061+ var char = string[i];
1062+ var word = string.charCodeAt(i);
1063+ if (0xDC00 <= word && word <= 0xDFFF)
1064+ {
1065+ i--;
1066+ char = string[i] + char;
1067+ }
1068+ if (!isGood(_Utils_chr(char)))
1069+ {
1070+ return false;
1071+ }
1072+ }
1073+ return true;
1074+});
1075+
1076+var _String_contains = F2(function(sub, str)
1077+{
1078+ return str.indexOf(sub) > -1;
1079+});
1080+
1081+var _String_startsWith = F2(function(sub, str)
1082+{
1083+ return str.indexOf(sub) === 0;
1084+});
1085+
1086+var _String_endsWith = F2(function(sub, str)
1087+{
1088+ return str.length >= sub.length &&
1089+ str.lastIndexOf(sub) === str.length - sub.length;
1090+});
1091+
1092+var _String_indexes = F2(function(sub, str)
1093+{
1094+ var subLen = sub.length;
1095+
1096+ if (subLen < 1)
1097+ {
1098+ return _List_Nil;
1099+ }
1100+
1101+ var i = 0;
1102+ var is = [];
1103+
1104+ while ((i = str.indexOf(sub, i)) > -1)
1105+ {
1106+ is.push(i);
1107+ i = i + subLen;
1108+ }
1109+
1110+ return _List_fromArray(is);
1111+});
1112+
1113+
1114+// TO STRING
1115+
1116+function _String_fromNumber(number)
1117+{
1118+ return number + '';
1119+}
1120+
1121+
1122+// INT CONVERSIONS
1123+
1124+function _String_toInt(str)
1125+{
1126+ var total = 0;
1127+ var code0 = str.charCodeAt(0);
1128+ var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;
1129+
1130+ for (var i = start; i < str.length; ++i)
1131+ {
1132+ var code = str.charCodeAt(i);
1133+ if (code < 0x30 || 0x39 < code)
1134+ {
1135+ return $elm$core$Maybe$Nothing;
1136+ }
1137+ total = 10 * total + code - 0x30;
1138+ }
1139+
1140+ return i == start
1141+ ? $elm$core$Maybe$Nothing
1142+ : $elm$core$Maybe$Just(code0 == 0x2D ? -total : total);
1143+}
1144+
1145+
1146+// FLOAT CONVERSIONS
1147+
1148+function _String_toFloat(s)
1149+{
1150+ // check if it is a hex, octal, or binary number
1151+ if (s.length === 0 || /[\sxbo]/.test(s))
1152+ {
1153+ return $elm$core$Maybe$Nothing;
1154+ }
1155+ var n = +s;
1156+ // faster isNaN check
1157+ return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing;
1158+}
1159+
1160+function _String_fromList(chars)
1161+{
1162+ return _List_toArray(chars).join('');
1163+}
1164+
1165+
1166+
1167+
1168+function _Char_toCode(char)
1169+{
1170+ var code = char.charCodeAt(0);
1171+ if (0xD800 <= code && code <= 0xDBFF)
1172+ {
1173+ return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000
1174+ }
1175+ return code;
1176+}
1177+
1178+function _Char_fromCode(code)
1179+{
1180+ return _Utils_chr(
1181+ (code < 0 || 0x10FFFF < code)
1182+ ? '\uFFFD'
1183+ :
1184+ (code <= 0xFFFF)
1185+ ? String.fromCharCode(code)
1186+ :
1187+ (code -= 0x10000,
1188+ String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)
1189+ )
1190+ );
1191+}
1192+
1193+function _Char_toUpper(char)
1194+{
1195+ return _Utils_chr(char.toUpperCase());
1196+}
1197+
1198+function _Char_toLower(char)
1199+{
1200+ return _Utils_chr(char.toLowerCase());
1201+}
1202+
1203+function _Char_toLocaleUpper(char)
1204+{
1205+ return _Utils_chr(char.toLocaleUpperCase());
1206+}
1207+
1208+function _Char_toLocaleLower(char)
1209+{
1210+ return _Utils_chr(char.toLocaleLowerCase());
1211+}
1212+
1213+
1214+
1215+/**/
1216+function _Json_errorToString(error)
1217+{
1218+ return $elm$json$Json$Decode$errorToString(error);
1219+}
1220+//*/
1221+
1222+
1223+// CORE DECODERS
1224+
1225+function _Json_succeed(msg)
1226+{
1227+ return {
1228+ $: 0,
1229+ a: msg
1230+ };
1231+}
1232+
1233+function _Json_fail(msg)
1234+{
1235+ return {
1236+ $: 1,
1237+ a: msg
1238+ };
1239+}
1240+
1241+function _Json_decodePrim(decoder)
1242+{
1243+ return { $: 2, b: decoder };
1244+}
1245+
1246+var _Json_decodeInt = _Json_decodePrim(function(value) {
1247+ return (typeof value !== 'number')
1248+ ? _Json_expecting('an INT', value)
1249+ :
1250+ (-2147483647 < value && value < 2147483647 && (value | 0) === value)
1251+ ? $elm$core$Result$Ok(value)
1252+ :
1253+ (isFinite(value) && !(value % 1))
1254+ ? $elm$core$Result$Ok(value)
1255+ : _Json_expecting('an INT', value);
1256+});
1257+
1258+var _Json_decodeBool = _Json_decodePrim(function(value) {
1259+ return (typeof value === 'boolean')
1260+ ? $elm$core$Result$Ok(value)
1261+ : _Json_expecting('a BOOL', value);
1262+});
1263+
1264+var _Json_decodeFloat = _Json_decodePrim(function(value) {
1265+ return (typeof value === 'number')
1266+ ? $elm$core$Result$Ok(value)
1267+ : _Json_expecting('a FLOAT', value);
1268+});
1269+
1270+var _Json_decodeValue = _Json_decodePrim(function(value) {
1271+ return $elm$core$Result$Ok(_Json_wrap(value));
1272+});
1273+
1274+var _Json_decodeString = _Json_decodePrim(function(value) {
1275+ return (typeof value === 'string')
1276+ ? $elm$core$Result$Ok(value)
1277+ : (value instanceof String)
1278+ ? $elm$core$Result$Ok(value + '')
1279+ : _Json_expecting('a STRING', value);
1280+});
1281+
1282+function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }
1283+function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }
1284+
1285+function _Json_decodeNull(value) { return { $: 5, c: value }; }
1286+
1287+var _Json_decodeField = F2(function(field, decoder)
1288+{
1289+ return {
1290+ $: 6,
1291+ d: field,
1292+ b: decoder
1293+ };
1294+});
1295+
1296+var _Json_decodeIndex = F2(function(index, decoder)
1297+{
1298+ return {
1299+ $: 7,
1300+ e: index,
1301+ b: decoder
1302+ };
1303+});
1304+
1305+function _Json_decodeKeyValuePairs(decoder)
1306+{
1307+ return {
1308+ $: 8,
1309+ b: decoder
1310+ };
1311+}
1312+
1313+function _Json_mapMany(f, decoders)
1314+{
1315+ return {
1316+ $: 9,
1317+ f: f,
1318+ g: decoders
1319+ };
1320+}
1321+
1322+var _Json_andThen = F2(function(callback, decoder)
1323+{
1324+ return {
1325+ $: 10,
1326+ b: decoder,
1327+ h: callback
1328+ };
1329+});
1330+
1331+function _Json_oneOf(decoders)
1332+{
1333+ return {
1334+ $: 11,
1335+ g: decoders
1336+ };
1337+}
1338+
1339+
1340+// DECODING OBJECTS
1341+
1342+var _Json_map1 = F2(function(f, d1)
1343+{
1344+ return _Json_mapMany(f, [d1]);
1345+});
1346+
1347+var _Json_map2 = F3(function(f, d1, d2)
1348+{
1349+ return _Json_mapMany(f, [d1, d2]);
1350+});
1351+
1352+var _Json_map3 = F4(function(f, d1, d2, d3)
1353+{
1354+ return _Json_mapMany(f, [d1, d2, d3]);
1355+});
1356+
1357+var _Json_map4 = F5(function(f, d1, d2, d3, d4)
1358+{
1359+ return _Json_mapMany(f, [d1, d2, d3, d4]);
1360+});
1361+
1362+var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)
1363+{
1364+ return _Json_mapMany(f, [d1, d2, d3, d4, d5]);
1365+});
1366+
1367+var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)
1368+{
1369+ return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);
1370+});
1371+
1372+var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)
1373+{
1374+ return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
1375+});
1376+
1377+var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)
1378+{
1379+ return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
1380+});
1381+
1382+
1383+// DECODE
1384+
1385+var _Json_runOnString = F2(function(decoder, string)
1386+{
1387+ try
1388+ {
1389+ var value = JSON.parse(string);
1390+ return _Json_runHelp(decoder, value);
1391+ }
1392+ catch (e)
1393+ {
1394+ return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string)));
1395+ }
1396+});
1397+
1398+var _Json_run = F2(function(decoder, value)
1399+{
1400+ return _Json_runHelp(decoder, _Json_unwrap(value));
1401+});
1402+
1403+function _Json_runHelp(decoder, value)
1404+{
1405+ switch (decoder.$)
1406+ {
1407+ case 2:
1408+ return decoder.b(value);
1409+
1410+ case 5:
1411+ return (value === null)
1412+ ? $elm$core$Result$Ok(decoder.c)
1413+ : _Json_expecting('null', value);
1414+
1415+ case 3:
1416+ if (!_Json_isArray(value))
1417+ {
1418+ return _Json_expecting('a LIST', value);
1419+ }
1420+ return _Json_runArrayDecoder(decoder.b, value, _List_fromArray);
1421+
1422+ case 4:
1423+ if (!_Json_isArray(value))
1424+ {
1425+ return _Json_expecting('an ARRAY', value);
1426+ }
1427+ return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);
1428+
1429+ case 6:
1430+ var field = decoder.d;
1431+ if (typeof value !== 'object' || value === null || !(field in value))
1432+ {
1433+ return _Json_expecting('an OBJECT with a field named `' + field + '`', value);
1434+ }
1435+ var result = _Json_runHelp(decoder.b, value[field]);
1436+ return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a));
1437+
1438+ case 7:
1439+ var index = decoder.e;
1440+ if (!_Json_isArray(value))
1441+ {
1442+ return _Json_expecting('an ARRAY', value);
1443+ }
1444+ if (index >= value.length)
1445+ {
1446+ return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);
1447+ }
1448+ var result = _Json_runHelp(decoder.b, value[index]);
1449+ return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a));
1450+
1451+ case 8:
1452+ if (typeof value !== 'object' || value === null || _Json_isArray(value))
1453+ {
1454+ return _Json_expecting('an OBJECT', value);
1455+ }
1456+
1457+ var keyValuePairs = _List_Nil;
1458+ // TODO test perf of Object.keys and switch when support is good enough
1459+ for (var key in value)
1460+ {
1461+ if (value.hasOwnProperty(key))
1462+ {
1463+ var result = _Json_runHelp(decoder.b, value[key]);
1464+ if (!$elm$core$Result$isOk(result))
1465+ {
1466+ return $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a));
1467+ }
1468+ keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);
1469+ }
1470+ }
1471+ return $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs));
1472+
1473+ case 9:
1474+ var answer = decoder.f;
1475+ var decoders = decoder.g;
1476+ for (var i = 0; i < decoders.length; i++)
1477+ {
1478+ var result = _Json_runHelp(decoders[i], value);
1479+ if (!$elm$core$Result$isOk(result))
1480+ {
1481+ return result;
1482+ }
1483+ answer = answer(result.a);
1484+ }
1485+ return $elm$core$Result$Ok(answer);
1486+
1487+ case 10:
1488+ var result = _Json_runHelp(decoder.b, value);
1489+ return (!$elm$core$Result$isOk(result))
1490+ ? result
1491+ : _Json_runHelp(decoder.h(result.a), value);
1492+
1493+ case 11:
1494+ var errors = _List_Nil;
1495+ for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS
1496+ {
1497+ var result = _Json_runHelp(temp.a, value);
1498+ if ($elm$core$Result$isOk(result))
1499+ {
1500+ return result;
1501+ }
1502+ errors = _List_Cons(result.a, errors);
1503+ }
1504+ return $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)));
1505+
1506+ case 1:
1507+ return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));
1508+
1509+ case 0:
1510+ return $elm$core$Result$Ok(decoder.a);
1511+ }
1512+}
1513+
1514+function _Json_runArrayDecoder(decoder, value, toElmValue)
1515+{
1516+ var len = value.length;
1517+ var array = new Array(len);
1518+ for (var i = 0; i < len; i++)
1519+ {
1520+ var result = _Json_runHelp(decoder, value[i]);
1521+ if (!$elm$core$Result$isOk(result))
1522+ {
1523+ return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a));
1524+ }
1525+ array[i] = result.a;
1526+ }
1527+ return $elm$core$Result$Ok(toElmValue(array));
1528+}
1529+
1530+function _Json_isArray(value)
1531+{
1532+ return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);
1533+}
1534+
1535+function _Json_toElmArray(array)
1536+{
1537+ return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; });
1538+}
1539+
1540+function _Json_expecting(type, value)
1541+{
1542+ return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));
1543+}
1544+
1545+
1546+// EQUALITY
1547+
1548+function _Json_equality(x, y)
1549+{
1550+ if (x === y)
1551+ {
1552+ return true;
1553+ }
1554+
1555+ if (x.$ !== y.$)
1556+ {
1557+ return false;
1558+ }
1559+
1560+ switch (x.$)
1561+ {
1562+ case 0:
1563+ case 1:
1564+ return x.a === y.a;
1565+
1566+ case 2:
1567+ return x.b === y.b;
1568+
1569+ case 5:
1570+ return x.c === y.c;
1571+
1572+ case 3:
1573+ case 4:
1574+ case 8:
1575+ return _Json_equality(x.b, y.b);
1576+
1577+ case 6:
1578+ return x.d === y.d && _Json_equality(x.b, y.b);
1579+
1580+ case 7:
1581+ return x.e === y.e && _Json_equality(x.b, y.b);
1582+
1583+ case 9:
1584+ return x.f === y.f && _Json_listEquality(x.g, y.g);
1585+
1586+ case 10:
1587+ return x.h === y.h && _Json_equality(x.b, y.b);
1588+
1589+ case 11:
1590+ return _Json_listEquality(x.g, y.g);
1591+ }
1592+}
1593+
1594+function _Json_listEquality(aDecoders, bDecoders)
1595+{
1596+ var len = aDecoders.length;
1597+ if (len !== bDecoders.length)
1598+ {
1599+ return false;
1600+ }
1601+ for (var i = 0; i < len; i++)
1602+ {
1603+ if (!_Json_equality(aDecoders[i], bDecoders[i]))
1604+ {
1605+ return false;
1606+ }
1607+ }
1608+ return true;
1609+}
1610+
1611+
1612+// ENCODE
1613+
1614+var _Json_encode = F2(function(indentLevel, value)
1615+{
1616+ return JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';
1617+});
1618+
1619+function _Json_wrap(value) { return { $: 0, a: value }; }
1620+function _Json_unwrap(value) { return value.a; }
1621+
1622+function _Json_wrap_UNUSED(value) { return value; }
1623+function _Json_unwrap_UNUSED(value) { return value; }
1624+
1625+function _Json_emptyArray() { return []; }
1626+function _Json_emptyObject() { return {}; }
1627+
1628+var _Json_addField = F3(function(key, value, object)
1629+{
1630+ object[key] = _Json_unwrap(value);
1631+ return object;
1632+});
1633+
1634+function _Json_addEntry(func)
1635+{
1636+ return F2(function(entry, array)
1637+ {
1638+ array.push(_Json_unwrap(func(entry)));
1639+ return array;
1640+ });
1641+}
1642+
1643+var _Json_encodeNull = _Json_wrap(null);
1644+
1645+
1646+
1647+var _Lynx_g = (typeof globalThis !== 'undefined' ? globalThis : scope);
1648+function _Lynx_papi(name) { return _Lynx_g['_' + '_' + name] || function() {}; }
1649+function _Lynx_createElement(tag) {
1650+ var pId = (_Lynx_g['native'] && _Lynx_g['native']['currentPageId']) || 0;
1651+ var creators = { 'view': 'CreateView', 'text': 'CreateText', 'image': 'CreateImage' };
1652+ var name = creators[tag] || 'CreateView';
1653+ var fn = _Lynx_g['_' + '_' + name];
1654+ if (typeof fn === 'function') { return fn(pId); }
1655+ return _Lynx_papi('CreateElement')(tag, pId);
1656+}
1657+function _Lynx_createRawText(text) {
1658+ var fn = _Lynx_g['_' + '_CreateRawText'];
1659+ if (typeof fn === 'function') { return fn(text); }
1660+ return {};
1661+}
1662+var _Lynx_appendChild = _Lynx_papi('AppendElement');
1663+var _Lynx_removeElement = _Lynx_papi('RemoveElement');
1664+var _Lynx_replaceElement = _Lynx_papi('ReplaceElement');
1665+var _Lynx_insertBefore = _Lynx_papi('InsertElementBefore');
1666+var _Lynx_setAttribute = _Lynx_papi('SetAttribute');
1667+var _Lynx_getChildren = _Lynx_g['_' + '_GetChildren'] || function() { return []; };
1668+var _Lynx_getParent = _Lynx_g['_' + '_GetParent'] || function() { return null; };
1669+var _Lynx_addEvent = _Lynx_papi('AddEvent');
1670+var _Lynx_setInlineStyles = _Lynx_papi('SetInlineStyles');
1671+var _VirtualDom_elementMeta = new Map();
1672+function _VirtualDom_getMeta(el) {
1673+ var meta = _VirtualDom_elementMeta.get(el);
1674+ if (!meta) { meta = {}; _VirtualDom_elementMeta.set(el, meta); }
1675+ return meta;
1676+}
1677+
1678+
1679+// HELPERS
1680+
1681+
1682+
1683+
1684+
1685+function _VirtualDom_appendChild(parent, child)
1686+{
1687+ _Lynx_appendChild(parent, child);
1688+}
1689+
1690+var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args)
1691+{
1692+ // NOTE: this function needs _Platform_export available to work
1693+ var rootPage = args['node'] || _Lynx_g['page'];
1694+ var tree = _VirtualDom_render(virtualNode, function() {});
1695+ _Lynx_appendChild(rootPage, tree);
1696+ return {};
1697+});
1698+
1699+
1700+
1701+// TEXT
1702+
1703+
1704+function _VirtualDom_text(string)
1705+{
1706+ return {
1707+ $: 0,
1708+ a: string
1709+ };
1710+}
1711+
1712+
1713+
1714+// NODE
1715+
1716+
1717+var _VirtualDom_nodeNS = F2(function(namespace, tag)
1718+{
1719+ return F2(function(factList, kidList)
1720+ {
1721+ for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
1722+ {
1723+ var kid = kidList.a;
1724+ descendantsCount += (kid.b || 0);
1725+ kids.push(kid);
1726+ }
1727+ descendantsCount += kids.length;
1728+
1729+ return {
1730+ $: 1,
1731+ c: tag,
1732+ d: _VirtualDom_organizeFacts(factList),
1733+ e: kids,
1734+ f: namespace,
1735+ b: descendantsCount
1736+ };
1737+ });
1738+});
1739+
1740+
1741+var _VirtualDom_node = _VirtualDom_nodeNS(undefined);
1742+
1743+
1744+
1745+// KEYED NODE
1746+
1747+
1748+var _VirtualDom_keyedNodeNS = F2(function(namespace, tag)
1749+{
1750+ return F2(function(factList, kidList)
1751+ {
1752+ for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
1753+ {
1754+ var kid = kidList.a;
1755+ descendantsCount += (kid.b.b || 0);
1756+ kids.push(kid);
1757+ }
1758+ descendantsCount += kids.length;
1759+
1760+ return {
1761+ $: 2,
1762+ c: tag,
1763+ d: _VirtualDom_organizeFacts(factList),
1764+ e: kids,
1765+ f: namespace,
1766+ b: descendantsCount
1767+ };
1768+ });
1769+});
1770+
1771+
1772+var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined);
1773+
1774+
1775+
1776+// CUSTOM
1777+
1778+
1779+function _VirtualDom_custom(factList, model, render, diff)
1780+{
1781+ return {
1782+ $: 3,
1783+ d: _VirtualDom_organizeFacts(factList),
1784+ g: model,
1785+ h: render,
1786+ i: diff
1787+ };
1788+}
1789+
1790+
1791+
1792+// MAP
1793+
1794+
1795+var _VirtualDom_map = F2(function(tagger, node)
1796+{
1797+ return {
1798+ $: 4,
1799+ j: tagger,
1800+ k: node,
1801+ b: 1 + (node.b || 0)
1802+ };
1803+});
1804+
1805+
1806+
1807+// LAZY
1808+
1809+
1810+function _VirtualDom_thunk(refs, thunk)
1811+{
1812+ return {
1813+ $: 5,
1814+ l: refs,
1815+ m: thunk,
1816+ k: undefined
1817+ };
1818+}
1819+
1820+var _VirtualDom_lazy = F2(function(func, a)
1821+{
1822+ return _VirtualDom_thunk([func, a], function() {
1823+ return func(a);
1824+ });
1825+});
1826+
1827+var _VirtualDom_lazy2 = F3(function(func, a, b)
1828+{
1829+ return _VirtualDom_thunk([func, a, b], function() {
1830+ return A2(func, a, b);
1831+ });
1832+});
1833+
1834+var _VirtualDom_lazy3 = F4(function(func, a, b, c)
1835+{
1836+ return _VirtualDom_thunk([func, a, b, c], function() {
1837+ return A3(func, a, b, c);
1838+ });
1839+});
1840+
1841+var _VirtualDom_lazy4 = F5(function(func, a, b, c, d)
1842+{
1843+ return _VirtualDom_thunk([func, a, b, c, d], function() {
1844+ return A4(func, a, b, c, d);
1845+ });
1846+});
1847+
1848+var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e)
1849+{
1850+ return _VirtualDom_thunk([func, a, b, c, d, e], function() {
1851+ return A5(func, a, b, c, d, e);
1852+ });
1853+});
1854+
1855+var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f)
1856+{
1857+ return _VirtualDom_thunk([func, a, b, c, d, e, f], function() {
1858+ return A6(func, a, b, c, d, e, f);
1859+ });
1860+});
1861+
1862+var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g)
1863+{
1864+ return _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() {
1865+ return A7(func, a, b, c, d, e, f, g);
1866+ });
1867+});
1868+
1869+var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h)
1870+{
1871+ return _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() {
1872+ return A8(func, a, b, c, d, e, f, g, h);
1873+ });
1874+});
1875+
1876+
1877+
1878+// FACTS
1879+
1880+
1881+var _VirtualDom_on = F2(function(key, handler)
1882+{
1883+ return {
1884+ $: 'a0',
1885+ n: key,
1886+ o: handler
1887+ };
1888+});
1889+var _VirtualDom_style = F2(function(key, value)
1890+{
1891+ return {
1892+ $: 'a1',
1893+ n: key,
1894+ o: value
1895+ };
1896+});
1897+var _VirtualDom_property = F2(function(key, value)
1898+{
1899+ return {
1900+ $: 'a2',
1901+ n: key,
1902+ o: value
1903+ };
1904+});
1905+var _VirtualDom_attribute = F2(function(key, value)
1906+{
1907+ return {
1908+ $: 'a3',
1909+ n: key,
1910+ o: value
1911+ };
1912+});
1913+var _VirtualDom_attributeNS = F3(function(namespace, key, value)
1914+{
1915+ return {
1916+ $: 'a4',
1917+ n: key,
1918+ o: { f: namespace, o: value }
1919+ };
1920+});
1921+
1922+
1923+
1924+// XSS ATTACK VECTOR CHECKS
1925+//
1926+// For some reason, tabs can appear in href protocols and it still works.
1927+// So '\tjava\tSCRIPT:alert("!!!")' and 'javascript:alert("!!!")' are the same
1928+// in practice. That is why _VirtualDom_RE_js and _VirtualDom_RE_js_html look
1929+// so freaky.
1930+//
1931+// Pulling the regular expressions out to the top level gives a slight speed
1932+// boost in small benchmarks (4-10%) but hoisting values to reduce allocation
1933+// can be unpredictable in large programs where JIT may have a harder time with
1934+// functions are not fully self-contained. The benefit is more that the js and
1935+// js_html ones are so weird that I prefer to see them near each other.
1936+
1937+
1938+
1939+
1940+
1941+function _VirtualDom_noScript(tag)
1942+{
1943+ return tag;
1944+}
1945+
1946+function _VirtualDom_noOnOrFormAction(key)
1947+{
1948+ return key;
1949+}
1950+
1951+function _VirtualDom_noInnerHtmlOrFormAction(key)
1952+{
1953+ return key;
1954+}
1955+
1956+function _VirtualDom_noJavaScriptUri(value)
1957+{
1958+ return value;
1959+}
1960+
1961+function _VirtualDom_noJavaScriptOrHtmlUri(value)
1962+{
1963+ return value;
1964+}
1965+
1966+function _VirtualDom_noJavaScriptOrHtmlJson(value)
1967+{
1968+ return value;
1969+}
1970+
1971+
1972+
1973+// MAP FACTS
1974+
1975+
1976+var _VirtualDom_mapAttribute = F2(function(func, attr)
1977+{
1978+ return (attr.$ === 'a0')
1979+ ? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o))
1980+ : attr;
1981+});
1982+
1983+function _VirtualDom_mapHandler(func, handler)
1984+{
1985+ var tag = $lynxjs_elm$virtual_dom$VirtualDom$toHandlerInt(handler);
1986+
1987+ // 0 = Normal
1988+ // 1 = MayStopPropagation
1989+ // 2 = MayPreventDefault
1990+ // 3 = Custom
1991+
1992+ return {
1993+ $: handler.$,
1994+ a:
1995+ !tag
1996+ ? A2($elm$json$Json$Decode$map, func, handler.a)
1997+ :
1998+ A3($elm$json$Json$Decode$map2,
1999+ tag < 3
2000+ ? _VirtualDom_mapEventTuple
2001+ : _VirtualDom_mapEventRecord,
2002+ $elm$json$Json$Decode$succeed(func),
2003+ handler.a
2004+ )
2005+ };
2006+}
2007+
2008+var _VirtualDom_mapEventTuple = F2(function(func, tuple)
2009+{
2010+ return _Utils_Tuple2(func(tuple.a), tuple.b);
2011+});
2012+
2013+var _VirtualDom_mapEventRecord = F2(function(func, record)
2014+{
2015+ return {
2016+ message: func(record.message),
2017+ stopPropagation: record.stopPropagation,
2018+ preventDefault: record.preventDefault
2019+ }
2020+});
2021+
2022+
2023+
2024+// ORGANIZE FACTS
2025+
2026+
2027+function _VirtualDom_organizeFacts(factList)
2028+{
2029+ for (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS
2030+ {
2031+ var entry = factList.a;
2032+
2033+ var tag = entry.$;
2034+ var key = entry.n;
2035+ var value = entry.o;
2036+
2037+ if (tag === 'a2')
2038+ {
2039+ (key === 'className')
2040+ ? _VirtualDom_addClass(facts, key, _Json_unwrap(value))
2041+ : facts[key] = _Json_unwrap(value);
2042+
2043+ continue;
2044+ }
2045+
2046+ var subFacts = facts[tag] || (facts[tag] = {});
2047+ (tag === 'a3' && key === 'class')
2048+ ? _VirtualDom_addClass(subFacts, key, value)
2049+ : subFacts[key] = value;
2050+ }
2051+
2052+ return facts;
2053+}
2054+
2055+function _VirtualDom_addClass(object, key, newClass)
2056+{
2057+ var classes = object[key];
2058+ object[key] = classes ? classes + ' ' + newClass : newClass;
2059+}
2060+
2061+
2062+
2063+// RENDER
2064+
2065+
2066+function _VirtualDom_render(vNode, eventNode)
2067+{
2068+ var tag = vNode.$;
2069+
2070+ if (tag === 5)
2071+ {
2072+ return _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode);
2073+ }
2074+
2075+ if (tag === 0)
2076+ {
2077+ return _Lynx_createRawText(vNode.a);
2078+ }
2079+
2080+ if (tag === 4)
2081+ {
2082+ var subNode = vNode.k;
2083+ var tagger = vNode.j;
2084+
2085+ while (subNode.$ === 4)
2086+ {
2087+ typeof tagger !== 'object'
2088+ ? tagger = [tagger, subNode.j]
2089+ : tagger.push(subNode.j);
2090+
2091+ subNode = subNode.k;
2092+ }
2093+
2094+ var subEventRoot = { j: tagger, p: eventNode };
2095+ var domNode = _VirtualDom_render(subNode, subEventRoot);
2096+ _VirtualDom_getMeta(domNode).elm_event_node_ref = subEventRoot;
2097+ return domNode;
2098+ }
2099+
2100+ if (tag === 3)
2101+ {
2102+ var domNode = vNode.h(vNode.g);
2103+ _VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2104+ return domNode;
2105+ }
2106+
2107+ // at this point `tag` must be 1 or 2
2108+
2109+ var domNode = _Lynx_createElement(vNode.c);
2110+
2111+ _VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2112+
2113+ for (var kids = vNode.e, i = 0; i < kids.length; i++)
2114+ {
2115+ var kid = tag === 1 ? kids[i] : kids[i].b;
2116+ if (kid.$ === 0)
2117+ {
2118+ _Lynx_appendChild(domNode, _Lynx_createRawText(kid.a));
2119+ }
2120+ else
2121+ {
2122+ _VirtualDom_appendChild(domNode, _VirtualDom_render(kid, eventNode));
2123+ }
2124+ }
2125+
2126+ return domNode;
2127+}
2128+
2129+
2130+
2131+// APPLY FACTS
2132+
2133+
2134+function _VirtualDom_applyFacts(domNode, eventNode, facts)
2135+{
2136+ for (var key in facts)
2137+ {
2138+ var value = facts[key];
2139+
2140+ key === 'a1'
2141+ ? _VirtualDom_applyStyles(domNode, value)
2142+ :
2143+ key === 'a0'
2144+ ? _VirtualDom_applyEvents(domNode, eventNode, value)
2145+ :
2146+ key === 'a3'
2147+ ? _VirtualDom_applyAttrs(domNode, value)
2148+ :
2149+ key === 'a4'
2150+ ? _VirtualDom_applyAttrsNS(domNode, value)
2151+ :
2152+ (key !== 'value' && key !== 'checked' || domNode[key] !== value) && _Lynx_setAttribute(domNode, key === 'className' ? 'class' : key, String(value));
2153+ }
2154+}
2155+
2156+
2157+
2158+// APPLY STYLES
2159+
2160+
2161+function _VirtualDom_applyStyles(domNode, styles)
2162+{
2163+ var _sIS = _Lynx_g['_' + '_SetInlineStyles'];
2164+ if (typeof _sIS === 'function')
2165+ {
2166+ _sIS(domNode, styles);
2167+ }
2168+}
2169+
2170+
2171+
2172+// APPLY ATTRS
2173+
2174+
2175+function _VirtualDom_applyAttrs(domNode, attrs)
2176+{
2177+ for (var key in attrs)
2178+ {
2179+ var value = attrs[key];
2180+ if (typeof value !== 'undefined')
2181+ {
2182+ _Lynx_setAttribute(domNode, key, value);
2183+ }
2184+ }
2185+}
2186+
2187+
2188+
2189+// APPLY NAMESPACED ATTRS
2190+
2191+
2192+function _VirtualDom_applyAttrsNS(domNode, nsAttrs)
2193+{
2194+ for (var key in nsAttrs)
2195+ {
2196+ var pair = nsAttrs[key];
2197+ var value = pair.o;
2198+
2199+ if (typeof value !== 'undefined')
2200+ {
2201+ _Lynx_setAttribute(domNode, key, value);
2202+ }
2203+ }
2204+}
2205+
2206+
2207+
2208+// APPLY EVENTS
2209+
2210+
2211+function _VirtualDom_applyEvents(domNode, eventNode, events)
2212+{
2213+ var meta = _VirtualDom_getMeta(domNode);
2214+ var allCallbacks = meta.elmFs || (meta.elmFs = {});
2215+
2216+ for (var key in events)
2217+ {
2218+ var newHandler = events[key];
2219+ var oldCallback = allCallbacks[key];
2220+
2221+ if (!newHandler)
2222+ {
2223+ allCallbacks[key] = undefined;
2224+ continue;
2225+ }
2226+
2227+ if (oldCallback)
2228+ {
2229+ var oldHandler = oldCallback.q;
2230+ if (oldHandler.$ === newHandler.$)
2231+ {
2232+ oldCallback.q = newHandler;
2233+ continue;
2234+ }
2235+ }
2236+
2237+ oldCallback = _VirtualDom_makeCallback(eventNode, newHandler);
2238+ allCallbacks[key] = oldCallback;
2239+
2240+ var lynxEventName = _VirtualDom_mapEventName(key);
2241+ var handlerType = $lynxjs_elm$virtual_dom$VirtualDom$toHandlerInt(newHandler);
2242+ var prefix = (handlerType === 1) ? 'catch' : 'bind';
2243+ _Lynx_addEvent(domNode, 'catchEvent', lynxEventName, { type: 'worklet', value: oldCallback });
2244+ }
2245+}
2246+
2247+function _VirtualDom_mapEventName(name)
2248+{
2249+ switch (name)
2250+ {
2251+ case 'click': return 'tap';
2252+ case 'dblclick': return 'tap';
2253+ case 'mousedown': return 'touchstart';
2254+ case 'mousemove': return 'touchmove';
2255+ case 'mouseup': return 'touchend';
2256+ default: return name;
2257+ }
2258+}
2259+
2260+
2261+
2262+// PASSIVE EVENTS
2263+
2264+
2265+
2266+// EVENT HANDLERS
2267+
2268+
2269+function _VirtualDom_makeCallback(eventNode, initialHandler)
2270+{
2271+ function callback(event)
2272+ {
2273+ var handler = callback.q;
2274+ var result = _Json_runHelp(handler.a, event);
2275+
2276+ if (!$elm$core$Result$isOk(result))
2277+ {
2278+ return;
2279+ }
2280+
2281+ var tag = $lynxjs_elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2282+
2283+ // 0 = Normal
2284+ // 1 = MayStopPropagation
2285+ // 2 = MayPreventDefault
2286+ // 3 = Custom
2287+
2288+ var value = result.a;
2289+ var message = !tag ? value : tag < 3 ? value.a : value.message;
2290+ var stopPropagation = tag == 1 ? value.b : tag == 3 && value.stopPropagation;
2291+ var currentEventNode = eventNode;
2292+ var tagger;
2293+ var i;
2294+ while (tagger = currentEventNode.j)
2295+ {
2296+ if (typeof tagger == 'function')
2297+ {
2298+ message = tagger(message);
2299+ }
2300+ else
2301+ {
2302+ for (var i = tagger.length; i--; )
2303+ {
2304+ message = tagger[i](message);
2305+ }
2306+ }
2307+ currentEventNode = currentEventNode.p;
2308+ }
2309+ currentEventNode(message, stopPropagation); // stopPropagation implies isSync
2310+ }
2311+
2312+ callback.q = initialHandler;
2313+
2314+ return callback;
2315+}
2316+
2317+function _VirtualDom_equalEvents(x, y)
2318+{
2319+ return x.$ == y.$ && _Json_equality(x.a, y.a);
2320+}
2321+
2322+
2323+
2324+// DIFF
2325+
2326+
2327+// TODO: Should we do patches like in iOS?
2328+//
2329+// type Patch
2330+// = At Int Patch
2331+// | Batch (List Patch)
2332+// | Change ...
2333+//
2334+// How could it not be better?
2335+//
2336+function _VirtualDom_diff(x, y)
2337+{
2338+ var patches = [];
2339+ _VirtualDom_diffHelp(x, y, patches, 0);
2340+ return patches;
2341+}
2342+
2343+
2344+function _VirtualDom_pushPatch(patches, type, index, data)
2345+{
2346+ var patch = {
2347+ $: type,
2348+ r: index,
2349+ s: data,
2350+ t: undefined,
2351+ u: undefined
2352+ };
2353+ patches.push(patch);
2354+ return patch;
2355+}
2356+
2357+
2358+function _VirtualDom_diffHelp(x, y, patches, index)
2359+{
2360+ if (x === y)
2361+ {
2362+ return;
2363+ }
2364+
2365+ var xType = x.$;
2366+ var yType = y.$;
2367+
2368+ // Bail if you run into different types of nodes. Implies that the
2369+ // structure has changed significantly and it's not worth a diff.
2370+ if (xType !== yType)
2371+ {
2372+ if (xType === 1 && yType === 2)
2373+ {
2374+ y = _VirtualDom_dekey(y);
2375+ yType = 1;
2376+ }
2377+ else
2378+ {
2379+ _VirtualDom_pushPatch(patches, 0, index, y);
2380+ return;
2381+ }
2382+ }
2383+
2384+ // Now we know that both nodes are the same $.
2385+ switch (yType)
2386+ {
2387+ case 5:
2388+ var xRefs = x.l;
2389+ var yRefs = y.l;
2390+ var i = xRefs.length;
2391+ var same = i === yRefs.length;
2392+ while (same && i--)
2393+ {
2394+ same = xRefs[i] === yRefs[i];
2395+ }
2396+ if (same)
2397+ {
2398+ y.k = x.k;
2399+ return;
2400+ }
2401+ y.k = y.m();
2402+ var subPatches = [];
2403+ _VirtualDom_diffHelp(x.k, y.k, subPatches, 0);
2404+ subPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches);
2405+ return;
2406+
2407+ case 4:
2408+ // gather nested taggers
2409+ var xTaggers = x.j;
2410+ var yTaggers = y.j;
2411+ var nesting = false;
2412+
2413+ var xSubNode = x.k;
2414+ while (xSubNode.$ === 4)
2415+ {
2416+ nesting = true;
2417+
2418+ typeof xTaggers !== 'object'
2419+ ? xTaggers = [xTaggers, xSubNode.j]
2420+ : xTaggers.push(xSubNode.j);
2421+
2422+ xSubNode = xSubNode.k;
2423+ }
2424+
2425+ var ySubNode = y.k;
2426+ while (ySubNode.$ === 4)
2427+ {
2428+ nesting = true;
2429+
2430+ typeof yTaggers !== 'object'
2431+ ? yTaggers = [yTaggers, ySubNode.j]
2432+ : yTaggers.push(ySubNode.j);
2433+
2434+ ySubNode = ySubNode.k;
2435+ }
2436+
2437+ // Just bail if different numbers of taggers. This implies the
2438+ // structure of the virtual DOM has changed.
2439+ if (nesting && xTaggers.length !== yTaggers.length)
2440+ {
2441+ _VirtualDom_pushPatch(patches, 0, index, y);
2442+ return;
2443+ }
2444+
2445+ // check if taggers are "the same"
2446+ if (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers)
2447+ {
2448+ _VirtualDom_pushPatch(patches, 2, index, yTaggers);
2449+ }
2450+
2451+ // diff everything below the taggers
2452+ _VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1);
2453+ return;
2454+
2455+ case 0:
2456+ if (x.a !== y.a)
2457+ {
2458+ _VirtualDom_pushPatch(patches, 3, index, y.a);
2459+ }
2460+ return;
2461+
2462+ case 1:
2463+ _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids);
2464+ return;
2465+
2466+ case 2:
2467+ _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids);
2468+ return;
2469+
2470+ case 3:
2471+ if (x.h !== y.h)
2472+ {
2473+ _VirtualDom_pushPatch(patches, 0, index, y);
2474+ return;
2475+ }
2476+
2477+ var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
2478+ factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
2479+
2480+ var patch = y.i(x.g, y.g);
2481+ patch && _VirtualDom_pushPatch(patches, 5, index, patch);
2482+
2483+ return;
2484+ }
2485+}
2486+
2487+// assumes the incoming arrays are the same length
2488+function _VirtualDom_pairwiseRefEqual(as, bs)
2489+{
2490+ for (var i = 0; i < as.length; i++)
2491+ {
2492+ if (as[i] !== bs[i])
2493+ {
2494+ return false;
2495+ }
2496+ }
2497+
2498+ return true;
2499+}
2500+
2501+function _VirtualDom_diffNodes(x, y, patches, index, diffKids)
2502+{
2503+ // Bail if obvious indicators have changed. Implies more serious
2504+ // structural changes such that it's not worth it to diff.
2505+ if (x.c !== y.c || x.f !== y.f)
2506+ {
2507+ _VirtualDom_pushPatch(patches, 0, index, y);
2508+ return;
2509+ }
2510+
2511+ var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
2512+ factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
2513+
2514+ diffKids(x, y, patches, index);
2515+}
2516+
2517+
2518+
2519+// DIFF FACTS
2520+
2521+
2522+// TODO Instead of creating a new diff object, it's possible to just test if
2523+// there *is* a diff. During the actual patch, do the diff again and make the
2524+// modifications directly. This way, there's no new allocations. Worth it?
2525+function _VirtualDom_diffFacts(x, y, category)
2526+{
2527+ var diff;
2528+
2529+ // look for changes and removals
2530+ for (var xKey in x)
2531+ {
2532+ if (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4')
2533+ {
2534+ var subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey);
2535+ if (subDiff)
2536+ {
2537+ diff = diff || {};
2538+ diff[xKey] = subDiff;
2539+ }
2540+ continue;
2541+ }
2542+
2543+ // remove if not in the new facts
2544+ if (!(xKey in y))
2545+ {
2546+ diff = diff || {};
2547+ diff[xKey] =
2548+ !category
2549+ ? (typeof x[xKey] === 'string' ? '' : null)
2550+ :
2551+ (category === 'a1')
2552+ ? ''
2553+ :
2554+ (category === 'a0' || category === 'a3')
2555+ ? undefined
2556+ :
2557+ { f: x[xKey].f, o: undefined };
2558+
2559+ continue;
2560+ }
2561+
2562+ var xValue = x[xKey];
2563+ var yValue = y[xKey];
2564+
2565+ // reference equal, so don't worry about it
2566+ if (xValue === yValue && xKey !== 'value' && xKey !== 'checked'
2567+ || category === 'a0' && _VirtualDom_equalEvents(xValue, yValue))
2568+ {
2569+ continue;
2570+ }
2571+
2572+ diff = diff || {};
2573+ diff[xKey] = yValue;
2574+ }
2575+
2576+ // add new stuff
2577+ for (var yKey in y)
2578+ {
2579+ if (!(yKey in x))
2580+ {
2581+ diff = diff || {};
2582+ diff[yKey] = y[yKey];
2583+ }
2584+ }
2585+
2586+ return diff;
2587+}
2588+
2589+
2590+
2591+// DIFF KIDS
2592+
2593+
2594+function _VirtualDom_diffKids(xParent, yParent, patches, index)
2595+{
2596+ var xKids = xParent.e;
2597+ var yKids = yParent.e;
2598+
2599+ var xLen = xKids.length;
2600+ var yLen = yKids.length;
2601+
2602+ // FIGURE OUT IF THERE ARE INSERTS OR REMOVALS
2603+
2604+ if (xLen > yLen)
2605+ {
2606+ _VirtualDom_pushPatch(patches, 6, index, {
2607+ v: yLen,
2608+ i: xLen - yLen
2609+ });
2610+ }
2611+ else if (xLen < yLen)
2612+ {
2613+ _VirtualDom_pushPatch(patches, 7, index, {
2614+ v: xLen,
2615+ e: yKids
2616+ });
2617+ }
2618+
2619+ // PAIRWISE DIFF EVERYTHING ELSE
2620+
2621+ for (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++)
2622+ {
2623+ var xKid = xKids[i];
2624+ _VirtualDom_diffHelp(xKid, yKids[i], patches, ++index);
2625+ index += xKid.b || 0;
2626+ }
2627+}
2628+
2629+
2630+
2631+// KEYED DIFF
2632+
2633+
2634+function _VirtualDom_diffKeyedKids(xParent, yParent, patches, rootIndex)
2635+{
2636+ var localPatches = [];
2637+
2638+ var changes = {}; // Dict String Entry
2639+ var inserts = []; // Array { index : Int, entry : Entry }
2640+ // type Entry = { tag : String, vnode : VNode, index : Int, data : _ }
2641+
2642+ var xKids = xParent.e;
2643+ var yKids = yParent.e;
2644+ var xLen = xKids.length;
2645+ var yLen = yKids.length;
2646+ var xIndex = 0;
2647+ var yIndex = 0;
2648+
2649+ var index = rootIndex;
2650+
2651+ while (xIndex < xLen && yIndex < yLen)
2652+ {
2653+ var x = xKids[xIndex];
2654+ var y = yKids[yIndex];
2655+
2656+ var xKey = x.a;
2657+ var yKey = y.a;
2658+ var xNode = x.b;
2659+ var yNode = y.b;
2660+
2661+ var newMatch = undefined;
2662+ var oldMatch = undefined;
2663+
2664+ // check if keys match
2665+
2666+ if (xKey === yKey)
2667+ {
2668+ index++;
2669+ _VirtualDom_diffHelp(xNode, yNode, localPatches, index);
2670+ index += xNode.b || 0;
2671+
2672+ xIndex++;
2673+ yIndex++;
2674+ continue;
2675+ }
2676+
2677+ // look ahead 1 to detect insertions and removals.
2678+
2679+ var xNext = xKids[xIndex + 1];
2680+ var yNext = yKids[yIndex + 1];
2681+
2682+ if (xNext)
2683+ {
2684+ var xNextKey = xNext.a;
2685+ var xNextNode = xNext.b;
2686+ oldMatch = yKey === xNextKey;
2687+ }
2688+
2689+ if (yNext)
2690+ {
2691+ var yNextKey = yNext.a;
2692+ var yNextNode = yNext.b;
2693+ newMatch = xKey === yNextKey;
2694+ }
2695+
2696+
2697+ // swap x and y
2698+ if (newMatch && oldMatch)
2699+ {
2700+ index++;
2701+ _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
2702+ _VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts);
2703+ index += xNode.b || 0;
2704+
2705+ index++;
2706+ _VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index);
2707+ index += xNextNode.b || 0;
2708+
2709+ xIndex += 2;
2710+ yIndex += 2;
2711+ continue;
2712+ }
2713+
2714+ // insert y
2715+ if (newMatch)
2716+ {
2717+ index++;
2718+ _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
2719+ _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
2720+ index += xNode.b || 0;
2721+
2722+ xIndex += 1;
2723+ yIndex += 2;
2724+ continue;
2725+ }
2726+
2727+ // remove x
2728+ if (oldMatch)
2729+ {
2730+ index++;
2731+ _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
2732+ index += xNode.b || 0;
2733+
2734+ index++;
2735+ _VirtualDom_diffHelp(xNextNode, yNode, localPatches, index);
2736+ index += xNextNode.b || 0;
2737+
2738+ xIndex += 2;
2739+ yIndex += 1;
2740+ continue;
2741+ }
2742+
2743+ // remove x, insert y
2744+ if (xNext && xNextKey === yNextKey)
2745+ {
2746+ index++;
2747+ _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
2748+ _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
2749+ index += xNode.b || 0;
2750+
2751+ index++;
2752+ _VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index);
2753+ index += xNextNode.b || 0;
2754+
2755+ xIndex += 2;
2756+ yIndex += 2;
2757+ continue;
2758+ }
2759+
2760+ break;
2761+ }
2762+
2763+ // eat up any remaining nodes with removeNode and insertNode
2764+
2765+ while (xIndex < xLen)
2766+ {
2767+ index++;
2768+ var x = xKids[xIndex];
2769+ var xNode = x.b;
2770+ _VirtualDom_removeNode(changes, localPatches, x.a, xNode, index);
2771+ index += xNode.b || 0;
2772+ xIndex++;
2773+ }
2774+
2775+ while (yIndex < yLen)
2776+ {
2777+ var endInserts = endInserts || [];
2778+ var y = yKids[yIndex];
2779+ _VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts);
2780+ yIndex++;
2781+ }
2782+
2783+ if (localPatches.length > 0 || inserts.length > 0 || endInserts)
2784+ {
2785+ _VirtualDom_pushPatch(patches, 8, rootIndex, {
2786+ w: localPatches,
2787+ x: inserts,
2788+ y: endInserts
2789+ });
2790+ }
2791+}
2792+
2793+
2794+
2795+// CHANGES FROM KEYED DIFF
2796+
2797+
2798+var _VirtualDom_POSTFIX = '_elmW6BL';
2799+
2800+
2801+function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts)
2802+{
2803+ var entry = changes[key];
2804+
2805+ // never seen this key before
2806+ if (!entry)
2807+ {
2808+ entry = {
2809+ c: 0,
2810+ z: vnode,
2811+ r: yIndex,
2812+ s: undefined
2813+ };
2814+
2815+ inserts.push({ r: yIndex, A: entry });
2816+ changes[key] = entry;
2817+
2818+ return;
2819+ }
2820+
2821+ // this key was removed earlier, a match!
2822+ if (entry.c === 1)
2823+ {
2824+ inserts.push({ r: yIndex, A: entry });
2825+
2826+ entry.c = 2;
2827+ var subPatches = [];
2828+ _VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r);
2829+ entry.r = yIndex;
2830+ entry.s.s = {
2831+ w: subPatches,
2832+ A: entry
2833+ };
2834+
2835+ return;
2836+ }
2837+
2838+ // this key has already been inserted or moved, a duplicate!
2839+ _VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts);
2840+}
2841+
2842+
2843+function _VirtualDom_removeNode(changes, localPatches, key, vnode, index)
2844+{
2845+ var entry = changes[key];
2846+
2847+ // never seen this key before
2848+ if (!entry)
2849+ {
2850+ var patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined);
2851+
2852+ changes[key] = {
2853+ c: 1,
2854+ z: vnode,
2855+ r: index,
2856+ s: patch
2857+ };
2858+
2859+ return;
2860+ }
2861+
2862+ // this key was inserted earlier, a match!
2863+ if (entry.c === 0)
2864+ {
2865+ entry.c = 2;
2866+ var subPatches = [];
2867+ _VirtualDom_diffHelp(vnode, entry.z, subPatches, index);
2868+
2869+ _VirtualDom_pushPatch(localPatches, 9, index, {
2870+ w: subPatches,
2871+ A: entry
2872+ });
2873+
2874+ return;
2875+ }
2876+
2877+ // this key has already been removed or moved, a duplicate!
2878+ _VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, index);
2879+}
2880+
2881+
2882+
2883+// ADD DOM NODES
2884+//
2885+// Each DOM node has an "index" assigned in order of traversal. It is important
2886+// to minimize our crawl over the actual DOM, so these indexes (along with the
2887+// descendantsCount of virtual nodes) let us skip touching entire subtrees of
2888+// the DOM if we know there are no patches there.
2889+
2890+
2891+function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode)
2892+{
2893+ _VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode);
2894+}
2895+
2896+
2897+// assumes `patches` is non-empty and indexes increase monotonically.
2898+function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode)
2899+{
2900+ var patch = patches[i];
2901+ var index = patch.r;
2902+
2903+ while (index === low)
2904+ {
2905+ var patchType = patch.$;
2906+
2907+ if (patchType === 1)
2908+ {
2909+ _VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode);
2910+ }
2911+ else if (patchType === 8)
2912+ {
2913+ patch.t = domNode;
2914+ patch.u = eventNode;
2915+
2916+ var subPatches = patch.s.w;
2917+ if (subPatches.length > 0)
2918+ {
2919+ _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
2920+ }
2921+ }
2922+ else if (patchType === 9)
2923+ {
2924+ patch.t = domNode;
2925+ patch.u = eventNode;
2926+
2927+ var data = patch.s;
2928+ if (data)
2929+ {
2930+ data.A.s = domNode;
2931+ var subPatches = data.w;
2932+ if (subPatches.length > 0)
2933+ {
2934+ _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
2935+ }
2936+ }
2937+ }
2938+ else
2939+ {
2940+ patch.t = domNode;
2941+ patch.u = eventNode;
2942+ }
2943+
2944+ i++;
2945+
2946+ if (!(patch = patches[i]) || (index = patch.r) > high)
2947+ {
2948+ return i;
2949+ }
2950+ }
2951+
2952+ var tag = vNode.$;
2953+
2954+ if (tag === 4)
2955+ {
2956+ var subNode = vNode.k;
2957+
2958+ while (subNode.$ === 4)
2959+ {
2960+ subNode = subNode.k;
2961+ }
2962+
2963+ return _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, _VirtualDom_getMeta(domNode).elm_event_node_ref);
2964+ }
2965+
2966+ // tag must be 1 or 2 at this point
2967+
2968+ var vKids = vNode.e;
2969+ var childNodes = _Lynx_getChildren(domNode);
2970+ for (var j = 0; j < vKids.length; j++)
2971+ {
2972+ low++;
2973+ var vKid = tag === 1 ? vKids[j] : vKids[j].b;
2974+ var nextLow = low + (vKid.b || 0);
2975+ if (low <= index && index <= nextLow)
2976+ {
2977+ i = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode);
2978+ if (!(patch = patches[i]) || (index = patch.r) > high)
2979+ {
2980+ return i;
2981+ }
2982+ }
2983+ low = nextLow;
2984+ }
2985+ return i;
2986+}
2987+
2988+
2989+
2990+// APPLY PATCHES
2991+
2992+
2993+function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode)
2994+{
2995+ if (patches.length === 0)
2996+ {
2997+ return rootDomNode;
2998+ }
2999+
3000+ _VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);
3001+ return _VirtualDom_applyPatchesHelp(rootDomNode, patches);
3002+}
3003+
3004+function _VirtualDom_applyPatchesHelp(rootDomNode, patches)
3005+{
3006+ for (var i = 0; i < patches.length; i++)
3007+ {
3008+ var patch = patches[i];
3009+ var localDomNode = patch.t
3010+ var newNode = _VirtualDom_applyPatch(localDomNode, patch);
3011+ if (localDomNode === rootDomNode)
3012+ {
3013+ rootDomNode = newNode;
3014+ }
3015+ }
3016+ return rootDomNode;
3017+}
3018+
3019+function _VirtualDom_applyPatch(domNode, patch)
3020+{
3021+ switch (patch.$)
3022+ {
3023+ case 0:
3024+ return _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u);
3025+
3026+ case 4:
3027+ _VirtualDom_applyFacts(domNode, patch.u, patch.s);
3028+ return domNode;
3029+
3030+ case 3:
3031+ _Lynx_setAttribute(domNode, 'text', patch.s);
3032+ return domNode;
3033+
3034+ case 1:
3035+ return _VirtualDom_applyPatchesHelp(domNode, patch.s);
3036+
3037+ case 2:
3038+ if (_VirtualDom_getMeta(domNode).elm_event_node_ref)
3039+ {
3040+ _VirtualDom_getMeta(domNode).elm_event_node_ref.j = patch.s;
3041+ }
3042+ else
3043+ {
3044+ _VirtualDom_getMeta(domNode).elm_event_node_ref = { j: patch.s, p: patch.u };
3045+ }
3046+ return domNode;
3047+
3048+ case 6:
3049+ var data = patch.s;
3050+ for (var i = 0; i < data.i; i++)
3051+ {
3052+ var children = _Lynx_getChildren(domNode);
3053+ _Lynx_removeElement(domNode, children[data.v]);
3054+ }
3055+ return domNode;
3056+
3057+ case 7:
3058+ var data = patch.s;
3059+ var kids = data.e;
3060+ for (var i = data.v; i < kids.length; i++)
3061+ {
3062+ _Lynx_appendChild(domNode, _VirtualDom_render(kids[i], patch.u));
3063+ }
3064+ return domNode;
3065+
3066+ case 9:
3067+ var data = patch.s;
3068+ if (!data)
3069+ {
3070+ _Lynx_removeElement(_Lynx_getParent(domNode), domNode);
3071+ return domNode;
3072+ }
3073+ var entry = data.A;
3074+ if (typeof entry.r !== 'undefined')
3075+ {
3076+ _Lynx_removeElement(_Lynx_getParent(domNode), domNode);
3077+ }
3078+ entry.s = _VirtualDom_applyPatchesHelp(domNode, data.w);
3079+ return domNode;
3080+
3081+ case 8:
3082+ return _VirtualDom_applyPatchReorder(domNode, patch);
3083+
3084+ case 5:
3085+ return patch.s(domNode);
3086+
3087+ default:
3088+ _Debug_crash(10); // 'Ran into an unknown patch!'
3089+ }
3090+}
3091+
3092+
3093+function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode)
3094+{
3095+ var parentNode = _Lynx_getParent(domNode);
3096+ var newNode = _VirtualDom_render(vNode, eventNode);
3097+
3098+ if (!_VirtualDom_getMeta(newNode).elm_event_node_ref)
3099+ {
3100+ _VirtualDom_getMeta(newNode).elm_event_node_ref = _VirtualDom_getMeta(domNode).elm_event_node_ref;
3101+ }
3102+
3103+ if (parentNode && newNode !== domNode)
3104+ {
3105+ _Lynx_replaceElement(parentNode, newNode, domNode);
3106+ }
3107+ return newNode;
3108+}
3109+
3110+
3111+function _VirtualDom_applyPatchReorder(domNode, patch)
3112+{
3113+ var data = patch.s;
3114+
3115+ // remove end inserts
3116+ var endInsertNodes = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch);
3117+
3118+ // removals
3119+ domNode = _VirtualDom_applyPatchesHelp(domNode, data.w);
3120+
3121+ // inserts
3122+ var inserts = data.x;
3123+ for (var i = 0; i < inserts.length; i++)
3124+ {
3125+ var insert = inserts[i];
3126+ var entry = insert.A;
3127+ var node = entry.c === 2
3128+ ? entry.s
3129+ : _VirtualDom_render(entry.z, patch.u);
3130+ var children = _Lynx_getChildren(domNode);
3131+ _Lynx_insertBefore(domNode, node, children[insert.r]);
3132+ }
3133+
3134+ // add end inserts
3135+ if (endInsertNodes)
3136+ {
3137+ for (var i = 0; i < endInsertNodes.length; i++)
3138+ {
3139+ _Lynx_appendChild(domNode, endInsertNodes[i]);
3140+ }
3141+ }
3142+
3143+ return domNode;
3144+}
3145+
3146+
3147+function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch)
3148+{
3149+ if (!endInserts)
3150+ {
3151+ return;
3152+ }
3153+
3154+ var nodes = [];
3155+ for (var i = 0; i < endInserts.length; i++)
3156+ {
3157+ var insert = endInserts[i];
3158+ var entry = insert.A;
3159+ nodes.push(entry.c === 2
3160+ ? entry.s
3161+ : _VirtualDom_render(entry.z, patch.u)
3162+ );
3163+ }
3164+ return nodes;
3165+}
3166+
3167+
3168+function _VirtualDom_dekey(keyedNode)
3169+{
3170+ var keyedKids = keyedNode.e;
3171+ var len = keyedKids.length;
3172+ var kids = new Array(len);
3173+ for (var i = 0; i < len; i++)
3174+ {
3175+ kids[i] = keyedKids[i].b;
3176+ }
3177+
3178+ return {
3179+ $: 1,
3180+ c: keyedNode.c,
3181+ d: keyedNode.d,
3182+ e: kids,
3183+ f: keyedNode.f,
3184+ b: keyedNode.b
3185+ };
3186+}
3187+var $elm$core$List$cons = _List_cons;
3188+var $elm$core$Elm$JsArray$foldr = _JsArray_foldr;
3189+var $elm$core$Array$foldr = F3(
3190+ function (func, baseCase, _v0) {
3191+ var tree = _v0.c;
3192+ var tail = _v0.d;
3193+ var helper = F2(
3194+ function (node, acc) {
3195+ if (node.$ === 'SubTree') {
3196+ var subTree = node.a;
3197+ return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);
3198+ } else {
3199+ var values = node.a;
3200+ return A3($elm$core$Elm$JsArray$foldr, func, acc, values);
3201+ }
3202+ });
3203+ return A3(
3204+ $elm$core$Elm$JsArray$foldr,
3205+ helper,
3206+ A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail),
3207+ tree);
3208+ });
3209+var $elm$core$Array$toList = function (array) {
3210+ return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array);
3211+};
3212+var $elm$core$Dict$foldr = F3(
3213+ function (func, acc, t) {
3214+ foldr:
3215+ while (true) {
3216+ if (t.$ === 'RBEmpty_elm_builtin') {
3217+ return acc;
3218+ } else {
3219+ var key = t.b;
3220+ var value = t.c;
3221+ var left = t.d;
3222+ var right = t.e;
3223+ var $temp$func = func,
3224+ $temp$acc = A3(
3225+ func,
3226+ key,
3227+ value,
3228+ A3($elm$core$Dict$foldr, func, acc, right)),
3229+ $temp$t = left;
3230+ func = $temp$func;
3231+ acc = $temp$acc;
3232+ t = $temp$t;
3233+ continue foldr;
3234+ }
3235+ }
3236+ });
3237+var $elm$core$Dict$toList = function (dict) {
3238+ return A3(
3239+ $elm$core$Dict$foldr,
3240+ F3(
3241+ function (key, value, list) {
3242+ return A2(
3243+ $elm$core$List$cons,
3244+ _Utils_Tuple2(key, value),
3245+ list);
3246+ }),
3247+ _List_Nil,
3248+ dict);
3249+};
3250+var $elm$core$Dict$keys = function (dict) {
3251+ return A3(
3252+ $elm$core$Dict$foldr,
3253+ F3(
3254+ function (key, value, keyList) {
3255+ return A2($elm$core$List$cons, key, keyList);
3256+ }),
3257+ _List_Nil,
3258+ dict);
3259+};
3260+var $elm$core$Set$toList = function (_v0) {
3261+ var dict = _v0.a;
3262+ return $elm$core$Dict$keys(dict);
3263+};
3264+var $elm$core$Basics$EQ = {$: 'EQ'};
3265+var $elm$core$Basics$GT = {$: 'GT'};
3266+var $elm$core$Basics$LT = {$: 'LT'};
3267+var $elm$core$Result$Err = function (a) {
3268+ return {$: 'Err', a: a};
3269+};
3270+var $elm$json$Json$Decode$Failure = F2(
3271+ function (a, b) {
3272+ return {$: 'Failure', a: a, b: b};
3273+ });
3274+var $elm$json$Json$Decode$Field = F2(
3275+ function (a, b) {
3276+ return {$: 'Field', a: a, b: b};
3277+ });
3278+var $elm$json$Json$Decode$Index = F2(
3279+ function (a, b) {
3280+ return {$: 'Index', a: a, b: b};
3281+ });
3282+var $elm$core$Result$Ok = function (a) {
3283+ return {$: 'Ok', a: a};
3284+};
3285+var $elm$json$Json$Decode$OneOf = function (a) {
3286+ return {$: 'OneOf', a: a};
3287+};
3288+var $elm$core$Basics$False = {$: 'False'};
3289+var $elm$core$Basics$add = _Basics_add;
3290+var $elm$core$Maybe$Just = function (a) {
3291+ return {$: 'Just', a: a};
3292+};
3293+var $elm$core$Maybe$Nothing = {$: 'Nothing'};
3294+var $elm$core$String$all = _String_all;
3295+var $elm$core$Basics$and = _Basics_and;
3296+var $elm$core$Basics$append = _Utils_append;
3297+var $elm$json$Json$Encode$encode = _Json_encode;
3298+var $elm$core$String$fromInt = _String_fromNumber;
3299+var $elm$core$String$join = F2(
3300+ function (sep, chunks) {
3301+ return A2(
3302+ _String_join,
3303+ sep,
3304+ _List_toArray(chunks));
3305+ });
3306+var $elm$core$String$split = F2(
3307+ function (sep, string) {
3308+ return _List_fromArray(
3309+ A2(_String_split, sep, string));
3310+ });
3311+var $elm$json$Json$Decode$indent = function (str) {
3312+ return A2(
3313+ $elm$core$String$join,
3314+ '\n ',
3315+ A2($elm$core$String$split, '\n', str));
3316+};
3317+var $elm$core$List$foldl = F3(
3318+ function (func, acc, list) {
3319+ foldl:
3320+ while (true) {
3321+ if (!list.b) {
3322+ return acc;
3323+ } else {
3324+ var x = list.a;
3325+ var xs = list.b;
3326+ var $temp$func = func,
3327+ $temp$acc = A2(func, x, acc),
3328+ $temp$list = xs;
3329+ func = $temp$func;
3330+ acc = $temp$acc;
3331+ list = $temp$list;
3332+ continue foldl;
3333+ }
3334+ }
3335+ });
3336+var $elm$core$List$length = function (xs) {
3337+ return A3(
3338+ $elm$core$List$foldl,
3339+ F2(
3340+ function (_v0, i) {
3341+ return i + 1;
3342+ }),
3343+ 0,
3344+ xs);
3345+};
3346+var $elm$core$List$map2 = _List_map2;
3347+var $elm$core$Basics$le = _Utils_le;
3348+var $elm$core$Basics$sub = _Basics_sub;
3349+var $elm$core$List$rangeHelp = F3(
3350+ function (lo, hi, list) {
3351+ rangeHelp:
3352+ while (true) {
3353+ if (_Utils_cmp(lo, hi) < 1) {
3354+ var $temp$lo = lo,
3355+ $temp$hi = hi - 1,
3356+ $temp$list = A2($elm$core$List$cons, hi, list);
3357+ lo = $temp$lo;
3358+ hi = $temp$hi;
3359+ list = $temp$list;
3360+ continue rangeHelp;
3361+ } else {
3362+ return list;
3363+ }
3364+ }
3365+ });
3366+var $elm$core$List$range = F2(
3367+ function (lo, hi) {
3368+ return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil);
3369+ });
3370+var $elm$core$List$indexedMap = F2(
3371+ function (f, xs) {
3372+ return A3(
3373+ $elm$core$List$map2,
3374+ f,
3375+ A2(
3376+ $elm$core$List$range,
3377+ 0,
3378+ $elm$core$List$length(xs) - 1),
3379+ xs);
3380+ });
3381+var $elm$core$Char$toCode = _Char_toCode;
3382+var $elm$core$Char$isLower = function (_char) {
3383+ var code = $elm$core$Char$toCode(_char);
3384+ return (97 <= code) && (code <= 122);
3385+};
3386+var $elm$core$Char$isUpper = function (_char) {
3387+ var code = $elm$core$Char$toCode(_char);
3388+ return (code <= 90) && (65 <= code);
3389+};
3390+var $elm$core$Basics$or = _Basics_or;
3391+var $elm$core$Char$isAlpha = function (_char) {
3392+ return $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char);
3393+};
3394+var $elm$core$Char$isDigit = function (_char) {
3395+ var code = $elm$core$Char$toCode(_char);
3396+ return (code <= 57) && (48 <= code);
3397+};
3398+var $elm$core$Char$isAlphaNum = function (_char) {
3399+ return $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char));
3400+};
3401+var $elm$core$List$reverse = function (list) {
3402+ return A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list);
3403+};
3404+var $elm$core$String$uncons = _String_uncons;
3405+var $elm$json$Json$Decode$errorOneOf = F2(
3406+ function (i, error) {
3407+ return '\n\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent(
3408+ $elm$json$Json$Decode$errorToString(error))));
3409+ });
3410+var $elm$json$Json$Decode$errorToString = function (error) {
3411+ return A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);
3412+};
3413+var $elm$json$Json$Decode$errorToStringHelp = F2(
3414+ function (error, context) {
3415+ errorToStringHelp:
3416+ while (true) {
3417+ switch (error.$) {
3418+ case 'Field':
3419+ var f = error.a;
3420+ var err = error.b;
3421+ var isSimple = function () {
3422+ var _v1 = $elm$core$String$uncons(f);
3423+ if (_v1.$ === 'Nothing') {
3424+ return false;
3425+ } else {
3426+ var _v2 = _v1.a;
3427+ var _char = _v2.a;
3428+ var rest = _v2.b;
3429+ return $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest);
3430+ }
3431+ }();
3432+ var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']'));
3433+ var $temp$error = err,
3434+ $temp$context = A2($elm$core$List$cons, fieldName, context);
3435+ error = $temp$error;
3436+ context = $temp$context;
3437+ continue errorToStringHelp;
3438+ case 'Index':
3439+ var i = error.a;
3440+ var err = error.b;
3441+ var indexName = '[' + ($elm$core$String$fromInt(i) + ']');
3442+ var $temp$error = err,
3443+ $temp$context = A2($elm$core$List$cons, indexName, context);
3444+ error = $temp$error;
3445+ context = $temp$context;
3446+ continue errorToStringHelp;
3447+ case 'OneOf':
3448+ var errors = error.a;
3449+ if (!errors.b) {
3450+ return 'Ran into a Json.Decode.oneOf with no possibilities' + function () {
3451+ if (!context.b) {
3452+ return '!';
3453+ } else {
3454+ return ' at json' + A2(
3455+ $elm$core$String$join,
3456+ '',
3457+ $elm$core$List$reverse(context));
3458+ }
3459+ }();
3460+ } else {
3461+ if (!errors.b.b) {
3462+ var err = errors.a;
3463+ var $temp$error = err,
3464+ $temp$context = context;
3465+ error = $temp$error;
3466+ context = $temp$context;
3467+ continue errorToStringHelp;
3468+ } else {
3469+ var starter = function () {
3470+ if (!context.b) {
3471+ return 'Json.Decode.oneOf';
3472+ } else {
3473+ return 'The Json.Decode.oneOf at json' + A2(
3474+ $elm$core$String$join,
3475+ '',
3476+ $elm$core$List$reverse(context));
3477+ }
3478+ }();
3479+ var introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt(
3480+ $elm$core$List$length(errors)) + ' ways:'));
3481+ return A2(
3482+ $elm$core$String$join,
3483+ '\n\n',
3484+ A2(
3485+ $elm$core$List$cons,
3486+ introduction,
3487+ A2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors)));
3488+ }
3489+ }
3490+ default:
3491+ var msg = error.a;
3492+ var json = error.b;
3493+ var introduction = function () {
3494+ if (!context.b) {
3495+ return 'Problem with the given value:\n\n';
3496+ } else {
3497+ return 'Problem with the value at json' + (A2(
3498+ $elm$core$String$join,
3499+ '',
3500+ $elm$core$List$reverse(context)) + ':\n\n ');
3501+ }
3502+ }();
3503+ return introduction + ($elm$json$Json$Decode$indent(
3504+ A2($elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg));
3505+ }
3506+ }
3507+ });
3508+var $elm$core$Array$branchFactor = 32;
3509+var $elm$core$Array$Array_elm_builtin = F4(
3510+ function (a, b, c, d) {
3511+ return {$: 'Array_elm_builtin', a: a, b: b, c: c, d: d};
3512+ });
3513+var $elm$core$Elm$JsArray$empty = _JsArray_empty;
3514+var $elm$core$Basics$ceiling = _Basics_ceiling;
3515+var $elm$core$Basics$fdiv = _Basics_fdiv;
3516+var $elm$core$Basics$logBase = F2(
3517+ function (base, number) {
3518+ return _Basics_log(number) / _Basics_log(base);
3519+ });
3520+var $elm$core$Basics$toFloat = _Basics_toFloat;
3521+var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling(
3522+ A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor));
3523+var $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);
3524+var $elm$core$Elm$JsArray$initialize = _JsArray_initialize;
3525+var $elm$core$Array$Leaf = function (a) {
3526+ return {$: 'Leaf', a: a};
3527+};
3528+var $elm$core$Basics$apL = F2(
3529+ function (f, x) {
3530+ return f(x);
3531+ });
3532+var $elm$core$Basics$apR = F2(
3533+ function (x, f) {
3534+ return f(x);
3535+ });
3536+var $elm$core$Basics$eq = _Utils_equal;
3537+var $elm$core$Basics$floor = _Basics_floor;
3538+var $elm$core$Elm$JsArray$length = _JsArray_length;
3539+var $elm$core$Basics$gt = _Utils_gt;
3540+var $elm$core$Basics$max = F2(
3541+ function (x, y) {
3542+ return (_Utils_cmp(x, y) > 0) ? x : y;
3543+ });
3544+var $elm$core$Basics$mul = _Basics_mul;
3545+var $elm$core$Array$SubTree = function (a) {
3546+ return {$: 'SubTree', a: a};
3547+};
3548+var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;
3549+var $elm$core$Array$compressNodes = F2(
3550+ function (nodes, acc) {
3551+ compressNodes:
3552+ while (true) {
3553+ var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes);
3554+ var node = _v0.a;
3555+ var remainingNodes = _v0.b;
3556+ var newAcc = A2(
3557+ $elm$core$List$cons,
3558+ $elm$core$Array$SubTree(node),
3559+ acc);
3560+ if (!remainingNodes.b) {
3561+ return $elm$core$List$reverse(newAcc);
3562+ } else {
3563+ var $temp$nodes = remainingNodes,
3564+ $temp$acc = newAcc;
3565+ nodes = $temp$nodes;
3566+ acc = $temp$acc;
3567+ continue compressNodes;
3568+ }
3569+ }
3570+ });
3571+var $elm$core$Tuple$first = function (_v0) {
3572+ var x = _v0.a;
3573+ return x;
3574+};
3575+var $elm$core$Array$treeFromBuilder = F2(
3576+ function (nodeList, nodeListSize) {
3577+ treeFromBuilder:
3578+ while (true) {
3579+ var newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor);
3580+ if (newNodeSize === 1) {
3581+ return A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a;
3582+ } else {
3583+ var $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil),
3584+ $temp$nodeListSize = newNodeSize;
3585+ nodeList = $temp$nodeList;
3586+ nodeListSize = $temp$nodeListSize;
3587+ continue treeFromBuilder;
3588+ }
3589+ }
3590+ });
3591+var $elm$core$Array$builderToArray = F2(
3592+ function (reverseNodeList, builder) {
3593+ if (!builder.nodeListSize) {
3594+ return A4(
3595+ $elm$core$Array$Array_elm_builtin,
3596+ $elm$core$Elm$JsArray$length(builder.tail),
3597+ $elm$core$Array$shiftStep,
3598+ $elm$core$Elm$JsArray$empty,
3599+ builder.tail);
3600+ } else {
3601+ var treeLen = builder.nodeListSize * $elm$core$Array$branchFactor;
3602+ var depth = $elm$core$Basics$floor(
3603+ A2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1));
3604+ var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.nodeList) : builder.nodeList;
3605+ var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.nodeListSize);
3606+ return A4(
3607+ $elm$core$Array$Array_elm_builtin,
3608+ $elm$core$Elm$JsArray$length(builder.tail) + treeLen,
3609+ A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep),
3610+ tree,
3611+ builder.tail);
3612+ }
3613+ });
3614+var $elm$core$Basics$idiv = _Basics_idiv;
3615+var $elm$core$Basics$lt = _Utils_lt;
3616+var $elm$core$Array$initializeHelp = F5(
3617+ function (fn, fromIndex, len, nodeList, tail) {
3618+ initializeHelp:
3619+ while (true) {
3620+ if (fromIndex < 0) {
3621+ return A2(
3622+ $elm$core$Array$builderToArray,
3623+ false,
3624+ {nodeList: nodeList, nodeListSize: (len / $elm$core$Array$branchFactor) | 0, tail: tail});
3625+ } else {
3626+ var leaf = $elm$core$Array$Leaf(
3627+ A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn));
3628+ var $temp$fn = fn,
3629+ $temp$fromIndex = fromIndex - $elm$core$Array$branchFactor,
3630+ $temp$len = len,
3631+ $temp$nodeList = A2($elm$core$List$cons, leaf, nodeList),
3632+ $temp$tail = tail;
3633+ fn = $temp$fn;
3634+ fromIndex = $temp$fromIndex;
3635+ len = $temp$len;
3636+ nodeList = $temp$nodeList;
3637+ tail = $temp$tail;
3638+ continue initializeHelp;
3639+ }
3640+ }
3641+ });
3642+var $elm$core$Basics$remainderBy = _Basics_remainderBy;
3643+var $elm$core$Array$initialize = F2(
3644+ function (len, fn) {
3645+ if (len <= 0) {
3646+ return $elm$core$Array$empty;
3647+ } else {
3648+ var tailLen = len % $elm$core$Array$branchFactor;
3649+ var tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn);
3650+ var initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor;
3651+ return A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);
3652+ }
3653+ });
3654+var $elm$core$Basics$True = {$: 'True'};
3655+var $elm$core$Result$isOk = function (result) {
3656+ if (result.$ === 'Ok') {
3657+ return true;
3658+ } else {
3659+ return false;
3660+ }
3661+};
3662+var $elm$json$Json$Decode$map = _Json_map1;
3663+var $elm$json$Json$Decode$map2 = _Json_map2;
3664+var $elm$json$Json$Decode$succeed = _Json_succeed;
3665+var $lynxjs_elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) {
3666+ switch (handler.$) {
3667+ case 'Normal':
3668+ return 0;
3669+ case 'MayStopPropagation':
3670+ return 1;
3671+ case 'MayPreventDefault':
3672+ return 2;
3673+ default:
3674+ return 3;
3675+ }
3676+};
3677+var $lynxjs_elm$virtual_dom$VirtualDom$node = function (tag) {
3678+ return _VirtualDom_node(
3679+ _VirtualDom_noScript(tag));
3680+};
3681+var $lynxjs_elm$virtual_dom$VirtualDom$text = _VirtualDom_text;
3682+var $author$project$Main$main = A3(
3683+ $lynxjs_elm$virtual_dom$VirtualDom$node,
3684+ 'view',
3685+ _List_Nil,
3686+ _List_fromArray(
3687+ [
3688+ A3(
3689+ $lynxjs_elm$virtual_dom$VirtualDom$node,
3690+ 'text',
3691+ _List_Nil,
3692+ _List_fromArray(
3693+ [
3694+ $lynxjs_elm$virtual_dom$VirtualDom$text('Hello from Elm on LynxJS!')
3695+ ]))
3696+ ]));
3697+_Platform_export({'Main':{'init':_VirtualDom_init($author$project$Main$main)(0)(0)}});}(globalThis));
examples/hello-world/elm.jsonnew file+19
@@ -0,0 +1,19 @@
1+{
2+ "type": "application",
3+ "source-directories": [
4+ "src"
5+ ],
6+ "elm-version": "0.19.1",
7+ "dependencies": {
8+ "direct": {
9+ "elm/core": "1.0.5",
10+ "elm/json": "1.1.3",
11+ "lynxjs-elm/virtual-dom": "1.0.0"
12+ },
13+ "indirect": {}
14+ },
15+ "test-dependencies": {
16+ "direct": {},
17+ "indirect": {}
18+ }
19+}
examples/hello-world/src/Main.elmnew file+14
@@ -0,0 +1,14 @@
1+module Main exposing (main)
2+
3+{-| Phase 1 verification: Static rendering.
4+Renders a view with a text element. No events, no TEA.
5+-}
6+
7+import VirtualDom exposing (Node, node, text)
8+
9+
10+main : Node msg
11+main =
12+ node "view" []
13+ [ node "text" [] [ text "Hello from Elm on LynxJS!" ]
14+ ]
examples/http-example/elm.jsnew file+6126

This diff is too big to show here.

examples/http-example/elm.jsonnew file+27

This diff is too big to show here.

examples/http-example/main.htmlnew file+6220

This diff is too big to show here.

examples/http-example/src/Main.elmnew file+114

This diff is too big to show here.