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