https://lucamug.github.io/lucamug/elm.js

1(function(scope){
2'use strict';
3
4function F(arity, fun, wrapper) {
5  wrapper.a = arity;
6  wrapper.f = fun;
7  return wrapper;
8}
9
10function F2(fun) {
11  return F(2, fun, function(a) { return function(b) { return fun(a,b); }; })
12}
13function F3(fun) {
14  return F(3, fun, function(a) {
15    return function(b) { return function(c) { return fun(a, b, c); }; };
16  });
17}
18function F4(fun) {
19  return F(4, fun, function(a) { return function(b) { return function(c) {
20    return function(d) { return fun(a, b, c, d); }; }; };
21  });
22}
23function F5(fun) {
24  return F(5, fun, function(a) { return function(b) { return function(c) {
25    return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };
26  });
27}
28function F6(fun) {
29  return F(6, fun, function(a) { return function(b) { return function(c) {
30    return function(d) { return function(e) { return function(f) {
31    return fun(a, b, c, d, e, f); }; }; }; }; };
32  });
33}
34function F7(fun) {
35  return F(7, fun, function(a) { return function(b) { return function(c) {
36    return function(d) { return function(e) { return function(f) {
37    return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };
38  });
39}
40function F8(fun) {
41  return F(8, fun, function(a) { return function(b) { return function(c) {
42    return function(d) { return function(e) { return function(f) {
43    return function(g) { return function(h) {
44    return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };
45  });
46}
47function F9(fun) {
48  return F(9, fun, function(a) { return function(b) { return function(c) {
49    return function(d) { return function(e) { return function(f) {
50    return function(g) { return function(h) { return function(i) {
51    return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };
52  });
53}
54
55function A2(fun, a, b) {
56  return fun.a === 2 ? fun.f(a, b) : fun(a)(b);
57}
58function A3(fun, a, b, c) {
59  return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c);
60}
61function A4(fun, a, b, c, d) {
62  return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d);
63}
64function A5(fun, a, b, c, d, e) {
65  return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e);
66}
67function A6(fun, a, b, c, d, e, f) {
68  return fun.a === 6 ? fun.f(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f);
69}
70function A7(fun, a, b, c, d, e, f, g) {
71  return fun.a === 7 ? fun.f(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g);
72}
73function A8(fun, a, b, c, d, e, f, g, h) {
74  return fun.a === 8 ? fun.f(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h);
75}
76function A9(fun, a, b, c, d, e, f, g, h, i) {
77  return fun.a === 9 ? fun.f(a, b, c, d, e, f, g, h, i) : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
78}
79
80
81
82
83var _JsArray_empty = [];
84
85function _JsArray_singleton(value)
86{
87    return [value];
88}
89
90function _JsArray_length(array)
91{
92    return array.length;
93}
94
95var _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
107var _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
121var _JsArray_unsafeGet = F2(function(index, array)
122{
123    return array[index];
124});
125
126var _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
140var _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
154var _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
166var _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
176var _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
189var _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
202var _JsArray_slice = F3(function(from, to, array)
203{
204    return array.slice(from, to);
205});
206
207var _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
237var _Debug_log = F2(function(tag, value)
238{
239	return value;
240});
241
242var _Debug_log_UNUSED = F2(function(tag, value)
243{
244	console.log(tag + ': ' + _Debug_toString(value));
245	return value;
246});
247
248
249// TODOS
250
251function _Debug_todo(moduleName, region)
252{
253	return function(message) {
254		_Debug_crash(8, moduleName, region, message);
255	};
256}
257
258function _Debug_todoCase(moduleName, region, value)
259{
260	return function(message) {
261		_Debug_crash(9, moduleName, region, value, message);
262	};
263}
264
265
266// TO STRING
267
268function _Debug_toString(value)
269{
270	return '<internals>';
271}
272
273function _Debug_toString_UNUSED(value)
274{
275	return _Debug_toAnsiString(false, value);
276}
277
278function _Debug_toAnsiString(ansi, value)
279{
280	if (typeof value === 'function')
281	{
282		return _Debug_internalColor(ansi, '<function>');
283	}
284
285	if (typeof value === 'boolean')
286	{
287		return _Debug_ctorColor(ansi, value ? 'True' : 'False');
288	}
289
290	if (typeof value === 'number')
291	{
292		return _Debug_numberColor(ansi, value + '');
293	}
294
295	if (value instanceof String)
296	{
297		return _Debug_charColor(ansi, "'" + _Debug_addSlashes(value, true) + "'");
298	}
299
300	if (typeof value === 'string')
301	{
302		return _Debug_stringColor(ansi, '"' + _Debug_addSlashes(value, false) + '"');
303	}
304
305	if (typeof value === 'object' && '$' in value)
306	{
307		var tag = value.$;
308
309		if (typeof tag === 'number')
310		{
311			return _Debug_internalColor(ansi, '<internals>');
312		}
313
314		if (tag[0] === '#')
315		{
316			var output = [];
317			for (var k in value)
318			{
319				if (k === '$') continue;
320				output.push(_Debug_toAnsiString(ansi, value[k]));
321			}
322			return '(' + output.join(',') + ')';
323		}
324
325		if (tag === 'Set_elm_builtin')
326		{
327			return _Debug_ctorColor(ansi, 'Set')
328				+ _Debug_fadeColor(ansi, '.fromList') + ' '
329				+ _Debug_toAnsiString(ansi, $elm$core$Set$toList(value));
330		}
331
332		if (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin')
333		{
334			return _Debug_ctorColor(ansi, 'Dict')
335				+ _Debug_fadeColor(ansi, '.fromList') + ' '
336				+ _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value));
337		}
338
339		if (tag === 'Array_elm_builtin')
340		{
341			return _Debug_ctorColor(ansi, 'Array')
342				+ _Debug_fadeColor(ansi, '.fromList') + ' '
343				+ _Debug_toAnsiString(ansi, $elm$core$Array$toList(value));
344		}
345
346		if (tag === '::' || tag === '[]')
347		{
348			var output = '[';
349
350			value.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b)
351
352			for (; value.b; value = value.b) // WHILE_CONS
353			{
354				output += ',' + _Debug_toAnsiString(ansi, value.a);
355			}
356			return output + ']';
357		}
358
359		var output = '';
360		for (var i in value)
361		{
362			if (i === '$') continue;
363			var str = _Debug_toAnsiString(ansi, value[i]);
364			var c0 = str[0];
365			var parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
366			output += ' ' + (parenless ? str : '(' + str + ')');
367		}
368		return _Debug_ctorColor(ansi, tag) + output;
369	}
370
371	if (typeof DataView === 'function' && value instanceof DataView)
372	{
373		return _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>');
374	}
375
376	if (typeof File !== 'undefined' && value instanceof File)
377	{
378		return _Debug_internalColor(ansi, '<' + value.name + '>');
379	}
380
381	if (typeof value === 'object')
382	{
383		var output = [];
384		for (var key in value)
385		{
386			var field = key[0] === '_' ? key.slice(1) : key;
387			output.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key]));
388		}
389		if (output.length === 0)
390		{
391			return '{}';
392		}
393		return '{ ' + output.join(', ') + ' }';
394	}
395
396	return _Debug_internalColor(ansi, '<internals>');
397}
398
399function _Debug_addSlashes(str, isChar)
400{
401	var s = str
402		.replace(/\\/g, '\\\\')
403		.replace(/\n/g, '\\n')
404		.replace(/\t/g, '\\t')
405		.replace(/\r/g, '\\r')
406		.replace(/\v/g, '\\v')
407		.replace(/\0/g, '\\0');
408
409	if (isChar)
410	{
411		return s.replace(/\'/g, '\\\'');
412	}
413	else
414	{
415		return s.replace(/\"/g, '\\"');
416	}
417}
418
419function _Debug_ctorColor(ansi, string)
420{
421	return ansi ? '\x1b[96m' + string + '\x1b[0m' : string;
422}
423
424function _Debug_numberColor(ansi, string)
425{
426	return ansi ? '\x1b[95m' + string + '\x1b[0m' : string;
427}
428
429function _Debug_stringColor(ansi, string)
430{
431	return ansi ? '\x1b[93m' + string + '\x1b[0m' : string;
432}
433
434function _Debug_charColor(ansi, string)
435{
436	return ansi ? '\x1b[92m' + string + '\x1b[0m' : string;
437}
438
439function _Debug_fadeColor(ansi, string)
440{
441	return ansi ? '\x1b[37m' + string + '\x1b[0m' : string;
442}
443
444function _Debug_internalColor(ansi, string)
445{
446	return ansi ? '\x1b[36m' + string + '\x1b[0m' : string;
447}
448
449function _Debug_toHexDigit(n)
450{
451	return String.fromCharCode(n < 10 ? 48 + n : 55 + n);
452}
453
454
455// CRASH
456
457
458function _Debug_crash(identifier)
459{
460	throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');
461}
462
463
464function _Debug_crash_UNUSED(identifier, fact1, fact2, fact3, fact4)
465{
466	switch(identifier)
467	{
468		case 0:
469			throw new Error('What node should I take over? In JavaScript I need something like:\n\n    Elm.Main.init({\n        node: document.getElementById("elm-node")\n    })\n\nYou need to do this with any Browser.sandbox or Browser.element program.');
470
471		case 1:
472			throw new Error('Browser.application programs cannot handle URLs like this:\n\n    ' + document.location.href + '\n\nWhat is the root? The root of your file system? Try looking at this program with `elm reactor` or some other server.');
473
474		case 2:
475			var jsonErrorString = fact1;
476			throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString);
477
478		case 3:
479			var portName = fact1;
480			throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.');
481
482		case 4:
483			var portName = fact1;
484			var problem = fact2;
485			throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem);
486
487		case 5:
488			throw new Error('Trying to use `(==)` on functions.\nThere is no way to know if functions are "the same" in the Elm sense.\nRead more about this at https://package.elm-lang.org/packages/elm/core/latest/Basics#== which describes why it is this way and what the better version will look like.');
489
490		case 6:
491			var moduleName = fact1;
492			throw new Error('Your page is loading multiple Elm scripts with a module named ' + moduleName + '. Maybe a duplicate script is getting loaded accidentally? If not, rename one of them so I know which is which!');
493
494		case 8:
495			var moduleName = fact1;
496			var region = fact2;
497			var message = fact3;
498			throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message);
499
500		case 9:
501			var moduleName = fact1;
502			var region = fact2;
503			var value = fact3;
504			var message = fact4;
505			throw new Error(
506				'TODO in module `' + moduleName + '` from the `case` expression '
507				+ _Debug_regionToString(region) + '\n\nIt received the following value:\n\n    '
508				+ _Debug_toString(value).replace('\n', '\n    ')
509				+ '\n\nBut the branch that handles it says:\n\n    ' + message.replace('\n', '\n    ')
510			);
511
512		case 10:
513			throw new Error('Bug in https://github.com/elm/virtual-dom/issues');
514
515		case 11:
516			throw new Error('Cannot perform mod 0. Division by zero error.');
517	}
518}
519
520function _Debug_regionToString(region)
521{
522	if (region.cV.bh === region.dn.bh)
523	{
524		return 'on line ' + region.cV.bh;
525	}
526	return 'on lines ' + region.cV.bh + ' through ' + region.dn.bh;
527}
528
529
530
531// EQUALITY
532
533function _Utils_eq(x, y)
534{
535	for (
536		var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);
537		isEqual && (pair = stack.pop());
538		isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack)
539		)
540	{}
541
542	return isEqual;
543}
544
545function _Utils_eqHelp(x, y, depth, stack)
546{
547	if (x === y)
548	{
549		return true;
550	}
551
552	if (typeof x !== 'object' || x === null || y === null)
553	{

554		typeof x === 'function' && _Debug_crash(5);
555		return false;
556	}
557
558	if (depth > 100)
559	{
560		stack.push(_Utils_Tuple2(x,y));
561		return true;
562	}
563
564	/**_UNUSED/
565	if (x.$ === 'Set_elm_builtin')
566	{
567		x = $elm$core$Set$toList(x);
568		y = $elm$core$Set$toList(y);
569	}
570	if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')
571	{
572		x = $elm$core$Dict$toList(x);
573		y = $elm$core$Dict$toList(y);
574	}
575	//*/
576
577	/**/
578	if (x.$ < 0)
579	{
580		x = $elm$core$Dict$toList(x);
581		y = $elm$core$Dict$toList(y);
582	}
583	//*/
584
585	for (var key in x)
586	{
587		if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))
588		{
589			return false;
590		}
591	}
592	return true;
593}
594
595var _Utils_equal = F2(_Utils_eq);
596var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); });
597
598
599
600// COMPARISONS
601
602// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
603// the particular integer values assigned to LT, EQ, and GT.
604
605function _Utils_cmp(x, y, ord)
606{
607	if (typeof x !== 'object')
608	{
609		return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1;
610	}
611
612	/**_UNUSED/
613	if (x instanceof String)
614	{
615		var a = x.valueOf();
616		var b = y.valueOf();
617		return a === b ? 0 : a < b ? -1 : 1;
618	}
619	//*/
620
621	/**/
622	if (typeof x.$ === 'undefined')
623	//*/
624	/**_UNUSED/
625	if (x.$[0] === '#')
626	//*/
627	{
628		return (ord = _Utils_cmp(x.a, y.a))
629			? ord
630			: (ord = _Utils_cmp(x.b, y.b))
631				? ord
632				: _Utils_cmp(x.c, y.c);
633	}
634
635	// traverse conses until end of a list or a mismatch
636	for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES
637	return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);
638}
639
640var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; });
641var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; });
642var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; });
643var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; });
644
645var _Utils_compare = F2(function(x, y)
646{
647	var n = _Utils_cmp(x, y);
648	return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ;
649});
650
651
652// COMMON VALUES
653
654var _Utils_Tuple0 = 0;
655var _Utils_Tuple0_UNUSED = { $: '#0' };
656
657function _Utils_Tuple2(a, b) { return { a: a, b: b }; }
658function _Utils_Tuple2_UNUSED(a, b) { return { $: '#2', a: a, b: b }; }
659
660function _Utils_Tuple3(a, b, c) { return { a: a, b: b, c: c }; }
661function _Utils_Tuple3_UNUSED(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }
662
663function _Utils_chr(c) { return c; }
664function _Utils_chr_UNUSED(c) { return new String(c); }
665
666
667// RECORDS
668
669function _Utils_update(oldRecord, updatedFields)
670{
671	var newRecord = {};
672
673	for (var key in oldRecord)
674	{
675		newRecord[key] = oldRecord[key];
676	}
677
678	for (var key in updatedFields)
679	{
680		newRecord[key] = updatedFields[key];
681	}
682
683	return newRecord;
684}
685
686
687// APPEND
688
689var _Utils_append = F2(_Utils_ap);
690
691function _Utils_ap(xs, ys)
692{
693	// append Strings
694	if (typeof xs === 'string')
695	{
696		return xs + ys;
697	}
698
699	// append Lists
700	if (!xs.b)
701	{
702		return ys;
703	}
704	var root = _List_Cons(xs.a, ys);
705	xs = xs.b
706	for (var curr = root; xs.b; xs = xs.b) // WHILE_CONS
707	{
708		curr = curr.b = _List_Cons(xs.a, ys);
709	}
710	return root;
711}
712
713
714
715var _List_Nil = { $: 0 };
716var _List_Nil_UNUSED = { $: '[]' };
717
718function _List_Cons(hd, tl) { return { $: 1, a: hd, b: tl }; }
719function _List_Cons_UNUSED(hd, tl) { return { $: '::', a: hd, b: tl }; }
720
721
722var _List_cons = F2(_List_Cons);
723
724function _List_fromArray(arr)
725{
726	var out = _List_Nil;
727	for (var i = arr.length; i--; )
728	{
729		out = _List_Cons(arr[i], out);
730	}
731	return out;
732}
733
734function _List_toArray(xs)
735{
736	for (var out = []; xs.b; xs = xs.b) // WHILE_CONS
737	{
738		out.push(xs.a);
739	}
740	return out;
741}
742
743var _List_map2 = F3(function(f, xs, ys)
744{
745	for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES
746	{
747		arr.push(A2(f, xs.a, ys.a));
748	}
749	return _List_fromArray(arr);
750});
751
752var _List_map3 = F4(function(f, xs, ys, zs)
753{
754	for (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
755	{
756		arr.push(A3(f, xs.a, ys.a, zs.a));
757	}
758	return _List_fromArray(arr);
759});
760
761var _List_map4 = F5(function(f, ws, xs, ys, zs)
762{
763	for (var arr = []; ws.b && xs.b && ys.b && zs.b; ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
764	{
765		arr.push(A4(f, ws.a, xs.a, ys.a, zs.a));
766	}
767	return _List_fromArray(arr);
768});
769
770var _List_map5 = F6(function(f, vs, ws, xs, ys, zs)
771{
772	for (var arr = []; vs.b && ws.b && xs.b && ys.b && zs.b; vs = vs.b, ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
773	{
774		arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a));
775	}
776	return _List_fromArray(arr);
777});
778
779var _List_sortBy = F2(function(f, xs)
780{
781	return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
782		return _Utils_cmp(f(a), f(b));
783	}));
784});
785
786var _List_sortWith = F2(function(f, xs)
787{
788	return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
789		var ord = A2(f, a, b);
790		return ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1;
791	}));
792});
793
794
795
796// MATH
797
798var _Basics_add = F2(function(a, b) { return a + b; });
799var _Basics_sub = F2(function(a, b) { return a - b; });
800var _Basics_mul = F2(function(a, b) { return a * b; });
801var _Basics_fdiv = F2(function(a, b) { return a / b; });
802var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; });
803var _Basics_pow = F2(Math.pow);
804
805var _Basics_remainderBy = F2(function(b, a) { return a % b; });
806

807// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
808var _Basics_modBy = F2(function(modulus, x)
809{
810	var answer = x % modulus;
811	return modulus === 0
812		? _Debug_crash(11)
813		:
814	((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0))
815		? answer + modulus
816		: answer;
817});
818
819
820// TRIGONOMETRY
821
822var _Basics_pi = Math.PI;
823var _Basics_e = Math.E;
824var _Basics_cos = Math.cos;
825var _Basics_sin = Math.sin;
826var _Basics_tan = Math.tan;
827var _Basics_acos = Math.acos;
828var _Basics_asin = Math.asin;
829var _Basics_atan = Math.atan;
830var _Basics_atan2 = F2(Math.atan2);
831
832
833// MORE MATH
834
835function _Basics_toFloat(x) { return x; }
836function _Basics_truncate(n) { return n | 0; }
837function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; }
838
839var _Basics_ceiling = Math.ceil;
840var _Basics_floor = Math.floor;
841var _Basics_round = Math.round;
842var _Basics_sqrt = Math.sqrt;
843var _Basics_log = Math.log;
844var _Basics_isNaN = isNaN;
845
846
847// BOOLEANS
848
849function _Basics_not(bool) { return !bool; }
850var _Basics_and = F2(function(a, b) { return a && b; });
851var _Basics_or  = F2(function(a, b) { return a || b; });
852var _Basics_xor = F2(function(a, b) { return a !== b; });
853
854
855
856var _String_cons = F2(function(chr, str)
857{
858	return chr + str;
859});
860
861function _String_uncons(string)
862{
863	var word = string.charCodeAt(0);
864	return !isNaN(word)
865		? $elm$core$Maybe$Just(
866			0xD800 <= word && word <= 0xDBFF
867				? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))
868				: _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))
869		)
870		: $elm$core$Maybe$Nothing;
871}
872
873var _String_append = F2(function(a, b)
874{
875	return a + b;
876});
877
878function _String_length(str)
879{
880	return str.length;
881}
882
883function _String_normalize(str)
884{
885    return str.normalize();
886
887}
888
889var _String_map = F2(function(func, string)
890{
891	var len = string.length;
892	var array = new Array(len);
893	var i = 0;
894	while (i < len)
895	{
896		var word = string.charCodeAt(i);
897		if (0xD800 <= word && word <= 0xDBFF)
898		{
899			array[i] = func(_Utils_chr(string[i] + string[i+1]));
900			i += 2;
901			continue;
902		}
903		array[i] = func(_Utils_chr(string[i]));
904		i++;
905	}
906	return array.join('');
907});
908
909var _String_filter = F2(function(isGood, str)
910{
911	var arr = [];
912	var len = str.length;
913	var i = 0;
914	while (i < len)
915	{
916		var char = str[i];
917		var word = str.charCodeAt(i);
918		i++;
919		if (0xD800 <= word && word <= 0xDBFF)
920		{
921			char += str[i];
922			i++;
923		}
924
925		if (isGood(_Utils_chr(char)))
926		{
927			arr.push(char);
928		}
929	}
930	return arr.join('');
931});
932
933function _String_reverse(str)
934{
935	var len = str.length;
936	var arr = new Array(len);
937	var i = 0;
938	while (i < len)
939	{
940		var word = str.charCodeAt(i);
941		if (0xD800 <= word && word <= 0xDBFF)
942		{
943			arr[len - i] = str[i + 1];
944			i++;
945			arr[len - i] = str[i - 1];
946			i++;
947		}
948		else
949		{
950			arr[len - i] = str[i];
951			i++;
952		}
953	}
954	return arr.join('');
955}
956
957var _String_foldl = F3(function(func, state, string)
958{
959	var len = string.length;
960	var i = 0;
961	while (i < len)
962	{
963		var char = string[i];
964		var word = string.charCodeAt(i);
965		i++;
966		if (0xD800 <= word && word <= 0xDBFF)
967		{
968			char += string[i];
969			i++;
970		}
971		state = A2(func, _Utils_chr(char), state);
972	}
973	return state;
974});
975
976var _String_foldr = F3(function(func, state, string)
977{
978	var i = string.length;
979	while (i--)
980	{
981		var char = string[i];
982		var word = string.charCodeAt(i);
983		if (0xDC00 <= word && word <= 0xDFFF)
984		{
985			i--;
986			char = string[i] + char;
987		}
988		state = A2(func, _Utils_chr(char), state);
989	}
990	return state;
991});
992
993var _String_split = F2(function(sep, str)
994{
995	return str.split(sep);
996});
997
998var _String_join = F2(function(sep, strs)
999{
1000	return strs.join(sep);
1001});
1002
1003var _String_slice = F3(function(start, end, str) {
1004	return str.slice(start, end);
1005});
1006
1007function _String_trim(str)
1008{
1009	return str.trim();
1010}
1011
1012function _String_trimLeft(str)
1013{
1014	return str.replace(/^\s+/, '');
1015}
1016
1017function _String_trimRight(str)
1018{
1019	return str.replace(/\s+$/, '');
1020}
1021
1022function _String_words(str)
1023{
1024	return _List_fromArray(str.trim().split(/\s+/g));
1025}
1026
1027function _String_lines(str)
1028{
1029	return _List_fromArray(str.split(/\r\n|\r|\n/g));
1030}
1031
1032function _String_toUpper(str)
1033{
1034	return str.toUpperCase();
1035}
1036
1037function _String_toLower(str)
1038{
1039	return str.toLowerCase();
1040}
1041
1042var _String_any = F2(function(isGood, string)
1043{
1044	var i = string.length;
1045	while (i--)
1046	{
1047		var char = string[i];
1048		var word = string.charCodeAt(i);

1049		if (0xDC00 <= word && word <= 0xDFFF)
1050		{
1051			i--;
1052			char = string[i] + char;
1053		}
1054		if (isGood(_Utils_chr(char)))
1055		{
1056			return true;
1057		}
1058	}
1059	return false;
1060});
1061
1062var _String_all = F2(function(isGood, string)
1063{
1064	var i = string.length;
1065	while (i--)
1066	{
1067		var char = string[i];
1068		var word = string.charCodeAt(i);
1069		if (0xDC00 <= word && word <= 0xDFFF)
1070		{
1071			i--;
1072			char = string[i] + char;
1073		}
1074		if (!isGood(_Utils_chr(char)))
1075		{
1076			return false;
1077		}
1078	}
1079	return true;
1080});
1081
1082var _String_contains = F2(function(sub, str)
1083{
1084	return str.indexOf(sub) > -1;
1085});
1086
1087var _String_startsWith = F2(function(sub, str)
1088{
1089	return str.indexOf(sub) === 0;
1090});
1091
1092var _String_endsWith = F2(function(sub, str)
1093{
1094	return str.length >= sub.length &&
1095		str.lastIndexOf(sub) === str.length - sub.length;
1096});
1097
1098var _String_indexes = F2(function(sub, str)
1099{
1100	var subLen = sub.length;
1101
1102	if (subLen < 1)
1103	{
1104		return _List_Nil;
1105	}
1106
1107	var i = 0;
1108	var is = [];
1109
1110	while ((i = str.indexOf(sub, i)) > -1)
1111	{
1112		is.push(i);
1113		i = i + subLen;
1114	}
1115
1116	return _List_fromArray(is);
1117});
1118
1119
1120// TO STRING
1121
1122function _String_fromNumber(number)
1123{
1124	return number + '';
1125}
1126
1127
1128// INT CONVERSIONS
1129
1130function _String_toInt(str)
1131{
1132	var total = 0;
1133	var code0 = str.charCodeAt(0);
1134	var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;
1135
1136	for (var i = start; i < str.length; ++i)
1137	{
1138		var code = str.charCodeAt(i);
1139		if (code < 0x30 || 0x39 < code)
1140		{
1141			return $elm$core$Maybe$Nothing;
1142		}
1143		total = 10 * total + code - 0x30;
1144	}
1145
1146	return i == start
1147		? $elm$core$Maybe$Nothing
1148		: $elm$core$Maybe$Just(code0 == 0x2D ? -total : total);
1149}
1150
1151
1152// FLOAT CONVERSIONS
1153
1154function _String_toFloat(s)
1155{
1156	// check if it is a hex, octal, or binary number
1157	if (s.length === 0 || /[\sxbo]/.test(s))
1158	{
1159		return $elm$core$Maybe$Nothing;
1160	}
1161	var n = +s;
1162	// faster isNaN check
1163	return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing;
1164}
1165
1166function _String_fromList(chars)
1167{
1168	return _List_toArray(chars).join('');
1169}
1170
1171
1172
1173
1174function _Char_toCode(char)
1175{
1176	var code = char.charCodeAt(0);
1177	if (0xD800 <= code && code <= 0xDBFF)
1178	{
1179		return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000
1180	}
1181	return code;
1182}
1183
1184function _Char_fromCode(code)
1185{
1186	return _Utils_chr(
1187		(code < 0 || 0x10FFFF < code)
1188			? '\uFFFD'
1189			:
1190		(code <= 0xFFFF)
1191			? String.fromCharCode(code)
1192			:
1193		(code -= 0x10000,
1194			String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)
1195		)
1196	);
1197}
1198
1199function _Char_toUpper(char)
1200{
1201	return _Utils_chr(char.toUpperCase());
1202}
1203
1204function _Char_toLower(char)
1205{
1206	return _Utils_chr(char.toLowerCase());
1207}
1208
1209function _Char_toLocaleUpper(char)
1210{
1211	return _Utils_chr(char.toLocaleUpperCase());
1212}
1213
1214function _Char_toLocaleLower(char)
1215{
1216	return _Utils_chr(char.toLocaleLowerCase());
1217}
1218
1219
1220
1221/**_UNUSED/
1222function _Json_errorToString(error)
1223{
1224	return $elm$json$Json$Decode$errorToString(error);
1225}
1226//*/
1227
1228
1229// CORE DECODERS
1230
1231function _Json_succeed(msg)
1232{
1233	return {
1234		$: 0,
1235		a: msg
1236	};
1237}
1238
1239function _Json_fail(msg)
1240{
1241	return {
1242		$: 1,
1243		a: msg
1244	};
1245}
1246
1247function _Json_decodePrim(decoder)
1248{
1249	return { $: 2, b: decoder };
1250}
1251
1252var _Json_decodeInt = _Json_decodePrim(function(value) {
1253	return (typeof value !== 'number')
1254		? _Json_expecting('an INT', value)
1255		:
1256	(-2147483647 < value && value < 2147483647 && (value | 0) === value)
1257		? $elm$core$Result$Ok(value)
1258		:
1259	(isFinite(value) && !(value % 1))
1260		? $elm$core$Result$Ok(value)
1261		: _Json_expecting('an INT', value);
1262});
1263
1264var _Json_decodeBool = _Json_decodePrim(function(value) {
1265	return (typeof value === 'boolean')
1266		? $elm$core$Result$Ok(value)
1267		: _Json_expecting('a BOOL', value);
1268});
1269
1270var _Json_decodeFloat = _Json_decodePrim(function(value) {
1271	return (typeof value === 'number')
1272		? $elm$core$Result$Ok(value)
1273		: _Json_expecting('a FLOAT', value);
1274});
1275
1276var _Json_decodeValue = _Json_decodePrim(function(value) {
1277	return $elm$core$Result$Ok(_Json_wrap(value));
1278});
1279
1280var _Json_decodeString = _Json_decodePrim(function(value) {
1281	return (typeof value === 'string')
1282		? $elm$core$Result$Ok(value)
1283		: (value instanceof String)
1284			? $elm$core$Result$Ok(value + '')
1285			: _Json_expecting('a STRING', value);
1286});
1287
1288function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }
1289function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }
1290
1291function _Json_decodeNull(value) { return { $: 5, c: value }; }
1292
1293var _Json_decodeField = F2(function(field, decoder)
1294{
1295	return {
1296		$: 6,
1297		d: field,
1298		b: decoder
1299	};
1300});
1301
1302var _Json_decodeIndex = F2(function(index, decoder)
1303{
1304	return {
1305		$: 7,
1306		e: index,
1307		b: decoder
1308	};
1309});
1310
1311function _Json_decodeKeyValuePairs(decoder)
1312{
1313	return {
1314		$: 8,
1315		b: decoder
1316	};
1317}
1318
1319function _Json_mapMany(f, decoders)
1320{
1321	return {
1322		$: 9,
1323		f: f,
1324		g: decoders
1325	};
1326}
1327
1328var _Json_andThen = F2(function(callback, decoder)
1329{
1330	return {
1331		$: 10,
1332		b: decoder,
1333		h: callback
1334	};
1335});
1336
1337function _Json_oneOf(decoders)
1338{
1339	return {
1340		$: 11,
1341		g: decoders
1342	};
1343}
1344
1345
1346// DECODING OBJECTS
1347
1348var _Json_map1 = F2(function(f, d1)
1349{
1350	return _Json_mapMany(f, [d1]);
1351});
1352
1353var _Json_map2 = F3(function(f, d1, d2)
1354{
1355	return _Json_mapMany(f, [d1, d2]);
1356});
1357
1358var _Json_map3 = F4(function(f, d1, d2, d3)
1359{
1360	return _Json_mapMany(f, [d1, d2, d3]);
1361});
1362
1363var _Json_map4 = F5(function(f, d1, d2, d3, d4)
1364{
1365	return _Json_mapMany(f, [d1, d2, d3, d4]);
1366});
1367
1368var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)
1369{
1370	return _Json_mapMany(f, [d1, d2, d3, d4, d5]);
1371});
1372
1373var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)
1374{
1375	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);
1376});
1377
1378var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)
1379{
1380	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
1381});
1382
1383var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)
1384{
1385	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
1386});
1387
1388
1389// DECODE
1390
1391var _Json_runOnString = F2(function(decoder, string)
1392{
1393	try
1394	{
1395		var value = JSON.parse(string);
1396		return _Json_runHelp(decoder, value);
1397	}
1398	catch (e)
1399	{
1400		return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not val

1400id JSON! ' + e.message, _Json_wrap(string)));
1401	}
1402});
1403
1404var _Json_run = F2(function(decoder, value)
1405{
1406	return _Json_runHelp(decoder, _Json_unwrap(value));
1407});
1408
1409function _Json_runHelp(decoder, value)
1410{
1411	switch (decoder.$)
1412	{
1413		case 2:
1414			return decoder.b(value);
1415
1416		case 5:
1417			return (value === null)
1418				? $elm$core$Result$Ok(decoder.c)
1419				: _Json_expecting('null', value);
1420
1421		case 3:
1422			if (!_Json_isArray(value))
1423			{
1424				return _Json_expecting('a LIST', value);
1425			}
1426			return _Json_runArrayDecoder(decoder.b, value, _List_fromArray);
1427
1428		case 4:
1429			if (!_Json_isArray(value))
1430			{
1431				return _Json_expecting('an ARRAY', value);
1432			}
1433			return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);
1434
1435		case 6:
1436			var field = decoder.d;
1437			if (typeof value !== 'object' || value === null || !(field in value))
1438			{
1439				return _Json_expecting('an OBJECT with a field named `' + field + '`', value);
1440			}
1441			var result = _Json_runHelp(decoder.b, value[field]);
1442			return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a));
1443
1444		case 7:
1445			var index = decoder.e;
1446			if (!_Json_isArray(value))
1447			{
1448				return _Json_expecting('an ARRAY', value);
1449			}
1450			if (index >= value.length)
1451			{
1452				return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);
1453			}
1454			var result = _Json_runHelp(decoder.b, value[index]);
1455			return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a));
1456
1457		case 8:
1458			if (typeof value !== 'object' || value === null || _Json_isArray(value))
1459			{
1460				return _Json_expecting('an OBJECT', value);
1461			}
1462
1463			var keyValuePairs = _List_Nil;
1464			// TODO test perf of Object.keys and switch when support is good enough
1465			for (var key in value)
1466			{
1467				if (value.hasOwnProperty(key))
1468				{
1469					var result = _Json_runHelp(decoder.b, value[key]);
1470					if (!$elm$core$Result$isOk(result))
1471					{
1472						return $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a));
1473					}
1474					keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);
1475				}
1476			}
1477			return $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs));
1478
1479		case 9:
1480			var answer = decoder.f;
1481			var decoders = decoder.g;
1482			for (var i = 0; i < decoders.length; i++)
1483			{
1484				var result = _Json_runHelp(decoders[i], value);
1485				if (!$elm$core$Result$isOk(result))
1486				{
1487					return result;
1488				}
1489				answer = answer(result.a);
1490			}
1491			return $elm$core$Result$Ok(answer);
1492
1493		case 10:
1494			var result = _Json_runHelp(decoder.b, value);
1495			return (!$elm$core$Result$isOk(result))
1496				? result
1497				: _Json_runHelp(decoder.h(result.a), value);
1498
1499		case 11:
1500			var errors = _List_Nil;
1501			for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS
1502			{
1503				var result = _Json_runHelp(temp.a, value);
1504				if ($elm$core$Result$isOk(result))
1505				{
1506					return result;
1507				}
1508				errors = _List_Cons(result.a, errors);
1509			}
1510			return $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)));
1511
1512		case 1:
1513			return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));
1514
1515		case 0:
1516			return $elm$core$Result$Ok(decoder.a);
1517	}
1518}
1519
1520function _Json_runArrayDecoder(decoder, value, toElmValue)
1521{
1522	var len = value.length;
1523	var array = new Array(len);
1524	for (var i = 0; i < len; i++)
1525	{
1526		var result = _Json_runHelp(decoder, value[i]);
1527		if (!$elm$core$Result$isOk(result))
1528		{
1529			return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a));
1530		}
1531		array[i] = result.a;
1532	}
1533	return $elm$core$Result$Ok(toElmValue(array));
1534}
1535
1536function _Json_isArray(value)
1537{
1538	return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);
1539}
1540
1541function _Json_toElmArray(array)
1542{
1543	return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; });
1544}
1545
1546function _Json_expecting(type, value)
1547{
1548	return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));
1549}
1550
1551
1552// EQUALITY
1553
1554function _Json_equality(x, y)
1555{
1556	if (x === y)
1557	{
1558		return true;
1559	}
1560
1561	if (x.$ !== y.$)
1562	{
1563		return false;

1564	}
1565
1566	switch (x.$)
1567	{
1568		case 0:
1569		case 1:
1570			return x.a === y.a;
1571
1572		case 2:
1573			return x.b === y.b;
1574
1575		case 5:
1576			return x.c === y.c;
1577
1578		case 3:
1579		case 4:
1580		case 8:
1581			return _Json_equality(x.b, y.b);
1582
1583		case 6:
1584			return x.d === y.d && _Json_equality(x.b, y.b);
1585
1586		case 7:
1587			return x.e === y.e && _Json_equality(x.b, y.b);
1588
1589		case 9:
1590			return x.f === y.f && _Json_listEquality(x.g, y.g);
1591
1592		case 10:
1593			return x.h === y.h && _Json_equality(x.b, y.b);
1594
1595		case 11:
1596			return _Json_listEquality(x.g, y.g);
1597	}
1598}
1599
1600function _Json_listEquality(aDecoders, bDecoders)
1601{
1602	var len = aDecoders.length;
1603	if (len !== bDecoders.length)
1604	{
1605		return false;
1606	}
1607	for (var i = 0; i < len; i++)
1608	{
1609		if (!_Json_equality(aDecoders[i], bDecoders[i]))
1610		{
1611			return false;
1612		}
1613	}
1614	return true;
1615}
1616
1617
1618// ENCODE
1619
1620var _Json_encode = F2(function(indentLevel, value)
1621{
1622	return JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';
1623});
1624
1625function _Json_wrap_UNUSED(value) { return { $: 0, a: value }; }
1626function _Json_unwrap_UNUSED(value) { return value.a; }
1627
1628function _Json_wrap(value) { return value; }
1629function _Json_unwrap(value) { return value; }
1630
1631function _Json_emptyArray() { return []; }
1632function _Json_emptyObject() { return {}; }
1633
1634var _Json_addField = F3(function(key, value, object)
1635{
1636	object[key] = _Json_unwrap(value);
1637	return object;
1638});
1639
1640function _Json_addEntry(func)
1641{
1642	return F2(function(entry, array)
1643	{
1644		array.push(_Json_unwrap(func(entry)));
1645		return array;
1646	});
1647}
1648
1649var _Json_encodeNull = _Json_wrap(null);
1650
1651
1652
1653// TASKS
1654
1655function _Scheduler_succeed(value)
1656{
1657	return {
1658		$: 0,
1659		a: value
1660	};
1661}
1662
1663function _Scheduler_fail(error)
1664{
1665	return {
1666		$: 1,
1667		a: error
1668	};
1669}
1670
1671function _Scheduler_binding(callback)
1672{
1673	return {
1674		$: 2,
1675		b: callback,
1676		c: null
1677	};
1678}
1679
1680var _Scheduler_andThen = F2(function(callback, task)
1681{
1682	return {
1683		$: 3,
1684		b: callback,
1685		d: task
1686	};
1687});
1688
1689var _Scheduler_onError = F2(function(callback, task)
1690{
1691	return {
1692		$: 4,
1693		b: callback,
1694		d: task
1695	};
1696});
1697
1698function _Scheduler_receive(callback)
1699{
1700	return {
1701		$: 5,
1702		b: callback
1703	};
1704}
1705
1706
1707// PROCESSES
1708
1709var _Scheduler_guid = 0;
1710
1711function _Scheduler_rawSpawn(task)
1712{
1713	var proc = {
1714		$: 0,
1715		e: _Scheduler_guid++,
1716		f: task,
1717		g: null,
1718		h: []
1719	};
1720
1721	_Scheduler_enqueue(proc);
1722
1723	return proc;
1724}
1725
1726function _Scheduler_spawn(task)
1727{
1728	return _Scheduler_binding(function(callback) {
1729		callback(_Scheduler_succeed(_Scheduler_rawSpawn(task)));
1730	});
1731}
1732
1733function _Scheduler_rawSend(proc, msg)
1734{
1735	proc.h.push(msg);
1736	_Scheduler_enqueue(proc);
1737}
1738
1739var _Scheduler_send = F2(function(proc, msg)
1740{
1741	return _Scheduler_binding(function(callback) {
1742		_Scheduler_rawSend(proc, msg);
1743		callback(_Scheduler_succeed(_Utils_Tuple0));
1744	});
1745});
1746
1747function _Scheduler_kill(proc)
1748{
1749	return _Scheduler_binding(function(callback) {
1750		var task = proc.f;
1751		if (task.$ === 2 && task.c)
1752		{
1753			task.c();
1754		}
1755
1756		proc.f = null;
1757
1758		callback(_Scheduler_succeed(_Utils_Tuple0));
1759	});
1760}
1761
1762
1763/* STEP PROCESSES
1764
1765type alias Process =
1766  { $ : tag
1767  , id : unique_id
1768  , root : Task
1769  , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack }
1770  , mailbox : [msg]
1771  }
1772
1773*/
1774
1775
1776var _Scheduler_working = false;
1777var _Scheduler_queue = [];
1778
1779
1780function _Scheduler_enqueue(proc)
1781{
1782	_Scheduler_queue.push(proc);
1783	if (_Scheduler_working)
1784	{
1785		return;
1786	}
1787	_Scheduler_working = true;
1788	while (proc = _Scheduler_queue.shift())
1789	{
1790		_Scheduler_step(proc);
1791	}
1792	_Scheduler_working = false;
1793}
1794
1795
1796function _Scheduler_step(proc)
1797{
1798	while (proc.f)
1799	{
1800		var rootTag = proc.f.$;
1801		if (rootTag === 0 || rootTag === 1)
1802		{
1803			while (proc.g && proc.g.$ !== rootTag)
1804			{
1805				proc.g = proc.g.i;
1806			}
1807			if (!proc.g)
1808			{
1809				return;
1810			}
1811			proc.f = proc.g.b(proc.f.a);
1812			proc.g = proc.g.i;
1813		}
1814		else if (rootTag === 2)
1815		{
1816			proc.f.c = proc.f.b(function(newRoot) {
1817				proc.f = newRoot;
1818				_Scheduler_enqueue(proc);
1819			});
1820			return;
1821		}
1822		else if (rootTag === 5)
1823		{
1824			if (proc.h.length === 0)
1825			{
1826				return;
1827			}
1828			proc.f = proc.f.b(proc.h.shift());
1829		}
1830		else // if (rootTag === 3 || rootTag === 4)
1831		{
1832			proc.g = {
1833				$: rootTag === 3 ? 0 : 1,
1834				b: proc.f.b,
1835				i: proc.g
1836			};
1837			proc.f = proc.f.d;
1838		}
1839	}
1840}
1841
1842
1843
1844function _Process_sleep(time)
1845{
1846	return _Scheduler_binding(function(callback) {
1847		var id = setTimeout(function() {

1848			callback(_Scheduler_succeed(_Utils_Tuple0));
1849		}, time);
1850
1851		return function() { clearTimeout(id); };
1852	});
1853}
1854
1855
1856
1857
1858// PROGRAMS
1859
1860
1861var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args)
1862{
1863	return _Platform_initialize(
1864		flagDecoder,
1865		args,
1866		impl.fQ,
1867		impl.ha,
1868		impl.gQ,
1869		function() { return function() {} }
1870	);
1871});
1872
1873
1874
1875// INITIALIZE A PROGRAM
1876
1877
1878function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder)
1879{
1880	var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined));
1881	$elm$core$Result$isOk(result) || _Debug_crash(2 /**_UNUSED/, _Json_errorToString(result.a) /**/);
1882	var managers = {};
1883	var initPair = init(result.a);
1884	var model = initPair.a;
1885	var stepper = stepperBuilder(sendToApp, model);
1886	var ports = _Platform_setupEffects(managers, sendToApp);
1887
1888	function sendToApp(msg, viewMetadata)
1889	{
1890		var pair = A2(update, msg, model);
1891		stepper(model = pair.a, viewMetadata);
1892		_Platform_enqueueEffects(managers, pair.b, subscriptions(model));
1893	}
1894
1895	_Platform_enqueueEffects(managers, initPair.b, subscriptions(model));
1896
1897	return ports ? { ports: ports } : {};
1898}
1899
1900
1901
1902// TRACK PRELOADS
1903//
1904// This is used by code in elm/browser and elm/http
1905// to register any HTTP requests that are triggered by init.
1906//
1907
1908
1909var _Platform_preload;
1910
1911
1912function _Platform_registerPreload(url)
1913{
1914	_Platform_preload.add(url);
1915}
1916
1917
1918
1919// EFFECT MANAGERS
1920
1921
1922var _Platform_effectManagers = {};
1923
1924
1925function _Platform_setupEffects(managers, sendToApp)
1926{
1927	var ports;
1928
1929	// setup all necessary effect managers
1930	for (var key in _Platform_effectManagers)
1931	{
1932		var manager = _Platform_effectManagers[key];
1933
1934		if (manager.a)
1935		{
1936			ports = ports || {};
1937			ports[key] = manager.a(key, sendToApp);
1938		}
1939
1940		managers[key] = _Platform_instantiateManager(manager, sendToApp);
1941	}
1942
1943	return ports;
1944}
1945
1946
1947function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap)
1948{
1949	return {
1950		b: init,
1951		c: onEffects,
1952		d: onSelfMsg,
1953		e: cmdMap,
1954		f: subMap
1955	};
1956}
1957
1958
1959function _Platform_instantiateManager(info, sendToApp)
1960{
1961	var router = {
1962		g: sendToApp,
1963		h: undefined
1964	};
1965
1966	var onEffects = info.c;
1967	var onSelfMsg = info.d;
1968	var cmdMap = info.e;
1969	var subMap = info.f;
1970
1971	function loop(state)
1972	{
1973		return A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg)
1974		{
1975			var value = msg.a;
1976
1977			if (msg.$ === 0)
1978			{
1979				return A3(onSelfMsg, router, value, state);
1980			}
1981
1982			return cmdMap && subMap
1983				? A4(onEffects, router, value.i, value.j, state)
1984				: A3(onEffects, router, cmdMap ? value.i : value.j, state);
1985		}));
1986	}
1987
1988	return router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b));
1989}
1990
1991
1992
1993// ROUTING
1994
1995
1996var _Platform_sendToApp = F2(function(router, msg)
1997{
1998	return _Scheduler_binding(function(callback)
1999	{
2000		router.g(msg);
2001		callback(_Scheduler_succeed(_Utils_Tuple0));
2002	});
2003});
2004
2005
2006var _Platform_sendToSelf = F2(function(router, msg)
2007{
2008	return A2(_Scheduler_send, router.h, {
2009		$: 0,
2010		a: msg
2011	});
2012});
2013
2014
2015
2016// BAGS
2017
2018
2019function _Platform_leaf(home)
2020{
2021	return function(value)
2022	{
2023		return {
2024			$: 1,
2025			k: home,
2026			l: value
2027		};
2028	};
2029}
2030
2031
2032function _Platform_batch(list)
2033{
2034	return {
2035		$: 2,
2036		m: list
2037	};
2038}
2039
2040
2041var _Platform_map = F2(function(tagger, bag)
2042{
2043	return {
2044		$: 3,
2045		n: tagger,
2046		o: bag
2047	}
2048});
2049
2050
2051
2052// PIPE BAGS INTO EFFECT MANAGERS
2053//
2054// Effects must be queued!
2055//
2056// Say your init contains a synchronous command, like Time.now or Time.here
2057//
2058//   - This will produce a batch of effects (FX_1)
2059//   - The synchronous task triggers the subsequent `update` call
2060//   - This will produce a batch of effects (FX_2)
2061//
2062// If we just start dispatching FX_2, subscriptions from FX_2 can be processed
2063// before subscriptions from FX_1. No good! Earlier versions of this code had
2064// this problem, leading to these reports:
2065//
2066//   https://github.com/elm/core/issues/980
2067//   https://github.com/elm/core/pull/981
2068//   https://github.com/elm/compiler/issues/1776
2069//
2070// The queue is necessary to avoid ordering issues for synchronous commands.
2071
2072
2073// Why use true/false here? Why not just check the length of the queue?
2074// The goal is to detect "are we currently dispatching effects?" If we
2075// are, we need to bail and let the ongoing while loop handle things.
2076//
2077// Now say the queue has 1 element. When we dequeue the final element,
2078// the queue will be empty, but we are still actively dispatching effects.
2079// So you could get queue jumping in a really tricky category of cases.
2080//
2081var _Platform_effectsQueue = [];
2082var _Platform_effectsActive = false;

2083
2084
2085function _Platform_enqueueEffects(managers, cmdBag, subBag)
2086{
2087	_Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag });
2088
2089	if (_Platform_effectsActive) return;
2090
2091	_Platform_effectsActive = true;
2092	for (var fx; fx = _Platform_effectsQueue.shift(); )
2093	{
2094		_Platform_dispatchEffects(fx.p, fx.q, fx.r);
2095	}
2096	_Platform_effectsActive = false;
2097}
2098
2099
2100function _Platform_dispatchEffects(managers, cmdBag, subBag)
2101{
2102	var effectsDict = {};
2103	_Platform_gatherEffects(true, cmdBag, effectsDict, null);
2104	_Platform_gatherEffects(false, subBag, effectsDict, null);
2105
2106	for (var home in managers)
2107	{
2108		_Scheduler_rawSend(managers[home], {
2109			$: 'fx',
2110			a: effectsDict[home] || { i: _List_Nil, j: _List_Nil }
2111		});
2112	}
2113}
2114
2115
2116function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers)
2117{
2118	switch (bag.$)
2119	{
2120		case 1:
2121			var home = bag.k;
2122			var effect = _Platform_toEffect(isCmd, home, taggers, bag.l);
2123			effectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]);
2124			return;
2125
2126		case 2:
2127			for (var list = bag.m; list.b; list = list.b) // WHILE_CONS
2128			{
2129				_Platform_gatherEffects(isCmd, list.a, effectsDict, taggers);
2130			}
2131			return;
2132
2133		case 3:
2134			_Platform_gatherEffects(isCmd, bag.o, effectsDict, {
2135				s: bag.n,
2136				t: taggers
2137			});
2138			return;
2139	}
2140}
2141
2142
2143function _Platform_toEffect(isCmd, home, taggers, value)
2144{
2145	function applyTaggers(x)
2146	{
2147		for (var temp = taggers; temp; temp = temp.t)
2148		{
2149			x = temp.s(x);
2150		}
2151		return x;
2152	}
2153
2154	var map = isCmd
2155		? _Platform_effectManagers[home].e
2156		: _Platform_effectManagers[home].f;
2157
2158	return A2(map, applyTaggers, value)
2159}
2160
2161
2162function _Platform_insert(isCmd, newEffect, effects)
2163{
2164	effects = effects || { i: _List_Nil, j: _List_Nil };
2165
2166	isCmd
2167		? (effects.i = _List_Cons(newEffect, effects.i))
2168		: (effects.j = _List_Cons(newEffect, effects.j));
2169
2170	return effects;
2171}
2172
2173
2174
2175// PORTS
2176
2177
2178function _Platform_checkPortName(name)
2179{
2180	if (_Platform_effectManagers[name])
2181	{
2182		_Debug_crash(3, name)
2183	}
2184}
2185
2186
2187
2188// OUTGOING PORTS
2189
2190
2191function _Platform_outgoingPort(name, converter)
2192{
2193	_Platform_checkPortName(name);
2194	_Platform_effectManagers[name] = {
2195		e: _Platform_outgoingPortMap,
2196		u: converter,
2197		a: _Platform_setupOutgoingPort
2198	};
2199	return _Platform_leaf(name);
2200}
2201
2202
2203var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; });
2204
2205
2206function _Platform_setupOutgoingPort(name)
2207{
2208	var subs = [];
2209	var converter = _Platform_effectManagers[name].u;
2210
2211	// CREATE MANAGER
2212
2213	var init = _Process_sleep(0);
2214
2215	_Platform_effectManagers[name].b = init;
2216	_Platform_effectManagers[name].c = F3(function(router, cmdList, state)
2217	{
2218		for ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS
2219		{
2220			// grab a separate reference to subs in case unsubscribe is called
2221			var currentSubs = subs;
2222			var value = _Json_unwrap(converter(cmdList.a));
2223			for (var i = 0; i < currentSubs.length; i++)
2224			{
2225				currentSubs[i](value);
2226			}
2227		}
2228		return init;
2229	});
2230
2231	// PUBLIC API
2232
2233	function subscribe(callback)
2234	{
2235		subs.push(callback);
2236	}
2237
2238	function unsubscribe(callback)
2239	{
2240		// copy subs into a new array in case unsubscribe is called within a
2241		// subscribed callback
2242		subs = subs.slice();
2243		var index = subs.indexOf(callback);
2244		if (index >= 0)
2245		{
2246			subs.splice(index, 1);
2247		}
2248	}
2249
2250	return {
2251		subscribe: subscribe,
2252		unsubscribe: unsubscribe
2253	};
2254}
2255
2256
2257
2258// INCOMING PORTS
2259
2260
2261function _Platform_incomingPort(name, converter)
2262{
2263	_Platform_checkPortName(name);
2264	_Platform_effectManagers[name] = {
2265		f: _Platform_incomingPortMap,
2266		u: converter,
2267		a: _Platform_setupIncomingPort
2268	};
2269	return _Platform_leaf(name);
2270}
2271
2272
2273var _Platform_incomingPortMap = F2(function(tagger, finalTagger)
2274{
2275	return function(value)
2276	{
2277		return tagger(finalTagger(value));
2278	};
2279});
2280
2281
2282function _Platform_setupIncomingPort(name, sendToApp)
2283{
2284	var subs = _List_Nil;
2285	var converter = _Platform_effectManagers[name].u;
2286
2287	// CREATE MANAGER
2288
2289	var init = _Scheduler_succeed(null);
2290
2291	_Platform_effectManagers[name].b = init;
2292	_Platform_effectManagers[name].c = F3(function(router, subList, state)
2293	{
2294		subs = subList;
2295		return init;
2296	});
2297
2298	// PUBLIC API
2299
2300	function send(incomingValue)
2301	{
2302		var result = A2(_Json_run, converter, _Json_wrap(incomingValue));
2303
2304		$elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a);
2305
2306		var value = result.a;
2307		for (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS
2308		{
2309			sendToApp(temp.a(value));
2310		}
2311	}
2312
2313	return { send: send };
2314}
2315
2316
2317
2318// EXPORT ELM MODULES
2319//

2320// Have DEBUG and PROD versions so that we can (1) give nicer errors in
2321// debug mode and (2) not pay for the bits needed for that in prod mode.
2322//
2323
2324
2325function _Platform_export(exports)
2326{
2327	scope['Elm']
2328		? _Platform_mergeExportsProd(scope['Elm'], exports)
2329		: scope['Elm'] = exports;
2330}
2331
2332
2333function _Platform_mergeExportsProd(obj, exports)
2334{
2335	for (var name in exports)
2336	{
2337		(name in obj)
2338			? (name == 'init')
2339				? _Debug_crash(6)
2340				: _Platform_mergeExportsProd(obj[name], exports[name])
2341			: (obj[name] = exports[name]);
2342	}
2343}
2344
2345
2346function _Platform_export_UNUSED(exports)
2347{
2348	scope['Elm']
2349		? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports)
2350		: scope['Elm'] = exports;
2351}
2352
2353
2354function _Platform_mergeExportsDebug(moduleName, obj, exports)
2355{
2356	for (var name in exports)
2357	{
2358		(name in obj)
2359			? (name == 'init')
2360				? _Debug_crash(6, moduleName)
2361				: _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name])
2362			: (obj[name] = exports[name]);
2363	}
2364}
2365
2366
2367
2368
2369// HELPERS
2370
2371
2372var _VirtualDom_divertHrefToApp;
2373
2374var _VirtualDom_doc = typeof document !== 'undefined' ? document : {};
2375
2376
2377function _VirtualDom_appendChild(parent, child)
2378{
2379	parent.appendChild(child);
2380}
2381
2382var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args)
2383{
2384	// NOTE: this function needs _Platform_export available to work
2385
2386	/**/
2387	var node = args['node'];
2388	//*/
2389	/**_UNUSED/
2390	var node = args && args['node'] ? args['node'] : _Debug_crash(0);
2391	//*/
2392
2393	node.parentNode.replaceChild(
2394		_VirtualDom_render(virtualNode, function() {}),
2395		node
2396	);
2397
2398	return {};
2399});
2400
2401
2402
2403// TEXT
2404
2405
2406function _VirtualDom_text(string)
2407{
2408	return {
2409		$: 0,
2410		a: string
2411	};
2412}
2413
2414
2415
2416// NODE
2417
2418
2419var _VirtualDom_nodeNS = F2(function(namespace, tag)
2420{
2421	return F2(function(factList, kidList)
2422	{
2423		for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
2424		{
2425			var kid = kidList.a;
2426			descendantsCount += (kid.b || 0);
2427			kids.push(kid);
2428		}
2429		descendantsCount += kids.length;
2430
2431		return {
2432			$: 1,
2433			c: tag,
2434			d: _VirtualDom_organizeFacts(factList),
2435			e: kids,
2436			f: namespace,
2437			b: descendantsCount
2438		};
2439	});
2440});
2441
2442
2443var _VirtualDom_node = _VirtualDom_nodeNS(undefined);
2444
2445
2446
2447// KEYED NODE
2448
2449
2450var _VirtualDom_keyedNodeNS = F2(function(namespace, tag)
2451{
2452	return F2(function(factList, kidList)
2453	{
2454		for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
2455		{
2456			var kid = kidList.a;
2457			descendantsCount += (kid.b.b || 0);
2458			kids.push(kid);
2459		}
2460		descendantsCount += kids.length;
2461
2462		return {
2463			$: 2,
2464			c: tag,
2465			d: _VirtualDom_organizeFacts(factList),
2466			e: kids,
2467			f: namespace,
2468			b: descendantsCount
2469		};
2470	});
2471});
2472
2473
2474var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined);
2475
2476
2477
2478// CUSTOM
2479
2480
2481function _VirtualDom_custom(factList, model, render, diff)
2482{
2483	return {
2484		$: 3,
2485		d: _VirtualDom_organizeFacts(factList),
2486		g: model,
2487		h: render,
2488		i: diff
2489	};
2490}
2491
2492
2493
2494// MAP
2495
2496
2497var _VirtualDom_map = F2(function(tagger, node)
2498{
2499	return {
2500		$: 4,
2501		j: tagger,
2502		k: node,
2503		b: 1 + (node.b || 0)
2504	};
2505});
2506
2507
2508
2509// LAZY
2510
2511
2512function _VirtualDom_thunk(refs, thunk)
2513{
2514	return {
2515		$: 5,
2516		l: refs,
2517		m: thunk,
2518		k: undefined
2519	};
2520}
2521
2522var _VirtualDom_lazy = F2(function(func, a)
2523{
2524	return _VirtualDom_thunk([func, a], function() {
2525		return func(a);
2526	});
2527});
2528
2529var _VirtualDom_lazy2 = F3(function(func, a, b)
2530{
2531	return _VirtualDom_thunk([func, a, b], function() {
2532		return A2(func, a, b);
2533	});
2534});
2535
2536var _VirtualDom_lazy3 = F4(function(func, a, b, c)
2537{
2538	return _VirtualDom_thunk([func, a, b, c], function() {
2539		return A3(func, a, b, c);
2540	});
2541});
2542
2543var _VirtualDom_lazy4 = F5(function(func, a, b, c, d)
2544{
2545	return _VirtualDom_thunk([func, a, b, c, d], function() {
2546		return A4(func, a, b, c, d);
2547	});
2548});
2549
2550var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e)
2551{
2552	return _VirtualDom_thunk([func, a, b, c, d, e], function() {
2553		return A5(func, a, b, c, d, e);
2554	});
2555});
2556
2557var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f)
2558{
2559	return _VirtualDom_thunk([func, a, b, c, d, e, f], function() {
2560		return A6(func, a, b, c, d, e, f);
2561	});
2562});
2563
2564var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g)
2565{
2566	return _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() {
2567		return A7(func, a, b, c, d, e, f, g);
2568	});
2569});
2570
2571var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h)
2572{
2573	return _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() {
2574		return A8(func, a, b, c, d, e, f, g, h);
2575	});
2576});
2577
2578
2579
2580// FACTS
2581
2582
2583var _VirtualDom_on = F2(function(key, handler)
2584{
2585	return {
2586		$: 'a0',
2587		n: key,
2588		o: handler
2589	};
2590});
2591var _VirtualDom_style = F2(function(key, value)
2592{
2593	return {
2594		$: 'a1',
2595		n: key,
2596		o: value
2597	};
2598});
2599var _VirtualDom_property = F2(function(key, value)
2600{
2601	return {
2602		$: 'a2',
2603		n: key,
2604		o: value
2605	};
2606});
2607var _VirtualDom_attribute = F2(function(key, value)
2608{
2609	return {
2610		$: 'a3',
2611		n: key,
2612		o: value
2613	};
2614});
2615var _VirtualDom_attributeNS = F3(function(namespace, key, value)
2616{
2617	return {
2618		$: 'a4',
2619		n: key,
2620		o: { f: namespace, o: value }
2621	};
2622});
2623
2624
2625
2626// XSS ATTACK VECTOR CHECKS
2627//
2628// For some reason, tabs can appear in href protocols and it still works.
2629// So '\tjava\tSCRIPT:alert("!!!")' and 'javascript:alert("!!!")' are the same

2630// in practice. That is why _VirtualDom_RE_js and _VirtualDom_RE_js_html look
2631// so freaky.
2632//
2633// Pulling the regular expressions out to the top level gives a slight speed
2634// boost in small benchmarks (4-10%) but hoisting values to reduce allocation
2635// can be unpredictable in large programs where JIT may have a harder time with
2636// functions are not fully self-contained. The benefit is more that the js and
2637// js_html ones are so weird that I prefer to see them near each other.
2638
2639
2640var _VirtualDom_RE_script = /^script$/i;
2641var _VirtualDom_RE_on_formAction = /^(on|formAction$)/i;
2642var _VirtualDom_RE_js = /^\s*j\s*a\s*v\s*a\s*s\s*c\s*r\s*i\s*p\s*t\s*:/i;
2643var _VirtualDom_RE_js_html = /^\s*(j\s*a\s*v\s*a\s*s\s*c\s*r\s*i\s*p\s*t\s*:|d\s*a\s*t\s*a\s*:\s*t\s*e\s*x\s*t\s*\/\s*h\s*t\s*m\s*l\s*(,|;))/i;
2644
2645
2646function _VirtualDom_noScript(tag)
2647{
2648	return _VirtualDom_RE_script.test(tag) ? 'p' : tag;
2649}
2650
2651function _VirtualDom_noOnOrFormAction(key)
2652{
2653	return _VirtualDom_RE_on_formAction.test(key) ? 'data-' + key : key;
2654}
2655
2656function _VirtualDom_noInnerHtmlOrFormAction(key)
2657{
2658	return key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key;
2659}
2660
2661function _VirtualDom_noJavaScriptUri(value)
2662{
2663	return _VirtualDom_RE_js.test(value)
2664		? /**/''//*//**_UNUSED/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/
2665		: value;
2666}
2667
2668function _VirtualDom_noJavaScriptOrHtmlUri(value)
2669{
2670	return _VirtualDom_RE_js_html.test(value)
2671		? /**/''//*//**_UNUSED/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/
2672		: value;
2673}
2674
2675function _VirtualDom_noJavaScriptOrHtmlJson(value)
2676{
2677	return (typeof _Json_unwrap(value) === 'string' && _VirtualDom_RE_js_html.test(_Json_unwrap(value)))
2678		? _Json_wrap(
2679			/**/''//*//**_UNUSED/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/
2680		) : value;
2681}
2682
2683
2684
2685// MAP FACTS
2686
2687
2688var _VirtualDom_mapAttribute = F2(function(func, attr)
2689{
2690	return (attr.$ === 'a0')
2691		? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o))
2692		: attr;
2693});
2694
2695function _VirtualDom_mapHandler(func, handler)
2696{
2697	var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2698
2699	// 0 = Normal
2700	// 1 = MayStopPropagation
2701	// 2 = MayPreventDefault
2702	// 3 = Custom
2703
2704	return {
2705		$: handler.$,
2706		a:
2707			!tag
2708				? A2($elm$json$Json$Decode$map, func, handler.a)
2709				:
2710			A3($elm$json$Json$Decode$map2,
2711				tag < 3
2712					? _VirtualDom_mapEventTuple
2713					: _VirtualDom_mapEventRecord,
2714				$elm$json$Json$Decode$succeed(func),
2715				handler.a
2716			)
2717	};
2718}
2719
2720var _VirtualDom_mapEventTuple = F2(function(func, tuple)
2721{
2722	return _Utils_Tuple2(func(tuple.a), tuple.b);
2723});
2724
2725var _VirtualDom_mapEventRecord = F2(function(func, record)
2726{
2727	return {
2728		as: func(record.as),
2729		cW: record.cW,
2730		cN: record.cN
2731	}
2732});
2733
2734
2735
2736// ORGANIZE FACTS
2737
2738
2739function _VirtualDom_organizeFacts(factList)
2740{
2741	for (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS
2742	{
2743		var entry = factList.a;
2744
2745		var tag = entry.$;
2746		var key = entry.n;
2747		var value = entry.o;
2748
2749		if (tag === 'a2')
2750		{
2751			(key === 'className')
2752				? _VirtualDom_addClass(facts, key, _Json_unwrap(value))
2753				: facts[key] = _Json_unwrap(value);
2754
2755			continue;
2756		}
2757
2758		var subFacts = facts[tag] || (facts[tag] = {});
2759		(tag === 'a3' && key === 'class')
2760			? _VirtualDom_addClass(subFacts, key, value)
2761			: subFacts[key] = value;
2762	}
2763
2764	return facts;
2765}
2766
2767function _VirtualDom_addClass(object, key, newClass)
2768{
2769	var classes = object[key];
2770	object[key] = classes ? classes + ' ' + newClass : newClass;
2771}
2772
2773
2774
2775// RENDER
2776
2777
2778function _VirtualDom_render(vNode, eventNode)
2779{
2780	var tag = vNode.$;
2781
2782	if (tag === 5)
2783	{
2784		return _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode);
2785	}
2786
2787	if (tag === 0)
2788	{
2789		return _VirtualDom_doc.createTextNode(vNode.a);
2790	}
2791
2792	if (tag === 4)
2793	{
2794		var subNode = vNode.k;
2795		var tagger = vNode.j;
2796
2797		while (subNode.$ === 4)
2798		{
2799			typeof tagger !== 'object'
2800				? tagger = [tagger, subNode.j]
2801				: tagger.push(subNode.j);
2802
2803			subNode = subNode.k;
2804		}
2805
2806		var subEventRoot = { j: tagger, p: eventNode };

2807		var domNode = _VirtualDom_render(subNode, subEventRoot);
2808		domNode.elm_event_node_ref = subEventRoot;
2809		return domNode;
2810	}
2811
2812	if (tag === 3)
2813	{
2814		var domNode = vNode.h(vNode.g);
2815		_VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2816		return domNode;
2817	}
2818
2819	// at this point `tag` must be 1 or 2
2820
2821	var domNode = vNode.f
2822		? _VirtualDom_doc.createElementNS(vNode.f, vNode.c)
2823		: _VirtualDom_doc.createElement(vNode.c);
2824
2825	if (_VirtualDom_divertHrefToApp && vNode.c == 'a')
2826	{
2827		domNode.addEventListener('click', _VirtualDom_divertHrefToApp(domNode));
2828	}
2829
2830	_VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2831
2832	for (var kids = vNode.e, i = 0; i < kids.length; i++)
2833	{
2834		_VirtualDom_appendChild(domNode, _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode));
2835	}
2836
2837	return domNode;
2838}
2839
2840
2841
2842// APPLY FACTS
2843
2844
2845function _VirtualDom_applyFacts(domNode, eventNode, facts)
2846{
2847	for (var key in facts)
2848	{
2849		var value = facts[key];
2850
2851		key === 'a1'
2852			? _VirtualDom_applyStyles(domNode, value)
2853			:
2854		key === 'a0'
2855			? _VirtualDom_applyEvents(domNode, eventNode, value)
2856			:
2857		key === 'a3'
2858			? _VirtualDom_applyAttrs(domNode, value)
2859			:
2860		key === 'a4'
2861			? _VirtualDom_applyAttrsNS(domNode, value)
2862			:
2863		((key !== 'value' && key !== 'checked') || domNode[key] !== value) && (domNode[key] = value);
2864	}
2865}
2866
2867
2868
2869// APPLY STYLES
2870
2871
2872function _VirtualDom_applyStyles(domNode, styles)
2873{
2874	var domNodeStyle = domNode.style;
2875
2876	for (var key in styles)
2877	{
2878		domNodeStyle[key] = styles[key];
2879	}
2880}
2881
2882
2883
2884// APPLY ATTRS
2885
2886
2887function _VirtualDom_applyAttrs(domNode, attrs)
2888{
2889	for (var key in attrs)
2890	{
2891		var value = attrs[key];
2892		typeof value !== 'undefined'
2893			? domNode.setAttribute(key, value)
2894			: domNode.removeAttribute(key);
2895	}
2896}
2897
2898
2899
2900// APPLY NAMESPACED ATTRS
2901
2902
2903function _VirtualDom_applyAttrsNS(domNode, nsAttrs)
2904{
2905	for (var key in nsAttrs)
2906	{
2907		var pair = nsAttrs[key];
2908		var namespace = pair.f;
2909		var value = pair.o;
2910
2911		typeof value !== 'undefined'
2912			? domNode.setAttributeNS(namespace, key, value)
2913			: domNode.removeAttributeNS(namespace, key);
2914	}
2915}
2916
2917
2918
2919// APPLY EVENTS
2920
2921
2922function _VirtualDom_applyEvents(domNode, eventNode, events)
2923{
2924	var allCallbacks = domNode.elmFs || (domNode.elmFs = {});
2925
2926	for (var key in events)
2927	{
2928		var newHandler = events[key];
2929		var oldCallback = allCallbacks[key];
2930
2931		if (!newHandler)
2932		{
2933			domNode.removeEventListener(key, oldCallback);
2934			allCallbacks[key] = undefined;
2935			continue;
2936		}
2937
2938		if (oldCallback)
2939		{
2940			var oldHandler = oldCallback.q;
2941			if (oldHandler.$ === newHandler.$)
2942			{
2943				oldCallback.q = newHandler;
2944				continue;
2945			}
2946			domNode.removeEventListener(key, oldCallback);
2947		}
2948
2949		oldCallback = _VirtualDom_makeCallback(eventNode, newHandler);
2950		domNode.addEventListener(key, oldCallback,
2951			_VirtualDom_passiveSupported
2952			&& { passive: $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 }
2953		);
2954		allCallbacks[key] = oldCallback;
2955	}
2956}
2957
2958
2959
2960// PASSIVE EVENTS
2961
2962
2963var _VirtualDom_passiveSupported;
2964
2965try
2966{
2967	window.addEventListener('t', null, Object.defineProperty({}, 'passive', {
2968		get: function() { _VirtualDom_passiveSupported = true; }
2969	}));
2970}
2971catch(e) {}
2972
2973
2974
2975// EVENT HANDLERS
2976
2977
2978function _VirtualDom_makeCallback(eventNode, initialHandler)
2979{
2980	function callback(event)
2981	{
2982		var handler = callback.q;
2983		var result = _Json_runHelp(handler.a, event);
2984
2985		if (!$elm$core$Result$isOk(result))
2986		{
2987			return;
2988		}
2989
2990		var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2991
2992		// 0 = Normal
2993		// 1 = MayStopPropagation
2994		// 2 = MayPreventDefault
2995		// 3 = Custom
2996
2997		var value = result.a;
2998		var message = !tag ? value : tag < 3 ? value.a : value.as;
2999		var stopPropagation = tag == 1 ? value.b : tag == 3 && value.cW;
3000		var currentEventNode = (
3001			stopPropagation && event.stopPropagation(),
3002			(tag == 2 ? value.b : tag == 3 && value.cN) && event.preventDefault(),
3003			eventNode
3004		);
3005		var tagger;
3006		var i;
3007		while (tagger = currentEventNode.j)
3008		{
3009			if (typeof tagger == 'function')
3010			{
3011				message = tagger(message);
3012			}
3013			else
3014			{
3015				for (var i = tagger.length; i--; )
3016				{
3017					message = tagger[i](message);
3018				}
3019			}
3020			currentEventNode = currentEventNode.p;
3021		}
3022		currentEventNode(message, stopPropagation); // stopPropagation implies isSync
3023	}
3024
3025	callback.q = initialHandler;
3026
3027	return callback;
3028}
3029
3030function _VirtualDom_equalEvents(x, y)
3031{
3032	return x.$ == y.$ && _Json_equality(x.a, y.a);
3033}
3034
3035
3036
3037// DIFF
3038
3039
3040// TODO: Should we do patches like in iOS?
3041//
3042// type Patch
3043//   = At Int Patch
3044//   | Batch (List Patch)
3045//   | Change ...
3046//
3047// How could it not be better?
3048//
3049function _VirtualDom_diff(x, y)
3050{
3051	var patches = [];
3052	_VirtualDom_diffHelp(x, y, patches, 0);
3053	return patches;
3054}
3055
3056

3057function _VirtualDom_pushPatch(patches, type, index, data)
3058{
3059	var patch = {
3060		$: type,
3061		r: index,
3062		s: data,
3063		t: undefined,
3064		u: undefined
3065	};
3066	patches.push(patch);
3067	return patch;
3068}
3069
3070
3071function _VirtualDom_diffHelp(x, y, patches, index)
3072{
3073	if (x === y)
3074	{
3075		return;
3076	}
3077
3078	var xType = x.$;
3079	var yType = y.$;
3080
3081	// Bail if you run into different types of nodes. Implies that the
3082	// structure has changed significantly and it's not worth a diff.
3083	if (xType !== yType)
3084	{
3085		if (xType === 1 && yType === 2)
3086		{
3087			y = _VirtualDom_dekey(y);
3088			yType = 1;
3089		}
3090		else
3091		{
3092			_VirtualDom_pushPatch(patches, 0, index, y);
3093			return;
3094		}
3095	}
3096
3097	// Now we know that both nodes are the same $.
3098	switch (yType)
3099	{
3100		case 5:
3101			var xRefs = x.l;
3102			var yRefs = y.l;
3103			var i = xRefs.length;
3104			var same = i === yRefs.length;
3105			while (same && i--)
3106			{
3107				same = xRefs[i] === yRefs[i];
3108			}
3109			if (same)
3110			{
3111				y.k = x.k;
3112				return;
3113			}
3114			y.k = y.m();
3115			var subPatches = [];
3116			_VirtualDom_diffHelp(x.k, y.k, subPatches, 0);
3117			subPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches);
3118			return;
3119
3120		case 4:
3121			// gather nested taggers
3122			var xTaggers = x.j;
3123			var yTaggers = y.j;
3124			var nesting = false;
3125
3126			var xSubNode = x.k;
3127			while (xSubNode.$ === 4)
3128			{
3129				nesting = true;
3130
3131				typeof xTaggers !== 'object'
3132					? xTaggers = [xTaggers, xSubNode.j]
3133					: xTaggers.push(xSubNode.j);
3134
3135				xSubNode = xSubNode.k;
3136			}
3137
3138			var ySubNode = y.k;
3139			while (ySubNode.$ === 4)
3140			{
3141				nesting = true;
3142
3143				typeof yTaggers !== 'object'
3144					? yTaggers = [yTaggers, ySubNode.j]
3145					: yTaggers.push(ySubNode.j);
3146
3147				ySubNode = ySubNode.k;
3148			}
3149
3150			// Just bail if different numbers of taggers. This implies the
3151			// structure of the virtual DOM has changed.
3152			if (nesting && xTaggers.length !== yTaggers.length)
3153			{
3154				_VirtualDom_pushPatch(patches, 0, index, y);
3155				return;
3156			}
3157
3158			// check if taggers are "the same"
3159			if (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers)
3160			{
3161				_VirtualDom_pushPatch(patches, 2, index, yTaggers);
3162			}
3163
3164			// diff everything below the taggers
3165			_VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1);
3166			return;
3167
3168		case 0:
3169			if (x.a !== y.a)
3170			{
3171				_VirtualDom_pushPatch(patches, 3, index, y.a);
3172			}
3173			return;
3174
3175		case 1:
3176			_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids);
3177			return;
3178
3179		case 2:
3180			_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids);
3181			return;
3182
3183		case 3:
3184			if (x.h !== y.h)
3185			{
3186				_VirtualDom_pushPatch(patches, 0, index, y);
3187				return;
3188			}
3189
3190			var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3191			factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3192
3193			var patch = y.i(x.g, y.g);
3194			patch && _VirtualDom_pushPatch(patches, 5, index, patch);
3195
3196			return;
3197	}
3198}
3199
3200// assumes the incoming arrays are the same length
3201function _VirtualDom_pairwiseRefEqual(as, bs)
3202{
3203	for (var i = 0; i < as.length; i++)
3204	{
3205		if (as[i] !== bs[i])
3206		{
3207			return false;
3208		}
3209	}
3210
3211	return true;
3212}
3213
3214function _VirtualDom_diffNodes(x, y, patches, index, diffKids)
3215{
3216	// Bail if obvious indicators have changed. Implies more serious
3217	// structural changes such that it's not worth it to diff.
3218	if (x.c !== y.c || x.f !== y.f)
3219	{
3220		_VirtualDom_pushPatch(patches, 0, index, y);
3221		return;
3222	}
3223
3224	var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3225	factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3226
3227	diffKids(x, y, patches, index);
3228}
3229
3230
3231
3232// DIFF FACTS
3233
3234
3235// TODO Instead of creating a new diff object, it's possible to just test if
3236// there *is* a diff. During the actual patch, do the diff again and make the
3237// modifications directly. This way, there's no new allocations. Worth it?
3238function _VirtualDom_diffFacts(x, y, category)
3239{
3240	var diff;
3241
3242	// look for changes and removals
3243	for (var xKey in x)
3244	{
3245		if (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4')
3246		{
3247			var subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey);
3248			if (subDiff)
3249			{
3250				diff = diff || {};
3251				diff[xKey] = subDiff;
3252			}
3253			continue;
3254		}
3255
3256		// remove if not in the new facts
3257		if (!(xKey in y))
3258		{
3259			diff = diff || {};
3260			diff[xKey] =
3261				!category
3262					? (typeof x[xKey] === 'string' ? '' : null)
3263					:
3264				(category === 'a1')
3265					? ''
3266					:
3267				(category === 'a0' || category === 'a3')
3268					? undefined
3269					:
3270				{ f: x[xKey].f, o: undefined };
3271
3272			continue;
3273		}
3274
3275		var xValue = x[xKey];
3276		var yValue = y[xKey];
3277
3278		// reference equal, so don't worry about it
3279		if (xValue === yValue && xKey !== 'value' && xKey !== 'checked'
3280			|| category === 'a0' && _VirtualDom_equalEvents(xValue, yValue))
3281		{

3282			continue;
3283		}
3284
3285		diff = diff || {};
3286		diff[xKey] = yValue;
3287	}
3288
3289	// add new stuff
3290	for (var yKey in y)
3291	{
3292		if (!(yKey in x))
3293		{
3294			diff = diff || {};
3295			diff[yKey] = y[yKey];
3296		}
3297	}
3298
3299	return diff;
3300}
3301
3302
3303
3304// DIFF KIDS
3305
3306
3307function _VirtualDom_diffKids(xParent, yParent, patches, index)
3308{
3309	var xKids = xParent.e;
3310	var yKids = yParent.e;
3311
3312	var xLen = xKids.length;
3313	var yLen = yKids.length;
3314
3315	// FIGURE OUT IF THERE ARE INSERTS OR REMOVALS
3316
3317	if (xLen > yLen)
3318	{
3319		_VirtualDom_pushPatch(patches, 6, index, {
3320			v: yLen,
3321			i: xLen - yLen
3322		});
3323	}
3324	else if (xLen < yLen)
3325	{
3326		_VirtualDom_pushPatch(patches, 7, index, {
3327			v: xLen,
3328			e: yKids
3329		});
3330	}
3331
3332	// PAIRWISE DIFF EVERYTHING ELSE
3333
3334	for (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++)
3335	{
3336		var xKid = xKids[i];
3337		_VirtualDom_diffHelp(xKid, yKids[i], patches, ++index);
3338		index += xKid.b || 0;
3339	}
3340}
3341
3342
3343
3344// KEYED DIFF
3345
3346
3347function _VirtualDom_diffKeyedKids(xParent, yParent, patches, rootIndex)
3348{
3349	var localPatches = [];
3350
3351	var changes = {}; // Dict String Entry
3352	var inserts = []; // Array { index : Int, entry : Entry }
3353	// type Entry = { tag : String, vnode : VNode, index : Int, data : _ }
3354
3355	var xKids = xParent.e;
3356	var yKids = yParent.e;
3357	var xLen = xKids.length;
3358	var yLen = yKids.length;
3359	var xIndex = 0;
3360	var yIndex = 0;
3361
3362	var index = rootIndex;
3363
3364	while (xIndex < xLen && yIndex < yLen)
3365	{
3366		var x = xKids[xIndex];
3367		var y = yKids[yIndex];
3368
3369		var xKey = x.a;
3370		var yKey = y.a;
3371		var xNode = x.b;
3372		var yNode = y.b;
3373
3374		var newMatch = undefined;
3375		var oldMatch = undefined;
3376
3377		// check if keys match
3378
3379		if (xKey === yKey)
3380		{
3381			index++;
3382			_VirtualDom_diffHelp(xNode, yNode, localPatches, index);
3383			index += xNode.b || 0;
3384
3385			xIndex++;
3386			yIndex++;
3387			continue;
3388		}
3389
3390		// look ahead 1 to detect insertions and removals.
3391
3392		var xNext = xKids[xIndex + 1];
3393		var yNext = yKids[yIndex + 1];
3394
3395		if (xNext)
3396		{
3397			var xNextKey = xNext.a;
3398			var xNextNode = xNext.b;
3399			oldMatch = yKey === xNextKey;
3400		}
3401
3402		if (yNext)
3403		{
3404			var yNextKey = yNext.a;
3405			var yNextNode = yNext.b;
3406			newMatch = xKey === yNextKey;
3407		}
3408
3409
3410		// swap x and y
3411		if (newMatch && oldMatch)
3412		{
3413			index++;
3414			_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3415			_VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts);
3416			index += xNode.b || 0;
3417
3418			index++;
3419			_VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index);
3420			index += xNextNode.b || 0;
3421
3422			xIndex += 2;
3423			yIndex += 2;
3424			continue;
3425		}
3426
3427		// insert y
3428		if (newMatch)
3429		{
3430			index++;
3431			_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3432			_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3433			index += xNode.b || 0;
3434
3435			xIndex += 1;
3436			yIndex += 2;
3437			continue;
3438		}
3439
3440		// remove x
3441		if (oldMatch)
3442		{
3443			index++;
3444			_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3445			index += xNode.b || 0;
3446
3447			index++;
3448			_VirtualDom_diffHelp(xNextNode, yNode, localPatches, index);
3449			index += xNextNode.b || 0;
3450
3451			xIndex += 2;
3452			yIndex += 1;
3453			continue;
3454		}
3455
3456		// remove x, insert y
3457		if (xNext && xNextKey === yNextKey)
3458		{
3459			index++;
3460			_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3461			_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3462			index += xNode.b || 0;
3463
3464			index++;
3465			_VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index);
3466			index += xNextNode.b || 0;
3467
3468			xIndex += 2;
3469			yIndex += 2;
3470			continue;
3471		}
3472
3473		break;
3474	}
3475
3476	// eat up any remaining nodes with removeNode and insertNode
3477
3478	while (xIndex < xLen)
3479	{
3480		index++;
3481		var x = xKids[xIndex];
3482		var xNode = x.b;
3483		_VirtualDom_removeNode(changes, localPatches, x.a, xNode, index);
3484		index += xNode.b || 0;
3485		xIndex++;
3486	}
3487
3488	while (yIndex < yLen)
3489	{
3490		var endInserts = endInserts || [];
3491		var y = yKids[yIndex];
3492		_VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts);
3493		yIndex++;
3494	}
3495
3496	if (localPatches.length > 0 || inserts.length > 0 || endInserts)
3497	{
3498		_VirtualDom_pushPatch(patches, 8, rootIndex, {
3499			w: localPatches,
3500			x: inserts,
3501			y: endInserts
3502		});
3503	}
3504}
3505
3506
3507
3508// CHANGES FROM KEYED DIFF
3509
3510
3511var _VirtualDom_POSTFIX = '_elmW6BL';
3512
3513
3514function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts)
3515{
3516	var entry = changes[key];
3517
3518	// never seen this key before

3519	if (!entry)
3520	{
3521		entry = {
3522			c: 0,
3523			z: vnode,
3524			r: yIndex,
3525			s: undefined
3526		};
3527
3528		inserts.push({ r: yIndex, A: entry });
3529		changes[key] = entry;
3530
3531		return;
3532	}
3533
3534	// this key was removed earlier, a match!
3535	if (entry.c === 1)
3536	{
3537		inserts.push({ r: yIndex, A: entry });
3538
3539		entry.c = 2;
3540		var subPatches = [];
3541		_VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r);
3542		entry.r = yIndex;
3543		entry.s.s = {
3544			w: subPatches,
3545			A: entry
3546		};
3547
3548		return;
3549	}
3550
3551	// this key has already been inserted or moved, a duplicate!
3552	_VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts);
3553}
3554
3555
3556function _VirtualDom_removeNode(changes, localPatches, key, vnode, index)
3557{
3558	var entry = changes[key];
3559
3560	// never seen this key before
3561	if (!entry)
3562	{
3563		var patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined);
3564
3565		changes[key] = {
3566			c: 1,
3567			z: vnode,
3568			r: index,
3569			s: patch
3570		};
3571
3572		return;
3573	}
3574
3575	// this key was inserted earlier, a match!
3576	if (entry.c === 0)
3577	{
3578		entry.c = 2;
3579		var subPatches = [];
3580		_VirtualDom_diffHelp(vnode, entry.z, subPatches, index);
3581
3582		_VirtualDom_pushPatch(localPatches, 9, index, {
3583			w: subPatches,
3584			A: entry
3585		});
3586
3587		return;
3588	}
3589
3590	// this key has already been removed or moved, a duplicate!
3591	_VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, index);
3592}
3593
3594
3595
3596// ADD DOM NODES
3597//
3598// Each DOM node has an "index" assigned in order of traversal. It is important
3599// to minimize our crawl over the actual DOM, so these indexes (along with the
3600// descendantsCount of virtual nodes) let us skip touching entire subtrees of
3601// the DOM if we know there are no patches there.
3602
3603
3604function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode)
3605{
3606	_VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode);
3607}
3608
3609
3610// assumes `patches` is non-empty and indexes increase monotonically.
3611function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode)
3612{
3613	var patch = patches[i];
3614	var index = patch.r;
3615
3616	while (index === low)
3617	{
3618		var patchType = patch.$;
3619
3620		if (patchType === 1)
3621		{
3622			_VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode);
3623		}
3624		else if (patchType === 8)
3625		{
3626			patch.t = domNode;
3627			patch.u = eventNode;
3628
3629			var subPatches = patch.s.w;
3630			if (subPatches.length > 0)
3631			{
3632				_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3633			}
3634		}
3635		else if (patchType === 9)
3636		{
3637			patch.t = domNode;
3638			patch.u = eventNode;
3639
3640			var data = patch.s;
3641			if (data)
3642			{
3643				data.A.s = domNode;
3644				var subPatches = data.w;
3645				if (subPatches.length > 0)
3646				{
3647					_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3648				}
3649			}
3650		}
3651		else
3652		{
3653			patch.t = domNode;
3654			patch.u = eventNode;
3655		}
3656
3657		i++;
3658
3659		if (!(patch = patches[i]) || (index = patch.r) > high)
3660		{
3661			return i;
3662		}
3663	}
3664
3665	var tag = vNode.$;
3666
3667	if (tag === 4)
3668	{
3669		var subNode = vNode.k;
3670
3671		while (subNode.$ === 4)
3672		{
3673			subNode = subNode.k;
3674		}
3675
3676		return _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);
3677	}
3678
3679	// tag must be 1 or 2 at this point
3680
3681	var vKids = vNode.e;
3682	var childNodes = domNode.childNodes;
3683	for (var j = 0; j < vKids.length; j++)
3684	{
3685		low++;
3686		var vKid = tag === 1 ? vKids[j] : vKids[j].b;
3687		var nextLow = low + (vKid.b || 0);
3688		if (low <= index && index <= nextLow)
3689		{
3690			i = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode);
3691			if (!(patch = patches[i]) || (index = patch.r) > high)
3692			{
3693				return i;
3694			}
3695		}
3696		low = nextLow;
3697	}
3698	return i;
3699}
3700
3701
3702
3703// APPLY PATCHES
3704
3705
3706function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode)
3707{
3708	if (patches.length === 0)
3709	{
3710		return rootDomNode;
3711	}
3712
3713	_VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);
3714	return _VirtualDom_applyPatchesHelp(rootDomNode, patches);
3715}
3716
3717function _VirtualDom_applyPatchesHelp(rootDomNode, patches)
3718{
3719	for (var i = 0; i < patches.length; i++)
3720	{
3721		var patch = patches[i];
3722		var localDomNode = patch.t
3723		var newNode = _VirtualDom_applyPatch(localDomNode, patch);
3724		if (localDomNode === rootDomNode)
3725		{
3726			rootDomNode = newNode;
3727		}
3728	}
3729	return rootDomNode;
3730}
3731
3732function _VirtualDom_applyPatch(domNode, patch)
3733{
3734	switch (patch.$)
3735	{
3736		case 0:
3737			return _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u);
3738
3739		case 4:
3740			_VirtualDom_applyFacts(domNode, patch.u, patch.s);
3741			return domNode;
3742
3743		case 3:

3744			domNode.replaceData(0, domNode.length, patch.s);
3745			return domNode;
3746
3747		case 1:
3748			return _VirtualDom_applyPatchesHelp(domNode, patch.s);
3749
3750		case 2:
3751			if (domNode.elm_event_node_ref)
3752			{
3753				domNode.elm_event_node_ref.j = patch.s;
3754			}
3755			else
3756			{
3757				domNode.elm_event_node_ref = { j: patch.s, p: patch.u };
3758			}
3759			return domNode;
3760
3761		case 6:
3762			var data = patch.s;
3763			for (var i = 0; i < data.i; i++)
3764			{
3765				domNode.removeChild(domNode.childNodes[data.v]);
3766			}
3767			return domNode;
3768
3769		case 7:
3770			var data = patch.s;
3771			var kids = data.e;
3772			var i = data.v;
3773			var theEnd = domNode.childNodes[i];
3774			for (; i < kids.length; i++)
3775			{
3776				domNode.insertBefore(_VirtualDom_render(kids[i], patch.u), theEnd);
3777			}
3778			return domNode;
3779
3780		case 9:
3781			var data = patch.s;
3782			if (!data)
3783			{
3784				domNode.parentNode.removeChild(domNode);
3785				return domNode;
3786			}
3787			var entry = data.A;
3788			if (typeof entry.r !== 'undefined')
3789			{
3790				domNode.parentNode.removeChild(domNode);
3791			}
3792			entry.s = _VirtualDom_applyPatchesHelp(domNode, data.w);
3793			return domNode;
3794
3795		case 8:
3796			return _VirtualDom_applyPatchReorder(domNode, patch);
3797
3798		case 5:
3799			return patch.s(domNode);
3800
3801		default:
3802			_Debug_crash(10); // 'Ran into an unknown patch!'
3803	}
3804}
3805
3806
3807function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode)
3808{
3809	var parentNode = domNode.parentNode;
3810	var newNode = _VirtualDom_render(vNode, eventNode);
3811
3812	if (!newNode.elm_event_node_ref)
3813	{
3814		newNode.elm_event_node_ref = domNode.elm_event_node_ref;
3815	}
3816
3817	if (parentNode && newNode !== domNode)
3818	{
3819		parentNode.replaceChild(newNode, domNode);
3820	}
3821	return newNode;
3822}
3823
3824
3825function _VirtualDom_applyPatchReorder(domNode, patch)
3826{
3827	var data = patch.s;
3828
3829	// remove end inserts
3830	var frag = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch);
3831
3832	// removals
3833	domNode = _VirtualDom_applyPatchesHelp(domNode, data.w);
3834
3835	// inserts
3836	var inserts = data.x;
3837	for (var i = 0; i < inserts.length; i++)
3838	{
3839		var insert = inserts[i];
3840		var entry = insert.A;
3841		var node = entry.c === 2
3842			? entry.s
3843			: _VirtualDom_render(entry.z, patch.u);
3844		domNode.insertBefore(node, domNode.childNodes[insert.r]);
3845	}
3846
3847	// add end inserts
3848	if (frag)
3849	{
3850		_VirtualDom_appendChild(domNode, frag);
3851	}
3852
3853	return domNode;
3854}
3855
3856
3857function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch)
3858{
3859	if (!endInserts)
3860	{
3861		return;
3862	}
3863
3864	var frag = _VirtualDom_doc.createDocumentFragment();
3865	for (var i = 0; i < endInserts.length; i++)
3866	{
3867		var insert = endInserts[i];
3868		var entry = insert.A;
3869		_VirtualDom_appendChild(frag, entry.c === 2
3870			? entry.s
3871			: _VirtualDom_render(entry.z, patch.u)
3872		);
3873	}
3874	return frag;
3875}
3876
3877
3878function _VirtualDom_virtualize(node)
3879{
3880	// TEXT NODES
3881
3882	if (node.nodeType === 3)
3883	{
3884		return _VirtualDom_text(node.textContent);
3885	}
3886
3887
3888	// WEIRD NODES
3889
3890	if (node.nodeType !== 1)
3891	{
3892		return _VirtualDom_text('');
3893	}
3894
3895
3896	// ELEMENT NODES
3897
3898	var attrList = _List_Nil;
3899	var attrs = node.attributes;
3900	for (var i = attrs.length; i--; )
3901	{
3902		var attr = attrs[i];
3903		var name = attr.name;
3904		var value = attr.value;
3905		attrList = _List_Cons( A2(_VirtualDom_attribute, name, value), attrList );
3906	}
3907
3908	var tag = node.tagName.toLowerCase();
3909	var kidList = _List_Nil;
3910	var kids = node.childNodes;
3911
3912	for (var i = kids.length; i--; )
3913	{
3914		kidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList);
3915	}
3916	return A3(_VirtualDom_node, tag, attrList, kidList);
3917}
3918
3919function _VirtualDom_dekey(keyedNode)
3920{
3921	var keyedKids = keyedNode.e;
3922	var len = keyedKids.length;
3923	var kids = new Array(len);
3924	for (var i = 0; i < len; i++)
3925	{
3926		kids[i] = keyedKids[i].b;
3927	}
3928
3929	return {
3930		$: 1,
3931		c: keyedNode.c,
3932		d: keyedNode.d,
3933		e: kids,
3934		f: keyedNode.f,
3935		b: keyedNode.b
3936	};
3937}
3938
3939
3940
3941
3942// ELEMENT
3943
3944
3945var _Debugger_element;
3946
3947var _Browser_element = _Debugger_element || F4(function(impl, flagDecoder, debugMetadata, args)
3948{
3949	return _Platform_initialize(
3950		flagDecoder,
3951		args,
3952		impl.fQ,
3953		impl.ha,
3954		impl.gQ,
3955		function(sendToApp, initialModel) {
3956			var view = impl.hd;
3957			/**/
3958			var domNode = args['node'];
3959			//*/
3960			/**_UNUSED/
3961			var domNode = args && args['node'] ? args['node'] : _Debug_crash(0);
3962			//*/
3963			var currNode = _VirtualDom_virtualize(domNode);
3964
3965			return _Browser_makeAnimator(initialModel, function(model)
3966			{
3967				var nextNode = view(model);
3968				var patches = _VirtualDom_diff(currNode, nextNode);
3969				domNode = _VirtualDom_applyPatches(domNode, currNode, patches, sendToApp);
3970				currNode = nextNode;
3971			});
3972		}
3973	);
3974});
3975
3976
3977
3978// DOCUMENT
3979
3980
3981var _Debugger_document;
3982
3983var _Browser_document = _Debugger_document || F4(function(impl, flagDecoder, debugMetadata, args)
3984{
3985	return _Platform_initialize(
3986		flagDecoder,
3987		args,
3988		impl.fQ,
3989		impl.ha,
3990		impl.gQ,
3991		function(sendToApp, initialModel) {
3992			var divertHrefToApp = impl.cT && impl.cT(sendToApp)
3993			var view = impl.hd;
3994			var title = _VirtualDom_doc.title;
3995			var bodyNode = _VirtualDom_doc.body;
3996			var currNode = _VirtualDom_virtualize(bodyNode);
3997			return _Browser_makeAnimator(initialModel, function(model)
3998			{
3999				_VirtualDom_divertHrefToApp = divertHrefToApp;
4000				var doc = view(model);
4001				var nextNode = _VirtualDom_node('body')(_List_Nil)(doc.e$);
4002				var patches = _VirtualDom_diff(currNode, nextNode);
4003				bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp);
4004				currNode = nextNode;
4005				_VirtualDom_divertHrefToApp = 0;
4006				(title !== doc.g5) && (_VirtualDom_doc.title = title = doc.g5);
4007			});
4008		}
4009	);
4010});
4011
4012
4013
4014// ANIMATION
4015
4016
4017var _Browser_cancelAnimationFrame =
4018	typeof cancelAnimationFrame !== 'undefined'
4019		? cancelAnimationFrame
4020		: function(id) { clearTimeout(id); };
4021
4022var _Browser_requestAnimationFrame =
4023	typeof requestAnimationFrame !== 'undefined'
4024		? requestAnimationFrame
4025		: function(callback) { return setTimeout(callback, 1000 / 60); };
4026
4027
4028function _Browser_makeAnimator(model, draw)
4029{
4030	draw(model);
4031
4032	var state = 0;
4033
4034	function updateIfNeeded()
4035	{
4036		state = state === 1
4037			? 0
4038			: ( _Browser_requestAnimationFrame(updateIfNeeded), draw(model), 1 );
4039	}
4040
4041	return function(nextModel, isSync)
4042	{
4043		model = nextModel;
4044
4045		isSync
4046			? ( draw(model),
4047				state === 2 && (state = 1)
4048				)
4049			: ( state === 0 && _Browser_requestAnimationFrame(updateIfNeeded),
4050				state = 2
4051				);
4052	};
4053}
4054
4055
4056
4057// APPLICATION
4058
4059
4060function _Browser_application(impl)
4061{
4062	var onUrlChange = impl.gd;
4063	var onUrlRequest = impl.ge;
4064	var key = function() { key.a(onUrlChange(_Browser_getUrl())); };
4065
4066	return _Browser_document({
4067		cT: function(sendToApp)
4068		{
4069			key.a = sendToApp;
4070			_Browser_window.addEventListener('popstate', key);
4071			_Browser_window.navigator.userAgent.indexOf('Trident') < 0 || _Browser_window.addEventListener('hashchange', key);
4072
4073			return F2(function(domNode, event)
4074			{
4075				if (!event.ctrlKey && !event.metaKey && !event.shiftKey && event.button < 1 && !domNode.target && !domNode.hasAttribute('download'))
4076				{
4077					event.preventDefault();
4078					var href = domNode.href;
4079					var curr = _Browser_getUrl();
4080					var next = $elm$url$Url$fromString(href).a;
4081					sendToApp(onUrlRequest(
4082						(next
4083							&& curr.gk === next.gk
4084							&& curr.fJ === next.fJ
4085							&& curr.gj.a === next.gj.a
4086						)
4087							? $elm$browser$Browser$Internal(next)
4088							: $elm$browser$Browser$External(href)
4089					));
4090				}
4091			});
4092		},
4093		fQ: function(flags)
4094		{
4095			return A3(impl.fQ, flags, _Browser_getUrl(), key);
4096		},
4097		hd: impl.hd,
4098		ha: impl.ha,
4099		gQ: impl.gQ
4100	});
4101}
4102
4103function _Browser_getUrl()
4104{
4105	return $elm$url$Url$fromString(_VirtualDom_doc.location.href).a || _Debug_crash(1);
4106}
4107
4108var _Browser_go = F2(function(key, n)
4109{
4110	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4111		n && history.go(n);
4112		key();
4113	}));
4114});
4115
4116var _Browser_pushUrl = F2(function(key, url)
4117{
4118	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4119		history.pushState({}, '', url);
4120		key();
4121	}));
4122});
4123
4124var _Browser_replaceUrl = F2(function(key, url)
4125{
4126	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4127		history.replaceState({}, '', url);
4128		key();
4129	}));
4130});
4131
4132
4133
4134// GLOBAL EVENTS
4135
4136
4137var _Browser_fakeNode = { addEventListener: function() {}, removeEventListener: function() {} };
4138var _Browser_doc = typeof document !== 'undefined' ? document : _Browser_fakeNode;
4139var _Browser_window = typeof window !== 'undefined' ? window : _Browser_fakeNode;
4140
4141var _Browser_on = F3(function(node, eventName, sendToSelf)
4142{
4143	return _Scheduler_spawn(_Scheduler_binding(function(callback)
4144	{
4145		function handler(event)	{ _Scheduler_rawSpawn(sendToSelf(event)); }
4146		node.addEventListener(eventName, handler, _VirtualDom_passiveSupported && { passive: true });
4147		return function() { node.removeEventListener(eventName, handler); };
4148	}));
4149});
4150
4151var _Browser_decodeEvent = F2(function(decoder, event)
4152{
4153	var result = _Json_runHelp(decoder, event);
4154	return $elm$core$Result$isOk(result) ? $elm$core$Maybe$Just(result.a) : $elm$core$Maybe$Nothing;
4155});
4156
4157
4158
4159// PAGE VISIBILITY
4160
4161
4162function _Browser_visibilityInfo()
4163{
4164	return (typeof _VirtualDom_doc.hidden !== 'undefined')
4165		? { fI: 'hidden', fc: 'visibilitychange' }
4166		:
4167	(typeof _VirtualDom_doc.mozHidden !== 'undefined')
4168		? { fI: 'mozHidden', fc: 'mozvisibilitychange' }
4169		:
4170	(typeof _VirtualDom_doc.msHidden !== 'undefined')
4171		? { fI: 'msHidden', fc: 'msvisibilitychange' }
4172		:
4173	(typeof _VirtualDom_doc.webkitHidden !== 'undefined')
4174		? { fI: 'webkitHidden', fc: 'webkitvisibilitychange' }
4175		: { fI: 'hidden', fc: 'visibilitychange' };
4176}
4177
4178
4179
4180// ANIMATION FRAMES
4181
4182
4183function _Browser_rAF()
4184{
4185	return _Scheduler_binding(function(callback)
4186	{
4187		var id = _Browser_requestAnimationFrame(function() {

4188			callback(_Scheduler_succeed(Date.now()));
4189		});
4190
4191		return function() {
4192			_Browser_cancelAnimationFrame(id);
4193		};
4194	});
4195}
4196
4197
4198function _Browser_now()
4199{
4200	return _Scheduler_binding(function(callback)
4201	{
4202		callback(_Scheduler_succeed(Date.now()));
4203	});
4204}
4205
4206
4207
4208// DOM STUFF
4209
4210
4211function _Browser_withNode(id, doStuff)
4212{
4213	return _Scheduler_binding(function(callback)
4214	{
4215		_Browser_requestAnimationFrame(function() {
4216			var node = document.getElementById(id);
4217			callback(node
4218				? _Scheduler_succeed(doStuff(node))
4219				: _Scheduler_fail($elm$browser$Browser$Dom$NotFound(id))
4220			);
4221		});
4222	});
4223}
4224
4225
4226function _Browser_withWindow(doStuff)
4227{
4228	return _Scheduler_binding(function(callback)
4229	{
4230		_Browser_requestAnimationFrame(function() {
4231			callback(_Scheduler_succeed(doStuff()));
4232		});
4233	});
4234}
4235
4236
4237// FOCUS and BLUR
4238
4239
4240var _Browser_call = F2(function(functionName, id)
4241{
4242	return _Browser_withNode(id, function(node) {
4243		node[functionName]();
4244		return _Utils_Tuple0;
4245	});
4246});
4247
4248
4249
4250// WINDOW VIEWPORT
4251
4252
4253function _Browser_getViewport()
4254{
4255	return {
4256		ee: _Browser_getScene(),
4257		ew: {
4258			eB: _Browser_window.pageXOffset,
4259			eC: _Browser_window.pageYOffset,
4260			ey: _Browser_doc.documentElement.clientWidth,
4261			dv: _Browser_doc.documentElement.clientHeight
4262		}
4263	};
4264}
4265
4266function _Browser_getScene()
4267{
4268	var body = _Browser_doc.body;
4269	var elem = _Browser_doc.documentElement;
4270	return {
4271		ey: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth),
4272		dv: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight)
4273	};
4274}
4275
4276var _Browser_setViewport = F2(function(x, y)
4277{
4278	return _Browser_withWindow(function()
4279	{
4280		_Browser_window.scroll(x, y);
4281		return _Utils_Tuple0;
4282	});
4283});
4284
4285
4286
4287// ELEMENT VIEWPORT
4288
4289
4290function _Browser_getViewportOf(id)
4291{
4292	return _Browser_withNode(id, function(node)
4293	{
4294		return {
4295			ee: {
4296				ey: node.scrollWidth,
4297				dv: node.scrollHeight
4298			},
4299			ew: {
4300				eB: node.scrollLeft,
4301				eC: node.scrollTop,
4302				ey: node.clientWidth,
4303				dv: node.clientHeight
4304			}
4305		};
4306	});
4307}
4308
4309
4310var _Browser_setViewportOf = F3(function(id, x, y)
4311{
4312	return _Browser_withNode(id, function(node)
4313	{
4314		node.scrollLeft = x;
4315		node.scrollTop = y;
4316		return _Utils_Tuple0;
4317	});
4318});
4319
4320
4321
4322// ELEMENT
4323
4324
4325function _Browser_getElement(id)
4326{
4327	return _Browser_withNode(id, function(node)
4328	{
4329		var rect = node.getBoundingClientRect();
4330		var x = _Browser_window.pageXOffset;
4331		var y = _Browser_window.pageYOffset;
4332		return {
4333			ee: _Browser_getScene(),
4334			ew: {
4335				eB: x,
4336				eC: y,
4337				ey: _Browser_doc.documentElement.clientWidth,
4338				dv: _Browser_doc.documentElement.clientHeight
4339			},
4340			ft: {
4341				eB: x + rect.left,
4342				eC: y + rect.top,
4343				ey: rect.width,
4344				dv: rect.height
4345			}
4346		};
4347	});
4348}
4349
4350
4351
4352// LOAD and RELOAD
4353
4354
4355function _Browser_reload(skipCache)
4356{
4357	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4358	{
4359		_VirtualDom_doc.location.reload(skipCache);
4360	}));
4361}
4362
4363function _Browser_load(url)
4364{
4365	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4366	{
4367		try
4368		{
4369			_Browser_window.location = url;
4370		}
4371		catch(err)
4372		{
4373			// Only Firefox can throw a NS_ERROR_MALFORMED_URI exception here.
4374			// Other browsers reload the page, so let's be consistent about that.
4375			_VirtualDom_doc.location.reload(false);
4376		}
4377	}));
4378}
4379
4380
4381function _Url_percentEncode(string)
4382{
4383	return encodeURIComponent(string);
4384}
4385
4386function _Url_percentDecode(string)
4387{
4388	try
4389	{
4390		return $elm$core$Maybe$Just(decodeURIComponent(string));
4391	}
4392	catch (e)
4393	{
4394		return $elm$core$Maybe$Nothing;
4395	}
4396}
4397
4398
4399var _Bitwise_and = F2(function(a, b)
4400{
4401	return a & b;
4402});
4403
4404var _Bitwise_or = F2(function(a, b)
4405{
4406	return a | b;
4407});
4408
4409var _Bitwise_xor = F2(function(a, b)
4410{
4411	return a ^ b;
4412});
4413
4414function _Bitwise_complement(a)
4415{
4416	return ~a;
4417};
4418
4419var _Bitwise_shiftLeftBy = F2(function(offset, a)
4420{
4421	return a << offset;
4422});
4423
4424var _Bitwise_shiftRightBy = F2(function(offset, a)
4425{
4426	return a >> offset;
4427});
4428
4429var _Bitwise_shiftRightZfBy = F2(function(offset, a)
4430{
4431	return a >>> offset;
4432});
4433
4434
4435// CREATE
4436
4437var _Regex_never = /.^/;
4438
4439var _Regex_fromStringWith = F2(function(options, string)
4440{
4441	var flags = 'g';
4442	if (options.f6) { flags += 'm'; }
4443	if (options.fa) { flags += 'i'; }
4444
4445	try
4446	{
4447		return $elm$core$Maybe$Just(new RegExp(string, flags));
4448	}
4449	catch(error)
4450	{
4451		return $elm$core$Maybe$Nothing;
4452	}
4453});
4454
4455
4456// USE
4457
4458var _Regex_contains = F2(function(re, string)
4459{
4460	return string.match(re) !== null;
4461});
4462
4463
4464var _Regex_findAtMost = F3(function(n, re, str)
4465{
4466	var out = [];
4467	var number = 0;
4468	var string = str;
4469	var lastIndex = re.lastIndex;
4470	var prevLastIndex = -1;
4471	var result;
4472	while (number++ < n && (result = re.exec(string)))
4473	{
4474		if (prevLastIndex == re.lastIndex) break;
4475		var i = result.length - 1;
4476		var subs = new Array(i);
4477		while (i > 0)
4478		{
4479			var submatch = result[i];
4480			subs[--i] = submatch
4481				? $elm$core$Maybe$Just(submatch)
4482				: $elm$core$Maybe$Nothing;
4483		}
4484		out.push(A4($elm$regex$Regex$Match, result[0], result.index, number, _List_fromArray(subs)));
4485		prevLastIndex = re.lastIndex;
4486	}
4487	re.lastIndex = lastIndex;
4488	return _List_fromArray(out);
4489});
4490
4491
4492var _Regex_replaceAtMost = F4(function(n, re, replacer, string)
4493{
4494	var count = 0;
4495	function jsReplacer(match)
4496	{
4497		if (count++ >= n)
4498		{
4499			return match;
4500		}
4501		var i = arguments.length - 3;
4502		var submatches = new Array(i);
4503		while (i > 0)
4504		{
4505			var submatch = arguments[i];
4506			submatches[--i] = submatch
4507				? $elm$core$Maybe$Just(submatch)
4508				: $elm$core$Maybe$Nothing;
4509		}
4510		return replacer(A4($elm$regex$Regex$Match, match, arguments[arguments.length - 2], count, _List_fromArray(submatches)));
4511	}
4512	return string.replace(re, jsReplacer);
4513});
4514
4515var _Regex_splitAtMost = F3(function(n, re, str)
4516{
4517	var string = str;
4518	var out = [];
4519	var start = re.lastIndex;
4520	var restoreLastIndex = re.lastIndex;
4521	while (n--)
4522	{
4523		var result = re.exec(string);
4524		if (!result) break;
4525		out.push(string.slice(start, result.index));
4526		start = re.lastIndex;
4527	}
4528	out.push(string.slice(start));
4529	re.lastIndex = restoreLastIndex;
4530	return _List_fromArray(out);
4531});
4532
4533var _Regex_infinity = Infinity;
4534var $elm$core$List$cons = _List_cons;
4535var $elm$core$Elm$JsArray$foldr = _JsArray_foldr;
4536var $elm$core$Array$foldr = F3(

4537	function (func, baseCase, _v0) {
4538		var tree = _v0.c;
4539		var tail = _v0.d;
4540		var helper = F2(
4541			function (node, acc) {
4542				if (!node.$) {
4543					var subTree = node.a;
4544					return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);
4545				} else {
4546					var values = node.a;
4547					return A3($elm$core$Elm$JsArray$foldr, func, acc, values);
4548				}
4549			});
4550		return A3(
4551			$elm$core$Elm$JsArray$foldr,
4552			helper,
4553			A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail),
4554			tree);
4555	});
4556var $elm$core$Array$toList = function (array) {
4557	return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array);
4558};
4559var $elm$core$Dict$foldr = F3(
4560	function (func, acc, t) {
4561		foldr:
4562		while (true) {
4563			if (t.$ === -2) {
4564				return acc;
4565			} else {
4566				var key = t.b;
4567				var value = t.c;
4568				var left = t.d;
4569				var right = t.e;
4570				var $temp$func = func,
4571					$temp$acc = A3(
4572					func,
4573					key,
4574					value,
4575					A3($elm$core$Dict$foldr, func, acc, right)),
4576					$temp$t = left;
4577				func = $temp$func;
4578				acc = $temp$acc;
4579				t = $temp$t;
4580				continue foldr;
4581			}
4582		}
4583	});
4584var $elm$core$Dict$toList = function (dict) {
4585	return A3(
4586		$elm$core$Dict$foldr,
4587		F3(
4588			function (key, value, list) {
4589				return A2(
4590					$elm$core$List$cons,
4591					_Utils_Tuple2(key, value),
4592					list);
4593			}),
4594		_List_Nil,
4595		dict);
4596};
4597var $elm$core$Dict$keys = function (dict) {
4598	return A3(
4599		$elm$core$Dict$foldr,
4600		F3(
4601			function (key, value, keyList) {
4602				return A2($elm$core$List$cons, key, keyList);
4603			}),
4604		_List_Nil,
4605		dict);
4606};
4607var $elm$core$Set$toList = function (_v0) {
4608	var dict = _v0;
4609	return $elm$core$Dict$keys(dict);
4610};
4611var $elm$core$Basics$EQ = 1;
4612var $elm$core$Basics$GT = 2;
4613var $elm$core$Basics$LT = 0;
4614var $elm$core$Result$Err = function (a) {
4615	return {$: 1, a: a};
4616};
4617var $elm$json$Json$Decode$Failure = F2(
4618	function (a, b) {
4619		return {$: 3, a: a, b: b};
4620	});
4621var $elm$json$Json$Decode$Field = F2(
4622	function (a, b) {
4623		return {$: 0, a: a, b: b};
4624	});
4625var $elm$json$Json$Decode$Index = F2(
4626	function (a, b) {
4627		return {$: 1, a: a, b: b};
4628	});
4629var $elm$core$Result$Ok = function (a) {
4630	return {$: 0, a: a};
4631};
4632var $elm$json$Json$Decode$OneOf = function (a) {
4633	return {$: 2, a: a};
4634};
4635var $elm$core$Basics$False = 1;
4636var $elm$core$Basics$add = _Basics_add;
4637var $elm$core$Maybe$Just = function (a) {
4638	return {$: 0, a: a};
4639};
4640var $elm$core$Maybe$Nothing = {$: 1};
4641var $elm$core$String$all = _String_all;
4642var $elm$core$Basics$and = _Basics_and;
4643var $elm$core$Basics$append = _Utils_append;
4644var $elm$json$Json$Encode$encode = _Json_encode;

4645var $elm$core$String$fromInt = _String_fromNumber;
4646var $elm$core$String$join = F2(
4647	function (sep, chunks) {
4648		return A2(
4649			_String_join,
4650			sep,
4651			_List_toArray(chunks));
4652	});
4653var $elm$core$String$split = F2(
4654	function (sep, string) {
4655		return _List_fromArray(
4656			A2(_String_split, sep, string));
4657	});
4658var $elm$json$Json$Decode$indent = function (str) {
4659	return A2(
4660		$elm$core$String$join,
4661		'\n    ',
4662		A2($elm$core$String$split, '\n', str));
4663};
4664var $elm$core$List$foldl = F3(
4665	function (func, acc, list) {
4666		foldl:
4667		while (true) {
4668			if (!list.b) {
4669				return acc;
4670			} else {
4671				var x = list.a;
4672				var xs = list.b;
4673				var $temp$func = func,
4674					$temp$acc = A2(func, x, acc),
4675					$temp$list = xs;
4676				func = $temp$func;
4677				acc = $temp$acc;
4678				list = $temp$list;
4679				continue foldl;
4680			}
4681		}
4682	});
4683var $elm$core$List$length = function (xs) {
4684	return A3(
4685		$elm$core$List$foldl,
4686		F2(
4687			function (_v0, i) {
4688				return i + 1;
4689			}),
4690		0,
4691		xs);
4692};
4693var $elm$core$List$map2 = _List_map2;
4694var $elm$core$Basics$le = _Utils_le;
4695var $elm$core$Basics$sub = _Basics_sub;
4696var $elm$core$List$rangeHelp = F3(
4697	function (lo, hi, list) {
4698		rangeHelp:
4699		while (true) {
4700			if (_Utils_cmp(lo, hi) < 1) {
4701				var $temp$lo = lo,
4702					$temp$hi = hi - 1,
4703					$temp$list = A2($elm$core$List$cons, hi, list);
4704				lo = $temp$lo;
4705				hi = $temp$hi;
4706				list = $temp$list;
4707				continue rangeHelp;
4708			} else {
4709				return list;
4710			}
4711		}
4712	});
4713var $elm$core$List$range = F2(
4714	function (lo, hi) {
4715		return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil);
4716	});
4717var $elm$core$List$indexedMap = F2(
4718	function (f, xs) {
4719		return A3(
4720			$elm$core$List$map2,
4721			f,
4722			A2(
4723				$elm$core$List$range,
4724				0,
4725				$elm$core$List$length(xs) - 1),
4726			xs);
4727	});
4728var $elm$core$Char$toCode = _Char_toCode;
4729var $elm$core$Char$isLower = function (_char) {
4730	var code = $elm$core$Char$toCode(_char);
4731	return (97 <= code) && (code <= 122);
4732};
4733var $elm$core$Char$isUpper = function (_char) {
4734	var code = $elm$core$Char$toCode(_char);
4735	return (code <= 90) && (65 <= code);
4736};
4737var $elm$core$Basics$or = _Basics_or;
4738var $elm$core$Char$isAlpha = function (_char) {
4739	return $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char);
4740};
4741var $elm$core$Char$isDigit = function (_char) {
4742	var code = $elm$core$Char$toCode(_char);
4743	return (code <= 57) && (48 <= code);
4744};
4745var $elm$core$Char$isAlphaNum = function (_char) {
4746	return $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char));
4747};
4748var $elm$core$List$reverse = function (list) {
4749	return A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list);
4750};
4751var $elm$core$String$uncons = _String_uncons;
4752var $elm$json$Json$Decode$errorOneOf = F2(
4753	function (i, error) {
4754		return '\n\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent(
4755			$elm$json$Json$Decode$errorToString(error))));
4756	});
4757var $elm$json$Json$Decode$errorToString = function (error) {
4758	return A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);
4759};
4760var $elm$json$Json$Decode$errorToStringHelp = F2(
4761	function (error, context) {
4762		errorToStringHelp:
4763		while (true) {
4764			switch (error.$) {
4765				case 0:
4766					var f = error.a;
4767					var err = error.b;
4768					var isSimple = function () {
4769						var _v1 = $elm$core$String$uncons(f);
4770						if (_v1.$ === 1) {
4771							return false;
4772						} else {
4773							var _v2 = _v1.a;
4774							var _char = _v2.a;
4775							var rest = _v2.b;
4776							return $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest);
4777						}
4778					}();
4779					var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']'));
4780					var $temp$error = err,
4781						$temp$context = A2($elm$core$List$cons, fieldName, context);
4782					error = $temp$error;
4783					context = $temp$context;
4784					continue errorToStringHelp;
4785				case 1:
4786					var i = error.a;
4787					var err = error.b;
4788					var indexName = '[' + ($elm$core$String$fromInt(i) + ']');
4789					var $temp$error = err,
4790						$temp$context = A2($elm$core$List$cons, indexName, context);
4791					error = $temp$error;
4792					context = $temp$context;
4793					continue errorToStringHelp;
4794				case 2:
4795					var errors = error.a;
4796					if (!errors.b) {
4797						return 'Ran into a Json.Decode.oneOf with no possibilities' + function () {
4798							if (!context.b) {
4799								return '!';
4800							} else {
4801								return ' at json' + A2(
4802									$elm$core$String$join,
4803									'',
4804									$elm$core$List$reverse(context));
4805							}
4806						}();
4807					} else {
4808						if (!errors.b.b) {
4809							var err = errors.a;
4810							var $temp$error = err,
4811								$temp$context = context;
4812							error = $temp$error;
4813							context = $temp$context;
4814							continue errorToStringHelp;
4815						} else {
4816							var starter = function () {
4817								if (!context.b) {
4818									return 'Json.Decode.oneOf';
4819								} else {
4820									return 'The Json.Decode.oneOf at json' + A2(
4821										$elm$core$String$join,
4822										'',
4823										$elm$core$List$reverse(context));
4824								}
4825							}();
4826							var introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt(
4827								$elm$core$List$length(errors)) + ' ways:'));
4828							return A2(
4829								$elm$core$String$join,
4830								'\n\n',
4831								A2(
4832									$elm$core$List$cons,
4833									introduction,
4834									A2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors)));
4835						}
4836					}
4837				default:
4838					var msg = error.a;
4839					var json = error.b;
4840					var introduction = function () {
4841						if (!context.b) {
4842							return 'Problem with the given value:\n\n';
4843						} else {
4844							return 'Problem with the value at json' + (A2(
4845								$elm$core$String$join,
4846								'',
4847								$elm$core$List$reverse(context)) + ':\n\n    ');
4848						}
4849					}();
4850					return introduction + ($elm$json$Json$Decode$indent(
4851						A2($elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg));
4852			}
4853		}
4854	});
4855var $elm$core$Array$branchFactor = 32;
4856var $elm$core$Array$Array_elm_builtin = F4(
4857	function (a, b, c, d) {

4858		return {$: 0, a: a, b: b, c: c, d: d};
4859	});
4860var $elm$core$Elm$JsArray$empty = _JsArray_empty;
4861var $elm$core$Basics$ceiling = _Basics_ceiling;
4862var $elm$core$Basics$fdiv = _Basics_fdiv;
4863var $elm$core$Basics$logBase = F2(
4864	function (base, number) {
4865		return _Basics_log(number) / _Basics_log(base);
4866	});
4867var $elm$core$Basics$toFloat = _Basics_toFloat;
4868var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling(
4869	A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor));
4870var $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);
4871var $elm$core$Elm$JsArray$initialize = _JsArray_initialize;
4872var $elm$core$Array$Leaf = function (a) {
4873	return {$: 1, a: a};
4874};
4875var $elm$core$Basics$apL = F2(
4876	function (f, x) {
4877		return f(x);
4878	});
4879var $elm$core$Basics$apR = F2(
4880	function (x, f) {
4881		return f(x);
4882	});
4883var $elm$core$Basics$eq = _Utils_equal;
4884var $elm$core$Basics$floor = _Basics_floor;
4885var $elm$core$Elm$JsArray$length = _JsArray_length;
4886var $elm$core$Basics$gt = _Utils_gt;
4887var $elm$core$Basics$max = F2(
4888	function (x, y) {
4889		return (_Utils_cmp(x, y) > 0) ? x : y;
4890	});
4891var $elm$core$Basics$mul = _Basics_mul;
4892var $elm$core$Array$SubTree = function (a) {
4893	return {$: 0, a: a};
4894};
4895var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;
4896var $elm$core$Array$compressNodes = F2(
4897	function (nodes, acc) {
4898		compressNodes:
4899		while (true) {
4900			var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes);
4901			var node = _v0.a;
4902			var remainingNodes = _v0.b;
4903			var newAcc = A2(
4904				$elm$core$List$cons,
4905				$elm$core$Array$SubTree(node),
4906				acc);
4907			if (!remainingNodes.b) {
4908				return $elm$core$List$reverse(newAcc);
4909			} else {
4910				var $temp$nodes = remainingNodes,
4911					$temp$acc = newAcc;
4912				nodes = $temp$nodes;
4913				acc = $temp$acc;
4914				continue compressNodes;
4915			}
4916		}
4917	});
4918var $elm$core$Tuple$first = function (_v0) {
4919	var x = _v0.a;
4920	return x;
4921};
4922var $elm$core$Array$treeFromBuilder = F2(
4923	function (nodeList, nodeListSize) {
4924		treeFromBuilder:
4925		while (true) {
4926			var newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor);
4927			if (newNodeSize === 1) {
4928				return A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a;
4929			} else {
4930				var $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil),
4931					$temp$nodeListSize = newNodeSize;
4932				nodeList = $temp$nodeList;
4933				nodeListSize = $temp$nodeListSize;
4934				continue treeFromBuilder;
4935			}
4936		}
4937	});
4938var $elm$core$Array$builderToArray = F2(
4939	function (reverseNodeList, builder) {
4940		if (!builder.t) {
4941			return A4(
4942				$elm$core$Array$Array_elm_builtin,
4943				$elm$core$Elm$JsArray$length(builder.x),
4944				$elm$core$Array$shiftStep,
4945				$elm$core$Elm$JsArray$empty,
4946				builder.x);
4947		} else {
4948			var treeLen = builder.t * $elm$core$Array$branchFactor;
4949			var depth = $elm$core$Basics$floor(
4950				A2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1));
4951			var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.A) : builder.A;
4952			var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.t);
4953			return A4(
4954				$elm$core$Array$Array_elm_builtin,
4955				$elm$core$Elm$JsArray$length(builder.x) + treeLen,
4956				A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep),
4957				tree,
4958				builder.x);
4959		}
4960	});
4961var $elm$core$Basics$idiv = _Basics_idiv;
4962var $elm$core$Basics$lt = _Utils_lt;
4963var $elm$core$Array$initializeHelp = F5(
4964	function (fn, fromIndex, len, nodeList, tail) {
4965		initializeHelp:
4966		while (true) {
4967			if (fromIndex < 0) {
4968				return A2(
4969					$elm$core$Array$builderToArray,
4970					false,
4971					{A: nodeList, t: (len / $elm$core$Array$branchFactor) | 0, x: tail});
4972			} else {
4973				var leaf = $elm$core$Array$Leaf(
4974					A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn));
4975				var $temp$fn = fn,
4976					$temp$fromIndex = fromIndex - $elm$core$Array$branchFactor,
4977					$temp$len = len,
4978					$temp$nodeList = A2($elm$core$List$cons, leaf, nodeList),
4979					$temp$tail = tail;
4980				fn = $temp$fn;
4981				fromIndex = $temp$fromIndex;
4982				len = $temp$len;
4983				nodeList = $temp$nodeList;
4984				tail = $temp$tail;
4985				continue initializeHelp;
4986			}
4987		}
4988	});
4989var $elm$core$Basics$remainderBy = _Basics_remainderBy;
4990var $elm$core$Array$initialize = F2(
4991	function (len, fn) {
4992		if (len <= 0) {
4993			return $elm$core$Array$empty;
4994		} else {
4995			var tailLen = len % $elm$core$Array$branchFactor;
4996			var tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tail

4996Len, fn);
4997			var initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor;
4998			return A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);
4999		}
5000	});
5001var $elm$core$Basics$True = 0;
5002var $elm$core$Result$isOk = function (result) {
5003	if (!result.$) {
5004		return true;
5005	} else {
5006		return false;
5007	}
5008};
5009var $elm$json$Json$Decode$andThen = _Json_andThen;
5010var $elm$json$Json$Decode$map = _Json_map1;
5011var $elm$json$Json$Decode$map2 = _Json_map2;
5012var $elm$json$Json$Decode$succeed = _Json_succeed;
5013var $elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) {
5014	switch (handler.$) {
5015		case 0:
5016			return 0;
5017		case 1:
5018			return 1;
5019		case 2:
5020			return 2;
5021		default:
5022			return 3;
5023	}
5024};
5025var $elm$browser$Browser$External = function (a) {
5026	return {$: 1, a: a};
5027};
5028var $elm$browser$Browser$Internal = function (a) {
5029	return {$: 0, a: a};
5030};
5031var $elm$core$Basics$identity = function (x) {
5032	return x;
5033};
5034var $elm$browser$Browser$Dom$NotFound = $elm$core$Basics$identity;
5035var $elm$url$Url$Http = 0;
5036var $elm$url$Url$Https = 1;
5037var $elm$url$Url$Url = F6(
5038	function (protocol, host, port_, path, query, fragment) {
5039		return {fE: fragment, fJ: host, cM: path, gj: port_, gk: protocol, gl: query};
5040	});
5041var $elm$core$String$contains = _String_contains;
5042var $elm$core$String$length = _String_length;
5043var $elm$core$String$slice = _String_slice;
5044var $elm$core$String$dropLeft = F2(
5045	function (n, string) {
5046		return (n < 1) ? string : A3(
5047			$elm$core$String$slice,
5048			n,
5049			$elm$core$String$length(string),
5050			string);
5051	});
5052var $elm$core$String$indexes = _String_indexes;
5053var $elm$core$String$isEmpty = function (string) {
5054	return string === '';
5055};
5056var $elm$core$String$left = F2(
5057	function (n, string) {
5058		return (n < 1) ? '' : A3($elm$core$String$slice, 0, n, string);
5059	});
5060var $elm$core$String$toInt = _String_toInt;
5061var $elm$url$Url$chompBeforePath = F5(
5062	function (protocol, path, params, frag, str) {
5063		if ($elm$core$String$isEmpty(str) || A2($elm$core$String$contains, '@', str)) {
5064			return $elm$core$Maybe$Nothing;
5065		} else {
5066			var _v0 = A2($elm$core$String$indexes, ':', str);
5067			if (!_v0.b) {
5068				return $elm$core$Maybe$Just(
5069					A6($elm$url$Url$Url, protocol, str, $elm$core$Maybe$Nothing, path, params, frag));
5070			} else {
5071				if (!_v0.b.b) {
5072					var i = _v0.a;
5073					var _v1 = $elm$core$String$toInt(
5074						A2($elm$core$String$dropLeft, i + 1, str));
5075					if (_v1.$ === 1) {
5076						return $elm$core$Maybe$Nothing;
5077					} else {
5078						var port_ = _v1;
5079						return $elm$core$Maybe$Just(
5080							A6(
5081								$elm$url$Url$Url,
5082								protocol,
5083								A2($elm$core$String$left, i, str),
5084								port_,
5085								path,
5086								params,
5087								frag));
5088					}
5089				} else {
5090					return $elm$core$Maybe$Nothing;
5091				}
5092			}
5093		}
5094	});
5095var $elm$url$Url$chompBeforeQuery = F4(
5096	function (protocol, params, frag, str) {
5097		if ($elm$core$String$isEmpty(str)) {
5098			return $elm$core$Maybe$Nothing;
5099		} else {
5100			var _v0 = A2($elm$core$String$indexes, '/', str);
5101			if (!_v0.b) {
5102				return A5($elm$url$Url$chompBeforePath, protocol, '/', params, frag, str);
5103			} else {
5104				var i = _v0.a;
5105				return A5(
5106					$elm$url$Url$chompBeforePath,
5107					protocol,
5108					A2($elm$core$String$dropLeft, i, str),
5109					params,
5110					frag,
5111					A2($elm$core$String$left, i, str));
5112			}
5113		}
5114	});
5115var $elm$url$Url$chompBeforeFragment = F3(
5116	function (protocol, frag, str) {
5117		if ($elm$core$String$isEmpty(str)) {
5118			return $elm$core$Maybe$Nothing;
5119		} else {
5120			var _v0 = A2($elm$core$String$indexes, '?', str);
5121			if (!_v0.b) {
5122				return A4($elm$url$Url$chompBeforeQuery, protocol, $elm$core$Maybe$Nothing, frag, str);
5123			} else {
5124				var i = _v0.a;
5125				return A4(
5126					$elm$url$Url$chompBeforeQuery,
5127					protocol,
5128					$elm$core$Maybe$Just(
5129						A2($elm$core$String$dropLeft, i + 1, str)),
5130					frag,
5131					A2($elm$core$String$left, i, str));
5132			}
5133		}
5134	});
5135var $elm$url$Url$chompAfterProtocol = F2(
5136	function (protocol, str) {
5137		if ($elm$core$String$isEmpty(str)) {
5138			return $elm$core$Maybe$Nothing;
5139		} else {
5140			var _v0 = A2($elm$core$String$indexes, '#', str);
5141			if (!_v0.b) {
5142				return A3($elm$url$Url$chompBeforeFragment, protocol, $elm$core$Maybe$Nothing, str);
5143			} else {
5144				var i = _v0.a;
5145				return A3(
5146					$elm$url$Url$chompBeforeFragment,
5147					protocol,
5148					$elm$core$Maybe$Just(
5149						A2($elm$core$String$dropLeft, i + 1, str)),
5150					A2($elm$core$String$left, i, str));
5151			}
5152		}
5153	});
5154var $elm$core$String$startsWith = _String_startsWith;
5155var $elm$url$Url$fromString = function (str) {
5156	return A2($elm$core$String$startsWith, 'http://', str) ? A2(
5157		$elm$url$Url$chompAfterProtocol,
5158		0,
5159		A2($elm$core$String$dropLeft, 7, str)) : (A2($elm$core$String$startsWith, 'https://', str) ? A2(
5160		$elm$url$Url$chompAfterProtocol,

5161		1,
5162		A2($elm$core$String$dropLeft, 8, str)) : $elm$core$Maybe$Nothing);
5163};
5164var $elm$core$Basics$never = function (_v0) {
5165	never:
5166	while (true) {
5167		var nvr = _v0;
5168		var $temp$_v0 = nvr;
5169		_v0 = $temp$_v0;
5170		continue never;
5171	}
5172};
5173var $elm$core$Task$Perform = $elm$core$Basics$identity;
5174var $elm$core$Task$succeed = _Scheduler_succeed;
5175var $elm$core$Task$init = $elm$core$Task$succeed(0);
5176var $elm$core$List$foldrHelper = F4(
5177	function (fn, acc, ctr, ls) {
5178		if (!ls.b) {
5179			return acc;
5180		} else {
5181			var a = ls.a;
5182			var r1 = ls.b;
5183			if (!r1.b) {
5184				return A2(fn, a, acc);
5185			} else {
5186				var b = r1.a;
5187				var r2 = r1.b;
5188				if (!r2.b) {
5189					return A2(
5190						fn,
5191						a,
5192						A2(fn, b, acc));
5193				} else {
5194					var c = r2.a;
5195					var r3 = r2.b;
5196					if (!r3.b) {
5197						return A2(
5198							fn,
5199							a,
5200							A2(
5201								fn,
5202								b,
5203								A2(fn, c, acc)));
5204					} else {
5205						var d = r3.a;
5206						var r4 = r3.b;
5207						var res = (ctr > 500) ? A3(
5208							$elm$core$List$foldl,
5209							fn,
5210							acc,
5211							$elm$core$List$reverse(r4)) : A4($elm$core$List$foldrHelper, fn, acc, ctr + 1, r4);
5212						return A2(
5213							fn,
5214							a,
5215							A2(
5216								fn,
5217								b,
5218								A2(
5219									fn,
5220									c,
5221									A2(fn, d, res))));
5222					}
5223				}
5224			}
5225		}
5226	});
5227var $elm$core$List$foldr = F3(
5228	function (fn, acc, ls) {
5229		return A4($elm$core$List$foldrHelper, fn, acc, 0, ls);
5230	});
5231var $elm$core$List$map = F2(
5232	function (f, xs) {
5233		return A3(
5234			$elm$core$List$foldr,
5235			F2(
5236				function (x, acc) {
5237					return A2(
5238						$elm$core$List$cons,
5239						f(x),
5240						acc);
5241				}),
5242			_List_Nil,
5243			xs);
5244	});
5245var $elm$core$Task$andThen = _Scheduler_andThen;
5246var $elm$core$Task$map = F2(
5247	function (func, taskA) {
5248		return A2(
5249			$elm$core$Task$andThen,
5250			function (a) {
5251				return $elm$core$Task$succeed(
5252					func(a));
5253			},
5254			taskA);
5255	});
5256var $elm$core$Task$map2 = F3(
5257	function (func, taskA, taskB) {
5258		return A2(
5259			$elm$core$Task$andThen,
5260			function (a) {
5261				return A2(
5262					$elm$core$Task$andThen,
5263					function (b) {
5264						return $elm$core$Task$succeed(
5265							A2(func, a, b));
5266					},
5267					taskB);
5268			},
5269			taskA);
5270	});
5271var $elm$core$Task$sequence = function (tasks) {
5272	return A3(
5273		$elm$core$List$foldr,
5274		$elm$core$Task$map2($elm$core$List$cons),
5275		$elm$core$Task$succeed(_List_Nil),
5276		tasks);
5277};
5278var $elm$core$Platform$sendToApp = _Platform_sendToApp;
5279var $elm$core$Task$spawnCmd = F2(
5280	function (router, _v0) {
5281		var task = _v0;
5282		return _Scheduler_spawn(
5283			A2(
5284				$elm$core$Task$andThen,
5285				$elm$core$Platform$sendToApp(router),
5286				task));
5287	});
5288var $elm$core$Task$onEffects = F3(
5289	function (router, commands, state) {
5290		return A2(
5291			$elm$core$Task$map,
5292			function (_v0) {
5293				return 0;
5294			},
5295			$elm$core$Task$sequence(
5296				A2(
5297					$elm$core$List$map,
5298					$elm$core$Task$spawnCmd(router),
5299					commands)));
5300	});
5301var $elm$core$Task$onSelfMsg = F3(
5302	function (_v0, _v1, _v2) {
5303		return $elm$core$Task$succeed(0);
5304	});
5305var $elm$core$Task$cmdMap = F2(
5306	function (tagger, _v0) {
5307		var task = _v0;
5308		return A2($elm$core$Task$map, tagger, task);
5309	});
5310_Platform_effectManagers['Task'] = _Platform_createManager($elm$core$Task$init, $elm$core$Task$onEffects, $elm$core$Task$onSelfMsg, $elm$core$Task$cmdMap);
5311var $elm$core$Task$command = _Platform_leaf('Task');
5312var $elm$core$Task$perform = F2(
5313	function (toMessage, task) {
5314		return $elm$core$Task$command(
5315			A2($elm$core$Task$map, toMessage, task));
5316	});
5317var $elm$browser$Browser$element = _Browser_element;
5318var $elm$json$Json$Decode$field = _Json_decodeField;
5319var $author$project$Main$isItemShowing = function (route) {
5320	switch (route.$) {
5321		case 0:
5322			return $elm$core$Maybe$Nothing;
5323		case 1:
5324			return $elm$core$Maybe$Nothing;
5325		default:
5326			var id = route.a;
5327			return $elm$core$Maybe$Just(id);
5328	}
5329};
5330var $elm$json$Json$Encode$bool = _Json_wrap;
5331var $author$project$Main$modalOpen = _Platform_outgoingPort('modalOpen', $elm$json$Json$Encode$bool);
5332var $author$project$Main$cmdOnRouteChange = function (route) {
5333	var _v0 = $author$project$Main$isItemShowing(route);
5334	if (_v0.$ === 1) {
5335		return $author$project$Main$modalOpen(false);
5336	} else {
5337		return $author$project$Main$modalOpen(true);
5338	}
5339};
5340var $author$project$Main$RouteTop = {$: 0};
5341var $elm$core$Maybe$andThen = F2(
5342	function (callback, maybeValue) {
5343		if (!maybeValue.$) {
5344			var value = maybeValue.a;
5345			return callback(value);
5346		} else {
5347			return $elm$core$Maybe$Nothing;
5348		}
5349	});
5350var $elm$url$Url$Parser$State = F5(
5351	function (visited, unvisited, params, frag, value) {
5352		return {aC: frag, aG: params, aw: unvisited, ak: value, aM: visited};
5353	});
5354var $elm$url$Url$Parser$getFirstMatch = function (states) {
5355	getFirstMatch:
5356	while (true) {
5357		if (!states.b) {
5358			return $elm$core$Maybe$Nothing;
5359		} else {
5360			var state = states.a;
5361			var rest = states.b;
5362			var _v1 = state.aw;
5363			if (!_v1.b) {
5364				return $elm$core$Maybe$Just(state.ak);
5365			} else {
5366				if ((_v1.a === '') && (!_v1.b.b)) {
5367					return $elm$core$Maybe$Just(state.ak);
5368				} else {
5369					var $temp$states = rest;
5370					states = $temp$states;
5371					continue getFirstMatch;
5372				}
5373			}
5374		}
5375	}
5376};
5377var $elm$url$Url$Parser$removeFinalEmpty = function (segments) {
5378	if (!segments.b) {
5379		return _List_Nil;
5380	} else {
5381		if ((segments.a === '') && (!segments.b.b)) {
5382			return _List_Nil;
5383		} else {
5384			var segment = segments.a;
5385			var rest = segments.b;
5386			return A2(
5387				$elm$core$List$cons,
5388				segment,
5389				$elm$url$Url$Parser$removeFinalEmpty(rest));
5390		}
5391	}
5392};
5393var $elm$url$Url$Parser$preparePath = function (path) {
5394	var _v0 = A2($elm$core$String$split, '/', path);
5395	if (_v0.b && (_v0.a === '')) {
5396		var segments = _v0.b;
5397		return $elm$url$Url$Parser$removeFinalEmpty(segments);
5398	} else {
5399		var segments = _v0;
5400		return $elm$url$Url$Parser$removeFinalEmpty(segments);
5401	}
5402};
5403var $elm$url$Url$Parser$addToParametersHelp = F2(
5404	function (value, maybeList) {
5405		if (maybeList.$ === 1) {
5406			return $elm$core$Maybe$Just(
5407				_List_fromArray(
5408					[value]));
5409		} else {
5410			var list = maybeList.a;
5411			return $elm$core$Maybe$Just(
5412				A2($elm$core$List$cons, value, list));
5413		}
5414	});
5415var $elm$url$Url$percentDecode = _Url_percentDecode;
5416var $elm$core$Basics$compare = _Utils_compare;
5417var $elm$core$Dict$get = F2(
5418	function (targetKey, dict) {
5419		get:
5420		while (true) {
5421			if (dict.$ === -2) {
5422				return $elm$core$Maybe$Nothing;
5423			} else {
5424				var key = dict.b;
5425				var value = dict.c;
5426				var left = dict.d;
5427				var right = dict.e;

5428				var _v1 = A2($elm$core$Basics$compare, targetKey, key);
5429				switch (_v1) {
5430					case 0:
5431						var $temp$targetKey = targetKey,
5432							$temp$dict = left;
5433						targetKey = $temp$targetKey;
5434						dict = $temp$dict;
5435						continue get;
5436					case 1:
5437						return $elm$core$Maybe$Just(value);
5438					default:
5439						var $temp$targetKey = targetKey,
5440							$temp$dict = right;
5441						targetKey = $temp$targetKey;
5442						dict = $temp$dict;
5443						continue get;
5444				}
5445			}
5446		}
5447	});
5448var $elm$core$Dict$Black = 1;
5449var $elm$core$Dict$RBNode_elm_builtin = F5(
5450	function (a, b, c, d, e) {
5451		return {$: -1, a: a, b: b, c: c, d: d, e: e};
5452	});
5453var $elm$core$Dict$RBEmpty_elm_builtin = {$: -2};
5454var $elm$core$Dict$Red = 0;
5455var $elm$core$Dict$balance = F5(
5456	function (color, key, value, left, right) {
5457		if ((right.$ === -1) && (!right.a)) {
5458			var _v1 = right.a;
5459			var rK = right.b;
5460			var rV = right.c;
5461			var rLeft = right.d;
5462			var rRight = right.e;
5463			if ((left.$ === -1) && (!left.a)) {
5464				var _v3 = left.a;
5465				var lK = left.b;
5466				var lV = left.c;
5467				var lLeft = left.d;
5468				var lRight = left.e;
5469				return A5(
5470					$elm$core$Dict$RBNode_elm_builtin,
5471					0,
5472					key,
5473					value,
5474					A5($elm$core$Dict$RBNode_elm_builtin, 1, lK, lV, lLeft, lRight),
5475					A5($elm$core$Dict$RBNode_elm_builtin, 1, rK, rV, rLeft, rRight));
5476			} else {
5477				return A5(
5478					$elm$core$Dict$RBNode_elm_builtin,
5479					color,
5480					rK,
5481					rV,
5482					A5($elm$core$Dict$RBNode_elm_builtin, 0, key, value, left, rLeft),
5483					rRight);
5484			}
5485		} else {
5486			if ((((left.$ === -1) && (!left.a)) && (left.d.$ === -1)) && (!left.d.a)) {
5487				var _v5 = left.a;
5488				var lK = left.b;
5489				var lV = left.c;
5490				var _v6 = left.d;
5491				var _v7 = _v6.a;
5492				var llK = _v6.b;
5493				var llV = _v6.c;
5494				var llLeft = _v6.d;
5495				var llRight = _v6.e;
5496				var lRight = left.e;
5497				return A5(
5498					$elm$core$Dict$RBNode_elm_builtin,
5499					0,
5500					lK,
5501					lV,
5502					A5($elm$core$Dict$RBNode_elm_builtin, 1, llK, llV, llLeft, llRight),
5503					A5($elm$core$Dict$RBNode_elm_builtin, 1, key, value, lRight, right));
5504			} else {
5505				return A5($elm$core$Dict$RBNode_elm_builtin, color, key, value, left, right);
5506			}
5507		}
5508	});
5509var $elm$core$Dict$insertHelp = F3(
5510	function (key, value, dict) {
5511		if (dict.$ === -2) {
5512			return A5($elm$core$Dict$RBNode_elm_builtin, 0, key, value, $elm$core$Dict$RBEmpty_elm_builtin, $elm$core$Dict$RBEmpty_elm_builtin);
5513		} else {
5514			var nColor = dict.a;
5515			var nKey = dict.b;
5516			var nValue = dict.c;
5517			var nLeft = dict.d;
5518			var nRight = dict.e;
5519			var _v1 = A2($elm$core$Basics$compare, key, nKey);
5520			switch (_v1) {
5521				case 0:
5522					return A5(
5523						$elm$core$Dict$balance,
5524						nColor,
5525						nKey,
5526						nValue,
5527						A3($elm$core$Dict$insertHelp, key, value, nLeft),
5528						nRight);
5529				case 1:
5530					return A5($elm$core$Dict$RBNode_elm_builtin, nColor, nKey, value, nLeft, nRight);
5531				default:
5532					return A5(
5533						$elm$core$Dict$balance,
5534						nColor,
5535						nKey,
5536						nValue,
5537						nLeft,
5538						A3($elm$core$Dict$insertHelp, key, value, nRight));
5539			}
5540		}
5541	});
5542var $elm$core$Dict$insert = F3(
5543	function (key, value, dict) {
5544		var _v0 = A3($elm$core$Dict$insertHelp, key, value, dict);
5545		if ((_v0.$ === -1) && (!_v0.a)) {
5546			var _v1 = _v0.a;
5547			var k = _v0.b;
5548			var v = _v0.c;
5549			var l = _v0.d;
5550			var r = _v0.e;
5551			return A5($elm$core$Dict$RBNode_elm_builtin, 1, k, v, l, r);
5552		} else {
5553			var x = _v0;
5554			return x;
5555		}
5556	});
5557var $elm$core$Dict$getMin = function (dict) {
5558	getMin:
5559	while (true) {
5560		if ((dict.$ === -1) && (dict.d.$ === -1)) {
5561			var left = dict.d;
5562			var $temp$dict = left;
5563			dict = $temp$dict;
5564			continue getMin;
5565		} else {
5566			return dict;
5567		}
5568	}
5569};
5570var $elm$core$Dict$moveRedLeft = function (dict) {
5571	if (((dict.$ === -1) && (dict.d.$ === -1)) && (dict.e.$ === -1)) {
5572		if ((dict.e.d.$ === -1) && (!dict.e.d.a)) {
5573			var clr = dict.a;
5574			var k = dict.b;
5575			var v = dict.c;
5576			var _v1 = dict.d;
5577			var lClr = _v1.a;
5578			var lK = _v1.b;
5579			var lV = _v1.c;
5580			var lLeft = _v1.d;
5581			var lRight = _v1.e;
5582			var _v2 = dict.e;
5583			var rClr = _v2.a;
5584			var rK = _v2.b;
5585			var rV = _v2.c;
5586			var rLeft = _v2.d;
5587			var _v3 = rLeft.a;
5588			var rlK = rLeft.b;
5589			var rlV = rLeft.c;
5590			var rlL = rLeft.d;
5591			var rlR = rLeft.e;
5592			var rRight = _v2.e;
5593			return A5(
5594				$elm$core$Dict$RBNode_elm_builtin,
5595				0,
5596				rlK,
5597				rlV,
5598				A5(
5599					$elm$core$Dict$RBNode_elm_builtin,
5600					1,
5601					k,
5602					v,
5603					A5($elm$core$Dict$RBNode_elm_builtin, 0, lK, lV, lLeft, lRight),
5604					rlL),
5605				A5($elm$core$Dict$RBNode_elm_builtin, 1, rK, rV, rlR, rRight));
5606		} else {
5607			var clr = dict.a;
5608			var k = dict.b;
5609			var v = dict.c;
5610			var _v4 = dict.d;
5611			var lClr = _v4.a;
5612			var lK = _v4.b;
5613			var lV = _v4.c;
5614			var lLeft = _v4.d;
5615			var lRight = _v4.e;
5616			var _v5 = dict.e;
5617			var rClr = _v5.a;
5618			var rK = _v5.b;
5619			var rV = _v5.c;
5620			var rLeft = _v5.d;
5621			var rRight = _v5.e;
5622			if (clr === 1) {
5623				return A5(
5624					$elm$core$Dict$RBNode_elm_builtin,
5625					1,
5626					k,
5627					v,
5628					A5($elm$core$Dict$RBNode_elm_builtin, 0, lK, lV, lLeft, lRight),
5629					A5($elm$core$Dict$RBNode_elm_builtin, 0, rK, rV, rLeft, rRight));
5630			} else {
5631				return A5(
5632					$elm$core$Dict$RBNode_elm_builtin,
5633					1,
5634					k,
5635					v,
5636					A5($elm$core$Dict$RBNode_elm_builtin, 0, lK, lV, lLeft, lRight),
5637					A5($elm$core$Dict$RBNode_elm_builtin, 0, rK, rV, rLeft, rRight));
5638			}
5639		}
5640	} else {
5641		return dict;
5642	}
5643};
5644var $elm$core$Dict$moveRedRight = function (dict) {
5645	if (((dict.$ === -1) && (dict.d.$ === -1)) && (dict.e.$ === -1)) {
5646		if ((dict.d.d.$ === -1) && (!dict.d.d.a)) {
5647			var clr = dict.a;
5648			var k = dict.b;
5649			var v = dict.c;
5650			var _v1 = dict.d;
5651			var lClr = _v1.a;
5652			var lK = _v1.b;
5653			var lV = _v1.c;
5654			var _v2 = _v1.d;
5655			var _v3 = _v2.a;
5656			var llK = _v2.b;
5657			var llV = _v2.c;
5658			var llLeft = _v2.d;
5659			var llRight = _v2.e;
5660			var lRight = _v1.e;
5661			var _v4 = dict.e;
5662			var rClr = _v4.a;
5663			var rK = _v4.b;
5664			var rV = _v4.c;
5665			var rLeft = _v4.d;
5666			var rRight = _v4.e;
5667			return A5(
5668				$elm$core$Dict$RBNode_elm_builtin,
5669				0,
5670				lK,
5671				lV,
5672				A5($elm$core$Dict$RBNode_elm_builtin, 1, llK, llV, llLeft, llRight),
5673				A5(
5674					$elm$core$Dict$RBNode_elm_builtin,
5675					1,
5676					k,
5677					v,
5678					lRight,
5679					A5($elm$core$Dict$RBNode_elm_builtin, 0, rK, rV, rLeft, rRight)));
5680		} else {
5681			var clr = dict.a;
5682			var k = dict.b;
5683			var v = dict.c;
5684			var _v5 = dict.d;
5685			var lClr = _v5.a;
5686			var lK = _v5.b;
5687			var lV = _v5.c;
5688			var lLeft = _v5.d;
5689			var lRight = _v5.e;
5690			var _v6 = dict.e;
5691			var rClr = _v6.a;
5692			var rK = _v6.b;
5693			var rV = _v6.c;
5694			var rLeft = _v6.d;
5695			var rRight = _v6.e;
5696			if (clr === 1) {
5697				return A5(
5698					$elm$core$Dict$RBNode_elm_builtin,
5699					1,
5700					k,
5701					v,
5702					A5($elm$core$Dict$RBNode_elm_builtin, 0, lK, lV, lLeft, lRight),
5703					A5($elm$core$Dict$RBNode_elm_builtin, 0, rK, rV, rLeft, rRight));
5704			} else {
5705				return A5(
5706					$elm$core$Dict$RBNode_elm_builtin,
5707					1,
5708					k,
5709					v,
5710					A5($elm$core$Dict$RBNode_elm_builtin, 0, lK, lV, lLeft, lRight),
5711					A5($elm$core$Dict$RBNode_elm_builtin, 0, rK, rV, rLeft, rRight));
5712			}
5713		}
5714	} else {
5715		return dict;
5716	}
5717};
5718var $elm$core$Dict$removeHelpPrepEQGT = F7(
5719	function (targetKey, dict, color, key, value, left, right) {
5720		if ((left.$ === -1) && (!left.a)) {
5721			var _v1 = left.a;
5722			var lK = left.b;
5723			var lV = left.c;
5724			var lLeft = left.d;
5725			var lRight = left.e;
5726			return A5(
5727				$elm$core$Dict$RBNode_elm_builtin,
5728				color,
5729				lK,
5730				lV,
5731				lLeft,
5732				A5($elm$core$Dict$RBNode_elm_builtin, 0, key, value, lRight, right));
5733		} else {
5734			_v2$2:
5735			while (true) {
5736				if ((right.$ === -1) && (right.a === 1)) {
5737					if (right.d.$ === -1) {
5738						if (right.d.a === 1) {
5739							var _v3 = right.a;
5740							var _v4 = right.d;
5741							var _v5 = _v4.a;
5742							return $elm$core$Dict$moveRedRight(dict);
5743						} else {
5744							break _v2$2;
5745						}
5746					} else {
5747						var _v6 = right.a;
5748						var _v7 = right.d;
5749						return $elm$core$Dict$moveRedRight(dict);
5750					}
5751				} else {
5752					break _v2$2;
5753				}
5754			}
5755			return dict;
5756		}
5757	});
5758var $elm$core$Dict$removeMin = function (dict) {
5759	if ((dict.$ === -1) && (dict.d.$ === -1)) {
5760		var color = dict.a;
5761		var key = dict.b;
5762		var value = dict.c;
5763		var left = dict.d;
5764		var lColor = left.a;
5765		var lLeft = left.d;
5766		var right = dict.e;
5767		if (lColor === 1) {
5768			if ((lLeft.$ === -1) && (!lLeft.a)) {
5769				var _v3 = lLeft.a;
5770				return A5(
5771					$elm$core$Dict$RBNode_elm_builtin,
5772					color,
5773					key,
5774					value,
5775					$elm$core$Dict$removeMin(left),
5776					right);
5777			} else {
5778				var _v4 = $elm$core$Dict$moveRedLeft(dict);
5779				if (_v4.$ === -1) {
5780					var nColor = _v4.a;
5781					var nKey = _v4.b;
5782					var nValue = _v4.c;
5783					var nLeft = _v4.d;
5784					var nRight = _v4.e;
5785					return A5(
5786						$elm$core$Dict$balance,
5787						nColor,
5788						nKey,
5789						nValue,
5790						$elm$core$Dict$removeMin(nLeft),
5791						nRight);
5792				} else {
5793					return $elm$core$Dict$RBEmpty_elm_builtin;
5794				}
5795			}
5796		} else {
5797			return A5(
5798				$elm$core$Dict$RBNode_elm_builtin,
5799				color,
5800				key,
5801				value,
5802				$elm$core$Dict$removeMin(left),
5803				right);
5804		}
5805	} else {
5806		return $elm$core$Dict$RBEmpty_elm_builtin;
5807	}
5808};
5809var $elm$core$Dict$removeHelp = F2(
5810	function (targetKey, dict) {
5811		if (dict.$ === -2) {
5812			return $elm$core$Dict$RBEmpty_elm_builtin;
5813		} else {
5814			var color = dict.a;
5815			var key = dict.b;
5816			var value = dict.c;
5817			var left = dict.d;
5818			var right = dict.e;

5819			if (_Utils_cmp(targetKey, key) < 0) {
5820				if ((left.$ === -1) && (left.a === 1)) {
5821					var _v4 = left.a;
5822					var lLeft = left.d;
5823					if ((lLeft.$ === -1) && (!lLeft.a)) {
5824						var _v6 = lLeft.a;
5825						return A5(
5826							$elm$core$Dict$RBNode_elm_builtin,
5827							color,
5828							key,
5829							value,
5830							A2($elm$core$Dict$removeHelp, targetKey, left),
5831							right);
5832					} else {
5833						var _v7 = $elm$core$Dict$moveRedLeft(dict);
5834						if (_v7.$ === -1) {
5835							var nColor = _v7.a;
5836							var nKey = _v7.b;
5837							var nValue = _v7.c;
5838							var nLeft = _v7.d;
5839							var nRight = _v7.e;
5840							return A5(
5841								$elm$core$Dict$balance,
5842								nColor,
5843								nKey,
5844								nValue,
5845								A2($elm$core$Dict$removeHelp, targetKey, nLeft),
5846								nRight);
5847						} else {
5848							return $elm$core$Dict$RBEmpty_elm_builtin;
5849						}
5850					}
5851				} else {
5852					return A5(
5853						$elm$core$Dict$RBNode_elm_builtin,
5854						color,
5855						key,
5856						value,
5857						A2($elm$core$Dict$removeHelp, targetKey, left),
5858						right);
5859				}
5860			} else {
5861				return A2(
5862					$elm$core$Dict$removeHelpEQGT,
5863					targetKey,
5864					A7($elm$core$Dict$removeHelpPrepEQGT, targetKey, dict, color, key, value, left, right));
5865			}
5866		}
5867	});
5868var $elm$core$Dict$removeHelpEQGT = F2(
5869	function (targetKey, dict) {
5870		if (dict.$ === -1) {
5871			var color = dict.a;
5872			var key = dict.b;
5873			var value = dict.c;
5874			var left = dict.d;
5875			var right = dict.e;
5876			if (_Utils_eq(targetKey, key)) {
5877				var _v1 = $elm$core$Dict$getMin(right);
5878				if (_v1.$ === -1) {
5879					var minKey = _v1.b;
5880					var minValue = _v1.c;
5881					return A5(
5882						$elm$core$Dict$balance,
5883						color,
5884						minKey,
5885						minValue,
5886						left,
5887						$elm$core$Dict$removeMin(right));
5888				} else {
5889					return $elm$core$Dict$RBEmpty_elm_builtin;
5890				}
5891			} else {
5892				return A5(
5893					$elm$core$Dict$balance,
5894					color,
5895					key,
5896					value,
5897					left,
5898					A2($elm$core$Dict$removeHelp, targetKey, right));
5899			}
5900		} else {
5901			return $elm$core$Dict$RBEmpty_elm_builtin;
5902		}
5903	});
5904var $elm$core$Dict$remove = F2(
5905	function (key, dict) {
5906		var _v0 = A2($elm$core$Dict$removeHelp, key, dict);
5907		if ((_v0.$ === -1) && (!_v0.a)) {
5908			var _v1 = _v0.a;
5909			var k = _v0.b;
5910			var v = _v0.c;
5911			var l = _v0.d;
5912			var r = _v0.e;
5913			return A5($elm$core$Dict$RBNode_elm_builtin, 1, k, v, l, r);
5914		} else {
5915			var x = _v0;
5916			return x;
5917		}
5918	});
5919var $elm$core$Dict$update = F3(
5920	function (targetKey, alter, dictionary) {
5921		var _v0 = alter(
5922			A2($elm$core$Dict$get, targetKey, dictionary));
5923		if (!_v0.$) {
5924			var value = _v0.a;
5925			return A3($elm$core$Dict$insert, targetKey, value, dictionary);
5926		} else {
5927			return A2($elm$core$Dict$remove, targetKey, dictionary);
5928		}
5929	});
5930var $elm$url$Url$Parser$addParam = F2(
5931	function (segment, dict) {
5932		var _v0 = A2($elm$core$String$split, '=', segment);
5933		if ((_v0.b && _v0.b.b) && (!_v0.b.b.b)) {
5934			var rawKey = _v0.a;
5935			var _v1 = _v0.b;
5936			var rawValue = _v1.a;
5937			var _v2 = $elm$url$Url$percentDecode(rawKey);
5938			if (_v2.$ === 1) {
5939				return dict;
5940			} else {
5941				var key = _v2.a;
5942				var _v3 = $elm$url$Url$percentDecode(rawValue);
5943				if (_v3.$ === 1) {
5944					return dict;
5945				} else {
5946					var value = _v3.a;
5947					return A3(
5948						$elm$core$Dict$update,
5949						key,
5950						$elm$url$Url$Parser$addToParametersHelp(value),
5951						dict);
5952				}
5953			}
5954		} else {
5955			return dict;
5956		}
5957	});
5958var $elm$core$Dict$empty = $elm$core$Dict$RBEmpty_elm_builtin;
5959var $elm$url$Url$Parser$prepareQuery = function (maybeQuery) {
5960	if (maybeQuery.$ === 1) {
5961		return $elm$core$Dict$empty;
5962	} else {
5963		var qry = maybeQuery.a;
5964		return A3(
5965			$elm$core$List$foldr,
5966			$elm$url$Url$Parser$addParam,
5967			$elm$core$Dict$empty,
5968			A2($elm$core$String$split, '&', qry));
5969	}
5970};
5971var $elm$url$Url$Parser$parse = F2(
5972	function (_v0, url) {
5973		var parser = _v0;
5974		return $elm$url$Url$Parser$getFirstMatch(
5975			parser(
5976				A5(
5977					$elm$url$Url$Parser$State,
5978					_List_Nil,
5979					$elm$url$Url$Parser$preparePath(url.cM),
5980					$elm$url$Url$Parser$prepareQuery(url.gl),
5981					url.fE,
5982					$elm$core$Basics$identity)));
5983	});
5984var $author$project$Main$RouteItem = function (a) {
5985	return {$: 2, a: a};
5986};
5987var $author$project$Main$RouteList = {$: 1};
5988var $mdgriffith$elm_ui$Internal$Model$Rgba = F4(
5989	function (a, b, c, d) {

5990		return {$: 0, a: a, b: b, c: c, d: d};
5991	});
5992var $mdgriffith$elm_ui$Element$rgb = F3(
5993	function (r, g, b) {
5994		return A4($mdgriffith$elm_ui$Internal$Model$Rgba, r, g, b, 1);
5995	});
5996var $mdgriffith$elm_ui$Element$rgb255 = F3(
5997	function (red, green, blue) {
5998		return A4($mdgriffith$elm_ui$Internal$Model$Rgba, red / 255, green / 255, blue / 255, 1);
5999	});
6000var $author$project$Projects$Project$conf = {
6001	eV: A3($mdgriffith$elm_ui$Element$rgb255, 255, 255, 255),
6002	dl: 'Lucamug\'s Projects',
6003	fD: A3($mdgriffith$elm_ui$Element$rgb, 0, 0, 0),
6004	cU: 50,
6005	g5: 'lucamug',
6006	bU: 'lucamug'
6007};
6008var $elm$url$Url$Parser$Parser = $elm$core$Basics$identity;
6009var $elm$url$Url$Parser$mapState = F2(
6010	function (func, _v0) {
6011		var visited = _v0.aM;
6012		var unvisited = _v0.aw;
6013		var params = _v0.aG;
6014		var frag = _v0.aC;
6015		var value = _v0.ak;
6016		return A5(
6017			$elm$url$Url$Parser$State,
6018			visited,
6019			unvisited,
6020			params,
6021			frag,
6022			func(value));
6023	});
6024var $elm$url$Url$Parser$map = F2(
6025	function (subValue, _v0) {
6026		var parseArg = _v0;
6027		return function (_v1) {
6028			var visited = _v1.aM;
6029			var unvisited = _v1.aw;
6030			var params = _v1.aG;
6031			var frag = _v1.aC;
6032			var value = _v1.ak;
6033			return A2(
6034				$elm$core$List$map,
6035				$elm$url$Url$Parser$mapState(value),
6036				parseArg(
6037					A5($elm$url$Url$Parser$State, visited, unvisited, params, frag, subValue)));
6038		};
6039	});
6040var $elm$core$List$append = F2(
6041	function (xs, ys) {
6042		if (!ys.b) {
6043			return xs;
6044		} else {
6045			return A3($elm$core$List$foldr, $elm$core$List$cons, ys, xs);
6046		}
6047	});
6048var $elm$core$List$concat = function (lists) {
6049	return A3($elm$core$List$foldr, $elm$core$List$append, _List_Nil, lists);
6050};
6051var $elm$core$List$concatMap = F2(
6052	function (f, list) {
6053		return $elm$core$List$concat(
6054			A2($elm$core$List$map, f, list));
6055	});
6056var $elm$url$Url$Parser$oneOf = function (parsers) {
6057	return function (state) {
6058		return A2(
6059			$elm$core$List$concatMap,
6060			function (_v0) {
6061				var parser = _v0;
6062				return parser(state);
6063			},
6064			parsers);
6065	};
6066};
6067var $elm$url$Url$Parser$s = function (str) {
6068	return function (_v0) {
6069		var visited = _v0.aM;
6070		var unvisited = _v0.aw;
6071		var params = _v0.aG;
6072		var frag = _v0.aC;
6073		var value = _v0.ak;
6074		if (!unvisited.b) {
6075			return _List_Nil;
6076		} else {
6077			var next = unvisited.a;
6078			var rest = unvisited.b;
6079			return _Utils_eq(next, str) ? _List_fromArray(
6080				[
6081					A5(
6082					$elm$url$Url$Parser$State,
6083					A2($elm$core$List$cons, next, visited),
6084					rest,
6085					params,
6086					frag,
6087					value)
6088				]) : _List_Nil;
6089		}
6090	};
6091};
6092var $elm$url$Url$Parser$slash = F2(
6093	function (_v0, _v1) {
6094		var parseBefore = _v0;
6095		var parseAfter = _v1;
6096		return function (state) {
6097			return A2(
6098				$elm$core$List$concatMap,
6099				parseAfter,
6100				parseBefore(state));
6101		};
6102	});
6103var $elm$url$Url$Parser$custom = F2(
6104	function (tipe, stringToSomething) {
6105		return function (_v0) {
6106			var visited = _v0.aM;
6107			var unvisited = _v0.aw;
6108			var params = _v0.aG;
6109			var frag = _v0.aC;
6110			var value = _v0.ak;
6111			if (!unvisited.b) {
6112				return _List_Nil;
6113			} else {
6114				var next = unvisited.a;
6115				var rest = unvisited.b;
6116				var _v2 = stringToSomething(next);
6117				if (!_v2.$) {
6118					var nextValue = _v2.a;
6119					return _List_fromArray(
6120						[
6121							A5(
6122							$elm$url$Url$Parser$State,
6123							A2($elm$core$List$cons, next, visited),
6124							rest,
6125							params,
6126							frag,
6127							value(nextValue))
6128						]);
6129				} else {
6130					return _List_Nil;
6131				}
6132			}
6133		};
6134	});
6135var $elm$url$Url$Parser$string = A2($elm$url$Url$Parser$custom, 'STRING', $elm$core$Maybe$Just);
6136var $elm$url$Url$Parser$top = function (state) {
6137	return _List_fromArray(
6138		[state]);
6139};
6140var $author$project$Main$routex = $elm$url$Url$Parser$oneOf(
6141	_List_fromArray(
6142		[
6143			A2(
6144			$elm$url$Url$Parser$map,
6145			$author$project$Main$RouteList,
6146			$elm$url$Url$Parser$s('list')),
6147			A2(
6148			$elm$url$Url$Parser$map,
6149			$author$project$Main$RouteItem,
6150			A2(
6151				$elm$url$Url$Parser$slash,
6152				$elm$url$Url$Parser$s($author$project$Projects$Project$conf.bU),
6153				$elm$url$Url$Parser$string)),
6154			A2($elm$url$Url$Parser$map, $author$project$Main$RouteTop, $elm$url$Url$Parser$top)
6155		]));
6156var $author$project$Main$updateRoute = function (url) {
6157	return A2($elm$url$Url$Parser$parse, $author$project$Main$routex, url);
6158};
6159var $elm$core$Maybe$withDefault = F2(
6160	function (_default, maybe) {
6161		if (!maybe.$) {
6162			var value = maybe.a;
6163			return value;
6164		} else {
6165			return _default;
6166		}
6167	});
6168var $author$project$Main$locationHrefToRoute = function (locationHref) {
6169	return A2(
6170		$elm$core$Maybe$withDefault,
6171		$author$project$Main$RouteTop,
6172		A2(
6173			$elm$core$Maybe$andThen,
6174			$author$project$Main$updateRoute,
6175			$elm$url$Url$fromString(locationHref)));
6176};
6177var $author$project$Main$init = function (flags) {
6178	var newRoute = $author$project$Main$locationHrefToRoute(flags.cw);
6179	return _Utils_Tuple2(
6180		{W: newRoute},
6181		$author$project$Main$cmdOnRouteChange(newRoute));
6182};
6183var $elm$json$Json$Decode$string = _Json_decodeString;
6184var $author$project$Main$KeyDown = function (a) {
6185	return {$: 3, a: a};
6186};
6187var $author$project$Main$UrlChanged = function (a) {
6188	return {$: 2, a: a};
6189};
6190var $elm$core$Platform$Sub$batch = _Platform_batch;
6191var $elm$core$Basics$composeR = F3(
6192	function (f, g, x) {
6193		return g(
6194			f(x));
6195	});
6196var $elm$json$Json$Decode$int = _Json_decodeInt;
6197var $elm$html$Html$Events$keyCode = A2($elm$json$Json$Decode$field, 'keyCode', $elm$json$Json$Decode$int);
6198var $elm$browser$Browser$Events$Document = 0;
6199var $elm$browser$Browser$Events$MySub = F3(
6200	function (a, b, c) {

6201		return {$: 0, a: a, b: b, c: c};
6202	});
6203var $elm$browser$Browser$Events$State = F2(
6204	function (subs, pids) {
6205		return {d7: pids, em: subs};
6206	});
6207var $elm$browser$Browser$Events$init = $elm$core$Task$succeed(
6208	A2($elm$browser$Browser$Events$State, _List_Nil, $elm$core$Dict$empty));
6209var $elm$browser$Browser$Events$nodeToKey = function (node) {
6210	if (!node) {
6211		return 'd_';
6212	} else {
6213		return 'w_';
6214	}
6215};
6216var $elm$browser$Browser$Events$addKey = function (sub) {
6217	var node = sub.a;
6218	var name = sub.b;
6219	return _Utils_Tuple2(
6220		_Utils_ap(
6221			$elm$browser$Browser$Events$nodeToKey(node),
6222			name),
6223		sub);
6224};
6225var $elm$core$Dict$fromList = function (assocs) {
6226	return A3(
6227		$elm$core$List$foldl,
6228		F2(
6229			function (_v0, dict) {
6230				var key = _v0.a;
6231				var value = _v0.b;
6232				return A3($elm$core$Dict$insert, key, value, dict);
6233			}),
6234		$elm$core$Dict$empty,
6235		assocs);
6236};
6237var $elm$core$Process$kill = _Scheduler_kill;
6238var $elm$core$Dict$foldl = F3(
6239	function (func, acc, dict) {
6240		foldl:
6241		while (true) {
6242			if (dict.$ === -2) {
6243				return acc;
6244			} else {
6245				var key = dict.b;
6246				var value = dict.c;
6247				var left = dict.d;
6248				var right = dict.e;
6249				var $temp$func = func,
6250					$temp$acc = A3(
6251					func,
6252					key,
6253					value,
6254					A3($elm$core$Dict$foldl, func, acc, left)),
6255					$temp$dict = right;
6256				func = $temp$func;
6257				acc = $temp$acc;
6258				dict = $temp$dict;
6259				continue foldl;
6260			}
6261		}
6262	});
6263var $elm$core$Dict$merge = F6(
6264	function (leftStep, bothStep, rightStep, leftDict, rightDict, initialResult) {
6265		var stepState = F3(
6266			function (rKey, rValue, _v0) {
6267				stepState:
6268				while (true) {
6269					var list = _v0.a;
6270					var result = _v0.b;
6271					if (!list.b) {
6272						return _Utils_Tuple2(
6273							list,
6274							A3(rightStep, rKey, rValue, result));
6275					} else {
6276						var _v2 = list.a;
6277						var lKey = _v2.a;
6278						var lValue = _v2.b;
6279						var rest = list.b;
6280						if (_Utils_cmp(lKey, rKey) < 0) {
6281							var $temp$rKey = rKey,
6282								$temp$rValue = rValue,
6283								$temp$_v0 = _Utils_Tuple2(
6284								rest,
6285								A3(leftStep, lKey, lValue, result));
6286							rKey = $temp$rKey;
6287							rValue = $temp$rValue;
6288							_v0 = $temp$_v0;
6289							continue stepState;
6290						} else {
6291							if (_Utils_cmp(lKey, rKey) > 0) {
6292								return _Utils_Tuple2(
6293									list,
6294									A3(rightStep, rKey, rValue, result));
6295							} else {
6296								return _Utils_Tuple2(
6297									rest,
6298									A4(bothStep, lKey, lValue, rValue, result));
6299							}
6300						}
6301					}
6302				}
6303			});
6304		var _v3 = A3(
6305			$elm$core$Dict$foldl,
6306			stepState,
6307			_Utils_Tuple2(
6308				$elm$core$Dict$toList(leftDict),
6309				initialResult),
6310			rightDict);
6311		var leftovers = _v3.a;
6312		var intermediateResult = _v3.b;
6313		return A3(
6314			$elm$core$List$foldl,
6315			F2(
6316				function (_v4, result) {
6317					var k = _v4.a;
6318					var v = _v4.b;
6319					return A3(leftStep, k, v, result);
6320				}),
6321			intermediateResult,
6322			leftovers);
6323	});
6324var $elm$browser$Browser$Events$Event = F2(
6325	function (key, event) {
6326		return {dq: event, dB: key};
6327	});
6328var $elm$core$Platform$sendToSelf = _Platform_sendToSelf;
6329var $elm$browser$Browser$Events$spawn = F3(
6330	function (router, key, _v0) {
6331		var node = _v0.a;
6332		var name = _v0.b;
6333		var actualNode = function () {
6334			if (!node) {
6335				return _Browser_doc;
6336			} else {
6337				return _Browser_window;
6338			}
6339		}();
6340		return A2(
6341			$elm$core$Task$map,
6342			function (value) {
6343				return _Utils_Tuple2(key, value);
6344			},
6345			A3(
6346				_Browser_on,
6347				actualNode,
6348				name,
6349				function (event) {
6350					return A2(
6351						$elm$core$Platform$sendToSelf,
6352						router,
6353						A2($elm$browser$Browser$Events$Event, key, event));
6354				}));
6355	});
6356var $elm$core$Dict$union = F2(
6357	function (t1, t2) {
6358		return A3($elm$core$Dict$foldl, $elm$core$Dict$insert, t2, t1);
6359	});
6360var $elm$browser$Browser$Events$onEffects = F3(
6361	function (router, subs, state) {
6362		var stepRight = F3(
6363			function (key, sub, _v6) {
6364				var deads = _v6.a;
6365				var lives = _v6.b;
6366				var news = _v6.c;
6367				return _Utils_Tuple3(
6368					deads,
6369					lives,
6370					A2(
6371						$elm$core$List$cons,
6372						A3($elm$browser$Browser$Events$spawn, router, key, sub),
6373						news));
6374			});
6375		var stepLeft = F3(
6376			function (_v4, pid, _v5) {
6377				var deads = _v5.a;
6378				var lives = _v5.b;
6379				var news = _v5.c;
6380				return _Utils_Tuple3(
6381					A2($elm$core$List$cons, pid, deads),
6382					lives,
6383					news);
6384			});
6385		var stepBoth = F4(
6386			function (key, pid, _v2, _v3) {
6387				var deads = _v3.a;
6388				var lives = _v3.b;
6389				var news = _v3.c;
6390				return _Utils_Tuple3(
6391					deads,
6392					A3($elm$core$Dict$insert, key, pid, lives),
6393					news);
6394			});
6395		var newSubs = A2($elm$core$List$map, $elm$browser$Browser$Events$addKey, subs);
6396		var _v0 = A6(
6397			$elm$core$Dict$merge,
6398			stepLeft,
6399			stepBoth,
6400			stepRight,
6401			state.d7,
6402			$elm$core$Dict$fromList(newSubs),
6403			_Utils_Tuple3(_List_Nil, $elm$core$Dict$empty, _List_Nil));
6404		var deadPids = _v0.a;
6405		var livePids = _v0.b;
6406		var makeNewPids = _v0.c;
6407		return A2(
6408			$elm$core$Task$andThen,
6409			function (pids) {
6410				return $elm$core$Task$succeed(
6411					A2(
6412						$elm$browser$Browser$Events$State,
6413						newSubs,
6414						A2(
6415							$elm$core$Dict$union,
6416							livePids,
6417							$elm$core$Dict$fromList(pids))));
6418			},
6419			A2(
6420				$elm$core$Task$andThen,
6421				function (_v1) {
6422					return $elm$core$Task$sequence(makeNewPids);
6423				},
6424				$elm$core$Task$sequence(
6425					A2($elm$core$List$map, $elm$core$Process$kill, deadPids))));
6426	});
6427var $elm$core$List$maybeCons = F3(
6428	function (f, mx, xs) {
6429		var _v0 = f(mx);
6430		if (!_v0.$) {
6431			var x = _v0.a;
6432			return A2($elm$core$List$cons, x, xs);
6433		} else {
6434			return xs;
6435		}
6436	});
6437var $elm$core$List$filterMap = F2(
6438	function (f, xs) {
6439		return A3(
6440			$elm$core$List$foldr,
6441			$elm$core$List$maybeCons(f),
6442			_List_Nil,
6443			xs);
6444	});
6445var $elm$browser$Browser$Events$onSelfMsg = F3(
6446	function (router, _v0, state) {
6447		var key = _v0.dB;
6448		var event = _v0.dq;
6449		var toMessage = function (_v2) {
6450			var subKey = _v2.a;
6451			var _v3 = _v2.b;
6452			var node = _v3.a;
6453			var name = _v3.b;
6454			var decoder = _v3.c;
6455			return _Utils_eq(subKey, key) ? A2(_Browser_decodeEvent, decoder, event) : $elm$core$Maybe$Nothing;
6456		};
6457		var messages = A2($elm$core$List$filterMap, toMessage, state.em);
6458		return A2(
6459			$elm$core$Task$andThen,
6460			function (_v1) {
6461				return $elm$core$Task$succeed(state);
6462			},
6463			$elm$core$Task$sequence(
6464				A2(
6465					$elm$core$List$map,
6466					$elm$core$Platform$sendToApp(router),
6467					messages)));
6468	});
6469var $elm$browser$Browser$Events$subMap = F2(
6470	function (func, _v0) {
6471		var node = _v0.a;
6472		var name = _v0.b;
6473		var decoder = _v0.c;
6474		return A3(
6475			$elm$browser$Browser$Events$MySub,
6476			node,
6477			name,
6478			A2($elm$json$Json$Decode$map, func, decoder));
6479	});
6480_Platform_effectManagers['Browser.Events'] = _Platform_createManager($elm$browser$Browser$Events$init, $elm$browser$Browser$Events$onEffects, $elm$browser$Browser$Events$onSelfMsg, 0, $elm$browser$Browser$Events$subMap);
6481var $elm$browser$Browser$Events$subscription = _Platform_leaf('Browser.Events');
6482var $elm$browser$Browser$Events$on = F3(
6483	function (node, name, decoder) {
6484		return $elm$browser$Browser$Events$subscription(
6485			A3($elm$browser$Browser$Events$MySub, node, name, decoder));
6486	});
6487var $elm$browser$Browser$Events$onKeyDown = A2($elm$browser$Browser$Events$on, 0, 'keydown');
6488var $author$project$Main$onUrlChange = _Platform_incomingPort('onUrlChange', $elm$json$Json$Decode$string);
6489var $author$project$Main$subscriptions = function (model) {
6490	return $elm$core$Platform$Sub$batch(
6491		_List_fromArray(
6492			[
6493				$author$project$Main$onUrlChange(
6494				A2($elm$core$Basics$composeR, $author$project$Main$locationHrefToRoute, $author$project$Main$UrlChanged)),
6495				$elm$browser$Browser$Events$onKeyDown(
6496				A2($elm$json$Json$Decode$map, $author$project$Main$KeyDown, $elm$html$Html$Events$keyCode))
6497			]));
6498};
6499var $elm$core$Platform$Cmd$batch = _Platform_batch;
6500var $elm$json$Json$Encode$list = F2(
6501	function (func, entries) {
6502		return _Json_wrap(
6503			A3(
6504				$elm$core$List$foldl,
6505				_Json_addEntry(func),
6506				_Json_emptyArray(0),

6507				entries));
6508	});
6509var $elm$json$Json$Encode$string = _Json_wrap;
6510var $author$project$Main$changeMeta = _Platform_outgoingPort(
6511	'changeMeta',
6512	function ($) {
6513		var a = $.a;
6514		var b = $.b;
6515		var c = $.c;
6516		return A2(
6517			$elm$json$Json$Encode$list,
6518			$elm$core$Basics$identity,
6519			_List_fromArray(
6520				[
6521					$elm$json$Json$Encode$string(a),
6522					$elm$json$Json$Encode$string(b),
6523					$elm$json$Json$Encode$string(c)
6524				]));
6525	});
6526var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil);
6527var $author$project$Main$pushUrl = _Platform_outgoingPort('pushUrl', $elm$json$Json$Encode$string);
6528var $author$project$Main$closeModal = function (model) {
6529	var _v0 = model.W;
6530	if (_v0.$ === 2) {
6531		var itemItem = _v0.a;
6532		return _Utils_Tuple2(
6533			model,
6534			$author$project$Main$pushUrl('/lucamug/'));
6535	} else {
6536		return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none);
6537	}
6538};
6539var $elm_community$list_extra$List$Extra$findIndexHelp = F3(
6540	function (index, predicate, list) {
6541		findIndexHelp:
6542		while (true) {
6543			if (!list.b) {
6544				return $elm$core$Maybe$Nothing;
6545			} else {
6546				var x = list.a;
6547				var xs = list.b;
6548				if (predicate(x)) {
6549					return $elm$core$Maybe$Just(index);
6550				} else {
6551					var $temp$index = index + 1,
6552						$temp$predicate = predicate,
6553						$temp$list = xs;
6554					index = $temp$index;
6555					predicate = $temp$predicate;
6556					list = $temp$list;
6557					continue findIndexHelp;
6558				}
6559			}
6560		}
6561	});
6562var $elm_community$list_extra$List$Extra$findIndex = $elm_community$list_extra$List$Extra$findIndexHelp(0);
6563var $elm_community$list_extra$List$Extra$elemIndex = function (x) {
6564	return $elm_community$list_extra$List$Extra$findIndex(
6565		$elm$core$Basics$eq(x));
6566};
6567var $elm$core$List$drop = F2(
6568	function (n, list) {
6569		drop:
6570		while (true) {
6571			if (n <= 0) {
6572				return list;
6573			} else {
6574				if (!list.b) {
6575					return list;
6576				} else {
6577					var x = list.a;
6578					var xs = list.b;
6579					var $temp$n = n - 1,
6580						$temp$list = xs;
6581					n = $temp$n;
6582					list = $temp$list;
6583					continue drop;
6584				}
6585			}
6586		}
6587	});
6588var $elm$core$List$head = function (list) {
6589	if (list.b) {
6590		var x = list.a;
6591		var xs = list.b;
6592		return $elm$core$Maybe$Just(x);
6593	} else {
6594		return $elm$core$Maybe$Nothing;
6595	}
6596};
6597var $elm_community$list_extra$List$Extra$getAt = F2(
6598	function (idx, xs) {
6599		return (idx < 0) ? $elm$core$Maybe$Nothing : $elm$core$List$head(
6600			A2($elm$core$List$drop, idx, xs));
6601	});
6602var $author$project$Projects$Project$id = function ($) {
6603	return $.gp;
6604};
6605var $elm$core$List$filter = F2(
6606	function (isGood, list) {
6607		return A3(
6608			$elm$core$List$foldr,
6609			F2(
6610				function (x, xs) {
6611					return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs;
6612				}),
6613			_List_Nil,
6614			list);
6615	});
6616var $elm$core$String$replace = F3(
6617	function (before, after, string) {
6618		return A2(
6619			$elm$core$String$join,
6620			after,
6621			A2($elm$core$String$split, before, string));
6622	});
6623var $elm$core$String$toLower = _String_toLower;
6624var $author$project$Main$idDecoder = function (id) {
6625	return $elm$core$String$toLower(
6626		A3(
6627			$elm$core$String$replace,
6628			'_',
6629			' ',
6630			A2(
6631				$elm$core$Maybe$withDefault,
6632				id,
6633				$elm$url$Url$percentDecode(id))));
6634};
6635var $author$project$Projects$Project$items = _List_fromArray(
6636	[
6637		{c: 'https://github.com/lucamug/elm-tea', e: '', d: 'https://lucamug.github.io/elm-tea/', b: 'An animation that explains how TEA (The Elm Architecture) works, visually.', a: 'tea.jpg', gp: 'elm-tea', g5: '🔄 The Elm Architecture (TEA) animation', bT: 'https://lucamug.github.io/elm-tea/'},
6638		{c: 'https://github.com/lucamug/elm-transformer', e: '', d: 'https://lucamug.github.io/elm-transformer/', b: 'A library that can be used to easily view and edit any data structure of Elm code. Want to edit the Model of your running Elm app in real time directly from the browser? With this library you can do that easily. It supports all major data structures including Char, Bytes, Tuples, Array, Set, Dict, Maybe, Result, Custom types, and Records.', a: 'elm-transformer.jpg', gp: 'elm-transformer', g5: '🔧 elm-transformer - View and edit any Elm data structure in real time', bT: 'https://lucamug.github.io/elm-transformer/'},
6639		{c: '', e: '2025', d: '', b: 'A lightning talk examining how making side effects explicit and transparent can improve c

6639ode clarity, cut debugging time, and boost reliability. Includes a live web app demo.', a: 'beyond-console.jpg', gp: 'Talk \"Beyond console.log\" @ JSConf Japan 2025', g5: '🎤 Talk \"Beyond console.log: Developing and Debugging with Observable Side Effects\" @ JSConf Japan 2025', bT: 'https://jsconf.jp/2025/en/talks/beyond-console-log'},
6640		{c: 'https://github.com/lucamug/mor', e: '', d: 'https://lucamug.github.io/mor/', b: 'A simple map navigation system implemented in Elm, from scratch. This is a vibe coded project.', a: 'elm-test-map.jpg', gp: 'mor', g5: '🗺️ Elm Test Map - a simple map navigation system', bT: 'https://lucamug.github.io/mor/'},
6641		{c: 'https://github.com/lucamug/functional-pacman', e: 'January 2025', d: '', b: 'An interpretation of the Pac-Man game, written in approximately 1K lines of purely functional code. It runs both in the browser and in the terminal.', a: 'pacman.gif', gp: 'Functional Pac-Man, an interpretation of the game, written in purely functional code', g5: '🍒 Functional Pac-Man, an interpretation of the game, written in purely functional code', bT: 'https://lucamug.github.io/functional-pacman/'},
6642		{c: 'https://github.com/lucamug/tester', e: 'November 2024', d: 'https://lucamug.github.io/tester/', b: 'A tool to easily test any endpoint with a simple and generic UI. It also generates a `curl` command and a URL to easily share all the data typed in the form.', a: 'tester.png', gp: 'API Tester', g5: '⚙️ API Tester', bT: 'https://lucamug.github.io/tester/'},
6643		{c: 'https://github.com/lucamug/elm-a-year-in-review', e: '', d: '', b: '2023 has been an exciting year for Elm, with many interesting packages, blog posts, videos, podcasts, demos, tutorials, applications, and so on.', a: '2023_in_review.png', gp: 'Elm 2023, a year in review', g5: '📅 Elm 2023, a year in review', bT: 'https://dev.to/lucamug/elm-2023-a-year-in-review-23d6'},
6644		{c: 'https://github.com/lucamug/hope', e: 'Nov 19, 2023', d: 'https://www.youtube.com/watch?v=l_-5jsJrR2o', b: 'The solution for the exception problem is not having exceptions. Throwing exceptions and hoping that someone will take care of them may lead to disappointment. A sound type system can help us build resilient web applications. In Rakuten, we use Elm to prevent runtime exceptions in the authentication system used by millions of users every day. A similar technique can be implemented in TypeScript too.', a: 'hope_cover.jpg', gp: 'Talk \"Hope Is Postponed Disappointment\" @ JSConf Japan', g5: '🚂️🚃🚃🚃 Talk \"Hope Is Postponed Disappointment\" @ JSConf Japan', bT: 'https://jsconf.jp/2023/talk/luca-mugnaini-1/'},
6645		{c: 'https://github.com/lucamug/elm-web-components/blob/master/src/Main.elm', e: 'August, 2023', d: 'https://ellie-app.com/nNbgNpbfKHZa1', b: 'A random collection of interactive web components from the Shoelace library glued together using Elm.', a: 'shoelace_x_elm.png', gp: 'Shoelace X Elm - Web Components in Elm', g5: '➰👟 Shoelace X Elm - Web Components in Elm', bT: 'https://lucamug.github.io/elm-web-components/'},
6646		{c: 'https://github.com/lucamug/functional-programming-for-kids-in-elm', e: '', d: 'https://lucamug.github.io/functional-programming-for-kids-in-elm/#/robot', b: 'A collection of resources for teaching and learning Functional Programming, for begineers.', a: 'functional-programming-for-kids.png', gp: 'Functional Programming for Kids in Elm', g5: '🤖 Functional Programming for Kids in Elm', bT: 'https://lucamug.github.io/functional-programming-for-kids-in-elm/#/robot'},
6647		{c: 'https://github.com/lucamug/elm-a-year-in-review', e: '', d: '', b: '2022 has been an exciting year for Elm, with many interesting packages, blog posts, videos, podcasts, demos, tutorials, applications, and so on.', a: '2022_in_review.png', gp: 'Elm 2022, a year in review', g5: '📅 Elm 2022, a year in review', bT: 'https://dev.to/lucamug/elm-2022-a-year-in-review-33pp'},
6648		{c: 'https://github.com/lucamug/stringy', e: '', d: 'https://lucamug.github.io/stringy/', b: 'A collection of functions that transform strings to QR codes, CSS colors, hexadecimal numbers, dates, base64-encoded data, encrypted text, etc.', a: 'the-string-transformer.png', gp: 'Stringy - The String Transformer', g5: '🧵 Stringy - The String Transformer', bT: 'https://lucamug.github.io/stringy/'},
6649		{c: 'https://github.com/lucamug/elm-map', e: '', d: 'https://elm-map.guupa.com/', b: 'A proof of concept for a \"slippy\" geographic map in 100% #elmlang 🗺️ 🧭. Made with 380 lines of Elm and 1 line of JavaScript.', a: 'elm-map.jpg', gp: 'elm-map', g5: '🗺️ elm-map - A  \"slippy\" geographic map implementation using only Elm code', bT: 'https://elm-map.guupa.com/'},
6650		{c: '', e: '', d: '', b: 'In the front-end world, we finally can take an important decision: Familiarity or Guarantees?', a: 'lucamug16260.png', gp: 'Talk \"Familiarity or Guarantees? Functional Programming for the front-end\" @ Functionl C

6650onf', g5: '🎤 Talk \"Familiarity or Guarantees? Functional Programming for the front-end\" @ Functionl Conf', bT: 'https://confengine.com/conferences/functional-conf-2022/proposal/16260/familiarity-or-guarantees-functional-programming-for-the-front-end'},
6651		{c: '', e: '', d: '', b: 'Several times I have been asked about the differences between TypeScript and Elm. This is an attempt at listing down these differences.', a: 'typescript-and-elm.jpeg', gp: 'Differences between TypeScript and Elm', g5: '🔷 Differences between TypeScript and Elm', bT: 'https://dev.to/lucamug/typescript-and-elm-3g38'},
6652		{c: '', e: '', d: '', b: 'A comparison between the Elm language and the HyperScript through a simple implementation of the Wordle game.', a: 'elm-vs-hyperscript.jpeg', gp: 'Elm vs HyperScript - A Wordle implemetation', g5: '🔷 Elm vs HyperScript - A Wordle implemetation', bT: 'https://dev.to/lucamug/elm-vs-hyperscript-2m3m'},
6653		{c: '', e: '', d: '', b: '2021 has been an exciting year for Elm, with many interesting packages, blog posts, videos, podcasts, demos, tutorials, applications, and so on.', a: '2021_in_review.gif', gp: 'Elm 2021, a year in review', g5: '📅 Elm 2021, a year in review', bT: 'https://dev.to/lucamug/elm-2021-a-year-in-review-4pho'},
6654		{c: '', e: '', d: '', b: 'A short reminder about the guarantees of the Elm language', a: 'guarantees.jpeg', gp: 'Elm\'s guarantees', g5: '📦 Elm\'s guarantees', bT: 'https://dev.to/lucamug/elms-guarantees-13e4'},
6655		{c: 'https://github.com/lucamug/elm-donut/blob/master/src-donut-with-donut-shape/Main.elm', e: '', d: 'https://lucamug.github.io/elm-donut/', b: 'A conversion of the C donut in a functional language.', a: 'the_functional_donut.png', gp: 'The Functional Donut', g5: '🍩 The Functional Donut', bT: 'https://dev.to/lucamug/the-functional-donut-19pp'},
6656		{c: '', e: '', d: '', b: 'A simple goal, three different experiences. What happen when we try to leverage the type systems of JavaScript, TypeScript, and Elm?', a: 'dynamic_to_static_three_steps.png', gp: 'From dynamic to static typing in three steps', g5: '\uD83E\uDE9C From dynamic to static typing in three steps', bT: 'https://dev.to/lucamug/three-steps-4n7'},
6657		{c: 'https://github.com/lucamug/elm-exercises', e: '', d: '', b: 'A system to create Elm exercises leveraging the Ellie platform.', a: 'elm_exercises.png', gp: 'Elm Exercises', g5: '🏋️ Elm Exercises', bT: 'https://ellie-app.com/dZLQZGDGgNsa1'},
6658		{c: 'https://github.com/lucamug/elm-ecommerce', e: '', d: '', b: 'A simple eCommerce demo application in 2,500 lines of Elm code, all shrank into 40KB of JavaScript, including styling and icons.', a: 'elm-ecommerce.jpg', gp: 'Elm eCommerce', g5: '🛍️ Elm eCommerce', bT: 'https://elm-ecommerce.guupa.com/'},
6659		{c: '', e: '', d: '', b: 'The story of the adoption of Elm at rakuten, with likes and dislikes.', a: 'elm_at_rakuten.jpg', gp: 'Elm at Rakuten', g5: '🧩 Elm at Rakuten', bT: 'https://dev.to/lucamug/elm-6m8'},
6660		{c: 'https://github.com/lucamug/elm-cheat-sheet/', e: '', d: 'https://lucamug.github.io/elm-cheat-sheet/elm-cheat-sheet.color.pdf', b: 'Learning Elm? Download the Elm Cheat Sheet to support your learning process.', a: 'elm_cheat_sheet.jpg', gp: 'Elm Cheat Sheet', g5: '📄 Elm Cheat Sheet', bT: 'https://twitter.com/luca_mug/status/1366200906606252037'},
6661		{c: 'https://github.com/lucamug/elm-physics-example', e: '', d: '', b: 'Playing with Elm physics', a: 'elm-physics-example.gif', gp: 'Elm physics Example', g5: '🧲 Elm physics Example', bT: 'https://elm-physics-example.guupa.com/'},
6662		{c: '', e: '', d: '', b: 'Penrose Triangle Illustration for \"Elm at Rakuten\" article', a: 'penrose_triangle.jpg', gp: 'Penrose Triangle', g5: '🔺 Penrose Triangle', bT: 'https://ellie-app.com/bZVgZf8GJvja1'},
6663		{c: 'https://github.com/lucamug/mario/blob/master/src/Main.elm', e: '', d: '', b: 'Mario demo for the \"Elm at Rakuten\" article', a: 'mario.gif', gp: 'Mario demo', g5: '🍄 Mario demo', bT: 'https://lucamug.github.io/mario/'},
6664		{c: '', e: '', d: '', b: 'Illustration for \"Elm at Rakuten\" article', a: 'appeal_to_popularity.jpg', gp: 'Appeal to popularity', g5: '📈 Appeal to popularity', bT: 'https://ellie-app.com/bY2R6xF5mWda1'},
6665		{c: 'https://github.com/lucamug/elm-release', e: '', d: '', b: 'A Proof of Work application to release things in production.', a: 'elm-release.jpg', gp: 'Safe, Stress Free and Repeatable Releases', g5: '🛡️🧘♻️ Safe, Stress Free and Repeatable Releases', bT: 'https://elm-release.surge.sh'},
6666		{c: '', e: '', d: '', b: 'R10 is a library of interactive building blocks written in Elm and elm-ui that we use at Rakuten for creating user interfaces.', a: 'r10.jpg', gp: 'R10', g5: '🎨 R10', bT: 'https://r10.netlify.app/'},
6667		{c: '', e: '', d: '', b: 'A collection of cool 3D stuff made 100% in Elm.', a: '3d_graphics.gif', gp: '3D Graphics in the Browser with Elm', g5: '🧊 3D Graphics in the Browser with Elm', bT: 'https://dev.to/lucamug/3d-graphics-in-the-browser-with-elm-4oh3'},
6668		{c: '', e: '', d: '', b: '', a: 'elm_starter.jpg', gp: '\"elm-starter\", a tool for the Modern Web', g5: '🚀 \"elm-starter\", a tool for the Modern Web', bT: 'https://dev.to/lucamug/elm-starter-

6668a-tool-for-the-modern-web-53b1'},
6669		{c: '', e: '', d: '', b: 'An attempt to measure how good are front-end frameworks in dealing with simple errors.', a: 'resilience.png', gp: 'Resilience to errors in front-end frameworks', g5: '💪 Resilience to errors in front-end frameworks', bT: 'https://dev.to/lucamug/resilience-to-errors-of-front-end-frameworks-3hej'},
6670		{c: '', e: '', d: '', b: '', a: 'kaiten_sushi.jpg', gp: '🍣 Kaiten Sushi 🍣 Approaches to Web Animations', g5: '🍣 Kaiten Sushi 🍣 Approaches to Web Animations', bT: 'https://dev.to/lucamug/kaiten-sushi-approaches-to-web-animations-306k'},
6671		{c: '', e: '', d: '', b: '', a: 'ro-box.gif', gp: 'Ro-BOX', g5: '📦 Ro-BOX', bT: 'https://ro-box.netlify.app/'},
6672		{c: 'https://github.com/lucamug/elm-playground-3d', e: '', d: '', b: '', a: '3d_examples.gif', gp: 'Elm-Playground-3D Examples', g5: '🎲 Elm-Playground-3D Examples', bT: 'https://elm-playground-3d.netlify.app/'},
6673		{c: 'https://github.com/lucamug/elm-japan', e: '', d: '', b: 'Lead organizer of the first Elm conference in the Asia-Pacific region', a: 'elm_japan.jpg', gp: 'Elm Japan', g5: '🌸 Elm Japan 2020', bT: 'https://lucamug.github.io/elm-japan/'},
6674		{c: 'https://github.com/lucamug/elm-pages-editor', e: '', d: '', b: '', a: 'page_editor.jpg', gp: 'Elm Pages editor', g5: '📝 Elm Pages editor', bT: 'https://lucamug.github.io/elm-pages-editor/withEditorAndDebugger.html'},
6675		{c: 'https://github.com/lucamug/coach-a-test', e: '', d: '', b: '', a: 'doodle_weather.jpg', gp: 'Doodle Weather', g5: '☁️ Doodle Weather', bT: 'https://www.youtube.com/watch?v=oxVYKm47DNE'},
6676		{c: '', e: '', d: '', b: '', a: 'snackbar.jpg', gp: 'Elm Beginners Tutorial: How to make animated snackbars with zero CSS', g5: '🍫 Elm Beginners Tutorial: How to make animated snackbars with zero CSS', bT: 'https://dev.to/lucamug/elm-beginners-tutorial-how-to-make-animated-snackbars-with-zero-css-12g1'},
6677		{c: '', e: '', d: '', b: '', a: 'masonry2.gif', gp: 'Type Driven Development: Simple masonry layout in 50 lines of Elm code', g5: '🧱 Type Driven Development: Simple masonry layout in 50 lines of Elm code', bT: 'https://dev.to/lucamug/type-driven-development-simple-masonry-layout-in-50-lines-of-elm-code-44n0'},
6678		{c: '', e: '', d: '', b: 'A static page made in Elm for errors, such as 404 Page not Found.', a: '404_page.jpg', gp: 'Parallax', g5: '🏔️ Parallax', bT: 'https://login.account.rakuten.com/'},
6679		{c: '', e: '', d: '', b: 'A biased and superficial comparison between two frameworks that compile to Javascript', a: 'elm_vs_svelte-80.jpg', gp: 'Elm vs. Svelte', g5: '⚔️ Elm vs. Svelte', bT: 'https://medium.com/@l.mugnaini/elm-vs-svelte-d8e6f0abf667'},
6680		{c: '', e: '', d: '', b: '', a: 'elm_vs_vue.png', gp: 'Elm vs. Vue', g5: '⚔️ Elm vs. Vue', bT: 'https://dev.to/lucamug/elm-vs-vue-2jok'},
6681		{c: '', e: '', d: '', b: '', a: 'elm_vs_js.png', gp: 'Elm vs. Javascript: Side by Side Code Comparison', g5: '⚔️ Elm vs. Javascript: Side by Side Code Comparison', bT: 'https://dev.to/lucamug/javascript-elm-side-by-side-code-comparison-4372'},
6682		{c: '', e: '', d: '', b: 'Things that can go wrong without a strictly typed language\u200A—\u200APart II, a.k.a. "Los tipos son buena gente\"', a: 'elm_vs_react.jpg', gp: 'Elm vs. React', g5: '⚔️ Elm vs. React', bT: 'https://medium.com/@l.mugnaini/things-that-can-go-wrong-without-a-strictly-typed-language-part-ii-8b239a85f35a'},
6683		{c: '', e: '', d: '', b: 'A single Elm page that works also without Javascript and is SEO friendly.', a: 'rakuten_security.jpg', gp: 'Rakuten Security', g5: '🔐 Rakuten Security', bT: 'https://static.id.rakuten.co.jp/static/about_security/jpn/'},
6684		{c: '', e: '', d: '', b: 'The entire Front-end part of Rakuten Taiwan Sign In and Registration system. I talked about this system at the [2019 Oslo Elm Day conference](https://www.youtube.com/watch?v=yH6o322S8XQ).', a: 'rakuten_signin.jpg', gp: 'Rakuten Sign In', g5: '🔑 Rakuten Sign In', bT: 'https://login.account.rakuten.com/sso/register?client_id=rakuten_tw01&redirect_uri=https%3A%2F%2Fwww.rakuten.com.tw%2Fmember%2Fdelegate&response_type=code&scope=openid+profile+email#/registration/1'},
6685		{c: 'https://github.com/rakutentech/rakutentech.github.io', e: '', d: '', b: 'The Open Source page of Rakuten got a new re-write in March 2019. It is now completely written in Elm. It combines Rakuten Open Source project coming from 11 different Github accounts. The structure of the app is not an usual Elm structure. It is organized in a way that also engineer that are now familiar with Elm can maitain the website. The main `src` folder contain the configuration and the main views. The website logic (The Elm Architecture) is \"hidden\" in the `internal` folder.', a: 'rakuten_open_source.jpg', gp: 'Rakuten Open Source', g5: '🌐 Rakuten Open Source', bT: 'https://rakutentech.github.io/'},
6686		{c: '', e: '', d: '', b: 'A Masonry layout is a way to fit together elements of possibly different sizes without gaps.', a: 'masonry.jpg', gp: 'Masonry Layout', g5: '🧱 Simple masonry layout in 50 lines of Elm code', bT: 'https://medium.com/@l.mugnaini/simple-masonry-layout-in-50-lines-of-elm-code-304ea9e9475c'},
6687		{c: '', e: '2019', d: '', b: '', a: 'elm_at_large_companies.jpg', gp: 'Talk \"Elm at large (companies)\" @ Oslo Elm Day', g5: '🎤 Talk \"Elm at large (companies)\" @ Oslo Elm Day', bT: 'https://www.youtube.com/watch?v=yH6o322S8XQ'},
6688		{c: 'https://github.com/lucamug/elm-resources', e: '', d: '', b: 'Resources about Elm', a: 'elm_resources.jpg', gp: 'Elm Resources', g5: '📚 Elm Resources', bT: 'https://elm-resources.guupa.com/'},
6689		{c: '', e: '', d: '', b: 'Talking about Front-end and Elm is always fun. Some of the most recent events:\n\n* [Fighting Front-End Fatigue: Introduction to Elm | Workshop](https://www.meetup.com/CodeChrysalis/events/268496917/)\n* [Elm at large (companies)](https://webhack.connpass.com/event/122871/)\n* [Elm, a delightful language for reliable webapps](https://webhack.connpass.com/event/112206/)\n* [Iro iro: One year of Elm in 50 slides](https://elm-jp.connpass.com/event/156016/)\n* [Front-end Innovation: Fast and Curious](https://tech.rakuten.co.jp/sessions/front-end-innovation-fast-and-curious/)', a: 'events.jpg', gp: 'Events and Workshops', g5: '🎙️ Talks and Events', bT: ''},
6690		{c: '', e: '', d: '', b: 'An introduction to a simple Elm library to build animated three dimensional models', a: '3d_svg.gif', gp: '3D SVG', g5: '🎲 Basic 3D rendering in SVG: elm-playground-3d', bT: 'https://medium.com/@l.mugnaini/basic-3d-rendering-in-svg-elm-playground-3d-d1e8846cd06e'},
6691		{c: '', e: '', d: '', b: 'This is a tutorial on how to build a mildly complex web layout without any knowledge of CSS (and also any knowledge of Javascript and HTML…', a: 'layour_without_css.jpg', gp: 'How to build a responsive layout without a single CSS line*', g5: '📐 How to build a responsive layout without a single CSS line*', bT: 'https://medium.com/@l.mugnaini/how-to-build-a-responsive-layout-without-a-single-css-line-afbdfe89bb6d'},
6692		{c: '', e: '', d: '', b: 'Handling time in Elm seems to be a scaring thing for beginners.', a: 'time_in_elm.jpg', gp: 'Time in Elm', g5: '⏰ Time in Elm', bT: 'https://medium.com/@l.mugnaini/time-in-elm-42f08b8973f3'},
6693		{c: 'https://github.com/rakutentech/http-trinity', e: '', d: '', b: '', a: 'http_trinity.jpg', gp: 'HTTP Trinity', g5: '🔗 HTTP Trinity', bT: 'https://rakutentech.github.io/http-trinity/'},
6694		{c: '', e: '', d: '', b: 'Part 1 of 12 — The Game Loop', a: 'game_in_elm.jpg', gp: 'Beginner Tutorials: How to build a game in Elm — Part 1', g5: '🎮 Beginner Tutorials: How to build a game in Elm — Part 1', bT: 'https://medium.com/@l.mugnaini/beginner-tutorials-how-to-build-a-game-in-elm-5491d6de8f25'},
6695		{c: '', e: '', d: '', b: 'Part 2 of 12 — Add Keyboard', a: 'game_in_elm.jpg', gp: 'Beginner Tutorials: How to build a game in Elm — Part 2', g5: '🎮 Beginner Tutorials: How to build a game in Elm — Part 2', bT: 'https://medium.com/@l.mugnaini/beginner-tutorials-how-to-build-a-game-in-elm-part-2-ae26eef8610b'},
6696		{c: '', e: '', d: '', b: 'Part 3 of 12 — Add the Pause', a: 'game_in_elm.jpg', gp: 'Beginner Tutorials: How to build a game in Elm — Part 3', g5: '🎮 Beginner Tutorials: How to build a game in Elm — Part 3', bT: 'https://medium.com/@l.mugnaini/beginner-tutorials-how-to-build-a-game-in-elm-part-3-fe62

6696c51f7510'},
6697		{c: '', e: '', d: '', b: 'Note: This is a step by step tutorial about hosting an Elm application on glitch.com but most of the concepts are applicable to other…', a: 'glitch.jpg', gp: 'Tutorial: Real Time Collaboration and Free Hosting with glitch.com', g5: '🤝 Tutorial: Real Time Collaboration and Free Hosting with glitch.com', bT: 'https://medium.com/@l.mugnaini/tutorial-real-time-collaboration-and-free-hosting-with-glitch-com-307b0c7398c6'},
6698		{c: '', e: '', d: '', b: 'If you find yourself often running scripts in the terminal, why not adding some colored pixel art to them?', a: 'pixel_art.jpg', gp: 'Terminal Pixel Art', g5: '🖼️ Terminal Pixel Art', bT: 'https://medium.com/@l.mugnaini/terminal-pixel-art-ad386d186dad'},
6699		{c: '', e: '', d: '', b: 'What happen when an Elm developer write a Vue application', a: 'wrong_without_types.jpg', gp: 'Things that can go wrong without a strictly typed language\u200A—\u200APart I', g5: '⚠️ Things that can go wrong without a strictly typed language\u200A—\u200APart I', bT: 'https://itnext.io/things-that-can-go-wrong-without-a-strictly-typed-language-d91d418a53a1'},
6700		{c: '', e: '', d: '', b: 'I wanted to have a simple way to test all possible scenario of an http responses. There are tools like Mountebank but it is an extra thing…', a: 'mocking_api.jpg', gp: 'Mocking APIs from inside Elm', g5: '🎭 Mocking APIs from inside Elm', bT: 'https://medium.com/@l.mugnaini/mocking-apis-from-inside-elm-5efda32ee9fe'},
6701		{c: '', e: '', d: '', b: 'In Functional Programming we build programs only using functions. These functions, for simplicity, can return only one value.', a: 'monads_without_monads.jpg', gp: 'Monads without talking about Monads, in Elm', g5: '🌀 Monads without talking about Monads, in Elm', bT: 'https://medium.com/@l.mugnaini/monads-without-talking-about-monads-in-elm-4b9b6ffd5ad5'},
6702		{c: '', e: '', d: '', b: 'The "game loop" of Elm', a: 'tea.gif', gp: 'The Elm Architecture (TEA) animation', g5: '🍵 The Elm Architecture (TEA) animation', bT: 'https://medium.com/@l.mugnaini/the-elm-architecture-tea-animation-3efc555e8faf'},
6703		{c: '', e: '', d: '', b: 'Elm Version', a: 'monads_in_picture.jpg', gp: 'Functors, Applicatives, And Monads In Pictures (In Elm)', g5: '📸 Functors, Applicatives, And Monads In Pictures (In Elm)', bT: 'https://medium.com/@l.mugnaini/functors-applicatives-and-monads-in-pictures-784c2b5786f7'},
6704		{c: '', e: '', d: '', b: '', a: 'style_framework.jpg', gp: 'Proposal for a Style Framework in Elm', g5: '✏️ Proposal for a Style Framework in Elm', bT: 'https://medium.com/@l.mugnaini/proposal-for-a-style-framework-in-elm-f5a1919ab425'},
6705		{c: '', e: '', d: '', b: '', a: 'media_queries_in_elm.jpg', gp: 'Media queries in Elm', g5: '📱 Media queries in Elm', bT: 'https://medium.com/@l.mugnaini/media-queries-in-elm-7b8f75cabc72'},
6706		{c: '', e: '', d: '', b: '', a: 'unbreakable_json.jpg', gp: 'Unbreakable JSON', g5: '🔒 Unbreakable JSON', bT: 'https://medium.com/@l.mugnaini/unbreakable-json-95637300176c'},
6707		{c: '', e: '', d: '', b: '', a: 'tangram.gif', gp: 'Undo and Redo using browsers history - Tangram', g5: '↩️ Undo and Redo using browsers history - Tangram', bT: 'https://medium.com/@l.mugnaini/undo-and-redo-using-browsers-history-1f1f963bf722'},
6708		{c: '', e: '', d: '', b: 'Do you remember when I told you that separating layout from style was a good thing? Well, forget about it!', a: 'man_jump_from_space.jpg', gp: 'CSS Nirvana', g5: '✨ CSS Nirvana', bT: 'https://medium.com/front-end-weekly/css-nirvana-a92ba04cca06'},
6709		{c: '', e: '', d: '', b: 'Before artificial intelligence is taking over our Front-end jobs (here and here) let’s think some way to make our life less miserables.', a: 'future_frontend.gif', gp: 'Is the future of Front-end development without HTML, CSS and Javascript?', g5: '🔮 Is the future of Front-end development without HTML, CSS and Javascript?', bT: 'https://medium.com/@l.mugnaini/is-the-future-of-front-end-development-without-html-css-and-javascript-e7bb0877980e'},
6710		{c: '', e: '', d: '', b: '', a: 'spa_boilerplate.jpg', gp: 'Single Page Application Boilerplate for Elm', g5: '📋 Single Page Application Boilerplate for Elm', bT: 'https://medium.com/@l.mugnaini/single-page-application-boilerplate-for-elm-160bb5f3eec2'},
6711		{c: '', e: '', d: '', b: '', a: 'zero_maintenance.jpg', gp: 'Zero-maintenance Always-up-to-date Living Style Guide in Elm!', g5: '♾️ Zero-maintenance Always-up-to-date Living Style Guide in Elm!', bT: 'https://medium.com/@l.mugnaini/zero-maintenance-always-up-to-date-living-style-guide-in-elm-dbf236d07522'},
6712		{c: '', e: '', d: '', b: '', a: 'living_guide.jpg', gp: 'Living Website Style Guide and Documentation in Elm', g5: '📖 Living Website Style Guide and Documentation in Elm', bT: 'https://medium.com/@l.mugnaini/living-website-style-guide-and-documentation-in-elm-2f99b6d61da9'},
6713		{c: '', e: '', d: '', b: '', a: 'autocomplete.jpg', gp: 'Autocomplete widget in Elm', g5: '🔍 Autocomplete widget in Elm', bT: 'https://medium.com/@l.mugnaini/autocomplete-widget-in-elm-4927b8e275db'},
6714		{c: '', e: '', d: '', b: 'Part 3 — Spinner, Floating Labels, Checkboxes, Date Picker, Autocomplete', a: 'forms_in_elm.jpg', gp: 'Forms in Elm — Validation, Tutorial and Examples — Part 3', g5: '📝 Forms in Elm — Validation, Tutorial and Examples — Part 3', bT: 'https://medium.com/@l.mugnaini/forms-in-elm-validation-tutorial-and-examples-part-3-5f66f9c87679'},
6715		{c: '', e: '', d: '', b: 'Part 2 — Removing <form>, on-the-fly validation, Focus detection, Show/Hide the password', a: 'forms_in_elm.jpg', gp: 'Forms in Elm — Validation, Tutorial and Examples — Part 2', g5: '📝 Forms in Elm — Validation, Tutorial and Examples — Part 2', bT: 'https://medium.com/@l.mugnaini/forms-in-elm-validation-tutorial-and-examples-part-2-1b978437b5db'},
6716		{c: '', e: '', d: '', b: 'Sometime Elm’s newcomers complain about the complexity and the large amount of boilerplate needed to create forms.', a: 'forms_in_elm.jpg', gp: 'Forms in Elm —Validation, Tutorial and Examples — Part 1', g5: '📝 Forms in Elm —Validation, Tutorial and Examples — Part 1', bT: 'https://medium.com/@l.mugnaini/i-believe-css-is-more-about-separation-of-presentation-and-content-42bd0435005'},
6717		{c: '', e: '', d: '', b: 'Aggregated documentation of Elm Commands and Subscription', a: 'commands_and_subscriptions.jpg', gp: 'Commands and Subscriptions in Elm', g5: '📡 Commands and Subscriptions in Elm', bT: 'https://medium.com/@l.mugnaini/commands-and-subscriptions-in-elm-9ff506e75d2d'},
6718		{c: '', e: '', d: '', b: 'There are concepts in Elm, as in other Functional Languages, that are simple, fun and elegant at the same time.', a: 'maybe_and_result.jpg', gp: 'Brief beginners guide to Maybe and Result t

6718ypes in Elm', g5: '❓ Brief beginners guide to Maybe and Result types in Elm', bT: 'https://medium.com/@l.mugnaini/brief-beginners-guide-to-maybe-and-result-types-in-elm-7649d2c3b970'},
6719		{c: '', e: '', d: '', b: 'I wanted to replay the user interaction with an Elm app, including the scrolling of the pages.', a: 'record_and_replay.jpg', gp: 'Record and replay individual visitor interaction with Elm', g5: '📹 Record and replay individual visitor interaction with Elm', bT: 'https://medium.com/@l.mugnaini/record-and-replay-individual-visitor-interaction-with-elm-625814965508'},
6720		{c: '', e: '', d: '', b: 'I am intrigued with the concept of separating Layout and Style. Usually layout is defined using a mixture of html and css while style is…', a: 'separation_of_layout_and_style.jpg', gp: 'Separation of Layout and Style in Elm', g5: '✂️ Separation of Layout and Style in Elm', bT: 'https://medium.com/@l.mugnaini/separation-of-layout-and-style-in-elm-882a3cbe1e7f'},
6721		{c: '', e: '', d: '', b: 'I share here my personal notes that I took from Slack Elm https://elmlang.slack.com', a: 'elm_slack.jpg', gp: 'Lessons learned about Elm from Slack', g5: '💬 Lessons learned about Elm from Slack', bT: 'https://medium.com/@l.mugnaini/lessons-learned-about-elm-from-slack-1d807d5d3627'},
6722		{c: '', e: '', d: '', b: 'Simple experiment for Images Zooming', a: 'images_zoom.jpg', gp: 'Images Zoom in Elm', g5: '🔎 Images Zoom in Elm', bT: 'https://medium.com/@l.mugnaini/images-zoom-in-elm-ffb8c27b305e'},
6723		{c: '', e: '', d: '', b: '', a: 'faceted_variants.jpg', gp: 'Faceted Variants in Elm', g5: '💎 Faceted Variants in Elm', bT: 'https://medium.com/@l.mugnaini/faceted-variants-in-elm-c38b4d661355'},
6724		{c: '', e: '', d: '', b: 'I run some test to understand how Google Search Engine handle a Single Page Application. I built the website for running the test in Elm…', a: 'spa_and_seo.jpg', gp: 'SPA and SEO: Google (Googlebot) properly renders Single Page Application and execute Ajax calls', g5: '🕷️ SPA and SEO: Google (Googlebot) properly renders Single Page Application and execute Ajax calls', bT: 'https://medium.com/@l.mugnaini/spa-and-seo-is-googlebot-able-to-render-a-single-page-application-1f74e706ab11'},
6725		{c: '', e: '', d: '', b: '', a: 'recursion.jpg', gp: 'Tutorial — Permutations and Recursions in Elm', g5: '🔃 Tutorial — Permutations and Recursions in Elm', bT: 'https://medium.com/@l.mugnaini/tutorial-permutations-and-recursions-in-elm-ad15e2288567'},
6726		{c: '', e: '', d: '', b: '', a: 'scroll_and_resize.jpg', gp: 'Scroll and Resize events in Elm', g5: '📜 Scroll and Resize events in Elm', bT: 'https://medium.com/@l.mugnaini/scroll-and-resize-events-in-elm-ac4f0589f42'},
6727		{c: '', e: '', d: '', b: 'I know that the good Evan is going to release soon the version 0.19 that probably will implement the server side rendering.', a: 'server_side_rendering.jpg', gp: 'Server Side Rendering with Elm', g5: '🖥️ Server Side Rendering with Elm', bT: 'https://medium.com/@l.mugnaini/server-side-rendering-with-elm-9064170eb3cf'},
6728		{c: '', e: '', d: '', b: 'In the process of getting familiar with Data Structures in Elm I started to compile a table to compare all different types: Record, List…', a: 'data_structures.jpg', gp: 'Data Structures in Elm', g5: '🗂️ Data Structures in Elm', bT: 'https://medium.com/@l.mugnaini/data-structures-in-elm-3dd609be1fa3'},
6729		{c: '', e: 'Jul 12, 2017', d: '', b: 'A simple script to visualise some events in Elm', a: 'events_testing.jpg', gp: 'Elm Events Testing', g5: '🧪 Elm Events Testing', bT: 'https://medium.com/@l.mugnaini/elm-events-testing-a812dfbcb21'},
6730		{c: 'https://github.com/lucamug/mobile-parallax-scrolling', e: 'Jul 2, 2017', d: 'https://lucamug.github.io/mobile-parallax-scrolling/mobile-parallax-scrolling.html', b: '', a: 'mobile_parallax_scrolling.jpg', gp: 'Mobile Parallax Scrolling', g5: '📱 Mobile Parallax Scrolling', bT: 'https://medium.com/@l.mugnaini/mobile-parallax-scrolling-523c23f248c9'},
6731		{c: 'https://github.com/lucamug/kana-overlapping', e: 'Jun 16, 2017', d: 'https://lucamug.github.io/kana-overlapping/', b: '', a: 'kana_overlapping.jpg', gp: 'Kana Overlapping', g5: '🈯 Kana Overlapping', bT: 'https://codeburst.io/kana-overlapping-8a89d23109ec?source=your_stories_page---------------------------'},
6732		{c: '', e: 'Jun 15, 2017', d: 'https://lucamug.github.io/elm-meta-json-decoder/', b: '', a: 'decoding_json.jpg', gp: 'Decoding Json that contain Json using Elm', g5: '🔓 Decoding Json that contain Json using Elm', bT: 'https://medium.com/@l.mugnaini/decoding-json-that-contain-json-using-elm-be66d0dec0ff?source=your_stories_page---------------------------'},
6733		{c: 'https://github.com/wking-io/elm-live', e: '', d: '', b: 'I enjoyed collaborating with William King to add few feature to elm-live, including\n\n* Errors in console\n* Errors in browser\n* Colored errors\n* Hot reload implementations (Using [elm-hot](https://github.com/klazuka/elm-hot))\n* QRCode for mobile testing ([pending](https://github.com/wking-io/elm-live/issues/204))\n* Link in browser that open IDE directly ([pending](https://github.com/wking-io/elm-live/issues/204))', a: 'elm_live.jpg', gp: 'elm-live', g5: '⚡ Elm-Live Contribution', bT: 'https://www.npmjs.com/package/elm-live'},
6734		{c: '', e: 'Jun 4, 2017', d: '', b: 'This is a simple example of how is possible to implement a third party Carousel plugin in a Single Page Application (SPA) made in Elm.', a: 'carousel.jpg', gp: 'Carousel plugin in Elm', g5: '🎠 Carousel plugin in Elm', bT: 'https://medium.com/@l.mugnaini/carou

6734sel-plugin-in-elm-46e89272b185?source=your_stories_page---------------------------'},
6735		{c: '', e: 'May 29, 2017', d: '', b: 'I need to introduce Elm to some colleague and I was looking for a presentation that I could recycle. A while ago I remember seeing and…', a: 'elm_presentation.jpg', gp: 'A ready-to-use Elm Presentation to impress your colleagues', g5: '📊 A ready-to-use Elm Presentation to impress your colleagues', bT: 'https://medium.com/@l.mugnaini/a-ready-to-use-elm-presentation-to-impress-your-colleagues-ee71cac8fe14?source=your_stories_page---------------------------'},
6736		{c: 'https://github.com/lucamug/simple-neural-network-in-javascript', e: 'May 25, 2017', d: '', b: 'This is a port from Python to Javascript of the neural network implementation to describe the inner workings of backpropagation. This is…', a: 'neural_network_in_javascript.jpg', gp: 'A Neural Network in 11 lines of Javascript', g5: '🧠 A Neural Network in 11 lines of Javascript', bT: 'https://aboveintelligent.com/a-neural-network-in-11-lines-of-javascript-d58b38330178?source=your_stories_page---------------------------'},
6737		{c: '', e: 'on May 15, 2017', d: '', b: 'I wanted to prepare the API specification for the backend developers in the most efficient way possible. Elm code is quite self…', a: 'self_documenting_api.jpg', gp: 'Self documenting API specifications', g5: '📑 Self documenting API specifications', bT: 'https://medium.com/@l.mugnaini/self-documenting-api-specifications-41be58ec64a1?source=your_stories_page---------------------------'},
6738		{c: '', e: '', d: '', b: 'This is a response to the post titled \"Why I\'m leaving Elm\" written by Luke Plant that regularly came out in Google searches related to the Elm language.', a: 'response.png', gp: 'Response to "Why I am leaving Elm" (A.k.a. Why I didn’t leave Elm)', g5: '🗣️ Response to "Why I am leaving Elm" (A.k.a. Why I didn’t leave Elm)', bT: 'https://blog.guupa.com/post/response-to-why-i-am-leaving-elm.html'},
6739		{c: '', e: 'May 9, 2017', d: '', b: 'This tool automatically download data from Google Drive and generate all the posts of the Blog.', a: 'blog_using_google_spreadsheets.jpg', gp: 'A tool to generate and maintain a blog using Google spreadsheets', g5: '📰 A tool to generate and maintain a blog using Google spreadsheets', bT: 'https://medium.com/@l.mugnaini/a-tool-to-generate-and-maintain-a-blog-using-google-spreadsheets-a38367a94323?source=your_stories_page---------------------------'},
6740		{c: '', e: '', d: '', b: '', a: 'elm_japan_2020_old.jpg', gp: 'Old Elm Japan 2020 website', g5: '🏮 Old Elm Japan 2020 website', bT: 'https://elm-tokyo-2020.netlify.com'},
6741		{c: '', e: 'May 9, 2017', d: '', b: '*Bad in the sense that i wrote it, ignoring the most basic good practices', a: 'bad_javascript_vs_bad_elm.jpg', gp: 'Bad* Javascript vs Bad* Elm', g5: '😈 Bad* Javascript vs Bad* Elm', bT: 'https://medium.com/@l.mugnaini/bad-javascript-vs-bad-elm-6dc9661d109?source=your_stories_page---------------------------'},
6742		{c: '', e: 'May 6, 2017', d: '', b: 'Experimenting with recycling Elm code transforming it in a module', a: 'counters_bonanza.jpg', gp: 'Experimental reuse of code in Elm, Part III — Counters Bonanza', g5: '🔢 Experimental reuse of code in Elm, Part III — Counters Bonanza', bT: 'https://medium.com/@l.mugnaini/counters-bonanza-5e67855c0b83?source=your_stories_page---------------------------'},
6743		{c: '', e: 'May 6, 2017', d: '', b: 'This is the second part of a series:', a: 'the_counter.jpg', gp: 'Experimental reuse of code in Elm, Part II — The counter', g5: '🔢 Experimental reuse of code in Elm, Part II — The counter', bT: 'https://medium.com/@l.mugnaini/recycling-elm-code-transforming-it-in-a-module-4946d5ccd3cd?source=your_stories_page---------------------------'},
6744		{c: '', e: 'May 3, 2017', d: '', b: 'A simple Shopping Cart written while experimenting with Elm', a: 'simple_ecommerce.jpg', gp: 'Simple Ecommerce Shopping Cart written in Elm', g5: '🛒 Simple Ecommerce Shopping Cart written in Elm', bT: 'https://medium.com/@l.mugnaini/simple-e-commerce-shopping-cart-written-in-elm-7fe31c6bf13d?source=your_stories_page---------------------------'},
6745		{c: '', e: 'Apr 29, 2017', d: '', b: 'This is the first port of a series:', a: 'reuse_of_code.jpg', gp: 'Experimental reuse of code in Elm, Part I — Page with list of products', g5: '🔢 Experimental reuse of code in Elm, Part I — Page with list of products', bT: 'https://medium.com/@l.mugnaini/tutorial-how-to-recycle-in-elm-89b13b6c0bab?source=your_stories_page---------------------------'},
6746		{c: '', e: 'Mar 28, 2017', d: '', b: 'Try this code if you want to see how elm behave in the console:', a: 'flow_in_console.jpg', gp: 'Elm flow in the console', g5: '💻 Elm flow in the console', bT: 'https://medium.com/@l.mugnaini/elm-flow-in-the-console-16e6ceb4ce90?source=your_stories_page---------------------------'},
6747		{c: '', e: 'Jan 19, 2017', d: '', b: '', a: 'milk_container.jpg', gp: '10 Criteria to Judge a Good Milk Container', g5: '🥛 10 Criteria to Judge a Good Milk Container', bT: 'https://medium.com/@l.mugnaini/10-criteria-to-judge-a-good-milk-container-52a94d3d8202?source=your_stories_page---------------------------'},
6748		{c: '', e: 'Jan 18, 2017', d: '', b: 'I know this is a bit old, but today, watching an old Douglas Crockford’s video I was interested in his proposal of a new way of defining a…', a: 'dec64.jpg', gp: 'DEC64 — Douglas Crockford’s Decimal Notation', g5: '🔣 DEC64 — Douglas Crockford’s Decimal Notation', bT: 'https://medium.com/@l.mugnaini/dec64-douglas-crockfords-decimal-notation-b25f19348d63?source=your_stories_page---------------------------'},
6749		{c: '', e: 'Jan 17, 2017', d: '', b: 'Among several videos that I have been watching about functional programming, I found these two quite interesting and entertaining:', a: 'itroduction_fp.jpg', gp: 'Introduction to Functional Programming', g5: '🎓 Introduction to Functional Programming', bT: 'https://medium.com/@l.mugnaini/introduction-to-functional-programming-49c9e5c31df4?source=your_stories_page---------------------------'},
6750		{c: '', e: 'Jan 17, 2017', d: '', b: 'Would you like to download your multi-sheets-Google-spreadsheet in a simple format like this?', a: 'download_spreadsheet.jpg', gp: 'Javascript snippet to download a multi-sheets-Google-Spreadsheet in JSON', g5: '📊 Javascript snippet to download a multi-sheets-Google-Spreadsheet in JSON', bT: 'https://medium.com/@l.mugnaini/a-small-script-to-download-a-google-spreadsheet-with-multiple-worksheet-in-javascript-dafb14c65bae?source=your_stories_page---------------------------'},
6751		{c: '', e: '', d: '', b: 'Reviews of books for children, in Japanese.', a: 'mekke.jpg', gp: 'Mekke', g5: '📚 Mekke', bT: 'https://mekke.guupa.com/'},
6752		{c: '', e: '', d: '', b: '', a: 'elm_starter_demo.jpg', gp: 'Elm Starter Example', g5: '🌱 Elm Starter Example', bT: 'https://elm-starter.guupa.com/'},
6753		{c: '', e: '', d: '', b: '', a: 'todo.jpg', gp: 'Elm Todos Example', g5: '✅ Elm Todos Example', bT: 'https://elm-todomvc.guupa.com/'},
6754		{c: '', e: '', d: '', b: '', a: 'spa_example.jpg', gp: 'Elm SPA Example', g5: '📄 Elm SPA Example', bT: 'https://elm-spa-example.guupa.com/'},
6755		{c: '', e: '', d: '', b: '', a: 'nyoro_nyoro.jpg', gp: 'Nyoro-Nyoro Game', g5: '🐍 Nyoro-Nyoro Game', bT: 'https://nyny.surge.sh/'},
6756		{c: '', e: '', d: '', b: '', a: 'style_framework2.jpg', gp: 'Style Framework', g5: '🖌️ Style Framework', bT: 'https://lucamug.github.io/style-framework/'},
6757		{c: '', e: '', d: '', b: 'Experimental PWA with Geofencing', a: 'geofencing.jpg', gp: 'Geofencing', g5: '📍 Geofencing', bT: 'https://romantic-tereshkova-b938b5.netlify.app/'},
6758		{c: '', e: '', d: '', b: '', a: 'puchi.jpg', gp: 'Puchi Densha', g5: '🚃 Puchi Densha', bT: 'https://puchi.guupa.com'},

6759		{c: '', e: '', d: '', b: 'When Perl was cool, I collaborated to a section of the book \"Perl e Internet\" by Alessandro Bellini.', a: 'perl_e_internet.jpg', gp: 'Perl e Internet', g5: '🕸️ Perl e Internet', bT: 'https://www.libraccio.it/libro/9788838607783/alessandro-bellini-andrea-guidi/perl-e-internet.html'},
6760		{c: '', e: '', d: 'https://www.doomworld.com/files/file/12048-piazza-dei-miracoli/', b: 'A reconstruction of Pisa\'s Piazza dei Miracoli as a Doom level', a: 'pisa.jpeg', gp: 'PISA.WAD - PiAZZA DEi MiRACOLi', g5: '🏛️ PISA.WAD - PiAZZA DEi MiRACOLi', bT: 'https://www.youtube.com/watch?v=8dZ1CzfloRc'}
6761	]);
6762var $author$project$Main$idToMaybeItem = function (id) {
6763	var decodedId = $author$project$Main$idDecoder(id);
6764	return $elm$core$List$head(
6765		A2(
6766			$elm$core$List$filter,
6767			function (item) {
6768				return _Utils_eq(
6769					$elm$core$String$toLower(
6770						$author$project$Projects$Project$id(item)),
6771					decodedId);
6772			},
6773			$author$project$Projects$Project$items));
6774};
6775var $author$project$Projects$Project$itemNotFound = {c: '', e: '', d: '', b: '', a: '', gp: 'NOT FOUND', g5: 'NOT FOUND', bT: ''};
6776var $author$project$Main$idToItem = function (id) {
6777	return A2(
6778		$elm$core$Maybe$withDefault,
6779		$author$project$Projects$Project$itemNotFound,
6780		$author$project$Main$idToMaybeItem(id));
6781};
6782var $elm$core$Maybe$map = F2(
6783	function (f, maybe) {
6784		if (!maybe.$) {
6785			var value = maybe.a;
6786			return $elm$core$Maybe$Just(
6787				f(value));
6788		} else {
6789			return $elm$core$Maybe$Nothing;
6790		}
6791	});
6792var $elm$url$Url$Builder$toQueryPair = function (_v0) {
6793	var key = _v0.a;
6794	var value = _v0.b;
6795	return key + ('=' + value);
6796};
6797var $elm$url$Url$Builder$toQuery = function (parameters) {
6798	if (!parameters.b) {
6799		return '';
6800	} else {
6801		return '?' + A2(
6802			$elm$core$String$join,
6803			'&',
6804			A2($elm$core$List$map, $elm$url$Url$Builder$toQueryPair, parameters));
6805	}
6806};
6807var $elm$url$Url$Builder$absolute = F2(
6808	function (pathSegments, parameters) {
6809		return '/' + (A2($elm$core$String$join, '/', pathSegments) + $elm$url$Url$Builder$toQuery(parameters));
6810	});
6811var $elm$url$Url$percentEncode = _Url_percentEncode;
6812var $author$project$Main$idEncoder = function (id) {
6813	return $elm$url$Url$percentEncode(
6814		A3($elm$core$String$replace, ' ', '_', id));
6815};
6816var $author$project$Main$urlBuilder = function (id) {
6817	return $elm$core$String$toLower(
6818		A2(
6819			$elm$url$Url$Builder$absolute,
6820			_List_fromArray(
6821				[
6822					$author$project$Projects$Project$conf.bU,
6823					$author$project$Main$idEncoder(id)
6824				]),
6825			_List_Nil));
6826};
6827var $author$project$Main$previousNext = function (id) {
6828	var item = $author$project$Main$idToItem(id);
6829	var presentIndex = A2($elm_community$list_extra$List$Extra$elemIndex, item, $author$project$Projects$Project$items);
6830	var next = function () {
6831		if (!presentIndex.$) {
6832			var index = presentIndex.a;
6833			return (_Utils_cmp(
6834				index,
6835				$elm$core$List$length($author$project$Projects$Project$items)) < 0) ? A2(
6836				$elm$core$Maybe$map,
6837				$author$project$Main$urlBuilder,
6838				A2(
6839					$elm$core$Maybe$map,
6840					$author$project$Projects$Project$id,
6841					A2($elm_community$list_extra$List$Extra$getAt, index + 1, $author$project$Projects$Project$items))) : $elm$core$Maybe$Nothing;
6842		} else {
6843			return $elm$core$Maybe$Nothing;
6844		}
6845	}();
6846	var previous = function () {
6847		if (!presentIndex.$) {
6848			var index = presentIndex.a;
6849			return (index > 0) ? A2(
6850				$elm$core$Maybe$map,
6851				$author$project$Main$urlBuilder,
6852				A2(
6853					$elm$core$Maybe$map,
6854					$author$project$Projects$Project$id,
6855					A2($elm_community$list_extra$List$Extra$getAt, index - 1, $author$project$Projects$Project$items))) : $elm$core$Maybe$Nothing;
6856		} else {
6857			return $elm$core$Maybe$Nothing;
6858		}
6859	}();
6860	return _Utils_Tuple2(previous, next);
6861};
6862var $author$project$Main$update = F2(
6863	function (msg, model) {
6864		switch (msg.$) {
6865			case 0:
6866				return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none);
6867			case 1:
6868				var path = msg.a;
6869				return _Utils_Tuple2(
6870					model,
6871					$author$project$Main$pushUrl(path));
6872			case 2:
6873				var route = msg.a;
6874				return _Utils_Tuple2(
6875					_Utils_update(
6876						model,
6877						{W: route}),
6878					$elm$core$Platform$Cmd$batch(
6879						_List_fromArray(
6880							[
6881								$author$project$Main$cmdOnRouteChange(route),
6882								$author$project$Main$changeMeta(
6883								_Utils_Tuple3('title', 'innerHTML', 'new Title'))
6884							])));
6885			case 4:
6886				return $author$project$Main$closeModal(model);
6887			default:
6888				var key = msg.a;
6889				if (key === 27) {
6890					return $author$project$Main$closeModal(model);
6891				} else {
6892					if ((key === 37) || (key === 38)) {
6893						var _v1 = function () {
6894							var _v2 = $author$project$Main$isItemShowing(model.W);
6895							if (!_v2.$) {
6896								var id = _v2.a;
6897								return $author$project$Main$previousNext(id);
6898							} else {
6899								return _Utils_Tuple2($elm$core$Maybe$Nothing, $elm$core$Maybe$Nothing);
6900							}
6901						}();
6902						var previous = _v1.a;
6903						var next = _v1.b;
6904						if (!previous.$) {
6905							var url = previous.a;
6906							return _Utils_Tuple2(
6907								model,
6908								$author$project$Main$pushUrl(url));
6909						} else {
6910							return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none);
6911						}
6912					} else {
6913						if ((key === 39) || (key === 40)) {
6914							var _v4 = function () {
6915								var _v5 = $author$project$Main$isItemShowing(model.W);
6916								if (!_v5.$) {
6917									var id = _v5.a;
6918									return $author$project$Main$previousNext(id);
6919								} else {
6920									return _Utils_Tuple2($elm$core$Maybe$Nothing, $elm$core$Maybe$Nothing);
6921								}
6922							}();
6923							var previous = _v4.a;
6924							var next = _v4.b;
6925							if (!next.$) {
6926								var url = next.a;
6927								return _Utils_Tuple2(
6928									model,
6929									$author$project$Main$pushUrl(url));
6930							} else {
6931								return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none);
6932							}
6933						} else {
6934							return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none);
6935						}
6936					}
6937				}
6938		}
6939	});
6940var $author$project$Main$CloseModal = {$: 4};
6941var $elm$html$Html$a = _VirtualDom_node('a');
6942var $elm$html$Html$Attributes$stringProperty = F2(
6943	function (key, string) {
6944		return A2(
6945			_VirtualDom_property,
6946			key,
6947			$elm$json$Json$Encode$string(string));
6948	});
6949var $elm$html$Html$Attributes$class = $elm$html$Html$Attributes$stringProperty('className');
6950var $mdgriffith$elm_ui$Internal$Model$Colored = F3(
6951	function (a, b, c) {

6952		return {$: 4, a: a, b: b, c: c};
6953	});
6954var $mdgriffith$elm_ui$Internal$Model$StyleClass = F2(
6955	function (a, b) {
6956		return {$: 4, a: a, b: b};
6957	});
6958var $mdgriffith$elm_ui$Internal$Flag$Flag = function (a) {
6959	return {$: 0, a: a};
6960};
6961var $mdgriffith$elm_ui$Internal$Flag$Second = function (a) {
6962	return {$: 1, a: a};
6963};
6964var $elm$core$Bitwise$shiftLeftBy = _Bitwise_shiftLeftBy;
6965var $mdgriffith$elm_ui$Internal$Flag$flag = function (i) {
6966	return (i > 31) ? $mdgriffith$elm_ui$Internal$Flag$Second(1 << (i - 32)) : $mdgriffith$elm_ui$Internal$Flag$Flag(1 << i);
6967};
6968var $mdgriffith$elm_ui$Internal$Flag$bgColor = $mdgriffith$elm_ui$Internal$Flag$flag(8);
6969var $elm$core$Basics$round = _Basics_round;
6970var $mdgriffith$elm_ui$Internal$Model$floatClass = function (x) {
6971	return $elm$core$String$fromInt(
6972		$elm$core$Basics$round(x * 255));
6973};
6974var $mdgriffith$elm_ui$Internal$Model$formatColorClass = function (_v0) {
6975	var red = _v0.a;
6976	var green = _v0.b;
6977	var blue = _v0.c;
6978	var alpha = _v0.d;
6979	return $mdgriffith$elm_ui$Internal$Model$floatClass(red) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(green) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(blue) + ('-' + $mdgriffith$elm_ui$Internal$Model$floatClass(alpha))))));
6980};
6981var $mdgriffith$elm_ui$Element$Background$color = function (clr) {
6982	return A2(
6983		$mdgriffith$elm_ui$Internal$Model$StyleClass,
6984		$mdgriffith$elm_ui$Internal$Flag$bgColor,
6985		A3(
6986			$mdgriffith$elm_ui$Internal$Model$Colored,
6987			'bg-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(clr),
6988			'background-color',
6989			clr));
6990};
6991var $elm$html$Html$div = _VirtualDom_node('div');
6992var $mdgriffith$elm_ui$Internal$Model$Unkeyed = function (a) {
6993	return {$: 0, a: a};
6994};
6995var $mdgriffith$elm_ui$Internal$Model$AsEl = 2;
6996var $mdgriffith$elm_ui$Internal$Model$asEl = 2;
6997var $mdgriffith$elm_ui$Internal$Model$Generic = {$: 0};
6998var $mdgriffith$elm_ui$Internal$Model$div = $mdgriffith$elm_ui$Internal$Model$Generic;
6999var $mdgriffith$elm_ui$Internal$Model$NoNearbyChildren = {$: 0};
7000var $mdgriffith$elm_ui$Internal$Style$classes = {eE: 'a', bX: 'atv', eG: 'ab', eH: 'cx', eI: 'cy', eJ: 'acb', eK: 'accx', eL: 'accy', eM: 'acr', c9: 'al', da: 'ar', eN: 'at', bY: 'ah', bZ: 'av', eQ: 's', eX: 'bh', eY: 'b', e0: 'w7', e2: 'bd', e3: 'bdt', bt: 'bn', e4: 'bs', bv: 'cpe', ff: 'cp', fg: 'cpx', fh: 'cpy', ao: 'c', by: 'ctr', bz: 'cb', bA: 'ccx', ap: 'ccy', a6: 'cl', bB: 'cr', fk: 'ct', fl: 'cptr', fm: 'ctxt', fC: 'fcs', ds: 'focus-within', fF: 'fs', fH: 'g', cf: 'hbh', cg: 'hc', dw: 'he', ch: 'hf', dx: 'hfp', fK: 'hv', fM: 'ic', fO: 'fr', bG: 'lbl', fR: 'iml', fS: 'imlf', fT: 'imlp', fU: 'implw', fV: 'it', fX: 'i', f_: 'lnk', aW: 'nb', d0: 'notxt', ga: 'ol', gc: 'or', aF: 'oq', gg: 'oh', d4: 'pg', d5: 'p', gi: 'ppe', gr: 'ui', ab: 'r', gv: 'sb', gw: 'sbx', gx: 'sby', gy: 'sbt', gB: 'e', gD: 'cap', gF: 'sev', gO: 'sk', P: 't', gS: 'tc', gT: 'w8', gU: 'w2', gV: 'w9', gW: 'tj', bR: 'tja', gX: 'tl', gY: 'w3', gZ: 'w5', g_: 'w4', g$: 'tr', g0: 'w6', g1: 'w1', g2: 'tun', ep: 'ts', aL: 'clr', g9: 'u', c0: 'wc', ez: 'we', c1: 'wf', eA: 'wfp', c3: 'wrp'};
7001var $mdgriffith$elm_ui$Internal$Model$columnClass = $mdgriffith$elm_ui$Internal$Style$classes.eQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.ao);
7002var $mdgriffith$elm_ui$Internal$Model$gridClass = $mdgriffith$elm_ui$Internal$Style$classes.eQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.fH);
7003var $mdgriffith$elm_ui$Internal$Model$pageClass = $mdgriffith$elm_ui$Internal$Style$classes.eQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.d4);
7004var $mdgriffith$elm_ui$Internal$Model$paragraphClass = $mdgriffith$elm_ui$Internal$Style$classes.eQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.d5);
7005var $mdgriffith$elm_ui$Internal$Model$rowClass = $mdgriffith$elm_ui$Internal$Style$classes.eQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.ab);
7006var $mdgriffith$elm_ui$Internal$Model$singleClass = $mdgriffith$elm_ui$Internal$Style$classes.eQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.gB);
7007var $mdgriffith$elm_ui$Internal$Model$contextClasses = function (context) {
7008	switch (context) {
7009		case 0:
7010			return $mdgriffith$elm_ui$Internal$Model$rowClass;
7011		case 1:
7012			return $mdgriffith$elm_ui$Internal$Model$columnClass;
7013		case 2:
7014			return $mdgriffith$elm_ui$Internal$Model$singleClass;
7015		case 3:
7016			return $mdgriffith$elm_ui$Internal$Model$gridClass;
7017		case 4:
7018			return $mdgriffith$elm_ui$Internal$Model$paragraphClass;
7019		default:
7020			return $mdgriffith$elm_ui$Internal$Model$pageClass;
7021	}
7022};
7023var $mdgriffith$elm_ui$Internal$Model$Keyed = function (a) {
7024	return {$: 1, a: a};
7025};
7026var $mdgriffith$elm_ui$Internal$Model$NoStyleSheet = {$: 0};
7027var $mdgriffith$elm_ui$Internal$Model$Styled = function (a) {
7028	return {$: 1, a: a};
7029};
7030var $mdgriffith$elm_ui$Internal$Model$Unstyled = function (a) {
7031	return {$: 0, a: a};
7032};
7033var $mdgriffith$elm_ui$Internal$Model$addChildren = F2(
7034	function (existing, nearbyChildren) {
7035		switch (nearbyChildren.$) {
7036			case 0:
7037				return existing;
7038			case 1:
7039				var behind = nearbyChildren.a;
7040				return _Utils_ap(behind, existing);
7041			case 2:
7042				var inFront = nearbyChildren.a;
7043				return _Utils_ap(existing, inFront);
7044			default:
7045				var behind = nearbyChildren.a;
7046				var inFront = nearbyChildren.b;
7047				return _Utils_ap(
7048					behind,
7049					_Utils_ap(existing, inFront));
7050		}
7051	});
7052var $mdgriffith$elm_ui$Internal$Model$addKeyedChildren = F3(
7053	function (key, existing, nearbyChildren) {
7054		switch (nearbyChildren.$) {
7055			case 0:
7056				return existing;
7057			case 1:
7058				var behind = nearbyChildren.a;
7059				return _Utils_ap(
7060					A2(
7061						$elm$core$List$map,
7062						function (x) {
7063							return _Utils_Tuple2(key, x);
7064						},
7065						behind),
7066					existing);
7067			case 2:
7068				var inFront = nearbyChildren.a;
7069				return _Utils_ap(
7070					existing,
7071					A2(
7072						$elm$core$List$map,
7073						function (x) {
7074							return _Utils_Tuple2(key, x);
7075						},
7076						inFront));
7077			default:
7078				var behind = nearbyChildren.a;
7079				var inFront = nearbyChildren.b;
7080				return _Utils_ap(
7081					A2(
7082						$elm$core$List$map,
7083						function (x) {
7084							return _Utils_Tuple2(key, x);
7085						},
7086						behind),
7087					_Utils_ap(
7088						existing,
7089						A2(
7090							$elm$core$List$map,
7091							function (x) {
7092								return _Utils_Tuple2(key, x);
7093							},
7094							inFront)));
7095		}
7096	});
7097var $mdgriffith$elm_ui$Internal$Model$AsParagraph = 4;
7098var $mdgriffith$elm_ui$Internal$Model$asParagraph = 4;
7099var $mdgriffith$elm_ui$Internal$Flag$alignBottom = $mdgriffith$elm_ui$Internal$Flag$flag(41);
7100var $mdgriffith$elm_ui$Internal$Flag$alignRight = $mdgriffith$elm_ui$Internal$Flag$flag(40);
7101var $mdgriffith$elm_ui$Internal$Flag$centerX = $mdgriffith$elm_ui$Internal$Flag$flag(42);
7102var $mdgriffith$elm_ui$Internal$Flag$centerY = $mdgriffith$elm_ui$Internal$Flag$flag(43);
7103var $elm$core$Set$Set_elm_builtin = $elm$core$Basics$identity;
7104var $elm$core$Set$empty = $elm$core$Dict$empty;
7105var $mdgriffith$elm_ui$Internal$Model$lengthClassName = function (x) {
7106	switch (x.$) {
7107		case 0:
7108			var px = x.a;
7109			return $elm$core$String$fromInt(px) + 'px';
7110		case 1:
7111			return 'auto';
7112		case 2:
7113			var i = x.a;
7114			return $elm$core$String$fromInt(i) + 'fr';
7115		case 3:
7116			var min = x.a;
7117			var len = x.b;
7118			return 'min' + ($elm$core$String$fromInt(min) + $mdgriffith$elm_ui$Internal$Model$lengthClassName(len));
7119		default:
7120			var max = x.a;
7121			var len = x.b;
7122			return 'max' + ($elm$core$String$fromInt(max) + $mdgriffith$elm_ui$Internal$Model$lengthClassName(len));
7123	}
7124};
7125var $elm$core$Tuple$second = function (_v0) {
7126	var y = _v0.b;
7127	return y;
7128};
7129var $mdgriffith$elm_ui$Internal$Model$transformClass = function (transform) {
7130	switch (transform.$) {
7131		case 0:
7132			return $elm$core$Maybe$Nothing;
7133		case 1:
7134			var _v1 = transform.a;
7135			var x = _v1.a;
7136			var y = _v1.b;
7137			var z = _v1.c;
7138			return $elm$core$Maybe$Just(
7139				'mv-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(x) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(y) + ('-' + $mdgriffith$elm_ui$Internal$Model$floatClass(z))))));
7140		default:
7141			var _v2 = transform.a;
7142			var tx = _v2.a;
7143			var ty = _v2.b;
7144			var tz = _v2.c;
7145			var _v3 = transform.b;
7146			var sx = _v3.a;
7147			var sy = _v3.b;
7148			var sz = _v3.c;
7149			var _v4 = transform.c;
7150			var ox = _v4.a;
7151			var oy = _v4.b;
7152			var oz = _v4.c;
7153			var angle = transform.d;
7154			return $elm$core$Maybe$Just(
7155				'tfrm-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(tx) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(ty) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(tz) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(sx) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(sy) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(sz) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(ox) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(oy) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(oz) + ('-' + $mdgriffith$elm_ui$Internal$Model$floatClass(angle))))))))))))))))))));
7156	}
7157};
7158var $mdgriffith$elm_ui$Internal$Model$getStyleName = function (style) {
7159	switch (style.$) {
7160		case 13:
7161			var name = style.a;
7162			return name;
7163		case 12:
7164			var name = style.a;
7165			var o = style.b;
7166			return name;
7167		case 0:
7168			var _class = style.a;
7169			return _class;
7170		case 1:
7171			var name = style.a;
7172			return name;
7173		case 2:
7174			var i = style.a;
7175			return 'font-size-' + $elm$core$String$fromInt(i);
7176		case 3:
7177			var _class = style.a;
7178			return _class;
7179		case 4:
7180			var _class = style.a;
7181			return _class;
7182		case 5:
7183			var cls = style.a;
7184			var x = style.b;
7185			var y = style.c;
7186			return cls;
7187		case 7:
7188			var cls = style.a;
7189			var top = style.b;
7190			var right = style.c;
7191			var bottom = style.d;
7192			var left = style.e;
7193			return cls;
7194		case 6:
7195			var cls = style.a;
7196			var top = style.b;
7197			var right = style.c;
7198			var bottom = style.d;
7199			var left = style.e;
7200			return cls;
7201		case 8:
7202			var template = style.a;
7203			return 'grid-rows-' + (A2(
7204				$elm$core$String$join,

7205				'-',
7206				A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.gs)) + ('-cols-' + (A2(
7207				$elm$core$String$join,
7208				'-',
7209				A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.af)) + ('-space-x-' + ($mdgriffith$elm_ui$Internal$Model$lengthClassName(template.gG.a) + ('-space-y-' + $mdgriffith$elm_ui$Internal$Model$lengthClassName(template.gG.b)))))));
7210		case 9:
7211			var pos = style.a;
7212			return 'gp grid-pos-' + ($elm$core$String$fromInt(pos.ab) + ('-' + ($elm$core$String$fromInt(pos.fi) + ('-' + ($elm$core$String$fromInt(pos.ey) + ('-' + $elm$core$String$fromInt(pos.dv)))))));
7213		case 11:
7214			var selector = style.a;
7215			var subStyle = style.b;
7216			var name = function () {
7217				switch (selector) {
7218					case 0:
7219						return 'fs';
7220					case 1:
7221						return 'hv';
7222					default:
7223						return 'act';
7224				}
7225			}();
7226			return A2(
7227				$elm$core$String$join,
7228				' ',
7229				A2(
7230					$elm$core$List$map,
7231					function (sty) {
7232						var _v1 = $mdgriffith$elm_ui$Internal$Model$getStyleName(sty);
7233						if (_v1 === '') {
7234							return '';
7235						} else {
7236							var styleName = _v1;
7237							return styleName + ('-' + name);
7238						}
7239					},
7240					subStyle));
7241		default:
7242			var x = style.a;
7243			return A2(
7244				$elm$core$Maybe$withDefault,
7245				'',
7246				$mdgriffith$elm_ui$Internal$Model$transformClass(x));
7247	}
7248};
7249var $elm$core$Set$insert = F2(
7250	function (key, _v0) {
7251		var dict = _v0;
7252		return A3($elm$core$Dict$insert, key, 0, dict);
7253	});
7254var $elm$core$Dict$member = F2(
7255	function (key, dict) {
7256		var _v0 = A2($elm$core$Dict$get, key, dict);
7257		if (!_v0.$) {
7258			return true;
7259		} else {
7260			return false;
7261		}
7262	});
7263var $elm$core$Set$member = F2(
7264	function (key, _v0) {
7265		var dict = _v0;
7266		return A2($elm$core$Dict$member, key, dict);
7267	});
7268var $mdgriffith$elm_ui$Internal$Model$reduceStyles = F2(
7269	function (style, nevermind) {
7270		var cache = nevermind.a;
7271		var existing = nevermind.b;
7272		var styleName = $mdgriffith$elm_ui$Internal$Model$getStyleName(style);
7273		return A2($elm$core$Set$member, styleName, cache) ? nevermind : _Utils_Tuple2(
7274			A2($elm$core$Set$insert, styleName, cache),
7275			A2($elm$core$List$cons, style, existing));
7276	});
7277var $mdgriffith$elm_ui$Internal$Model$Property = F2(
7278	function (a, b) {
7279		return {$: 0, a: a, b: b};
7280	});
7281var $mdgriffith$elm_ui$Internal$Model$Style = F2(
7282	function (a, b) {
7283		return {$: 0, a: a, b: b};
7284	});
7285var $mdgriffith$elm_ui$Internal$Style$dot = function (c) {
7286	return '.' + c;
7287};
7288var $elm$core$String$fromFloat = _String_fromNumber;
7289var $mdgriffith$elm_ui$Internal$Model$formatColor = function (_v0) {
7290	var red = _v0.a;
7291	var green = _v0.b;
7292	var blue = _v0.c;
7293	var alpha = _v0.d;
7294	return 'rgba(' + ($elm$core$String$fromInt(
7295		$elm$core$Basics$round(red * 255)) + ((',' + $elm$core$String$fromInt(
7296		$elm$core$Basics$round(green * 255))) + ((',' + $elm$core$String$fromInt(
7297		$elm$core$Basics$round(blue * 255))) + (',' + ($elm$core$String$fromFloat(alpha) + ')')))));
7298};
7299var $mdgriffith$elm_ui$Internal$Model$formatBoxShadow = function (shadow) {
7300	return A2(
7301		$elm$core$String$join,
7302		' ',
7303		A2(
7304			$elm$core$List$filterMap,
7305			$elm$core$Basics$identity,
7306			_List_fromArray(
7307				[
7308					shadow.dA ? $elm$core$Maybe$Just('inset') : $elm$core$Maybe$Nothing,
7309					$elm$core$Maybe$Just(
7310					$elm$core$String$fromFloat(shadow.f9.a) + 'px'),
7311					$elm$core$Maybe$Just(
7312					$elm$core$String$fromFloat(shadow.f9.b) + 'px'),
7313					$elm$core$Maybe$Just(
7314					$elm$core$String$fromFloat(shadow.e_) + 'px'),
7315					$elm$core$Maybe$Just(
7316					$elm$core$String$fromFloat(shadow.gC) + 'px'),
7317					$elm$core$Maybe$Just(
7318					$mdgriffith$elm_ui$Internal$Model$formatColor(shadow.fj))
7319				])));
7320};
7321var $elm$core$Tuple$mapFirst = F2(
7322	function (func, _v0) {
7323		var x = _v0.a;
7324		var y = _v0.b;
7325		return _Utils_Tuple2(
7326			func(x),
7327			y);
7328	});
7329var $elm$core$Tuple$mapSecond = F2(
7330	function (func, _v0) {
7331		var x = _v0.a;
7332		var y = _v0.b;
7333		return _Utils_Tuple2(
7334			x,
7335			func(y));
7336	});
7337var $mdgriffith$elm_ui$Internal$Model$renderFocusStyle = function (focus) {
7338	return _List_fromArray(
7339		[
7340			A2(
7341			$mdgriffith$elm_ui$Internal$Model$Style,
7342			$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ds) + ':focus-within',
7343			A2(
7344				$elm$core$List$filterMap,
7345				$elm$core$Basics$identity,
7346				_List_fromArray(
7347					[
7348						A2(
7349						$elm$core$Maybe$map,
7350						function (color) {
7351							return A2(
7352								$mdgriffith$elm_ui$Internal$Model$Property,
7353								'border-color',
7354								$mdgriffith$elm_ui$Internal$Model$formatColor(color));
7355						},
7356						focus.e1),
7357						A2(
7358						$elm$core$Maybe$map,
7359						function (color) {
7360							return A2(
7361								$mdgriffith$elm_ui$Internal$Model$Property,
7362								'background-color',
7363								$mdgriffith$elm_ui$Internal$Model$formatColor(color));
7364						},
7365						focus.eV),
7366						A2(
7367						$elm$core$Maybe$map,
7368						function (shadow) {
7369							return A2(
7370								$mdgriffith$elm_ui$Internal$Model$Property,
7371								'box-shadow',
7372								$mdgriffith$elm_ui$Internal$Model$formatBoxShadow(
7373									{
7374										e_: shadow.e_,
7375										fj: shadow.fj,
7376										dA: false,
7377										f9: A2(
7378											$elm$core$Tuple$mapSecond,
7379											$elm$core$Basics$toFloat,
7380											A2($elm$core$Tuple$mapFirst, $elm$core$Basics$toFloat, shadow.f9)),
7381										gC: shadow.gC
7382									}));
7383						},
7384						focus.gA),
7385						$elm$core$Maybe$Just(
7386						A2($mdgriffith$elm_ui$Internal$Model$Property, 'outline', 'none'))
7387					]))),
7388			A2(
7389			$mdgriffith$elm_ui$Internal$Model$Style,
7390			($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ) + ':focus .focusable, ') + (($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ) + '.focusable:focus, ') + ('.ui-slide-bar:focus + ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ) + ' .focusable-thumb'))),
7391			A2(
7392				$elm$core$List$filterMap,
7393				$elm$core$Basics$identity,
7394				_List_fromArray(
7395					[
7396						A2(
7397						$elm$core$Maybe$map,
7398						function (color) {
7399							return A2(
7400								$mdgriffith$elm_ui$Internal$Model$Property,
7401								'border-color',
7402								$mdgriffith$elm_ui$Internal$Model$formatColor(color));
7403						},
7404						focus.e1),
7405						A2(
7406						$elm$core$Maybe$map,
7407						function (color) {
7408							return A2(
7409								$mdgriffith$elm_ui$Internal$Model$Property,
7410								'background-color',
7411								$mdgriffith$elm_ui$Internal$Model$formatColor(color));
7412						},
7413						focus.eV),
7414						A2(
7415						$elm$core$Maybe$map,
7416						function (shadow) {
7417							return A2(
7418								$mdgriffith$elm_ui$Internal$Model$Property,
7419								'box-shadow',
7420								$mdgriffith$elm_ui$Internal$Model$formatBoxShadow(
7421									{
7422										e_: shadow.e_,
7423										fj: shadow.fj,
7424										dA: false,
7425										f9: A2(
7426											$elm$core$Tuple$mapSecond,
7427											$elm$core$Basics$toFloat,
7428											A2($elm$core$Tuple$mapFirst, $elm$core$Basics$toFloat, shadow.f9)),
7429										gC: shadow.gC
7430									}));
7431						},
7432						focus.gA),
7433						$elm$core$Maybe$Just(
7434						A2($mdgriffith$elm_ui$Internal$Model$Property, 'outline', 'none'))
7435					])))
7436		]);
7437};

7438var $elm$virtual_dom$VirtualDom$node = function (tag) {
7439	return _VirtualDom_node(
7440		_VirtualDom_noScript(tag));
7441};
7442var $elm$virtual_dom$VirtualDom$property = F2(
7443	function (key, value) {
7444		return A2(
7445			_VirtualDom_property,
7446			_VirtualDom_noInnerHtmlOrFormAction(key),
7447			_VirtualDom_noJavaScriptOrHtmlJson(value));
7448	});
7449var $mdgriffith$elm_ui$Internal$Style$AllChildren = F2(
7450	function (a, b) {
7451		return {$: 2, a: a, b: b};
7452	});
7453var $mdgriffith$elm_ui$Internal$Style$Batch = function (a) {
7454	return {$: 6, a: a};
7455};
7456var $mdgriffith$elm_ui$Internal$Style$Child = F2(
7457	function (a, b) {
7458		return {$: 1, a: a, b: b};
7459	});
7460var $mdgriffith$elm_ui$Internal$Style$Class = F2(
7461	function (a, b) {
7462		return {$: 0, a: a, b: b};
7463	});
7464var $mdgriffith$elm_ui$Internal$Style$Descriptor = F2(
7465	function (a, b) {
7466		return {$: 4, a: a, b: b};
7467	});
7468var $mdgriffith$elm_ui$Internal$Style$Left = 3;
7469var $mdgriffith$elm_ui$Internal$Style$Prop = F2(
7470	function (a, b) {
7471		return {$: 0, a: a, b: b};
7472	});
7473var $mdgriffith$elm_ui$Internal$Style$Right = 2;
7474var $mdgriffith$elm_ui$Internal$Style$Self = $elm$core$Basics$identity;
7475var $mdgriffith$elm_ui$Internal$Style$Supports = F2(
7476	function (a, b) {
7477		return {$: 3, a: a, b: b};
7478	});
7479var $mdgriffith$elm_ui$Internal$Style$Content = $elm$core$Basics$identity;
7480var $mdgriffith$elm_ui$Internal$Style$Bottom = 1;
7481var $mdgriffith$elm_ui$Internal$Style$CenterX = 4;
7482var $mdgriffith$elm_ui$Internal$Style$CenterY = 5;
7483var $mdgriffith$elm_ui$Internal$Style$Top = 0;
7484var $mdgriffith$elm_ui$Internal$Style$alignments = _List_fromArray(
7485	[0, 1, 2, 3, 4, 5]);
7486var $mdgriffith$elm_ui$Internal$Style$contentName = function (desc) {
7487	switch (desc) {
7488		case 0:
7489			var _v1 = desc;
7490			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fk);
7491		case 1:
7492			var _v2 = desc;
7493			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bz);
7494		case 2:
7495			var _v3 = desc;
7496			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bB);
7497		case 3:
7498			var _v4 = desc;
7499			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.a6);
7500		case 4:
7501			var _v5 = desc;
7502			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bA);
7503		default:
7504			var _v6 = desc;
7505			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ap);
7506	}
7507};
7508var $mdgriffith$elm_ui$Internal$Style$selfName = function (desc) {
7509	switch (desc) {
7510		case 0:
7511			var _v1 = desc;
7512			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eN);
7513		case 1:
7514			var _v2 = desc;
7515			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eG);
7516		case 2:
7517			var _v3 = desc;
7518			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.da);
7519		case 3:
7520			var _v4 = desc;
7521			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c9);
7522		case 4:
7523			var _v5 = desc;
7524			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eH);
7525		default:
7526			var _v6 = desc;
7527			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eI);
7528	}
7529};
7530var $mdgriffith$elm_ui$Internal$Style$describeAlignment = function (values) {
7531	var createDescription = function (alignment) {
7532		var _v0 = values(alignment);
7533		var content = _v0.a;
7534		var indiv = _v0.b;
7535		return _List_fromArray(
7536			[
7537				A2(
7538				$mdgriffith$elm_ui$Internal$Style$Descriptor,
7539				$mdgriffith$elm_ui$Internal$Style$contentName(alignment),
7540				content),
7541				A2(
7542				$mdgriffith$elm_ui$Internal$Style$Child,
7543				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ),
7544				_List_fromArray(
7545					[
7546						A2(
7547						$mdgriffith$elm_ui$Internal$Style$Descriptor,
7548						$mdgriffith$elm_ui$Internal$Style$selfName(alignment),
7549						indiv)
7550					]))
7551			]);
7552	};
7553	return $mdgriffith$elm_ui$Internal$Style$Batch(
7554		A2($elm$core$List$concatMap, createDescription, $mdgriffith$elm_ui$Internal$Style$alignments));
7555};
7556var $mdgriffith$elm_ui$Internal$Style$elDescription = _List_fromArray(
7557	[
7558		A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'),
7559		A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'column'),
7560		A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre'),
7561		A2(
7562		$mdgriffith$elm_ui$Internal$Style$Descriptor,
7563		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cf),
7564		_List_fromArray(
7565			[
7566				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'),
7567				A2(
7568				$mdgriffith$elm_ui$Internal$Style$Child,
7569				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eX),
7570				_List_fromArray(
7571					[
7572						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '-1')
7573					]))
7574			])),
7575		A2(
7576		$mdgriffith$elm_ui$Internal$Style$Descriptor,
7577		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gy),
7578		_List_fromArray(
7579			[
7580				A2(
7581				$mdgriffith$elm_ui$Internal$Style$Child,
7582				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.P),
7583				_List_fromArray(
7584					[
7585						A2(
7586						$mdgriffith$elm_ui$Internal$Style$Descriptor,
7587						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ch),
7588						_List_fromArray(
7589							[
7590								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0')
7591							])),
7592						A2(
7593						$mdgriffith$elm_ui$Internal$Style$Descriptor,
7594						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c1),
7595						_List_fromArray(
7596							[
7597								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'auto !important')
7598							]))
7599					]))
7600			])),
7601		A2(
7602		$mdgriffith$elm_ui$Internal$Style$Child,
7603		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cg),
7604		_List_fromArray(
7605			[
7606				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto')
7607			])),
7608		A2(
7609		$mdgriffith$elm_ui$Internal$Style$Child,
7610		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ch),
7611		_List_fromArray(
7612			[
7613				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '100000')
7614			])),
7615		A2(
7616		$mdgriffith$elm_ui$Internal$Style$Child,
7617		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c1),
7618		_List_fromArray(
7619			[
7620				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
7621			])),
7622		A2(
7623		$mdgriffith$elm_ui$Internal$Style$Child,
7624		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eA),
7625		_List_fromArray(
7626			[
7627				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
7628			])),
7629		A2(
7630		$mdgriffith$elm_ui$Internal$Style$Child,
7631		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c0),
7632		_List_fromArray(
7633			[
7634				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start')
7635			])),
7636		$mdgriffith$elm_ui$Internal$Style$describeAlignment(
7637		function (alignment) {
7638			switch (alignment) {
7639				case 0:
7640					return _Utils_Tuple2(
7641						_List_fromArray(
7642							[
7643								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start')
7644							]),
7645						_List_fromArray(
7646							[
7647								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important'),
7648								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', '0 !important')
7649							]));
7650				case 1:
7651					return _Utils_Tuple2(
7652						_List_fromArray(
7653							[
7654								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end')
7655							]),
7656						_List_fromArray(
7657							[
7658								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'),
7659								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', '0 !important')
7660							]));
7661				case 2:
7662					return _Utils_Tuple2(
7663						_List_fromArray(
7664							[
7665								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end')
7666							]),
7667						_List_fromArray(
7668							[
7669								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-end')
7670							]));
7671				case 3:
7672					return _Utils_Tuple2(
7673						_List_fromArray(
7674							[
7675								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start')
7676							]),
7677						_List_fromArray(
7678							[
7679								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start')
7680							]));
7681				case 4:
7682					return _Utils_Tuple2(
7683						_List_fromArray(
7684							[
7685								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center')
7686							]),
7687						_List_fromArray(
7688							[
7689								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'center')
7690							]));
7691				default:
7692					return _Utils_Tuple2(
7693						_List_fromArray(
7694							[
7695								A2(
7696								$mdgriffith$elm_ui$Internal$Style$Child,
7697								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ),
7698								_List_fromArray(
7699									[
7700										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto'),

7701										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto')
7702									]))
7703							]),
7704						_List_fromArray(
7705							[
7706								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'),
7707								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important')
7708							]));
7709			}
7710		})
7711	]);
7712var $mdgriffith$elm_ui$Internal$Style$gridAlignments = function (values) {
7713	var createDescription = function (alignment) {
7714		return _List_fromArray(
7715			[
7716				A2(
7717				$mdgriffith$elm_ui$Internal$Style$Child,
7718				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ),
7719				_List_fromArray(
7720					[
7721						A2(
7722						$mdgriffith$elm_ui$Internal$Style$Descriptor,
7723						$mdgriffith$elm_ui$Internal$Style$selfName(alignment),
7724						values(alignment))
7725					]))
7726			]);
7727	};
7728	return $mdgriffith$elm_ui$Internal$Style$Batch(
7729		A2($elm$core$List$concatMap, createDescription, $mdgriffith$elm_ui$Internal$Style$alignments));
7730};
7731var $mdgriffith$elm_ui$Internal$Style$Above = 0;
7732var $mdgriffith$elm_ui$Internal$Style$Behind = 5;
7733var $mdgriffith$elm_ui$Internal$Style$Below = 1;
7734var $mdgriffith$elm_ui$Internal$Style$OnLeft = 3;
7735var $mdgriffith$elm_ui$Internal$Style$OnRight = 2;
7736var $mdgriffith$elm_ui$Internal$Style$Within = 4;
7737var $mdgriffith$elm_ui$Internal$Style$locations = function () {
7738	var loc = 0;
7739	var _v0 = function () {
7740		switch (loc) {
7741			case 0:
7742				return 0;
7743			case 1:
7744				return 0;
7745			case 2:
7746				return 0;
7747			case 3:
7748				return 0;
7749			case 4:
7750				return 0;
7751			default:
7752				return 0;
7753		}
7754	}();
7755	return _List_fromArray(
7756		[0, 1, 2, 3, 4, 5]);
7757}();
7758var $mdgriffith$elm_ui$Internal$Style$baseSheet = _List_fromArray(
7759	[
7760		A2(
7761		$mdgriffith$elm_ui$Internal$Style$Class,
7762		'html,body',
7763		_List_fromArray(
7764			[
7765				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
7766				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'padding', '0'),
7767				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0')
7768			])),
7769		A2(
7770		$mdgriffith$elm_ui$Internal$Style$Class,
7771		_Utils_ap(
7772			$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ),
7773			_Utils_ap(
7774				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gB),
7775				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fM))),
7776		_List_fromArray(
7777			[
7778				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'block'),
7779				A2(
7780				$mdgriffith$elm_ui$Internal$Style$Descriptor,
7781				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ch),
7782				_List_fromArray(
7783					[
7784						A2(
7785						$mdgriffith$elm_ui$Internal$Style$Child,
7786						'img',
7787						_List_fromArray(
7788							[
7789								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'max-height', '100%'),
7790								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'object-fit', 'cover')
7791							]))
7792					])),
7793				A2(
7794				$mdgriffith$elm_ui$Internal$Style$Descriptor,
7795				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c1),
7796				_List_fromArray(
7797					[
7798						A2(
7799						$mdgriffith$elm_ui$Internal$Style$Child,
7800						'img',
7801						_List_fromArray(
7802							[
7803								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'max-width', '100%'),
7804								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'object-fit', 'cover')
7805							]))
7806					]))
7807			])),
7808		A2(
7809		$mdgriffith$elm_ui$Internal$Style$Class,
7810		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ) + ':focus',
7811		_List_fromArray(
7812			[
7813				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'outline', 'none')
7814			])),
7815		A2(
7816		$mdgriffith$elm_ui$Internal$Style$Class,
7817		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gr),
7818		_List_fromArray(
7819			[
7820				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
7821				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto'),
7822				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'min-height', '100%'),
7823				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'),
7824				A2(
7825				$mdgriffith$elm_ui$Internal$Style$Descriptor,
7826				_Utils_ap(
7827					$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ),
7828					$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ch)),
7829				_List_fromArray(
7830					[
7831						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
7832						A2(
7833						$mdgriffith$elm_ui$Internal$Style$Child,
7834						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ch),
7835						_List_fromArray(
7836							[
7837								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%')
7838							]))
7839					])),
7840				A2(
7841				$mdgriffith$elm_ui$Internal$Style$Child,
7842				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fO),
7843				_List_fromArray(
7844					[
7845						A2(
7846						$mdgriffith$elm_ui$Internal$Style$Descriptor,
7847						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aW),
7848						_List_fromArray(
7849							[
7850								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'fixed'),
7851								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20')
7852							]))
7853					]))
7854			])),
7855		A2(
7856		$mdgriffith$elm_ui$Internal$Style$Class,
7857		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aW),
7858		_List_fromArray(
7859			[
7860				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'relative'),
7861				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border', 'none'),
7862				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'),
7863				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'row'),
7864				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'),

7865				A2(
7866				$mdgriffith$elm_ui$Internal$Style$Descriptor,
7867				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gB),
7868				$mdgriffith$elm_ui$Internal$Style$elDescription),
7869				$mdgriffith$elm_ui$Internal$Style$Batch(
7870				function (fn) {
7871					return A2($elm$core$List$map, fn, $mdgriffith$elm_ui$Internal$Style$locations);
7872				}(
7873					function (loc) {
7874						switch (loc) {
7875							case 0:
7876								return A2(
7877									$mdgriffith$elm_ui$Internal$Style$Descriptor,
7878									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eE),
7879									_List_fromArray(
7880										[
7881											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
7882											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'bottom', '100%'),
7883											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'),
7884											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
7885											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'),
7886											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
7887											A2(
7888											$mdgriffith$elm_ui$Internal$Style$Child,
7889											$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ch),
7890											_List_fromArray(
7891												[
7892													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto')
7893												])),
7894											A2(
7895											$mdgriffith$elm_ui$Internal$Style$Child,
7896											$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c1),
7897											_List_fromArray(
7898												[
7899													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
7900												])),
7901											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'),
7902											A2(
7903											$mdgriffith$elm_ui$Internal$Style$Child,
7904											'*',
7905											_List_fromArray(
7906												[
7907													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
7908												]))
7909										]));
7910							case 1:
7911								return A2(
7912									$mdgriffith$elm_ui$Internal$Style$Descriptor,
7913									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eY),
7914									_List_fromArray(
7915										[
7916											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
7917											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'bottom', '0'),
7918											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'),
7919											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '0'),
7920											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
7921											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'),
7922											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
7923											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'),
7924											A2(
7925											$mdgriffith$elm_ui$Internal$Style$Child,
7926											'*',
7927											_List_fromArray(
7928												[
7929													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
7930												])),
7931											A2(
7932											$mdgriffith$elm_ui$Internal$Style$Child,
7933											$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ch),
7934											_List_fromArray(
7935												[
7936													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto')
7937												]))
7938										]));
7939							case 2:
7940								return A2(
7941									$mdgriffith$elm_ui$Internal$Style$Descriptor,
7942									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gc),
7943									_List_fromArray(
7944										[
7945											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
7946											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '100%'),
7947											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'),
7948											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
7949											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
7950											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'),
7951											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'),
7952											A2(
7953											$mdgriffith$elm_ui$Internal$Style$Child,
7954											'*',
7955											_List_fromArray(
7956												[
7957													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
7958												]))
7959										]));
7960							case 3:
7961								return A2(
7962									$mdgriffith$elm_ui$Internal$Style$Descriptor,
7963									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ga),
7964									_List_fromArray(
7965										[
7966											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
7967											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'right', '100%'),
7968											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'),
7969											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
7970											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
7971											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'),
7972											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'n

7972one'),
7973											A2(
7974											$mdgriffith$elm_ui$Internal$Style$Child,
7975											'*',
7976											_List_fromArray(
7977												[
7978													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
7979												]))
7980										]));
7981							case 4:
7982								return A2(
7983									$mdgriffith$elm_ui$Internal$Style$Descriptor,
7984									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fO),
7985									_List_fromArray(
7986										[
7987											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
7988											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
7989											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
7990											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'),
7991											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'),
7992											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
7993											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'),
7994											A2(
7995											$mdgriffith$elm_ui$Internal$Style$Child,
7996											'*',
7997											_List_fromArray(
7998												[
7999													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
8000												]))
8001										]));
8002							default:
8003								return A2(
8004									$mdgriffith$elm_ui$Internal$Style$Descriptor,
8005									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eX),
8006									_List_fromArray(
8007										[
8008											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
8009											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
8010											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
8011											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'),
8012											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'),
8013											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
8014											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'),
8015											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'),
8016											A2(
8017											$mdgriffith$elm_ui$Internal$Style$Child,
8018											'*',
8019											_List_fromArray(
8020												[
8021													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
8022												]))
8023										]));
8024						}
8025					}))
8026			])),
8027		A2(
8028		$mdgriffith$elm_ui$Internal$Style$Class,
8029		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ),
8030		_List_fromArray(
8031			[
8032				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'relative'),
8033				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border', 'none'),
8034				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '0'),
8035				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'),
8036				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'row'),
8037				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'),
8038				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'resize', 'none'),
8039				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-feature-settings', 'inherit'),
8040				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'box-sizing', 'border-box'),
8041				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0'),
8042				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'padding', '0'),
8043				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-width', '0'),
8044				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'solid'),
8045				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-size', 'inherit'),
8046				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'color', 'inherit'),
8047				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-family', 'inherit'),
8048				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'line-height', '1'),
8049				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', 'inherit'),
8050				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'none'),
8051				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-style', 'inherit'),
8052				A2(
8053				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8054				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c3),
8055				_List_fromArray(
8056					[
8057						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-wrap', 'wrap')
8058					])),
8059				A2(
8060				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8061				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d0),
8062				_List_fromArray(
8063					[
8064						A2($mdgriffith$elm_ui$Internal$Style$Prop, '-moz-user-select', 'none'),
8065						A2($mdgriffith$elm_ui$Internal$Style$Prop, '-webkit-user-select', 'none'),
8066						A2($mdgriffith$elm_ui$Internal$Style$Prop, '-ms-user-select', 'none'),
8067						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'user-select', 'none')
8068					])),
8069				A2(
8070				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8071				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fl),
8072				_List_fromArray(
8073					[
8074						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'cursor', 'pointer')
8075					])),
8076				A2(
8077				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8078				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fm),
8079				_List_fromArray(
8080					[
8081						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'cursor', 'text')
8082					])),
8083				A2(
8084				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8085				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gi),
8086				_List_fromArray(
8087					[
8088						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'n

8088one !important')
8089					])),
8090				A2(
8091				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8092				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bv),
8093				_List_fromArray(
8094					[
8095						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto !important')
8096					])),
8097				A2(
8098				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8099				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aL),
8100				_List_fromArray(
8101					[
8102						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0')
8103					])),
8104				A2(
8105				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8106				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aF),
8107				_List_fromArray(
8108					[
8109						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1')
8110					])),
8111				A2(
8112				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8113				$mdgriffith$elm_ui$Internal$Style$dot(
8114					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.fK, $mdgriffith$elm_ui$Internal$Style$classes.aL)) + ':hover',
8115				_List_fromArray(
8116					[
8117						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0')
8118					])),
8119				A2(
8120				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8121				$mdgriffith$elm_ui$Internal$Style$dot(
8122					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.fK, $mdgriffith$elm_ui$Internal$Style$classes.aF)) + ':hover',
8123				_List_fromArray(
8124					[
8125						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1')
8126					])),
8127				A2(
8128				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8129				$mdgriffith$elm_ui$Internal$Style$dot(
8130					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.fC, $mdgriffith$elm_ui$Internal$Style$classes.aL)) + ':focus',
8131				_List_fromArray(
8132					[
8133						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0')
8134					])),
8135				A2(
8136				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8137				$mdgriffith$elm_ui$Internal$Style$dot(
8138					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.fC, $mdgriffith$elm_ui$Internal$Style$classes.aF)) + ':focus',
8139				_List_fromArray(
8140					[
8141						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1')
8142					])),
8143				A2(
8144				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8145				$mdgriffith$elm_ui$Internal$Style$dot(
8146					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.bX, $mdgriffith$elm_ui$Internal$Style$classes.aL)) + ':active',
8147				_List_fromArray(
8148					[
8149						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0')
8150					])),
8151				A2(
8152				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8153				$mdgriffith$elm_ui$Internal$Style$dot(
8154					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.bX, $mdgriffith$elm_ui$Internal$Style$classes.aF)) + ':active',
8155				_List_fromArray(
8156					[
8157						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1')
8158					])),
8159				A2(
8160				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8161				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ep),
8162				_List_fromArray(
8163					[
8164						A2(
8165						$mdgriffith$elm_ui$Internal$Style$Prop,
8166						'transition',
8167						A2(
8168							$elm$core$String$join,
8169							', ',
8170							A2(
8171								$elm$core$List$map,
8172								function (x) {
8173									return x + ' 160ms';
8174								},
8175								_List_fromArray(
8176									['transform', 'opacity', 'filter', 'background-color', 'color', 'font-size']))))
8177					])),
8178				A2(
8179				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8180				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gv),
8181				_List_fromArray(
8182					[
8183						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow', 'auto'),
8184						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1')
8185					])),
8186				A2(
8187				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8188				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gw),
8189				_List_fromArray(
8190					[
8191						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-x', 'auto'),
8192						A2(
8193						$mdgriffith$elm_ui$Internal$Style$Descriptor,
8194						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ab),
8195						_List_fromArray(
8196							[
8197								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1')
8198							]))
8199					])),
8200				A2(
8201				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8202				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gx),
8203				_List_fromArray(
8204					[
8205						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-y', 'auto'),

8206						A2(
8207						$mdgriffith$elm_ui$Internal$Style$Descriptor,
8208						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ao),
8209						_List_fromArray(
8210							[
8211								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1')
8212							])),
8213						A2(
8214						$mdgriffith$elm_ui$Internal$Style$Descriptor,
8215						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gB),
8216						_List_fromArray(
8217							[
8218								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1')
8219							]))
8220					])),
8221				A2(
8222				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8223				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ff),
8224				_List_fromArray(
8225					[
8226						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow', 'hidden')
8227					])),
8228				A2(
8229				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8230				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fg),
8231				_List_fromArray(
8232					[
8233						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-x', 'hidden')
8234					])),
8235				A2(
8236				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8237				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fh),
8238				_List_fromArray(
8239					[
8240						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-y', 'hidden')
8241					])),
8242				A2(
8243				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8244				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c0),
8245				_List_fromArray(
8246					[
8247						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', 'auto')
8248					])),
8249				A2(
8250				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8251				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bt),
8252				_List_fromArray(
8253					[
8254						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-width', '0')
8255					])),
8256				A2(
8257				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8258				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.e2),
8259				_List_fromArray(
8260					[
8261						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'dashed')
8262					])),
8263				A2(
8264				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8265				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.e3),
8266				_List_fromArray(
8267					[
8268						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'dotted')
8269					])),
8270				A2(
8271				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8272				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.e4),
8273				_List_fromArray(
8274					[
8275						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'solid')
8276					])),
8277				A2(
8278				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8279				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.P),
8280				_List_fromArray(
8281					[
8282						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre'),
8283						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-block')
8284					])),
8285				A2(
8286				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8287				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fV),
8288				_List_fromArray(
8289					[
8290						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'line-height', '1.05'),
8291						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'background', 'transparent'),
8292						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'inherit')
8293					])),
8294				A2(
8295				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8296				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gB),
8297				$mdgriffith$elm_ui$Internal$Style$elDescription),
8298				A2(
8299				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8300				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ab),
8301				_List_fromArray(
8302					[
8303						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'),
8304						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'row'),
8305						A2(
8306						$mdgriffith$elm_ui$Internal$Style$Child,
8307						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ),
8308						_List_fromArray(
8309							[
8310								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', '0%'),
8311								A2(
8312								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8313								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ez),
8314								_List_fromArray(
8315									[
8316										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto')
8317									])),
8318								A2(
8319								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8320								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.f_),
8321								_List_fromArray(
8322									[
8323										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto')
8324									]))
8325							])),
8326						A2(
8327						$mdgriffith$elm_ui$Internal$Style$Child,
8328						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ch),
8329						_List_fromArray(
8330							[
8331								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch !important')
8332							])),
8333						A2(
8334						$mdgriffith$elm_ui$Internal$Style$Child,
8335						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dx),
8336						_List_fromArray(
8337							[
8338								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch !important')
8339							])),
8340						A2(
8341						$mdgriffith$elm_ui$Internal$Style$Child,
8342						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c1),
8343						_List_fromArray(
8344							[
8345								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '100000')
8346							])),
8347						A2(
8348						$mdgriffith$elm_ui$Internal$Style$Child,
8349						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.by),
8350						_List_fromArray(
8351							[
8352								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0'),
8353								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'),

8354								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch')
8355							])),
8356						A2(
8357						$mdgriffith$elm_ui$Internal$Style$Child,
8358						'u:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.eM,
8359						_List_fromArray(
8360							[
8361								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1')
8362							])),
8363						A2(
8364						$mdgriffith$elm_ui$Internal$Style$Child,
8365						's:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.eK,
8366						_List_fromArray(
8367							[
8368								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
8369								A2(
8370								$mdgriffith$elm_ui$Internal$Style$Child,
8371								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eH),
8372								_List_fromArray(
8373									[
8374										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-left', 'auto !important')
8375									]))
8376							])),
8377						A2(
8378						$mdgriffith$elm_ui$Internal$Style$Child,
8379						's:last-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.eK,
8380						_List_fromArray(
8381							[
8382								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
8383								A2(
8384								$mdgriffith$elm_ui$Internal$Style$Child,
8385								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eH),
8386								_List_fromArray(
8387									[
8388										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-right', 'auto !important')
8389									]))
8390							])),
8391						A2(
8392						$mdgriffith$elm_ui$Internal$Style$Child,
8393						's:only-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.eK,
8394						_List_fromArray(
8395							[
8396								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
8397								A2(
8398								$mdgriffith$elm_ui$Internal$Style$Child,
8399								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eI),
8400								_List_fromArray(
8401									[
8402										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'),
8403										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important')
8404									]))
8405							])),
8406						A2(
8407						$mdgriffith$elm_ui$Internal$Style$Child,
8408						's:last-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.eK + ' ~ u'),
8409						_List_fromArray(
8410							[
8411								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0')
8412							])),
8413						A2(
8414						$mdgriffith$elm_ui$Internal$Style$Child,
8415						'u:first-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.eM + (' ~ s.' + $mdgriffith$elm_ui$Internal$Style$classes.eK)),
8416						_List_fromArray(
8417							[
8418								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0')
8419							])),
8420						$mdgriffith$elm_ui$Internal$Style$describeAlignment(
8421						function (alignment) {
8422							switch (alignment) {
8423								case 0:
8424									return _Utils_Tuple2(
8425										_List_fromArray(
8426											[
8427												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start')
8428											]),
8429										_List_fromArray(
8430											[
8431												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start')
8432											]));
8433								case 1:
8434									return _Utils_Tuple2(
8435										_List_fromArray(
8436											[
8437												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end')
8438											]),
8439										_List_fromArray(
8440											[
8441												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-end')
8442											]));
8443								case 2:
8444									return _Utils_Tuple2(
8445										_List_fromArray(
8446											[
8447												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end')
8448											]),
8449										_List_Nil);
8450								case 3:
8451									return _Utils_Tuple2(
8452										_List_fromArray(
8453											[
8454												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start')
8455											]),
8456										_List_Nil);
8457								case 4:
8458									return _Utils_Tuple2(
8459										_List_fromArray(
8460											[
8461												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'center')
8462											]),
8463										_List_Nil);
8464								default:
8465									return _Utils_Tuple2(
8466										_List_fromArray(
8467											[
8468												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center')
8469											]),
8470										_List_fromArray(
8471											[
8472												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'center')
8473											]));
8474							}
8475						}),
8476						A2(
8477						$mdgriffith$elm_ui$Internal$Style$Descriptor,
8478						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gF),
8479						_List_fromArray(
8480							[
8481								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'space-between')
8482							])),
8483						A2(
8484						$mdgriffith$elm_ui$Internal$Style$Descriptor,
8485						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bG),
8486						_List_fromArray(
8487							[
8488								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'baseline')
8489							]))
8490					])),
8491				A2(
8492				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8493				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ao),
8494				_List_fromArray(
8495					[
8496						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'),
8497						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'column'),
8498						A2(
8499						$mdgriffith$elm_ui$Internal$Style$Child,
8500						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ),
8501						_List_fromArray(
8502							[
8503								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', '0px'),
8504								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'min-height', 'min-content'),
8505								A2(
8506								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8507								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dw),
8508								_List_fromArray(
8509									[
8510										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto')
8511									]))
8512							])),
8513						A2(
8514						$mdgriffith$elm_ui$Internal$Style$Child,
8515						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ch),
8516						_List_fromArray(
8517							[
8518								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '100000')
8519							])),
8520						A2(
8521						$mdgriffith$elm_ui$Internal$Style$Child,
8522						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c1),
8523						_List_fromArray(
8524							[
8525								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
8526							])),
8527						A2(
8528						$mdgriffith$elm_ui$Internal$Style$Child,
8529						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eA),
8530						_List_fromArray(
8531							[
8532								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
8533							])),
8534						A2(
8535						$mdgriffith$elm_ui$Internal$Style$Child,
8536						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c0),
8537						_List_fromArray(
8538							[
8539								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start')
8540							])),
8541						A2(
8542						$mdgriffith$elm_ui$Internal$Style$Child,
8543						'u:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.eJ,
8544						_List_fromArray(
8545							[
8546								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1')
8547							])),
8548						A2(
8549						$mdgriffith$elm_ui$Internal$Style$Child,
8550						's:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.eL,
8551						_List_fromArray(
8552							[
8553								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
8554								A2(
8555								$mdgriffith$elm_ui$Internal$Style$Child,
8556								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eI),
8557								_List_fromArray(
8558									[
8559										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'),
8560										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', '0 !important')
8561									]))
8562							])),
8563						A2(
8564						$mdgriffith$elm_ui$Internal$Style$Child,
8565						's:last-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.eL,
8566						_List_fromArray(
8567							[
8568								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
8569								A2(
8570								$mdgriffith$elm_ui$Internal$Style$Child,
8571								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eI),
8572								_List_fromArray(
8573									[
8574										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important'),
8575										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', '0 !important')
8576									]))
8577							])),
8578						A2(
8579						$mdgriffith$elm_ui$Internal$Style$Child,
8580						's:only-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.eL,
8581						_List_fromArray(
8582							[
8583								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
8584								A2(
8585								$mdgriffith$elm_ui$Internal$Style$Child,
8586								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eI),
8587								_List_fromArray(
8588									[
8589										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'),
8590										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important')
8591									]))
8592							])),
8593						A2(
8594						$mdgriffith$elm_ui$Internal$Style$Child,
8595						's:last-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.eL + ' ~ u'),
8596						_List_fromArray(
8597							[
8598								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0')
8599							])),
8600						A2(
8601						$mdgriffith$elm_ui$Internal$Style$Child,
8602						'u:first-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.eJ + (' ~ s.' + $mdgriffith$elm_ui$Internal$Style$classes.eL)),
8603						_List_fromArray(
8604							[
8605								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0')
8606							])),
8607						$mdgriffith$elm_ui$Internal$Style$describeAlignment(
8608						function (alignment) {
8609							switch (alignment) {
8610								case 0:
8611									return _Utils_Tuple2(
8612										_List_fromArray(
8613											[
8614												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start')
8615											]),
8616										_List_fromArray(
8617											[
8618												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto')
8619											]));
8620								case 1:
8621									return _Utils_Tuple2(
8622										_List_fromArray(
8623											[
8624												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end')
8625											]),
8626										_List_fromArray(
8627											[
8628												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto')
8629											]));
8630								case 2:
8631									return _Utils_Tuple2(
8632										_List_fromArray(
8633											[
8634												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end')
8635											]),
8636										_List_fromArray(
8637											[
8638												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-end')
8639											]));
8640								case 3:
8641									return _Utils_Tuple2(
8642										_List_fromArray(
8643											[
8644												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start')
8645											]),
8646										_List_fromArray(
8647											[
8648												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start')
8649											]));
8650								case 4:
8651									return _Utils_Tuple2(
8652										_List_fromArray(
8653											[
8654												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center')
8655											]),
8656										_List_fromArray(
8657											[
8658												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'center')
8659											]));
8660								default:
8661									return _Utils_Tuple2(
8662										_List_fromArray(
8663											[
8664												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'center')
8665											]),
8666										_List_Nil);
8667							}
8668						}),
8669						A2(
8670						$mdgriffith$elm_ui$Internal$Style$Child,
8671						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.by),
8672						_List_fromArray(
8673							[
8674								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0'),
8675								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'),

8676								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
8677								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch !important')
8678							])),
8679						A2(
8680						$mdgriffith$elm_ui$Internal$Style$Descriptor,
8681						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gF),
8682						_List_fromArray(
8683							[
8684								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'space-between')
8685							]))
8686					])),
8687				A2(
8688				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8689				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fH),
8690				_List_fromArray(
8691					[
8692						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', '-ms-grid'),
8693						A2(
8694						$mdgriffith$elm_ui$Internal$Style$Child,
8695						'.gp',
8696						_List_fromArray(
8697							[
8698								A2(
8699								$mdgriffith$elm_ui$Internal$Style$Child,
8700								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ),
8701								_List_fromArray(
8702									[
8703										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
8704									]))
8705							])),
8706						A2(
8707						$mdgriffith$elm_ui$Internal$Style$Supports,
8708						_Utils_Tuple2('display', 'grid'),
8709						_List_fromArray(
8710							[
8711								_Utils_Tuple2('display', 'grid')
8712							])),
8713						$mdgriffith$elm_ui$Internal$Style$gridAlignments(
8714						function (alignment) {
8715							switch (alignment) {
8716								case 0:
8717									return _List_fromArray(
8718										[
8719											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start')
8720										]);
8721								case 1:
8722									return _List_fromArray(
8723										[
8724											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end')
8725										]);
8726								case 2:
8727									return _List_fromArray(
8728										[
8729											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end')
8730										]);
8731								case 3:
8732									return _List_fromArray(
8733										[
8734											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start')
8735										]);
8736								case 4:
8737									return _List_fromArray(
8738										[
8739											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center')
8740										]);
8741								default:
8742									return _List_fromArray(
8743										[
8744											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'center')
8745										]);
8746							}
8747						})
8748					])),
8749				A2(
8750				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8751				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d4),
8752				_List_fromArray(
8753					[
8754						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'block'),
8755						A2(
8756						$mdgriffith$elm_ui$Internal$Style$Child,
8757						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ + ':first-child'),
8758						_List_fromArray(
8759							[
8760								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important')
8761							])),
8762						A2(
8763						$mdgriffith$elm_ui$Internal$Style$Child,
8764						$mdgriffith$elm_ui$Internal$Style$dot(
8765							$mdgriffith$elm_ui$Internal$Style$classes.eQ + ($mdgriffith$elm_ui$Internal$Style$selfName(3) + (':first-child + .' + $mdgriffith$elm_ui$Internal$Style$classes.eQ))),
8766						_List_fromArray(
8767							[
8768								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important')
8769							])),
8770						A2(
8771						$mdgriffith$elm_ui$Internal$Style$Child,
8772						$mdgriffith$elm_ui$Internal$Style$dot(
8773							$mdgriffith$elm_ui$Internal$Style$classes.eQ + ($mdgriffith$elm_ui$Internal$Style$selfName(2) + (':first-child + .' + $mdgriffith$elm_ui$Internal$Style$classes.eQ))),
8774						_List_fromArray(
8775							[
8776								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important')
8777							])),
8778						$mdgriffith$elm_ui$Internal$Style$describeAlignment(
8779						function (alignment) {
8780							switch (alignment) {
8781								case 0:
8782									return _Utils_Tuple2(_List_Nil, _List_Nil);
8783								case 1:
8784									return _Utils_Tuple2(_List_Nil, _List_Nil);
8785								case 2:
8786									return _Utils_Tuple2(
8787										_List_Nil,
8788										_List_fromArray(
8789											[
8790												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'right'),
8791												A2(
8792												$mdgriffith$elm_ui$Internal$Style$Descriptor,
8793												'::after',
8794												_List_fromArray(
8795													[
8796														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'content', '\"\"'),
8797														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'table'),
8798														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'clear', 'both')
8799													]))
8800											]));
8801								case 3:
8802									return _Utils_Tuple2(
8803										_List_Nil,
8804										_List_fromArray(
8805											[
8806												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'left'),
8807												A2(
8808												$mdgriffith$elm_ui$Internal$Style$Descriptor,
8809												'::after',
8810												_List_fromArray(
8811													[
8812														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'content', '\"\"'),
8813														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'table'),
8814														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'clear', 'both')
8815													]))
8816											]));
8817								case 4:
8818									return _Utils_Tuple2(_List_Nil, _List_Nil);
8819								default:
8820									return _Utils_Tuple2(_List_Nil, _List_Nil);
8821							}
8822						})
8823					])),
8824				A2(
8825				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8826				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fR),
8827				_List_fromArray(
8828					[
8829						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre-wrap !important'),
8830						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
8831						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
8832						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'background-color', 'transparent')
8833					])),
8834				A2(
8835				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8836				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fU),
8837				_List_fromArray(
8838					[
8839						A2(
8840						$mdgriffith$elm_ui$Internal$Style$Descriptor,
8841						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gB),
8842						_List_fromArray(
8843							[
8844								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto')
8845							]))
8846					])),
8847				A2(
8848				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8849				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fT),
8850				_List_fromArray(
8851					[
8852						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre-wrap !important'),
8853						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'cursor', 'text'),
8854						A2(
8855						$mdgriffith$elm_ui$Internal$Style$Child,
8856						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fS),
8857						_List_fromArray(
8858							[
8859								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre-wrap !important'),
8860								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'color', 'transparent')
8861							]))
8862					])),
8863				A2(
8864				$mdgriffith$elm_ui$Internal$Style$Descriptor,
8865				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d5),
8866				_List_fromArray(
8867					[
8868						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'block'),
8869						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal'),
8870						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-wrap', 'break-word'),
8871						A2(
8872						$mdgriffith$elm_ui$Internal$Style$Descriptor,
8873						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cf),
8874						_List_fromArray(
8875							[
8876								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'),
8877								A2(
8878								$mdgriffith$elm_ui$Internal$Style$Child,
8879								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eX),
8880								_List_fromArray(
8881									[
8882										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '-1')
8883									]))
8884							])),
8885						A2(
8886						$mdgriffith$elm_ui$Internal$Style$AllChildren,
8887						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.P),
8888						_List_fromArray(
8889							[
8890								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'),
8891								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal')
8892							])),
8893						A2(
8894						$mdgriffith$elm_ui$Internal$Style$AllChildren,
8895						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d5),
8896						_List_fromArray(
8897							[
8898								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'),
8899								A2(
8900								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8901								'::after',
8902								_List_fromArray(
8903									[
8904										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'content', 'none')
8905									])),
8906								A2(
8907								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8908								'::before',
8909								_List_fromArray(
8910									[
8911										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'content', 'none')
8912									]))
8913							])),
8914						A2(
8915						$mdgriffith$elm_ui$Internal$Style$AllChildren,
8916						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gB),
8917						_List_fromArray(
8918							[
8919								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'),
8920								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal'),
8921								A2(
8922								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8923								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ez),
8924								_List_fromArray(
8925									[
8926										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-block')
8927									])),
8928								A2(
8929								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8930								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fO),
8931								_List_fromArray(
8932									[
8933										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
8934									])),
8935								A2(
8936								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8937								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eX),
8938								_List_fromArray(
8939									[
8940										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
8941									])),
8942								A2(
8943								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8944								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eE),
8945								_List_fromArray(
8946									[
8947										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
8948									])),
8949								A2(
8950								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8951								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eY),
8952								_List_fromArray(
8953									[
8954										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
8955									])),
8956								A2(
8957								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8958								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gc),
8959								_List_fromArray(
8960									[
8961										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
8962									])),
8963								A2(
8964								$mdgriffith$elm_ui$Internal$Style$Descriptor,
8965								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ga),
8966								_List_fromArray(
8967									[
8968										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
8969									])),
8970								A2(
8971								$mdgriffith$elm_ui$Internal$Style$Child,
8972								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.P),
8973								_List_fromArray(
8974									[
8975										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'),
8976										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal')
8977									]))
8978							])),
8979						A2(
8980						$mdgriffith$elm_ui$Internal$Style$Child,
8981						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ab),
8982						_List_fromArray(
8983							[
8984								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline')
8985							])),
8986						A2(
8987						$mdgriffith$elm_ui$Internal$Style$Child,
8988						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ao),
8989						_List_fromArray(
8990							[
8991								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-flex')
8992							])),
8993						A2(
8994						$mdgriffith$elm_ui$Internal$Style$Child,
8995						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fH),
8996						_List_fromArray(
8997							[
8998								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-grid')
8999							])),
9000						$mdgriffith$elm_ui$Internal$Style$describeAlignment(
9001						function (alignment) {
9002							switch (alignment) {
9003								case 0:
9004									return _Utils_Tuple2(_List_Nil, _List_Nil);
9005								case 1:
9006									return _Utils_Tuple2(_List_Nil, _List_Nil);
9007								case 2:
9008									return _Utils_Tuple2(
9009										_List_Nil,
9010										_List_fromArray(
9011											[
9012												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'right')
9013											]));
9014								case 3:
9015									return _Utils_Tuple2(
9016										_List_Nil,
9017										_List_fromArray(
9018											[
9019												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'left')
9020											]));
9021								case 4:
9022									return _Utils_Tuple2(_List_Nil, _List_Nil);
9023								default:
9024									return _Utils_Tuple2(_List_Nil, _List_Nil);
9025							}
9026						})
9027					])),
9028				A2(
9029				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9030				'.hidden',
9031				_List_fromArray(
9032					[
9033						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'none')
9034					])),
9035				A2(
9036				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9037				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.g1),
9038				_List_fromArray(
9039					[
9040						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '100')
9041					])),
9042				A2(
9043				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9044				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gU),
9045				_List_fromArray(
9046					[
9047						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '200')
9048					])),
9049				A2(
9050				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9051				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gY),
9052				_List_fromArray(
9053					[
9054						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '300')
9055					])),
9056				A2(
9057				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9058				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.g_),
9059				_List_fromArray(
9060					[
9061						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '400')
9062					])),
9063				A2(
9064				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9065				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gZ),
9066				_List_fromArray(
9067					[
9068						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '500')
9069					])),
9070				A2(
9071				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9072				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.g0),
9073				_List_fromArray(
9074					[
9075						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '600')
9076					])),
9077				A2(
9078				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9079				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.e0),
9080				_List_fromArray(
9081					[
9082						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '700')
9083					])),
9084				A2(
9085				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9086				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gT),
9087				_List_fromArray(
9088					[
9089						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '800')
9090					])),
9091				A2(
9092				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9093				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gV),
9094				_List_fromArray(
9095					[
9096						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '900')
9097					])),
9098				A2(
9099				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9100				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.fX),
9101				_List_fromArray(
9102					[
9103						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-style', 'italic')
9104					])),
9105				A2(
9106				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9107				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gO),
9108				_List_fromArray(
9109					[
9110						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'line-through')
9111					])),
9112				A2(
9113				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9114				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.g9),
9115				_List_fromArray(
9116					[
9117						

9117A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'underline'),
9118						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip-ink', 'auto'),
9119						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip', 'ink')
9120					])),
9121				A2(
9122				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9123				_Utils_ap(
9124					$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.g9),
9125					$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gO)),
9126				_List_fromArray(
9127					[
9128						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'line-through underline'),
9129						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip-ink', 'auto'),
9130						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip', 'ink')
9131					])),
9132				A2(
9133				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9134				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.g2),
9135				_List_fromArray(
9136					[
9137						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-style', 'normal')
9138					])),
9139				A2(
9140				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9141				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gW),
9142				_List_fromArray(
9143					[
9144						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'justify')
9145					])),
9146				A2(
9147				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9148				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bR),
9149				_List_fromArray(
9150					[
9151						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'justify-all')
9152					])),
9153				A2(
9154				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9155				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gS),
9156				_List_fromArray(
9157					[
9158						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'center')
9159					])),
9160				A2(
9161				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9162				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.g$),
9163				_List_fromArray(
9164					[
9165						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'right')
9166					])),
9167				A2(
9168				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9169				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.gX),
9170				_List_fromArray(
9171					[
9172						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'left')
9173					])),
9174				A2(
9175				$mdgriffith$elm_ui$Internal$Style$Descriptor,
9176				'.modal',
9177				_List_fromArray(
9178					[
9179						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'fixed'),
9180						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'),
9181						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'),
9182						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
9183						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
9184						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none')
9185					]))
9186			]))
9187	]);
9188var $mdgriffith$elm_ui$Internal$Style$fontVariant = function (_var) {
9189	return _List_fromArray(
9190		[
9191			A2(
9192			$mdgriffith$elm_ui$Internal$Style$Class,
9193			'.v-' + _var,
9194			_List_fromArray(
9195				[
9196					A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-feature-settings', '\"' + (_var + '\"'))
9197				])),
9198			A2(
9199			$mdgriffith$elm_ui$Internal$Style$Class,
9200			'.v-' + (_var + '-off'),
9201			_List_fromArray(
9202				[
9203					A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-feature-settings', '\"' + (_var + '\" 0'))
9204				]))
9205		]);
9206};
9207var $mdgriffith$elm_ui$Internal$Style$commonValues = $elm$core$List$concat(
9208	_List_fromArray(
9209		[
9210			A2(
9211			$elm$core$List$map,
9212			function (x) {
9213				return A2(
9214					$mdgriffith$elm_ui$Internal$Style$Class,
9215					'.border-' + $elm$core$String$fromInt(x),
9216					_List_fromArray(
9217						[
9218							A2(
9219							$mdgriffith$elm_ui$Internal$Style$Prop,
9220							'border-width',
9221							$elm$core$String$fromInt(x) + 'px')
9222						]));
9223			},
9224			A2($elm$core$List$range, 0, 6)),
9225			A2(
9226			$elm$core$List$map,
9227			function (i) {
9228				return A2(
9229					$mdgriffith$elm_ui$Internal$Style$Class,
9230					'.font-size-' + $elm$core$String$fromInt(i),
9231					_List_fromArray(
9232						[
9233							A2(
9234							$mdgriffith$elm_ui$Internal$Style$Prop,
9235							'font-size',
9236							$elm$core$String$fromInt(i) + 'px')
9237						]));
9238			},
9239			A2($elm$core$List$range, 8, 32)),
9240			A2(
9241			$elm$core$List$map,
9242			function (i) {
9243				return A2(
9244					$mdgriffith$elm_ui$Internal$Style$Class,
9245					'.p-' + $elm$core$String$fromInt(i),
9246					_List_fromArray(
9247						[
9248							A2(
9249							$mdgriffith$elm_ui$Internal$Style$Prop,
9250							'padding',
9251							$elm$core$String$fromInt(i) + 'px')
9252						]));
9253			},
9254			A2($elm$core$List$range, 0, 24)),
9255			_List_fromArray(
9256			[
9257				A2(
9258				$mdgriffith$elm_ui$Internal$Style$Class,
9259				'.v-smcp',
9260				_List_fromArray(
9261					[
9262						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-variant', 'small-caps')
9263					])),
9264				A2(
9265				$mdgriffith$elm_ui$Internal$Style$Class,
9266				'.v-smcp-off',
9267				_List_fromArray(
9268					[
9269						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-variant', 'normal')
9270					]))
9271			]),
9272			$mdgriffith$elm_ui$Internal$Style$fontVariant('zero'),
9273			$mdgriffith$elm_ui$Internal$Style$fontVariant('onum'),
9274			$mdgriffith$elm_ui$Internal$Style$fontVariant('liga'),
9275			$mdgriffith$elm_ui$Internal$Style$fontVariant('dlig'),
9276			$mdgriffith$elm_ui$Internal$Style$fontVariant('ordn'),
9277			$mdgriffith$elm_ui$Internal$Style$fontVariant('tnum'),
9278			$mdgriffith$elm_ui$Internal$Style$fontVariant('afrc'),
9279			$mdgriffith$elm_ui$Internal$Style$fontVariant('frac')
9280		]));
9281var $mdgriffith$elm_ui$Internal$Style$explainer = '\n.explain {\n    border: 6px solid rgb(174, 121, 15) !important;\n}\n.explain > .' + ($mdgriffith$elm_ui$Internal$Style$classes.eQ + (' {\n    border: 4px dashed rgb(0, 151, 167) !important;\n}\n\n.ctr {\n    border: none !important;\n}\n.explain > .ctr > .' + ($mdgriffith$elm_ui$Internal$Style$classes.eQ + ' {\n    border: 4px dashed rgb(0, 151, 167) !important;\n}\n\n')));
9282var $mdgriffith$elm_ui$Internal$Style$inputTextReset = '\ninput[type="search"],\ninput[type="search"]::-webkit-search-decoration,\ninput[type="search"]::-webkit-search-cancel-button,\ninput[type="search"]::-webkit-search-results-button,\ninput[type="search"]::-webkit-search-results-decoration {\n  -webkit-appearance:none;\n}\n';
9283var $mdgriffith$elm_ui$Internal$Style$sliderReset = '\ninput[type=range] {\n  -webkit-appearance: none; \n  background: transparent;\n  position:absolute;\n  left:0;\n  top:0;\n  z-index:10;\n  width: 100%;\n  outline: dashed 1px;\n  height: 100%;\n  opacity: 0;\n}\n';
9284var $mdgriffith$elm_ui$Internal$Style$thumbReset = '\ninput[type=range]::-webkit-slider-thumb {\n    -webkit-appearance: none;\n    opacity: 0.5;\n    width: 80px;\n    height: 80px;\n    background-color: black;\n    border:none;\n    border-radius: 5px;\n}\ninput[type=range]::-moz-range-thumb {\n    opacity: 0.5;\n    width: 80px;\n    height: 80px;\n    background-color: black;\n    border:none;\n    border-radius: 5px;\n}\ninput[type=range]::-ms-thumb {\n    opacity: 0.5;\n    width: 80px;\n    height: 80px;\n    background-color: black;\n    border:none;\n    border-radius: 5px;\n}\ninput[type=range][orient=vertical]{\n    writing-mode: bt-lr; /* IE */\n    -webkit-appearance: slider-vertical;  /* WebKit */\n}\n';
9285var $mdgriffith$elm_ui$Internal$Style$trackReset = '\ninput[type=range]::-moz-range-track {\n    background: transparent;\n    cursor: pointer;\n}\ninput[type=range]::-ms-track {\n    background: transparent;\n    cursor: pointer;\n}\ninput[type=range]::-webkit-slider-runnable-track {\n    background: transparent;\n    cursor: pointer;\n}\n';
9286var $mdgriffith$elm_ui$Internal$Style$overrides = '@media screen and (-ms-high-contrast: active), (-ms-high-contrast: none) {' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ) + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ab) + (' > ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ) + (' { flex-basis: auto !important; } ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ) + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ab) + (' > ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ) + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.by) + (' { flex-basis: auto !important; }}' + ($mdgriffith$elm_ui$Internal$Style$inputTextReset + ($mdgriffith$elm_ui$Internal$Style$sliderReset + ($mdgriffith$elm_ui$Internal$Style$trackReset + ($mdgriffith$elm_ui$Internal$Style$thumbReset + $mdgriffith$elm_ui$Internal$Style$explainer)))))))))))))));
9287var $elm$core$String$concat = function (strings) {
9288	return A2($elm$core$String$join, '', strings);
9289};
9290var $mdgriffith$elm_ui$Internal$Style$Intermediate = $elm$core$Basics$identity;
9291var $mdgriffith$elm_ui$Internal$Style$emptyIntermediate = F2(
9292	function (selector, closing) {
9293		return {bx: closing, D: _List_Nil, av: _List_Nil, ac: selector};
9294	});
9295var $mdgriffith$elm_ui$Internal$Style$renderRules = F2(
9296	function (_v0, rulesToRender) {
9297		var parent = _v0;
9298		var generateIntermediates = F2(
9299			function (rule, rendered) {
9300				switch (rule.$) {
9301					case 0:
9302						var name = rule.a;
9303						var val = rule.b;
9304						return _Utils_update(
9305							rendered,
9306							{
9307								av: A2(
9308									$elm$core$List$cons,
9309									_Utils_Tuple2(name, val),
9310									rendered.av)
9311							});
9312					case 3:
9313						var _v2 = rule.a;
9314						var prop = _v2.a;
9315						var value = _v2.b;
9316						var props = rule.b;
9317						return _Utils_update(
9318							rendered,
9319							{
9320								D: A2(
9321									$elm$core$List$cons,
9322									{bx: '\n}

9322', D: _List_Nil, av: props, ac: '@supports (' + (prop + (':' + (value + (') {' + parent.ac))))},
9323									rendered.D)
9324							});
9325					case 5:
9326						var selector = rule.a;
9327						var adjRules = rule.b;
9328						return _Utils_update(
9329							rendered,
9330							{
9331								D: A2(
9332									$elm$core$List$cons,
9333									A2(
9334										$mdgriffith$elm_ui$Internal$Style$renderRules,
9335										A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, parent.ac + (' + ' + selector), ''),
9336										adjRules),
9337									rendered.D)
9338							});
9339					case 1:
9340						var child = rule.a;
9341						var childRules = rule.b;
9342						return _Utils_update(
9343							rendered,
9344							{
9345								D: A2(
9346									$elm$core$List$cons,
9347									A2(
9348										$mdgriffith$elm_ui$Internal$Style$renderRules,
9349										A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, parent.ac + (' > ' + child), ''),
9350										childRules),
9351									rendered.D)
9352							});
9353					case 2:
9354						var child = rule.a;
9355						var childRules = rule.b;
9356						return _Utils_update(
9357							rendered,
9358							{
9359								D: A2(
9360									$elm$core$List$cons,
9361									A2(
9362										$mdgriffith$elm_ui$Internal$Style$renderRules,
9363										A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, parent.ac + (' ' + child), ''),
9364										childRules),
9365									rendered.D)
9366							});
9367					case 4:
9368						var descriptor = rule.a;
9369						var descriptorRules = rule.b;
9370						return _Utils_update(
9371							rendered,
9372							{
9373								D: A2(
9374									$elm$core$List$cons,
9375									A2(
9376										$mdgriffith$elm_ui$Internal$Style$renderRules,
9377										A2(
9378											$mdgriffith$elm_ui$Internal$Style$emptyIntermediate,
9379											_Utils_ap(parent.ac, descriptor),
9380											''),
9381										descriptorRules),
9382									rendered.D)
9383							});
9384					default:
9385						var batched = rule.a;
9386						return _Utils_update(
9387							rendered,
9388							{
9389								D: A2(
9390									$elm$core$List$cons,
9391									A2(
9392										$mdgriffith$elm_ui$Internal$Style$renderRules,
9393										A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, parent.ac, ''),
9394										batched),
9395									rendered.D)
9396							});
9397				}
9398			});
9399		return A3($elm$core$List$foldr, generateIntermediates, parent, rulesToRender);
9400	});
9401var $mdgriffith$elm_ui$Internal$Style$renderCompact = function (styleClasses) {
9402	var renderValues = function (values) {
9403		return $elm$core$String$concat(
9404			A2(
9405				$elm$core$List$map,
9406				function (_v3) {
9407					var x = _v3.a;
9408					var y = _v3.b;
9409					return x + (':' + (y + ';'));
9410				},
9411				values));
9412	};
9413	var renderClass = function (rule) {
9414		var _v2 = rule.av;
9415		if (!_v2.b) {
9416			return '';
9417		} else {
9418			return rule.ac + ('{' + (renderValues(rule.av) + (rule.bx + '}')));
9419		}
9420	};
9421	var renderIntermediate = function (_v0) {
9422		var rule = _v0;
9423		return _Utils_ap(
9424			renderClass(rule),
9425			$elm$core$String$concat(
9426				A2($elm$core$List$map, renderIntermediate, rule.D)));
9427	};
9428	return $elm$core$String$concat(
9429		A2(
9430			$elm$core$List$map,
9431			renderIntermediate,
9432			A3(
9433				$elm$core$List$foldr,
9434				F2(
9435					function (_v1, existing) {
9436						var name = _v1.a;
9437						var styleRules = _v1.b;
9438						return A2(
9439							$elm$core$List$cons,
9440							A2(
9441								$mdgriffith$elm_ui$Internal$Style$renderRules,
9442								A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, name, ''),
9443								styleRules),
9444							existing);
9445					}),
9446				_List_Nil,
9447				styleClasses)));
9448};
9449var $mdgriffith$elm_ui$Internal$Style$rules = _Utils_ap(
9450	$mdgriffith$elm_ui$Internal$Style$overrides,
9451	$mdgriffith$elm_ui$Internal$Style$renderCompact(
9452		_Utils_ap($mdgriffith$elm_ui$Internal$Style$baseSheet, $mdgriffith$elm_ui$Internal$Style$commonValues)));
9453var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text;
9454var $mdgriffith$elm_ui$Internal$Model$staticRoot = function (opts) {
9455	var _v0 = opts.f5;
9456	switch (_v0) {
9457		case 0:
9458			return A3(
9459				$elm$virtual_dom$VirtualDom$node,
9460				'div',
9461				_List_Nil,
9462				_List_fromArray(
9463					[
9464						A3(
9465						$elm$virtual_dom$VirtualDom$node,
9466						'style',
9467						_List_Nil,
9468						_List_fromArray(
9469							[
9470								$elm$virtual_dom$VirtualDom$text($mdgriffith$elm_ui$Internal$Style$rules)
9471							]))
9472					]));
9473		case 1:
9474			return $elm$virtual_dom$VirtualDom$text('');
9475		default:
9476			return A3(

9477				$elm$virtual_dom$VirtualDom$node,
9478				'elm-ui-static-rules',
9479				_List_fromArray(
9480					[
9481						A2(
9482						$elm$virtual_dom$VirtualDom$property,
9483						'rules',
9484						$elm$json$Json$Encode$string($mdgriffith$elm_ui$Internal$Style$rules))
9485					]),
9486				_List_Nil);
9487	}
9488};
9489var $elm$json$Json$Encode$object = function (pairs) {
9490	return _Json_wrap(
9491		A3(
9492			$elm$core$List$foldl,
9493			F2(
9494				function (_v0, obj) {
9495					var k = _v0.a;
9496					var v = _v0.b;
9497					return A3(_Json_addField, k, v, obj);
9498				}),
9499			_Json_emptyObject(0),
9500			pairs));
9501};
9502var $elm$core$List$any = F2(
9503	function (isOkay, list) {
9504		any:
9505		while (true) {
9506			if (!list.b) {
9507				return false;
9508			} else {
9509				var x = list.a;
9510				var xs = list.b;
9511				if (isOkay(x)) {
9512					return true;
9513				} else {
9514					var $temp$isOkay = isOkay,
9515						$temp$list = xs;
9516					isOkay = $temp$isOkay;
9517					list = $temp$list;
9518					continue any;
9519				}
9520			}
9521		}
9522	});
9523var $mdgriffith$elm_ui$Internal$Model$fontName = function (font) {
9524	switch (font.$) {
9525		case 0:
9526			return 'serif';
9527		case 1:
9528			return 'sans-serif';
9529		case 2:
9530			return 'monospace';
9531		case 3:
9532			var name = font.a;
9533			return '\"' + (name + '\"');
9534		case 4:
9535			var name = font.a;
9536			var url = font.b;
9537			return '\"' + (name + '\"');
9538		default:
9539			var name = font.a.d_;
9540			return '\"' + (name + '\"');
9541	}
9542};
9543var $mdgriffith$elm_ui$Internal$Model$isSmallCaps = function (_var) {
9544	switch (_var.$) {
9545		case 0:
9546			var name = _var.a;
9547			return name === 'smcp';
9548		case 1:
9549			var name = _var.a;
9550			return false;
9551		default:
9552			var name = _var.a;
9553			var index = _var.b;
9554			return (name === 'smcp') && (index === 1);
9555	}
9556};
9557var $mdgriffith$elm_ui$Internal$Model$hasSmallCaps = function (typeface) {
9558	if (typeface.$ === 5) {
9559		var font = typeface.a;
9560		return A2($elm$core$List$any, $mdgriffith$elm_ui$Internal$Model$isSmallCaps, font.et);
9561	} else {
9562		return false;
9563	}
9564};
9565var $elm$core$Basics$min = F2(
9566	function (x, y) {
9567		return (_Utils_cmp(x, y) < 0) ? x : y;
9568	});
9569var $elm$core$Basics$negate = function (n) {
9570	return -n;
9571};
9572var $mdgriffith$elm_ui$Internal$Model$renderProps = F3(
9573	function (force, _v0, existing) {
9574		var key = _v0.a;
9575		var val = _v0.b;
9576		return force ? (existing + ('\n  ' + (key + (': ' + (val + ' !important;'))))) : (existing + ('\n  ' + (key + (': ' + (val + ';')))));
9577	});
9578var $mdgriffith$elm_ui$Internal$Model$renderStyle = F4(
9579	function (options, maybePseudo, selector, props) {
9580		if (maybePseudo.$ === 1) {
9581			return _List_fromArray(
9582				[
9583					selector + ('{' + (A3(
9584					$elm$core$List$foldl,
9585					$mdgriffith$elm_ui$Internal$Model$renderProps(false),
9586					'',
9587					props) + '\n}'))
9588				]);
9589		} else {
9590			var pseudo = maybePseudo.a;
9591			switch (pseudo) {
9592				case 1:
9593					var _v2 = options.fK;
9594					switch (_v2) {
9595						case 0:
9596							return _List_Nil;
9597						case 2:
9598							return _List_fromArray(
9599								[
9600									selector + ('-hv {' + (A3(
9601									$elm$core$List$foldl,
9602									$mdgriffith$elm_ui$Internal$Model$renderProps(true),
9603									'',
9604									props) + '\n}'))
9605								]);
9606						default:
9607							return _List_fromArray(
9608								[
9609									selector + ('-hv:hover {' + (A3(
9610									$elm$core$List$foldl,
9611									$mdgriffith$elm_ui$Internal$Model$renderProps(false),
9612									'',
9613									props) + '\n}'))
9614								]);
9615					}
9616				case 0:
9617					var renderedProps = A3(
9618						$elm$core$List$foldl,
9619						$mdgriffith$elm_ui$Internal$Model$renderProps(false),
9620						'',
9621						props);
9622					return _List_fromArray(
9623						[
9624							selector + ('-fs:focus {' + (renderedProps + '\n}')),
9625							('.' + ($mdgriffith$elm_ui$Internal$Style$classes.eQ + (':focus ' + (selector + '-fs  {')))) + (renderedProps + '\n}'),
9626							(selector + '-fs:focus-within {') + (renderedProps + '\n}'),
9627							('.ui-slide-bar:focus + ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eQ) + (' .focusable-thumb' + (selector + '-fs {')))) + (renderedProps + '\n}')
9628						]);
9629				default:
9630					return _List_fromArray(
9631						[
9632							selector + ('-act:active {' + (A3(
9633							$elm$core$List$foldl,
9634							$mdgriffith$elm_ui$Internal$Model$renderProps(false),
9635							'',
9636							props) + '\n}'))
9637						]);
9638			}
9639		}
9640	});
9641var $mdgriffith$elm_ui$Internal$Model$renderVariant = function (_var) {
9642	switch (_var.$) {
9643		case 0:
9644			var name = _var.a;
9645			return '\"' + (name + '\"');
9646		case 1:
9647			var name = _var.a;
9648			return '\"' + (name + '\" 0');
9649		default:
9650			var name = _var.a;
9651			var index = _var.b;
9652			return '\"' + (name + ('\" ' + $elm$core$String$fromInt(index)));
9653	}
9654};
9655var $mdgriffith$elm_ui$Internal$Model$renderVariants = function (typeface) {
9656	if (typeface.$ === 5) {
9657		var font = typeface.a;
9658		return $elm$core$Maybe$Just(
9659			A2(
9660				$elm$core$String$join,
9661				', ',
9662				A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$renderVariant, font.et)));
9663	} else {
9664		return $elm$core$Maybe$Nothing;
9665	}
9666};
9667var $mdgriffith$elm_ui$Internal$Model$transformValue = function (transform) {
9668	switch (transform.$) {
9669		case 0:
9670			return $elm$core$Maybe$Nothing;
9671		case 1:
9672			var _v1 = transform.a;
9673			var x = _v1.a;
9674			var y = _v1.b;
9675			var z = _v1.c;
9676			return $elm$core$Maybe$Just(
9677				'translate3d(' + ($elm$core$String$fromFloat(x) + ('px, ' + ($elm$core$String$fromFloat(y) + ('px, ' + ($elm$core$String$fromFloat(z) + 'px)'))))));
9678		default:
9679			var _v2 = transform.a;
9680			var tx = _v2.a;
9681			var ty = _v2.b;
9682			var tz = _v2.c;
9683			var _v3 = transform.b;
9684			var sx = _v3.a;
9685			var sy = _v3.b;
9686			var sz = _v3.c;
9687			var _v4 = transform.c;
9688			var ox = _v4.a;
9689			var oy = _v4.b;
9690			var oz = _v4.c;
9691			var angle = transform.d;
9692			var translate = 'translate3d(' + ($elm$core$String$fromFloat(tx) + ('px, ' + ($elm$core$String$fromFloat(ty) + ('px, ' + ($elm$core$String$fromFloat(tz) + 'px)')))));
9693			var scale = 'scale3d(' + ($elm$core$String$fromFloat(sx) + (', ' + ($elm$core$String$fromFloat(sy) + (', ' + ($elm$core$String$fromFloat(sz) + ')')))));
9694			var rotate = 'rotate3d(' + ($elm$core$String$fromFloat(ox) + (', ' + ($elm$core$String$fromFloat(oy) + (', ' + ($elm$core$String$fromFloat(oz) + (', ' + ($elm$core$String$fromFloat(angle) + 'rad)')))))));
9695			return $elm$core$Maybe$Just(translate + (' ' + (scale + (' ' + rotate))));
9696	}
9697};
9698var $mdgriffith$elm_ui$Internal$Model$renderStyleRule = F3(
9699	function (options, rule, maybePseudo) {
9700		switch (rule.$) {
9701			case 0:
9702				var selector = rule.a;
9703				var props = rule.b;
9704				return A4($mdgriffith$elm_ui$Internal$Model$renderStyle, options, maybePseudo, selector, props);
9705			case 13:
9706				var name = rule.a;
9707				var prop = rule.b;
9708				return A4(
9709					$mdgriffith$elm_ui$Internal$Model$renderStyle,
9710					options,
9711					maybePseudo,
9712					'.' + name,
9713					_List_fromArray(
9714						[
9715							A2($mdgriffith$elm_ui$Internal$Model$Property, 'box-shadow', prop)
9716						]));
9717			case 12:
9718				var name = rule.a;
9719				var transparency = rule.b;
9720				var opacity = A2(
9721					$elm$core$Basics$max,
9722					0,
9723					A2($elm$core$Basics$min, 1, 1 - transparency));
9724				return A4(
9725					$mdgriffith$elm_ui$Internal$Model$renderStyle,
9726					options,
9727					maybePseudo,
9728					'.' + name,
9729					_List_fromArray(
9730						[
9731							A2(
9732							$mdgriffith$elm_ui$Internal$Model$Property,
9733							'opacity',
9734							$elm$core$String$fromFloat(opacity))
9735						]));
9736			case 2:
9737				var i = rule.a;
9738				return A4(
9739					$mdgriffith$elm_ui$Internal$Model$renderStyle,
9740					options,
9741					maybePseudo,
9742					'.font-size-' + $elm$core$String$fromInt(i),
9743					_List_fromArray(
9744						[
9745							A2(
9746							$mdgriffith$elm_ui$Internal$Model$Property,
9747							'font-size',
9748							$elm$core$String$fromInt(i) + 'px')
9749						]));
9750			case 1:
9751				var name = rule.a;
9752				var typefaces = rule.b;
9753				var features = A2(
9754					$elm$core$String$join,
9755					', ',
9756					A2($elm$core$List$filterMap, $mdgriffith$elm_ui$Internal$Model$renderVariants, typefaces));
9757				var families = _List_fromArray(
9758					[
9759						A2(
9760						$mdgriffith$elm_ui$Internal$Model$Property,
9761						'font-family',
9762						A2(
9763							$elm$core$String$join,
9764							', ',
9765							A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$fontName, typefaces))),
9766						A2($mdgriffith$elm_ui$Internal$Model$Property, 'font-feature-settings', features),
9767						A2(
9768						$mdgriffith$elm_ui$Internal$Model$Property,
9769						'font-variant',
9770						A2($elm$core$List$any, $mdgriffith$elm_ui$Internal$Model$hasSmallCaps, typefaces) ? 'small-caps' : 'normal')
9771					]);
9772				return A4($mdgriffith$elm_ui$Internal$Model$renderStyle, options, maybePseudo, '.' + name, families);
9773			case 3:
9774				var _class = rule.a;
9775				var prop = rule.b;
9776				var val = rule.c;
9777				return A4(
9778					$mdgriffith$elm_ui$Internal$Model$renderStyle,
9779					options,
9780					maybePseudo,
9781					'.' + _class,
9782					_List_fromArray(
9783						[
9784							A2($mdgriffith$elm_ui$Internal$Model$Property, prop, val)
9785						]));
9786			case 4:
9787				var _class = rule.a;
9788				var prop = rule.b;
9789				var color = rule.c;
9790				return A4(
9791					$mdgriffith$elm_ui$Internal$Model$renderStyle,
9792					options,
9793					maybePseudo,
9794					'.' + _class,
9795					_List_fromArray(
9796						[
9797							A2(
9798							$mdgriffith$elm_ui$Internal$Model$Property,
9799							prop,
9800							$mdgriffith$elm_ui$Internal$Model$formatColor(color))
9801						]));
9802			case 5:
9803				var cls = rule.a;
9804				var x = rule.b;
9805				var y = rule.c;
9806				var yPx = $elm$core$String$fromInt(y) + 'px';
9807				var xPx = $elm$core$String$fromInt(x) + 'px';
9808				var single = '.' + $mdgriffith$elm_ui$Internal$Style$classes.gB;
9809				var row = '.' + $mdgriffith$elm_ui$Internal$Style$classes.ab;
9810				var wrappedRow = '.' + ($mdgriffith$elm_ui$Internal$Style$classes.c3 + row);
9811				var right = '.' + $mdgriffith$elm_ui$Internal$Style$classes.da;
9812				var paragraph = '.' + $mdgriffith$elm_ui$Internal$Style$classes.d5;
9813				var page = '.' + $mdgriffith$elm_ui$Internal$Style$classes.d4;
9814				var left = '.' + $mdgriffith$elm_ui$Internal$Style$classes.c9;
9815				var halfY = $elm$core$String$fromFloat(y / 2) + 'px';
9816				var halfX = $elm$core$String$fromFloat(x / 2) + 'px';
9817				var column = '.' + $mdgriffith$elm_ui$Internal$Style$classes.ao;
9818				var _class = '.' + cls;
9819				var any = '.' + $mdgriffith$elm_ui$Internal$Style$classes.eQ;
9820				return $elm$core$List$concat(
9821					_List_fromArray(
9822						[
9823							A4(
9824							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9825							options,
9826							maybePseudo,
9827							_class + (row + (' > ' + (any + (' + ' + any)))),
9828							_List_fromArray(
9829								[
9830									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-left', xPx)
9831								])),
9832							A4(
9833							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9834							options,
9835							maybePseudo,
9836							_class + (wrappedRow + (' > ' + any)),
9837							_List_fromArray(
9838								[
9839									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin', halfY + (' ' + halfX))
9840								])),
9841							A4(
9842							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9843							options,
9844							maybePseudo,
9845							_class + (column + (' > ' + (any + (' + ' + any)))),
9846							_List_fromArray(
9847								[
9848									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-top', yPx)
9849								])),
9850							A4(
9851							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9852							options,
9853							maybePseudo,
9854							_class + (page + (' > ' + (any + (' + ' + any)))),
9855							_List_fromArray(
9856								[
9857									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-top', yPx)
9858								])),
9859							A4(
9860							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9861							options,
9862							maybePseudo,
9863							_class + (page + (' > ' + left)),
9864							_List_fromArray(
9865								[
9866									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-right', xPx)
9867								])),
9868							A4(
9869							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9870							options,
9871							maybePseudo,
9872							_class + (page + (' > ' + right)),
9873							_List_fromArray(
9874								[
9875									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-left', xPx)
9876								])),
9877							A4(
9878							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9879							options,
9880							maybePseudo,
9881							_Utils_ap(_class, paragraph),
9882							_List_fromArray(
9883								[
9884									A2(
9885									$mdgriffith$elm_ui$Internal$Model$Property,
9886									'line-height',
9887									'calc(1em + ' + ($elm$core$String$fromInt(y) + 'px)'))
9888								])),
9889							A4(
9890							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9891							options,
9892							maybePseudo,
9893							'textarea' + (any + _class),
9894							_List_fromArray(
9895								[
9896									A2(
9897									$mdgriffith$elm_ui$Internal$Model$Property,
9898									'line-height',
9899									'calc(1em + ' + ($elm$core$String$fromInt(y) + 'px)')),
9900									A2(
9901									$mdgriffith$elm_ui$Internal$Model$Property,
9902									'height',
9903									'calc(100% + ' + ($elm$core$String$fromInt(y) + 'px)'))
9904								])),
9905							A4(
9906							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9907							options,
9908							maybePseudo,
9909							_class + (paragraph + (' > ' + left)),
9910							_List_fromArray(
9911								[
9912									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-right', xPx)
9913								])),
9914							A4(
9915							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9916							options,
9917							maybePseudo,
9918							_class + (paragraph + (' > ' + right)),
9919							_List_fromArray(
9920								[
9921									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-left', xPx)
9922								])),
9923							A4(
9924							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9925							options,
9926							maybePseudo,
9927							_class + (paragraph + '::after'),
9928							_List_fromArray(
9929								[
9930									A2($mdgriffith$elm_ui$Internal$Model$Property, 'content', '\'\''),
9931									A2($mdgriffith$elm_ui$Internal$Model$Property, 'display', 'block'),
9932									A2($mdgriffith$elm_ui$Internal$Model$Property, 'height', '0'),
9933									A2($mdgriffith$elm_ui$Internal$Model$Property, 'width', '0'),
9934									A2(
9935									$mdgriffith$elm_ui$Internal$Model$Property,
9936									'margin-top',
9937									$elm$core$String$fromInt((-1) * ((y / 2) | 0)) + 'px')
9938								])),
9939							A4(
9940							$mdgriffith$elm_ui$Internal$Model$renderStyle,
9941							options,
9942							maybePseudo,
9943							_class + (paragraph + '::before'),
9944							_List_fromArray(
9945								[
9946									A2($mdgriffith$elm_ui$Internal$Model$Property, 'content', '\'\''),
9947									A2($mdgriffith$elm_ui$Internal$Model$Property, 'display', 'block'),
9948									A2($mdgriffith$elm_ui$Internal$Model$Property, 'height', '0'),
9949									A2($mdgriffith$elm_ui$Internal$Model$Property, 'width', '0'),
9950									A2(
9951									$mdgriffith$elm_ui$Internal$Model$Property,
9952									'margin-bottom',
9953									$elm$core$String$fromInt((-1) * ((y / 2) | 0)) + 'px')
9954								]))
9955						]));
9956			case 7:
9957				var cls = rule.a;
9958				var top = rule.b;
9959				var right = rule.c;
9960				var bottom = rule.d;
9961				var left = rule.e;
9962				var _class = '.' + cls;
9963				return A4(
9964					$mdgriffith$elm_ui$Internal$Model$renderStyle,
9965					options,
9966					maybePseudo,
9967					_class,
9968					_List_fromArray(
9969						[
9970							A2(
9971							$mdgriffith$elm_ui$Internal$Model$Property,
9972							'padding',
9973							$elm$core$String$fromFloat(top) + ('px ' + ($elm$core$String$fromFloat(right) + ('px ' + ($elm$core$String$fromFloat(bottom) + ('px ' + ($elm$core$String$fromFloat(left) + 'px')))))))
9974						]));
9975			case 6:
9976				var cls = rule.a;
9977				var top = rule.b;
9978				var right = rule.c;
9979				var bottom = rule.d;
9980				var left = rule.e;
9981				var _class = '.' + cls;
9982				return A4(
9983					$mdgriffith$elm_ui$Internal$Model$renderStyle,
9984					options,
9985					maybePseudo,
9986					_class,
9987					_List_fromArray(
9988						[
9989							A2(
9990							$mdgriffith$elm_ui$Internal$Model$Property,
9991							'border-width',
9992							$elm$core$String$fromInt(top) + ('px ' + ($elm$core$String$fromInt(right) + ('px ' + ($elm$core$String$fromInt(bottom) + ('px ' + ($elm$core$String$fromInt(left) + 'px')))))))
9993						]));
9994			case 8:
9995				var template = rule.a;
9996				var toGridLengthHelper = F3(
9997					function (minimum, maximum, x) {

9998						toGridLengthHelper:
9999						while (true) {
10000							switch (x.$) {
10001								case 0:
10002									var px = x.a;
10003									return $elm$core$String$fromInt(px) + 'px';
10004								case 1:
10005									var _v2 = _Utils_Tuple2(minimum, maximum);
10006									if (_v2.a.$ === 1) {
10007										if (_v2.b.$ === 1) {
10008											var _v3 = _v2.a;
10009											var _v4 = _v2.b;
10010											return 'max-content';
10011										} else {
10012											var _v6 = _v2.a;
10013											var maxSize = _v2.b.a;
10014											return 'minmax(max-content, ' + ($elm$core$String$fromInt(maxSize) + 'px)');
10015										}
10016									} else {
10017										if (_v2.b.$ === 1) {
10018											var minSize = _v2.a.a;
10019											var _v5 = _v2.b;
10020											return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + 'max-content)'));
10021										} else {
10022											var minSize = _v2.a.a;
10023											var maxSize = _v2.b.a;
10024											return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + ($elm$core$String$fromInt(maxSize) + 'px)')));
10025										}
10026									}
10027								case 2:
10028									var i = x.a;
10029									var _v7 = _Utils_Tuple2(minimum, maximum);
10030									if (_v7.a.$ === 1) {
10031										if (_v7.b.$ === 1) {
10032											var _v8 = _v7.a;
10033											var _v9 = _v7.b;
10034											return $elm$core$String$fromInt(i) + 'fr';
10035										} else {
10036											var _v11 = _v7.a;
10037											var maxSize = _v7.b.a;
10038											return 'minmax(max-content, ' + ($elm$core$String$fromInt(maxSize) + 'px)');
10039										}
10040									} else {
10041										if (_v7.b.$ === 1) {
10042											var minSize = _v7.a.a;
10043											var _v10 = _v7.b;
10044											return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + ($elm$core$String$fromInt(i) + ('fr' + 'fr)'))));
10045										} else {
10046											var minSize = _v7.a.a;
10047											var maxSize = _v7.b.a;
10048											return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + ($elm$core$String$fromInt(maxSize) + 'px)')));
10049										}
10050									}
10051								case 3:
10052									var m = x.a;
10053									var len = x.b;
10054									var $temp$minimum = $elm$core$Maybe$Just(m),
10055										$temp$maximum = maximum,
10056										$temp$x = len;
10057									minimum = $temp$minimum;
10058									maximum = $temp$maximum;
10059									x = $temp$x;
10060									continue toGridLengthHelper;
10061								default:
10062									var m = x.a;
10063									var len = x.b;
10064									var $temp$minimum = minimum,
10065										$temp$maximum = $elm$core$Maybe$Just(m),
10066										$temp$x = len;
10067									minimum = $temp$minimum;
10068									maximum = $temp$maximum;
10069									x = $temp$x;
10070									continue toGridLengthHelper;
10071							}
10072						}
10073					});
10074				var toGridLength = function (x) {
10075					return A3(toGridLengthHelper, $elm$core$Maybe$Nothing, $elm$core$Maybe$Nothing, x);
10076				};
10077				var xSpacing = toGridLength(template.gG.a);
10078				var ySpacing = toGridLength(template.gG.b);
10079				var rows = function (x) {
10080					return 'grid-template-rows: ' + (x + ';');
10081				}(
10082					A2(
10083						$elm$core$String$join,
10084						' ',
10085						A2($elm$core$List$map, toGridLength, template.gs)));
10086				var msRows = function (x) {
10087					return '-ms-grid-rows: ' + (x + ';');
10088				}(
10089					A2(
10090						$elm$core$String$join,
10091						ySpacing,
10092						A2($elm$core$List$map, toGridLength, template.af)));
10093				var msColumns = function (x) {
10094					return '-ms-grid-columns: ' + (x + ';');
10095				}(
10096					A2(
10097						$elm$core$String$join,
10098						ySpacing,
10099						A2($elm$core$List$map, toGridLength, template.af)));
10100				var gapY = 'grid-row-gap:' + (toGridLength(template.gG.b) + ';');
10101				var gapX = 'grid-column-gap:' + (toGridLength(template.gG.a) + ';');
10102				var columns = function (x) {
10103					return 'grid-template-columns: ' + (x + ';');
10104				}(
10105					A2(
10106						$elm$core$String$join,
10107						' ',
10108						A2($elm$core$List$map, toGridLength, template.af)));
10109				var _class = '.grid-rows-' + (A2(
10110					$elm$core$String$join,
10111					'-',
10112					A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.gs)) + ('-cols-' + (A2(
10113					$elm$core$String$join,
10114					'-',
10115					A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.af)) + ('-space-x-' + ($mdgriffith$elm_ui$Internal$Model$lengthClassName(template.gG.a) + ('-space-y-' + $mdgriffith$elm_ui$Internal$Model$lengthClassName(template.gG.b)))))));
10116				var modernGrid = _class + ('{' + (columns + (rows + (gapX + (gapY + '}')))));
10117				var supports = '@supports (display:grid) {' + (modernGrid + '}');
10118				var base = _class + ('{' + (msColumns + (msRows + '}')));
10119				return _List_fromArray(
10120					[base, supports]);
10121			case 9:
10122				var position = rule.a;
10123				var msPosition = A2(
10124					$elm$core$String$join,
10125					' ',
10126					_List_fromArray(
10127						[
10128							'-ms-grid-row: ' + ($elm$core$String$fromInt(position.ab) + ';'),
10129							'-ms-grid-row-span: ' + ($elm$core$String$fromInt(position.dv) + ';'),
10130							'-ms-grid-column: ' + ($elm$core$String$fromInt(position.fi) + ';'),
10131							'-ms-grid-column-span: ' + ($elm$core$String$fromInt(position.ey) + ';')
10132						]));
10133				var modernPosition = A2(
10134					$elm$core$String$join,
10135					' ',
10136					_List_fromArray(
10137						[
10138							'grid-row: ' + ($elm$core$String$fromInt(position.ab) + (' / ' + ($elm$core$String$fromInt(position.ab + position.dv) + ';'))),
10139							'grid-column: ' + ($elm$core$String$fromInt(position.fi) + (' / ' + ($elm$core$String$fromInt(position.fi + position.ey) + ';')))
10140						]));
10141				var _class = '.grid-pos-' + ($elm$core$String$fromInt(position.ab) + ('-' + ($elm$core$String$fromInt(position.fi) + ('-' + ($elm$core$String$fromInt(position.ey) + ('-' + $elm$core$String$fromInt(position.dv)))))));
10142				var modernGrid = _class + ('{' + (modernPosition + '}'));
10143				var supports = '@supports (display:grid) {' + (modernGrid + '}');
10144				var base = _class + ('{' + (msPosition + '}'));
10145				return _List_fromArray(
10146					[base, supports]);
10147			case 11:
10148				var _class = rule.a;
10149				var styles = rule.b;
10150				var renderPseudoRule = function (style) {
10151					return A3(
10152						$mdgriffith$elm_ui$Internal$Model$renderStyleRule,
10153						options,
10154						style,
10155						$elm$core$Maybe$Just(_class));
10156				};
10157				return A2($elm$core$List$concatMap, renderPseudoRule, styles);
10158			default:
10159				var transform = rule.a;
10160				var val = $mdgriffith$elm_ui$Internal$Model$transformValue(transform);
10161				var _class = $mdgriffith$elm_ui$Internal$Model$transformClass(transform);
10162				var _v12 = _Utils_Tuple2(_class, val);
10163				if ((!_v12.a.$) && (!_v12.b.$)) {
10164					var cls = _v12.a.a;
10165					var v = _v12.b.a;
10166					return A4(
10167						$mdgriffith$elm_ui$Internal$Model$renderStyle,
10168						options,
10169						maybePseudo,
10170						'.' + cls,
10171						_List_fromArray(
10172							[
10173								A2($mdgriffith$elm_ui$Internal$Model$Property, 'transform', v)
10174							]));
10175				} else {
10176					return _List_Nil;
10177				}
10178		}
10179	});
10180var $mdgriffith$elm_ui$Internal$Model$encodeStyles = F2(
10181	function (options, stylesheet) {
10182		return $elm$json$Json$Encode$object(
10183			A2(
10184				$elm$core$List$map,
10185				function (style) {
10186					var styled = A3($mdgriffith$elm_ui$Internal$Model$renderStyleRule, options, style, $elm$core$Maybe$Nothing);
10187					return _Utils_Tuple2(
10188						$mdgriffith$elm_ui$Internal$Model$getStyleName(style),
10189						A2($elm$json$Json$Encode$list, $elm$json$Json$Encode$string, styled));
10190				},
10191				stylesheet));
10192	});
10193var $mdgriffith$elm_ui$Internal$Model$bracket = F2(
10194	function (selector, rules) {
10195		var renderPair = function (_v0) {
10196			var name = _v0.a;
10197			var val = _v0.b;
10198			return name + (': ' + (val + ';'));
10199		};
10200		return selector + (' {' + (A2(
10201			$elm$core$String$join,
10202			'',
10203			A2($elm$core$List$map, renderPair, rules)) + '}'));
10204	});
10205var $mdgriffith$elm_ui$Internal$Model$fontRule = F3(
10206	function (name, modifier, _v0) {
10207		var parentAdj = _v0.a;
10208		var textAdjustment = _v0.b;
10209		return _List_fromArray(
10210			[
10211				A2($mdgriffith$elm_ui$Internal$Model$bracket, '.' + (name + ('.' + (modifier + (', ' + ('.' + (name + (' .' + modifier))))))), parentAdj),
10212				A2($mdgriffith$elm_ui$Internal$Model$bracket, '.' + (name + ('.' + (modifier + ('> .' + ($mdgriffith$elm_ui$Internal$Style$classes.P + (', .' + (name + (' .' + (modifier + (' >

10212 .' + $mdgriffith$elm_ui$Internal$Style$classes.P)))))))))), textAdjustment)
10213			]);
10214	});
10215var $mdgriffith$elm_ui$Internal$Model$renderFontAdjustmentRule = F3(
10216	function (fontToAdjust, _v0, otherFontName) {
10217		var full = _v0.a;
10218		var capital = _v0.b;
10219		var name = _Utils_eq(fontToAdjust, otherFontName) ? fontToAdjust : (otherFontName + (' .' + fontToAdjust));
10220		return A2(
10221			$elm$core$String$join,
10222			' ',
10223			_Utils_ap(
10224				A3($mdgriffith$elm_ui$Internal$Model$fontRule, name, $mdgriffith$elm_ui$Internal$Style$classes.gD, capital),
10225				A3($mdgriffith$elm_ui$Internal$Model$fontRule, name, $mdgriffith$elm_ui$Internal$Style$classes.fF, full)));
10226	});
10227var $mdgriffith$elm_ui$Internal$Model$renderNullAdjustmentRule = F2(
10228	function (fontToAdjust, otherFontName) {
10229		var name = _Utils_eq(fontToAdjust, otherFontName) ? fontToAdjust : (otherFontName + (' .' + fontToAdjust));
10230		return A2(
10231			$elm$core$String$join,
10232			' ',
10233			_List_fromArray(
10234				[
10235					A2(
10236					$mdgriffith$elm_ui$Internal$Model$bracket,
10237					'.' + (name + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.gD + (', ' + ('.' + (name + (' .' + $mdgriffith$elm_ui$Internal$Style$classes.gD))))))),
10238					_List_fromArray(
10239						[
10240							_Utils_Tuple2('line-height', '1')
10241						])),
10242					A2(
10243					$mdgriffith$elm_ui$Internal$Model$bracket,
10244					'.' + (name + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.gD + ('> .' + ($mdgriffith$elm_ui$Internal$Style$classes.P + (', .' + (name + (' .' + ($mdgriffith$elm_ui$Internal$Style$classes.gD + (' > .' + $mdgriffith$elm_ui$Internal$Style$classes.P)))))))))),
10245					_List_fromArray(
10246						[
10247							_Utils_Tuple2('vertical-align', '0'),
10248							_Utils_Tuple2('line-height', '1')
10249						]))
10250				]));
10251	});
10252var $mdgriffith$elm_ui$Internal$Model$adjust = F3(
10253	function (size, height, vertical) {
10254		return {dv: height / size, gC: size, ev: vertical};
10255	});
10256var $elm$core$List$maximum = function (list) {
10257	if (list.b) {
10258		var x = list.a;
10259		var xs = list.b;
10260		return $elm$core$Maybe$Just(
10261			A3($elm$core$List$foldl, $elm$core$Basics$max, x, xs));
10262	} else {
10263		return $elm$core$Maybe$Nothing;
10264	}
10265};
10266var $elm$core$List$minimum = function (list) {
10267	if (list.b) {
10268		var x = list.a;
10269		var xs = list.b;
10270		return $elm$core$Maybe$Just(
10271			A3($elm$core$List$foldl, $elm$core$Basics$min, x, xs));
10272	} else {
10273		return $elm$core$Maybe$Nothing;
10274	}
10275};
10276var $elm$core$Basics$neq = _Utils_notEqual;
10277var $mdgriffith$elm_ui$Internal$Model$convertAdjustment = function (adjustment) {
10278	var lines = _List_fromArray(
10279		[adjustment.e9, adjustment.eW, adjustment.fq, adjustment.f$]);
10280	var lineHeight = 1.5;
10281	var normalDescender = (lineHeight - 1) / 2;
10282	var oldMiddle = lineHeight / 2;
10283	var descender = A2(
10284		$elm$core$Maybe$withDefault,
10285		adjustment.fq,
10286		$elm$core$List$minimum(lines));
10287	var newBaseline = A2(
10288		$elm$core$Maybe$withDefault,
10289		adjustment.eW,
10290		$elm$core$List$minimum(
10291			A2(
10292				$elm$core$List$filter,
10293				function (x) {
10294					return !_Utils_eq(x, descender);
10295				},
10296				lines)));
10297	var base = lineHeight;
10298	var ascender = A2(
10299		$elm$core$Maybe$withDefault,
10300		adjustment.e9,
10301		$elm$core$List$maximum(lines));
10302	var capitalSize = 1 / (ascender - newBaseline);
10303	var capitalVertical = 1 - ascender;
10304	var fullSize = 1 / (ascender - descender);
10305	var fullVertical = 1 - ascender;
10306	var newCapitalMiddle = ((ascender - newBaseline) / 2) + newBaseline;

10307	var newFullMiddle = ((ascender - descender) / 2) + descender;
10308	return {
10309		e9: A3($mdgriffith$elm_ui$Internal$Model$adjust, capitalSize, ascender - newBaseline, capitalVertical),
10310		dt: A3($mdgriffith$elm_ui$Internal$Model$adjust, fullSize, ascender - descender, fullVertical)
10311	};
10312};
10313var $mdgriffith$elm_ui$Internal$Model$fontAdjustmentRules = function (converted) {
10314	return _Utils_Tuple2(
10315		_List_fromArray(
10316			[
10317				_Utils_Tuple2('display', 'block')
10318			]),
10319		_List_fromArray(
10320			[
10321				_Utils_Tuple2('display', 'inline-block'),
10322				_Utils_Tuple2(
10323				'line-height',
10324				$elm$core$String$fromFloat(converted.dv)),
10325				_Utils_Tuple2(
10326				'vertical-align',
10327				$elm$core$String$fromFloat(converted.ev) + 'em'),
10328				_Utils_Tuple2(
10329				'font-size',
10330				$elm$core$String$fromFloat(converted.gC) + 'em')
10331			]));
10332};
10333var $mdgriffith$elm_ui$Internal$Model$typefaceAdjustment = function (typefaces) {
10334	return A3(
10335		$elm$core$List$foldl,
10336		F2(
10337			function (face, found) {
10338				if (found.$ === 1) {
10339					if (face.$ === 5) {
10340						var _with = face.a;
10341						var _v2 = _with.eF;
10342						if (_v2.$ === 1) {
10343							return found;
10344						} else {
10345							var adjustment = _v2.a;
10346							return $elm$core$Maybe$Just(
10347								_Utils_Tuple2(
10348									$mdgriffith$elm_ui$Internal$Model$fontAdjustmentRules(
10349										function ($) {
10350											return $.dt;
10351										}(
10352											$mdgriffith$elm_ui$Internal$Model$convertAdjustment(adjustment))),
10353									$mdgriffith$elm_ui$Internal$Model$fontAdjustmentRules(
10354										function ($) {
10355											return $.e9;
10356										}(
10357											$mdgriffith$elm_ui$Internal$Model$convertAdjustment(adjustment)))));
10358						}
10359					} else {
10360						return found;
10361					}
10362				} else {
10363					return found;
10364				}
10365			}),
10366		$elm$core$Maybe$Nothing,
10367		typefaces);
10368};
10369var $mdgriffith$elm_ui$Internal$Model$renderTopLevelValues = function (rules) {
10370	var withImport = function (font) {
10371		if (font.$ === 4) {
10372			var url = font.b;
10373			return $elm$core$Maybe$Just('@import url(\'' + (url + '\');'));
10374		} else {
10375			return $elm$core$Maybe$Nothing;
10376		}
10377	};
10378	var fontImports = function (_v2) {
10379		var name = _v2.a;
10380		var typefaces = _v2.b;
10381		var imports = A2(
10382			$elm$core$String$join,
10383			'\n',
10384			A2($elm$core$List$filterMap, withImport, typefaces));
10385		return imports;
10386	};
10387	var allNames = A2($elm$core$List$map, $elm$core$Tuple$first, rules);
10388	var fontAdjustments = function (_v1) {
10389		var name = _v1.a;
10390		var typefaces = _v1.b;
10391		var _v0 = $mdgriffith$elm_ui$Internal$Model$typefaceAdjustment(typefaces);
10392		if (_v0.$ === 1) {
10393			return A2(
10394				$elm$core$String$join,
10395				'',
10396				A2(
10397					$elm$core$List$map,
10398					$mdgriffith$elm_ui$Internal$Model$renderNullAdjustmentRule(name),
10399					allNames));
10400		} else {
10401			var adjustment = _v0.a;
10402			return A2(
10403				$elm$core$String$join,
10404				'',
10405				A2(
10406					$elm$core$List$map,
10407					A2($mdgriffith$elm_ui$Internal$Model$renderFontAdjustmentRule, name, adjustment),
10408					allNames));
10409		}
10410	};
10411	return _Utils_ap(
10412		A2(
10413			$elm$core$String$join,
10414			'\n',
10415			A2($elm$core$List$map, fontImports, rules)),
10416		A2(
10417			$elm$core$String$join,
10418			'\n',
10419			A2($elm$core$List$map, fontAdjustments, rules)));
10420};
10421var $mdgriffith$elm_ui$Internal$Model$topLevelValue = function (rule) {
10422	if (rule.$ === 1) {
10423		var name = rule.a;
10424		var typefaces = rule.b;
10425		return $elm$core$Maybe$Just(
10426			_Utils_Tuple2(name, typefaces));
10427	} else {
10428		return $elm$core$Maybe$Nothing;
10429	}
10430};
10431var $mdgriffith$elm_ui$Internal$Model$toStyleSheetString = F2(
10432	function (options, stylesheet) {
10433		var combine = F2(
10434			function (style, rendered) {
10435				return {
10436					bO: _Utils_ap(
10437						rendered.bO,
10438						A3($mdgriffith$elm_ui$Internal$Model$renderStyleRule, options, style, $elm$core$Maybe$Nothing)),
10439					bq: function () {
10440						var _v1 = $mdgriffith$elm_ui$Internal$Model$topLevelValue(style);
10441						if (_v1.$ === 1) {
10442							return rendered.bq;
10443						} else {
10444							var topLevel = _v1.a;
10445							return A2($elm$core$List$cons, topLevel, rendered.bq);
10446						}
10447					}()
10448				};
10449			});
10450		var _v0 = A3(
10451			$elm$core$List$foldl,
10452			combine,
10453			{bO: _List_Nil, bq: _List_Nil},
10454			stylesheet);
10455		var topLevel = _v0.bq;
10456		var rules = _v0.bO;
10457		return _Utils_ap(
10458			$mdgriffith$elm_ui$Internal$Model$renderTopLevelValues(topLevel),
10459			$elm$core$String$concat(rules));
10460	});
10461var $mdgriffith$elm_ui$Internal$Model$toStyleSheet = F2(
10462	function (options, styleSheet) {
10463		var _v0 = options.f5;
10464		switch (_v0) {
10465			case 0:
10466				return A3(

10467					$elm$virtual_dom$VirtualDom$node,
10468					'div',
10469					_List_Nil,
10470					_List_fromArray(
10471						[
10472							A3(
10473							$elm$virtual_dom$VirtualDom$node,
10474							'style',
10475							_List_Nil,
10476							_List_fromArray(
10477								[
10478									$elm$virtual_dom$VirtualDom$text(
10479									A2($mdgriffith$elm_ui$Internal$Model$toStyleSheetString, options, styleSheet))
10480								]))
10481						]));
10482			case 1:
10483				return A3(
10484					$elm$virtual_dom$VirtualDom$node,
10485					'div',
10486					_List_Nil,
10487					_List_fromArray(
10488						[
10489							A3(
10490							$elm$virtual_dom$VirtualDom$node,
10491							'style',
10492							_List_Nil,
10493							_List_fromArray(
10494								[
10495									$elm$virtual_dom$VirtualDom$text(
10496									A2($mdgriffith$elm_ui$Internal$Model$toStyleSheetString, options, styleSheet))
10497								]))
10498						]));
10499			default:
10500				return A3(
10501					$elm$virtual_dom$VirtualDom$node,
10502					'elm-ui-rules',
10503					_List_fromArray(
10504						[
10505							A2(
10506							$elm$virtual_dom$VirtualDom$property,
10507							'rules',
10508							A2($mdgriffith$elm_ui$Internal$Model$encodeStyles, options, styleSheet))
10509						]),
10510					_List_Nil);
10511		}
10512	});
10513var $mdgriffith$elm_ui$Internal$Model$embedKeyed = F4(
10514	function (_static, opts, styles, children) {
10515		var dynamicStyleSheet = A2(
10516			$mdgriffith$elm_ui$Internal$Model$toStyleSheet,
10517			opts,
10518			A3(
10519				$elm$core$List$foldl,
10520				$mdgriffith$elm_ui$Internal$Model$reduceStyles,
10521				_Utils_Tuple2(
10522					$elm$core$Set$empty,
10523					$mdgriffith$elm_ui$Internal$Model$renderFocusStyle(opts.fC)),
10524				styles).b);
10525		return _static ? A2(
10526			$elm$core$List$cons,
10527			_Utils_Tuple2(
10528				'static-stylesheet',
10529				$mdgriffith$elm_ui$Internal$Model$staticRoot(opts)),
10530			A2(
10531				$elm$core$List$cons,
10532				_Utils_Tuple2('dynamic-stylesheet', dynamicStyleSheet),
10533				children)) : A2(
10534			$elm$core$List$cons,
10535			_Utils_Tuple2('dynamic-stylesheet', dynamicStyleSheet),
10536			children);
10537	});
10538var $mdgriffith$elm_ui$Internal$Model$embedWith = F4(
10539	function (_static, opts, styles, children) {
10540		var dynamicStyleSheet = A2(
10541			$mdgriffith$elm_ui$Internal$Model$toStyleSheet,
10542			opts,
10543			A3(
10544				$elm$core$List$foldl,
10545				$mdgriffith$elm_ui$Internal$Model$reduceStyles,
10546				_Utils_Tuple2(
10547					$elm$core$Set$empty,
10548					$mdgriffith$elm_ui$Internal$Model$renderFocusStyle(opts.fC)),
10549				styles).b);
10550		return _static ? A2(
10551			$elm$core$List$cons,
10552			$mdgriffith$elm_ui$Internal$Model$staticRoot(opts),
10553			A2($elm$core$List$cons, dynamicStyleSheet, children)) : A2($elm$core$List$cons, dynamicStyleSheet, children);
10554	});
10555var $mdgriffith$elm_ui$Internal$Flag$heightBetween = $mdgriffith$elm_ui$Internal$Flag$flag(45);
10556var $mdgriffith$elm_ui$Internal$Flag$heightFill = $mdgriffith$elm_ui$Internal$Flag$flag(37);
10557var $elm$virtual_dom$VirtualDom$keyedNode = function (tag) {
10558	return _VirtualDom_keyedNode(
10559		_VirtualDom_noScript(tag));
10560};
10561var $elm$core$Basics$not = _Basics_not;
10562var $elm$html$Html$p = _VirtualDom_node('p');
10563var $elm$core$Bitwise$and = _Bitwise_and;
10564var $mdgriffith$elm_ui$Internal$Flag$present = F2(
10565	function (myFlag, _v0) {
10566		var fieldOne = _v0.a;
10567		var fieldTwo = _v0.b;
10568		if (!myFlag.$) {
10569			var first = myFlag.a;
10570			return _Utils_eq(first & fieldOne, first);
10571		} else {
10572			var second = myFlag.a;
10573			return _Utils_eq(second & fieldTwo, second);
10574		}
10575	});
10576var $elm$html$Html$s = _VirtualDom_node('s');
10577var $elm$html$Html$u = _VirtualDom_node('u');
10578var $mdgriffith$elm_ui$Internal$Flag$widthBetween = $mdgriffith$elm_ui$Internal$Flag$flag(44);
10579var $mdgriffith$elm_ui$Internal$Flag$widthFill = $mdgriffith$elm_ui$Internal$Flag$flag(39);
10580var $mdgriffith$elm_ui$Internal$Model$finalizeNode = F6(
10581	function (has, node, attributes, children, embedMode, parentContext) {
10582		var createNode = F2(
10583			function (nodeName, attrs) {
10584				if (children.$ === 1) {
10585					var keyed = children.a;
10586					return A3(
10587						$elm$virtual_dom$VirtualDom$keyedNode,
10588						nodeName,
10589						attrs,
10590						function () {
10591							switch (embedMode.$) {
10592								case 0:
10593									return keyed;
10594								case 2:
10595									var opts = embedMode.a;
10596									var styles = embedMode.b;
10597									return A4($mdgriffith$elm_ui$Internal$Model$embedKeyed, false, opts, styles, keyed);
10598								default:
10599									var opts = embedMode.a;
10600									var styles = embedMode.b;
10601									return A4($mdgriffith$elm_ui$Internal$Model$embedKeyed, true, opts, styles, keyed);
10602							}
10603						}());
10604				} else {
10605					var unkeyed = children.a;
10606					return A2(
10607						function () {
10608							switch (nodeName) {
10609								case 'div':
10610									return $elm$html$Html$div;
10611								case 'p':
10612									return $elm$html$Html$p;
10613								default:

10614									return $elm$virtual_dom$VirtualDom$node(nodeName);
10615							}
10616						}(),
10617						attrs,
10618						function () {
10619							switch (embedMode.$) {
10620								case 0:
10621									return unkeyed;
10622								case 2:
10623									var opts = embedMode.a;
10624									var styles = embedMode.b;
10625									return A4($mdgriffith$elm_ui$Internal$Model$embedWith, false, opts, styles, unkeyed);
10626								default:
10627									var opts = embedMode.a;
10628									var styles = embedMode.b;
10629									return A4($mdgriffith$elm_ui$Internal$Model$embedWith, true, opts, styles, unkeyed);
10630							}
10631						}());
10632				}
10633			});
10634		var html = function () {
10635			switch (node.$) {
10636				case 0:
10637					return A2(createNode, 'div', attributes);
10638				case 1:
10639					var nodeName = node.a;
10640					return A2(createNode, nodeName, attributes);
10641				default:
10642					var nodeName = node.a;
10643					var internal = node.b;
10644					return A3(
10645						$elm$virtual_dom$VirtualDom$node,
10646						nodeName,
10647						attributes,
10648						_List_fromArray(
10649							[
10650								A2(
10651								createNode,
10652								internal,
10653								_List_fromArray(
10654									[
10655										$elm$html$Html$Attributes$class($mdgriffith$elm_ui$Internal$Style$classes.eQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.gB))
10656									]))
10657							]));
10658			}
10659		}();
10660		switch (parentContext) {
10661			case 0:
10662				return (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$widthFill, has) && (!A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$widthBetween, has))) ? html : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$alignRight, has) ? A2(
10663					$elm$html$Html$u,
10664					_List_fromArray(
10665						[
10666							$elm$html$Html$Attributes$class(
10667							A2(
10668								$elm$core$String$join,
10669								' ',
10670								_List_fromArray(
10671									[$mdgriffith$elm_ui$Internal$Style$classes.eQ, $mdgriffith$elm_ui$Internal$Style$classes.gB, $mdgriffith$elm_ui$Internal$Style$classes.by, $mdgriffith$elm_ui$Internal$Style$classes.ap, $mdgriffith$elm_ui$Internal$Style$classes.eM])))
10672						]),
10673					_List_fromArray(
10674						[html])) : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$centerX, has) ? A2(
10675					$elm$html$Html$s,
10676					_List_fromArray(
10677						[
10678							$elm$html$Html$Attributes$class(
10679							A2(
10680								$elm$core$String$join,
10681								' ',
10682								_List_fromArray(
10683									[$mdgriffith$elm_ui$Internal$Style$classes.eQ, $mdgriffith$elm_ui$Internal$Style$classes.gB, $mdgriffith$elm_ui$Internal$Style$classes.by, $mdgriffith$elm_ui$Internal$Style$classes.ap, $mdgriffith$elm_ui$Internal$Style$classes.eK])))
10684						]),
10685					_List_fromArray(
10686						[html])) : html));
10687			case 1:
10688				return (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$heightFill, has) && (!A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$heightBetween, has))) ? html : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$centerY, has) ? A2(
10689					$elm$html$Html$s,
10690					_List_fromArray(
10691						[
10692							$elm$html$Html$Attributes$class(
10693							A2(
10694								$elm$core$String$join,
10695								' ',
10696								_List_fromArray(
10697									[$mdgriffith$elm_ui$Internal$Style$classes.eQ, $mdgriffith$elm_ui$Internal$Style$classes.gB, $mdgriffith$elm_ui$Internal$Style$classes.by, $mdgriffith$elm_ui$Internal$Style$classes.eL])))
10698						]),
10699					_List_fromArray(
10700						[html])) : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$alignBottom, has) ? A2(
10701					$elm$html$Html$u,
10702					_List_fromArray(
10703						[
10704							$elm$html$Html$Attributes$class(
10705							A2(
10706								$elm$core$String$join,
10707								' ',
10708								_List_fromArray(
10709									[$mdgriffith$elm_ui$Internal$Style$classes.eQ, $mdgriffith$elm_ui$Internal$Style$classes.gB, $mdgriffith$elm_ui$Internal$Style$classes.by, $mdgriffith$elm_ui$Internal$Style$classes.eJ])))
10710						]),
10711					_List_fromArray(
10712						[html])) : html));
10713			default:
10714				return html;
10715		}
10716	});
10717var $elm$core$List$isEmpty = function (xs) {
10718	if (!xs.b) {
10719		return true;
10720	} else {
10721		return false;
10722	}
10723};
10724var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text;
10725var $mdgriffith$elm_ui$Internal$Model$textElementClasses = $mdgriffith$elm_ui$Internal$Style$classes.eQ + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.P + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.c0 + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.cg)))));
10726var $mdgriffith$elm_ui$Internal$Model$textElement = function (str) {
10727	return A2(
10728		$elm$html$Html$div,
10729		_List_fromArray(
10730			[
10731				$elm$html$Html$Attributes$class($mdgriffith$elm_ui$Internal$Model$textElementClasses)
10732			]),
10733		_List_fromArray(
10734			[
10735				$elm$html$Html$text(str)
10736			]));
10737};
10738var $mdgriffith$elm_ui$Internal$Model$textElementFillClasses = $mdgriffith$elm_ui$Internal$Style$classes.eQ + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.P + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.c1 + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.ch)))));
10739var $mdgriffith$elm_ui$Internal$Model$textElementFill = function (str) {
10740	return A2(
10741		$elm$html$Html$div,
10742		_List_fromArray(
10743			[
10744				$elm$html$Html$Attributes$class($mdgriffith$elm_ui$Internal$Model$textElementFillClasses)
10745			]),
10746		_List_fromArray(
10747			[
10748				$elm$html$Html$text(str)
10749			]));
10750};
10751var $mdgriffith$elm_ui$Internal$Model$createElement = F3(
10752	function (context, children, rendered) {
10753		var gatherKeyed = F2(
10754			function (_v8, _v9) {
10755				var key = _v8.a;
10756				var child = _v8.b;
10757				var htmls = _v9.a;
10758				var existingStyles = _v9.b;
10759				switch (child.$) {
10760					case 0:
10761						var html = child.a;
10762						return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2(
10763							A2(
10764								$elm$core$List$cons,
10765								_Utils_Tuple2(
10766									key,
10767									html(context)),
10768								htmls),
10769							existingStyles) : _Utils_Tuple2(
10770							A2(
10771								$elm$core$List$cons,
10772								_Utils_Tuple2(
10773									key,
10774									html(context)),
10775								htmls),
10776							existingStyles);
10777					case 1:
10778						var styled = child.a;
10779						return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2(
10780							A2(
10781								$elm$core$List$cons,
10782								_Utils_Tuple2(
10783									key,
10784									A2(styled.fL, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context)),
10785								htmls),
10786							$elm$core$List$isEmpty(existingStyles) ? styled.gP : _Utils_ap(styled.gP, existingStyles)) : _Utils_Tuple2(
10787							A2(
10788								$elm$core$List$cons,
10789								_Utils_Tuple2(
10790									key,
10791									A2(styled.fL, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context)),
10792								htmls),
10793							$elm$core$List$isEmpty(existingStyles) ? styled.gP : _Utils_ap(styled.gP, existingStyles));
10794					case 2:
10795						var str = child.a;
10796						return _Utils_Tuple2(
10797							A2(
10798								$elm$core$List$cons,
10799								_Utils_Tuple2(
10800									key,
10801									_Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asEl) ? $mdgriffith$elm_ui$Internal$Model$textElementFill(str) 

10801: $mdgriffith$elm_ui$Internal$Model$textElement(str)),
10802								htmls),
10803							existingStyles);
10804					default:
10805						return _Utils_Tuple2(htmls, existingStyles);
10806				}
10807			});
10808		var gather = F2(
10809			function (child, _v6) {
10810				var htmls = _v6.a;
10811				var existingStyles = _v6.b;
10812				switch (child.$) {
10813					case 0:
10814						var html = child.a;
10815						return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2(
10816							A2(
10817								$elm$core$List$cons,
10818								html(context),
10819								htmls),
10820							existingStyles) : _Utils_Tuple2(
10821							A2(
10822								$elm$core$List$cons,
10823								html(context),
10824								htmls),
10825							existingStyles);
10826					case 1:
10827						var styled = child.a;
10828						return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2(
10829							A2(
10830								$elm$core$List$cons,
10831								A2(styled.fL, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context),
10832								htmls),
10833							$elm$core$List$isEmpty(existingStyles) ? styled.gP : _Utils_ap(styled.gP, existingStyles)) : _Utils_Tuple2(
10834							A2(
10835								$elm$core$List$cons,
10836								A2(styled.fL, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context),
10837								htmls),
10838							$elm$core$List$isEmpty(existingStyles) ? styled.gP : _Utils_ap(styled.gP, existingStyles));
10839					case 2:
10840						var str = child.a;
10841						return _Utils_Tuple2(
10842							A2(
10843								$elm$core$List$cons,
10844								_Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asEl) ? $mdgriffith$elm_ui$Internal$Model$textElementFill(str) : $mdgriffith$elm_ui$Internal$Model$textElement(str),
10845								htmls),
10846							existingStyles);
10847					default:
10848						return _Utils_Tuple2(htmls, existingStyles);
10849				}
10850			});
10851		if (children.$ === 1) {
10852			var keyedChildren = children.a;
10853			var _v1 = A3(
10854				$elm$core$List$foldr,
10855				gatherKeyed,
10856				_Utils_Tuple2(_List_Nil, _List_Nil),
10857				keyedChildren);
10858			var keyed = _v1.a;
10859			var styles = _v1.b;
10860			var newStyles = $elm$core$List$isEmpty(styles) ? rendered.gP : _Utils_ap(rendered.gP, styles);
10861			if (!newStyles.b) {
10862				return $mdgriffith$elm_ui$Internal$Model$Unstyled(
10863					A5(
10864						$mdgriffith$elm_ui$Internal$Model$finalizeNode,
10865						rendered.aD,
10866						rendered.aE,
10867						rendered.ax,
10868						$mdgriffith$elm_ui$Internal$Model$Keyed(
10869							A3($mdgriffith$elm_ui$Internal$Model$addKeyedChildren, 'nearby-element-pls', keyed, rendered.aA)),
10870						$mdgriffith$elm_ui$Internal$Model$NoStyleSheet));
10871			} else {
10872				var allStyles = newStyles;
10873				return $mdgriffith$elm_ui$Internal$Model$Styled(
10874					{
10875						fL: A4(
10876							$mdgriffith$elm_ui$Internal$Model$finalizeNode,
10877							rendered.aD,
10878							rendered.aE,
10879							rendered.ax,
10880							$mdgriffith$elm_ui$Internal$Model$Keyed(
10881								A3($mdgriffith$elm_ui$Internal$Model$addKeyedChildren, 'nearby-element-pls', keyed, rendered.aA))),
10882						gP: allStyles
10883					});
10884			}
10885		} else {
10886			var unkeyedChildren = children.a;
10887			var _v3 = A3(
10888				$elm$core$List$foldr,
10889				gather,
10890				_Utils_Tuple2(_List_Nil, _List_Nil),
10891				unkeyedChildren);
10892			var unkeyed = _v3.a;
10893			var styles = _v3.b;
10894			var newStyles = $elm$core$List$isEmpty(styles) ? rendered.gP : _Utils_ap(rendered.gP, styles);
10895			if (!newStyles.b) {
10896				return $mdgriffith$elm_ui$Internal$Model$Unstyled(
10897					A5(
10898						$mdgriffith$elm_ui$Internal$Model$finalizeNode,
10899						rendered.aD,
10900						rendered.aE,
10901						rendered.ax,
10902						$mdgriffith$elm_ui$Internal$Model$Unkeyed(
10903							A2($mdgriffith$elm_ui$Internal$Model$addChildren, unkeyed, rendered.aA)),
10904						$mdgriffith$elm_ui$Internal$Model$NoStyleSheet));
10905			} else {
10906				var allStyles = newStyles;
10907				return $mdgriffith$elm_ui$Internal$Model$Styled(
10908					{
10909						fL: A4(
10910							$mdgriffith$elm_ui$Internal$Model$finalizeNode,
10911							rendered.aD,
10912							rendered.aE,
10913							rendered.ax,
10914							$mdgriffith$elm_ui$Internal$Model$Unkeyed(
10915								A2($mdgriffith$elm_ui$Internal$Model$addChildren, unkeyed, rendered.aA))),
10916						gP: allStyles
10917					});
10918			}
10919		}
10920	});
10921var $mdgriffith$elm_ui$Internal$Model$Single = F3(
10922	function (a, b, c) {
10923		return {$: 3, a: a, b: b, c: c};
10924	});
10925var $mdgriffith$elm_ui$Internal$Model$Transform = function (a) {
10926	return {$: 10, a: a};
10927};
10928var $mdgriffith$elm_ui$Internal$Flag$Field = F2(
10929	function (a, b) {
10930		return {$: 0, a: a, b: b};
10931	});
10932var $elm$core$Bitwise$or = _Bitwise_or;
10933var $mdgriffith$elm_ui$Internal$Flag$add = F2(
10934	function (myFlag, _v0) {
10935		var one = _v0.a;
10936		var two = _v0.b;
10937		if (!myFlag.$) {
10938			var first = myFlag.a;
10939			return A2($mdgriffith$elm_ui$Internal$Flag$Field, first | one, two);
10940		} else {
10941			var second = myFlag.a;
10942			return A2($mdgriffith$elm_ui$Internal$Flag$Field, one, second | two);
10943		}
10944	});
10945var $mdgriffith$elm_ui$Internal$Model$ChildrenBehind = function (a) {
10946	return {$: 1, a: a};
10947};
10948var $mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront = F2(
10949	function (a, b) {
10950		return {$: 3, a: a, b: b};
10951	});
10952var $mdgriffith$elm_ui$Internal$Model$ChildrenInFront = function (a) {
10953	return {$: 2, a: a};
10954};
10955var $mdgriffith$elm_ui$Internal$Model$nearbyElement = F2(
10956	function (location, elem) {
10957		return A2(
10958			$elm$html$Html$div,
10959			_List_fromArray(
10960				[
10961					$elm$html$Html$Attributes$class(
10962					function () {
10963						switch (location) {
10964							case 0:
10965								return A2(
10966									$elm$core$String$join,
10967									' ',
10968									_List_fromArray(
10969										[$mdgriffith$elm_ui$Internal$Style$classes.aW, $mdgriffith$elm_ui$Internal$Style$classes.gB, $mdgriffith$elm_ui$Internal$Style$classes.eE]));
10970							case 1:
10971								return A2(
10972									$elm$core$String$join,
10973									' ',
10974									_List_fromArray(
10975										[$mdgriffith$elm_ui$Internal$Style$classes.aW, $mdgriffith$elm_ui$Internal$Style$classes.gB, $mdgriffith$elm_ui$Internal$Style$classes.eY]));
10976							case 2:
10977								return A2(
10978									$elm$core$String$join,
10979									' ',
10980									_List_fromArray(
10981										[$mdgriffith$elm_ui$Internal$Style$classes.aW, $mdgriffith$elm_ui$Internal$Style$classes.gB, $mdgriffith$elm_ui$Internal$Style$classes.gc])

10981);
10982							case 3:
10983								return A2(
10984									$elm$core$String$join,
10985									' ',
10986									_List_fromArray(
10987										[$mdgriffith$elm_ui$Internal$Style$classes.aW, $mdgriffith$elm_ui$Internal$Style$classes.gB, $mdgriffith$elm_ui$Internal$Style$classes.ga]));
10988							case 4:
10989								return A2(
10990									$elm$core$String$join,
10991									' ',
10992									_List_fromArray(
10993										[$mdgriffith$elm_ui$Internal$Style$classes.aW, $mdgriffith$elm_ui$Internal$Style$classes.gB, $mdgriffith$elm_ui$Internal$Style$classes.fO]));
10994							default:
10995								return A2(
10996									$elm$core$String$join,
10997									' ',
10998									_List_fromArray(
10999										[$mdgriffith$elm_ui$Internal$Style$classes.aW, $mdgriffith$elm_ui$Internal$Style$classes.gB, $mdgriffith$elm_ui$Internal$Style$classes.eX]));
11000						}
11001					}())
11002				]),
11003			_List_fromArray(
11004				[
11005					function () {
11006					switch (elem.$) {
11007						case 3:
11008							return $elm$virtual_dom$VirtualDom$text('');
11009						case 2:
11010							var str = elem.a;
11011							return $mdgriffith$elm_ui$Internal$Model$textElement(str);
11012						case 0:
11013							var html = elem.a;
11014							return html($mdgriffith$elm_ui$Internal$Model$asEl);
11015						default:
11016							var styled = elem.a;
11017							return A2(styled.fL, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, $mdgriffith$elm_ui$Internal$Model$asEl);
11018					}
11019				}()
11020				]));
11021	});
11022var $mdgriffith$elm_ui$Internal$Model$addNearbyElement = F3(
11023	function (location, elem, existing) {
11024		var nearby = A2($mdgriffith$elm_ui$Internal$Model$nearbyElement, location, elem);
11025		switch (existing.$) {
11026			case 0:
11027				if (location === 5) {
11028					return $mdgriffith$elm_ui$Internal$Model$ChildrenBehind(
11029						_List_fromArray(
11030							[nearby]));
11031				} else {
11032					return $mdgriffith$elm_ui$Internal$Model$ChildrenInFront(
11033						_List_fromArray(
11034							[nearby]));
11035				}
11036			case 1:
11037				var existingBehind = existing.a;
11038				if (location === 5) {
11039					return $mdgriffith$elm_ui$Internal$Model$ChildrenBehind(
11040						A2($elm$core$List$cons, nearby, existingBehind));
11041				} else {
11042					return A2(
11043						$mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront,
11044						existingBehind,
11045						_List_fromArray(
11046							[nearby]));
11047				}
11048			case 2:
11049				var existingInFront = existing.a;
11050				if (location === 5) {
11051					return A2(
11052						$mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront,
11053						_List_fromArray(
11054							[nearby]),
11055						existingInFront);
11056				} else {
11057					return $mdgriffith$elm_ui$Internal$Model$ChildrenInFront(
11058						A2($elm$core$List$cons, nearby, existingInFront));
11059				}
11060			default:
11061				var existingBehind = existing.a;
11062				var existingInFront = existing.b;
11063				if (location === 5) {
11064					return A2(
11065						$mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront,
11066						A2($elm$core$List$cons, nearby, existingBehind),
11067						existingInFront);
11068				} else {
11069					return A2(
11070						$mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront,
11071						existingBehind,
11072						A2($elm$core$List$cons, nearby, existingInFront));
11073				}
11074		}
11075	});
11076var $mdgriffith$elm_ui$Internal$Model$Embedded = F2(
11077	function (a, b) {
11078		return {$: 2, a: a, b: b};
11079	});
11080var $mdgriffith$elm_ui$Internal$Model$NodeName = function (a) {
11081	return {$: 1, a: a};
11082};
11083var $mdgriffith$elm_ui$Internal$Model$addNodeName = F2(
11084	function (newNode, old) {
11085		switch (old.$) {
11086			case 0:
11087				return $mdgriffith$elm_ui$Internal$Model$NodeName(newNode);
11088			case 1:
11089				var name = old.a;
11090				return A2($mdgriffith$elm_ui$Internal$Model$Embedded, name, newNode);
11091			default:
11092				var x = old.a;
11093				var y = old.b;
11094				return A2($mdgriffith$elm_ui$Internal$Model$Embedded, x, y);
11095		}
11096	});
11097var $mdgriffith$elm_ui$Internal$Model$alignXName = function (align) {
11098	switch (align) {
11099		case 0:
11100			return $mdgriffith$elm_ui$Internal$Style$classes.bY + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.c9);
11101		case 2:
11102			return $mdgriffith$elm_ui$Internal$Style$classes.bY + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.da);
11103		default:
11104			return $mdgriffith$elm_ui$Internal$Style$classes.bY + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.eH);
11105	}
11106};
11107var $mdgriffith$elm_ui$Internal$Model$alignYName = function (align) {
11108	switch (align) {
11109		case 0:
11110			return $mdgriffith$elm_ui$Internal$Style$classes.bZ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.eN);
11111		case 2:
11112			return $mdgriffith$elm_ui$Internal$Style$classes.bZ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.eG);
11113		default:
11114			return $mdgriffith$elm_ui$Internal$Style$classes.bZ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.eI);
11115	}
11116};
11117var $elm$virtual_dom$VirtualDom$attribute = F2(
11118	function (key, value) {
11119		return A2(
11120			_VirtualDom_attribute,
11121			_VirtualDom_noOnOrFormAction(key),
11122			_VirtualDom_noJavaScriptOrHtmlUri(value));
11123	});
11124var $mdgriffith$elm_ui$Internal$Model$FullTransform = F4(
11125	function (a, b, c, d) {

11126		return {$: 2, a: a, b: b, c: c, d: d};
11127	});
11128var $mdgriffith$elm_ui$Internal$Model$Moved = function (a) {
11129	return {$: 1, a: a};
11130};
11131var $mdgriffith$elm_ui$Internal$Model$composeTransformation = F2(
11132	function (transform, component) {
11133		switch (transform.$) {
11134			case 0:
11135				switch (component.$) {
11136					case 0:
11137						var x = component.a;
11138						return $mdgriffith$elm_ui$Internal$Model$Moved(
11139							_Utils_Tuple3(x, 0, 0));
11140					case 1:
11141						var y = component.a;
11142						return $mdgriffith$elm_ui$Internal$Model$Moved(
11143							_Utils_Tuple3(0, y, 0));
11144					case 2:
11145						var z = component.a;
11146						return $mdgriffith$elm_ui$Internal$Model$Moved(
11147							_Utils_Tuple3(0, 0, z));
11148					case 3:
11149						var xyz = component.a;
11150						return $mdgriffith$elm_ui$Internal$Model$Moved(xyz);
11151					case 4:
11152						var xyz = component.a;
11153						var angle = component.b;
11154						return A4(
11155							$mdgriffith$elm_ui$Internal$Model$FullTransform,
11156							_Utils_Tuple3(0, 0, 0),
11157							_Utils_Tuple3(1, 1, 1),
11158							xyz,
11159							angle);
11160					default:
11161						var xyz = component.a;
11162						return A4(
11163							$mdgriffith$elm_ui$Internal$Model$FullTransform,
11164							_Utils_Tuple3(0, 0, 0),
11165							xyz,
11166							_Utils_Tuple3(0, 0, 1),
11167							0);
11168				}
11169			case 1:
11170				var moved = transform.a;
11171				var x = moved.a;
11172				var y = moved.b;
11173				var z = moved.c;
11174				switch (component.$) {
11175					case 0:
11176						var newX = component.a;
11177						return $mdgriffith$elm_ui$Internal$Model$Moved(
11178							_Utils_Tuple3(newX, y, z));
11179					case 1:
11180						var newY = component.a;
11181						return $mdgriffith$elm_ui$Internal$Model$Moved(
11182							_Utils_Tuple3(x, newY, z));
11183					case 2:
11184						var newZ = component.a;
11185						return $mdgriffith$elm_ui$Internal$Model$Moved(
11186							_Utils_Tuple3(x, y, newZ));
11187					case 3:
11188						var xyz = component.a;
11189						return $mdgriffith$elm_ui$Internal$Model$Moved(xyz);
11190					case 4:
11191						var xyz = component.a;
11192						var angle = component.b;
11193						return A4(
11194							$mdgriffith$elm_ui$Internal$Model$FullTransform,
11195							moved,
11196							_Utils_Tuple3(1, 1, 1),
11197							xyz,
11198							angle);
11199					default:
11200						var scale = component.a;
11201						return A4(
11202							$mdgriffith$elm_ui$Internal$Model$FullTransform,
11203							moved,
11204							scale,
11205							_Utils_Tuple3(0, 0, 1),
11206							0);
11207				}
11208			default:
11209				var moved = transform.a;
11210				var x = moved.a;
11211				var y = moved.b;
11212				var z = moved.c;
11213				var scaled = transform.b;
11214				var origin = transform.c;
11215				var angle = transform.d;
11216				switch (component.$) {
11217					case 0:
11218						var newX = component.a;
11219						return A4(
11220							$mdgriffith$elm_ui$Internal$Model$FullTransform,
11221							_Utils_Tuple3(newX, y, z),
11222							scaled,
11223							origin,
11224							angle);
11225					case 1:
11226						var newY = component.a;
11227						return A4(
11228							$mdgriffith$elm_ui$Internal$Model$FullTransform,
11229							_Utils_Tuple3(x, newY, z),
11230							scaled,
11231							origin,
11232							angle);
11233					case 2:
11234						var newZ = component.a;
11235						return A4(
11236							$mdgriffith$elm_ui$Internal$Model$FullTransform,
11237							_Utils_Tuple3(x, y, newZ),
11238							scaled,
11239							origin,
11240							angle);
11241					case 3:
11242						var newMove = component.a;
11243						return A4($mdgriffith$elm_ui$Internal$Model$FullTransform, newMove, scaled, origin, angle);
11244					case 4:
11245						var newOrigin = component.a;
11246						var newAngle = component.b;
11247						return A4($mdgriffith$elm_ui$Internal$Model$FullTransform, moved, scaled, newOrigin, newAngle);
11248					default:
11249						var newScale = component.a;
11250						return A4($mdgriffith$elm_ui$Internal$Model$FullTransform, moved, newScale, origin, angle);
11251				}
11252		}
11253	});
11254var $mdgriffith$elm_ui$Internal$Flag$height = $mdgriffith$elm_ui$Internal$Flag$flag(7);
11255var $mdgriffith$elm_ui$Internal$Flag$heightContent = $mdgriffith$elm_ui$Internal$Flag$flag(36);
11256var $mdgriffith$elm_ui$Internal$Flag$merge = F2(
11257	function (_v0, _v1) {
11258		var one = _v0.a;
11259		var two = _v0.b;
11260		var three = _v1.a;
11261		var four = _v1.b;
11262		return A2($mdgriffith$elm_ui$Internal$Flag$Field, one | three, two | four);
11263	});
11264var $mdgriffith$elm_ui$Internal$Flag$none = A2($mdgriffith$elm_ui$Internal$Flag$Field, 0, 0);
11265var $mdgriffith$elm_ui$Internal$Model$renderHeight = function (h) {
11266	switch (h.$) {
11267		case 0:
11268			var px = h.a;
11269			var val = $elm$core$String$fromInt(px);
11270			var name = 'height-px-' + val;
11271			return _Utils_Tuple3(
11272				$mdgriffith$elm_ui$Internal$Flag$none,
11273				$mdgriffith$elm_ui$Internal$Style$classes.dw + (' ' + name),
11274				_List_fromArray(
11275					[
11276						A3($mdgriffith$elm_ui$Internal$Model$Single, name, 'height', val + 'px')
11277					]));
11278		case 1:
11279			return _Utils_Tuple3(
11280				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height

11280Content, $mdgriffith$elm_ui$Internal$Flag$none),
11281				$mdgriffith$elm_ui$Internal$Style$classes.cg,
11282				_List_Nil);
11283		case 2:
11284			var portion = h.a;
11285			return (portion === 1) ? _Utils_Tuple3(
11286				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightFill, $mdgriffith$elm_ui$Internal$Flag$none),
11287				$mdgriffith$elm_ui$Internal$Style$classes.ch,
11288				_List_Nil) : _Utils_Tuple3(
11289				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightFill, $mdgriffith$elm_ui$Internal$Flag$none),
11290				$mdgriffith$elm_ui$Internal$Style$classes.dx + (' height-fill-' + $elm$core$String$fromInt(portion)),
11291				_List_fromArray(
11292					[
11293						A3(
11294						$mdgriffith$elm_ui$Internal$Model$Single,
11295						$mdgriffith$elm_ui$Internal$Style$classes.eQ + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.ao + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot(
11296							'height-fill-' + $elm$core$String$fromInt(portion))))),
11297						'flex-grow',
11298						$elm$core$String$fromInt(portion * 100000))
11299					]));
11300		case 3:
11301			var minSize = h.a;
11302			var len = h.b;
11303			var cls = 'min-height-' + $elm$core$String$fromInt(minSize);
11304			var style = A3(
11305				$mdgriffith$elm_ui$Internal$Model$Single,
11306				cls,
11307				'min-height',
11308				$elm$core$String$fromInt(minSize) + 'px !important');
11309			var _v1 = $mdgriffith$elm_ui$Internal$Model$renderHeight(len);
11310			var newFlag = _v1.a;
11311			var newAttrs = _v1.b;
11312			var newStyle = _v1.c;
11313			return _Utils_Tuple3(
11314				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightBetween, newFlag),
11315				cls + (' ' + newAttrs),
11316				A2($elm$core$List$cons, style, newStyle));
11317		default:
11318			var maxSize = h.a;
11319			var len = h.b;
11320			var cls = 'max-height-' + $elm$core$String$fromInt(maxSize);
11321			var style = A3(
11322				$mdgriffith$elm_ui$Internal$Model$Single,
11323				cls,
11324				'max-height',
11325				$elm$core$String$fromInt(maxSize) + 'px');
11326			var _v2 = $mdgriffith$elm_ui$Internal$Model$renderHeight(len);
11327			var newFlag = _v2.a;
11328			var newAttrs = _v2.b;
11329			var newStyle = _v2.c;
11330			return _Utils_Tuple3(
11331				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightBetween, newFlag),
11332				cls + (' ' + newAttrs),
11333				A2($elm$core$List$cons, style, newStyle));
11334	}
11335};
11336var $mdgriffith$elm_ui$Internal$Flag$widthContent = $mdgriffith$elm_ui$Internal$Flag$flag(38);
11337var $mdgriffith$elm_ui$Internal$Model$renderWidth = function (w) {
11338	switch (w.$) {
11339		case 0:
11340			var px = w.a;
11341			return _Utils_Tuple3(
11342				$mdgriffith$elm_ui$Internal$Flag$none,
11343				$mdgriffith$elm_ui$Internal$Style$classes.ez + (' width-px-' + $elm$core$String$fromInt(px)),
11344				_List_fromArray(
11345					[
11346						A3(
11347						$mdgriffith$elm_ui$Internal$Model$Single,
11348						'width-px-' + $elm$core$String$fromInt(px),
11349						'width',
11350						$elm$core$String$fromInt(px) + 'px')
11351					]));
11352		case 1:
11353			return _Utils_Tuple3(
11354				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthContent, $mdgriffith$elm_ui$Internal$Flag$none),
11355				$mdgriffith$elm_ui$Internal$Style$classes.c0,
11356				_List_Nil);
11357		case 2:
11358			var portion = w.a;
11359			return (portion === 1) ? _Utils_Tuple3(
11360				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthFill, $mdgriffith$elm_ui$Internal$Flag$none),
11361				$mdgriffith$elm_ui$Internal$Style$classes.c1,
11362				_List_Nil) : _Utils_Tuple3(
11363				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthFill, $mdgriffith$elm_ui$Internal$Flag$none),
11364				$mdgriffith$elm_ui$Internal$Style$classes.eA + (' width-fill-' + $elm$core$String$fromInt(portion)),
11365				_List_fromArray(
11366					[
11367						A3(
11368						$mdgriffith$elm_ui$Internal$Model$Single,
11369						$mdgriffith$elm_ui$Internal$Style$classes.eQ + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.ab + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot(
11370							'width-fill-' + $elm$core$String$fromInt(portion))))),
11371						'flex-grow',
11372						$elm$core$String$fromInt(portion * 100000))
11373					]));
11374		case 3:
11375			var minSize = w.a;
11376			var len = w.b;
11377			var cls = 'min-width-' + $elm$core$String$fromInt(minSize);
11378			var style = A3(
11379				$mdgriffith$elm_ui$Internal$Model$Single,
11380				cls,
11381				'min-width',
11382				$elm$core$String$fromInt(minSize) + 'px');
11383			var _v1 = $mdgriffith$elm_ui$Internal$Model$renderWidth(len);
11384			var newFlag = _v1.a;
11385			var newAttrs = _v1.b;
11386			var newStyle = _v1.c;
11387			return _Utils_Tuple3(
11388				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthBetween, newFlag),
11389				cls + (' ' + newAttrs),
11390				A2($elm$core$List$cons, style, newStyle));
11391		default:
11392			var maxSize = w.a;
11393			var len = w.b;
11394			var cls = 'max-width-' + $elm$core$String$fromInt(maxSize);
11395			var style = A3(
11396				$mdgriffith$elm_ui$Internal$Model$Single,
11397				cls,
11398				'max-width',
11399				$elm$core$String$fromInt(maxSize) + 'px');
11400			var _v2 = $mdgriffith$elm_ui$Internal$Model$renderWidth(len);
11401			var newFlag = _v2.a;
11402			var newAttrs = _v2.b;
11403			var newStyle = _v2.c;
11404			return _Utils_Tuple3(
11405				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthBetween, newFlag),
11406				cls + (' ' + newAttrs),
11407				A2($elm$core$List$cons, style, newStyle));
11408	}
11409};
11410var $mdgriffith$elm_ui$Internal$Flag$borderWidth = $mdgriffith$elm_ui$Internal$Flag$flag(27);
11411var $elm$core$Basics$ge = _Utils_ge;
11412var $mdgriffith$elm_ui$Internal$Model$skippable = F2(
11413	function (flag, style) {
11414		if (_Utils_eq(flag, $mdgriffith$elm_ui$Internal$Flag$borderWidth)) {
11415			if (style.$ === 3) {
11416				var val = style.c;
11417				switch (val) {
11418					case '0px':
11419						return true;
11420					case '1px':
11421						return true;
11422					case '2px':
11423						return true;
11424					case '3px':
11425						return true;
11426					case '4px':
11427						return true;
11428					case '5px':
11429						return true;
11430					case '6px':
11431						return true;
11432					default:
11433						return false;

11434				}
11435			} else {
11436				return false;
11437			}
11438		} else {
11439			switch (style.$) {
11440				case 2:
11441					var i = style.a;
11442					return (i >= 8) && (i <= 32);
11443				case 7:
11444					var name = style.a;
11445					var t = style.b;
11446					var r = style.c;
11447					var b = style.d;
11448					var l = style.e;
11449					return _Utils_eq(t, b) && (_Utils_eq(t, r) && (_Utils_eq(t, l) && ((t >= 0) && (t <= 24))));
11450				default:
11451					return false;
11452			}
11453		}
11454	});
11455var $mdgriffith$elm_ui$Internal$Flag$width = $mdgriffith$elm_ui$Internal$Flag$flag(6);
11456var $mdgriffith$elm_ui$Internal$Flag$xAlign = $mdgriffith$elm_ui$Internal$Flag$flag(30);
11457var $mdgriffith$elm_ui$Internal$Flag$yAlign = $mdgriffith$elm_ui$Internal$Flag$flag(29);
11458var $mdgriffith$elm_ui$Internal$Model$gatherAttrRecursive = F8(
11459	function (classes, node, has, transform, styles, attrs, children, elementAttrs) {
11460		gatherAttrRecursive:
11461		while (true) {
11462			if (!elementAttrs.b) {
11463				var _v1 = $mdgriffith$elm_ui$Internal$Model$transformClass(transform);
11464				if (_v1.$ === 1) {
11465					return {
11466						ax: A2(
11467							$elm$core$List$cons,
11468							$elm$html$Html$Attributes$class(classes),
11469							attrs),
11470						aA: children,
11471						aD: has,
11472						aE: node,
11473						gP: styles
11474					};
11475				} else {
11476					var _class = _v1.a;
11477					return {
11478						ax: A2(
11479							$elm$core$List$cons,
11480							$elm$html$Html$Attributes$class(classes + (' ' + _class)),
11481							attrs),
11482						aA: children,
11483						aD: has,
11484						aE: node,
11485						gP: A2(
11486							$elm$core$List$cons,
11487							$mdgriffith$elm_ui$Internal$Model$Transform(transform),
11488							styles)
11489					};
11490				}
11491			} else {
11492				var attribute = elementAttrs.a;
11493				var remaining = elementAttrs.b;
11494				switch (attribute.$) {
11495					case 0:
11496						var $temp$classes = classes,
11497							$temp$node = node,
11498							$temp$has = has,
11499							$temp$transform = transform,
11500							$temp$styles = styles,
11501							$temp$attrs = attrs,
11502							$temp$children = children,
11503							$temp$elementAttrs = remaining;
11504						classes = $temp$classes;
11505						node = $temp$node;
11506						has = $temp$has;
11507						transform = $temp$transform;
11508						styles = $temp$styles;
11509						attrs = $temp$attrs;
11510						children = $temp$children;
11511						elementAttrs = $temp$elementAttrs;
11512						continue gatherAttrRecursive;
11513					case 3:
11514						var flag = attribute.a;
11515						var exactClassName = attribute.b;
11516						if (A2($mdgriffith$elm_ui$Internal$Flag$present, flag, has)) {
11517							var $temp$classes = classes,
11518								$temp$node = node,
11519								$temp$has = has,
11520								$temp$transform = transform,
11521								$temp$styles = styles,
11522								$temp$attrs = attrs,
11523								$temp$children = children,
11524								$temp$elementAttrs = remaining;
11525							classes = $temp$classes;
11526							node = $temp$node;
11527							has = $temp$has;
11528							transform = $temp$transform;
11529							styles = $temp$styles;
11530							attrs = $temp$attrs;
11531							children = $temp$children;
11532							elementAttrs = $temp$elementAttrs;
11533							continue gatherAttrRecursive;
11534						} else {
11535							var $temp$classes = exactClassName + (' ' + classes),
11536								$temp$node = node,
11537								$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has),
11538								$temp$transform = transform,
11539								$temp$styles = styles,
11540								$temp$attrs = attrs,
11541								$temp$children = children,
11542								$temp$elementAttrs = remaining;
11543							classes = $temp$classes;
11544							node = $temp$node;
11545							has = $temp$has;
11546							transform = $temp$transform;
11547							styles = $temp$styles;
11548							attrs = $temp$attrs;
11549							children = $temp$children;
11550							elementAttrs = $temp$elementAttrs;
11551							continue gatherAttrRecursive;
11552						}
11553					case 1:
11554						var actualAttribute = attribute.a;
11555						var $temp$classes = classes,
11556							$temp$node = node,
11557							$temp$has = has,
11558							$temp$transform = transform,
11559							$temp$styles = styles,
11560							$temp$attrs = A2($elm$core$List$cons, actualAttribute, attrs),
11561							$temp$children = children,
11562							$temp$elementAttrs = remaining;
11563						classes = $temp$classes;
11564						node = $temp$node;
11565						has = $temp$has;
11566						transform = $temp$transform;
11567						styles = $temp$styles;
11568						attrs = $temp$attrs;
11569						children = $temp$children;
11570						elementAttrs = $temp$elementAttrs;
11571						continue gatherAttrRecursive;
11572					case 4:
11573						var flag = attribute.a;
11574						var style = attribute.b;
11575						if (A2($mdgriffith$elm_ui$Internal$Flag$present, flag, has)) {
11576							var $temp$classes = classes,
11577								$temp$node = node,
11578								$temp$has = has,
11579								$temp$transform = transform,
11580								$temp$styles = styles,
11581								$temp$attrs = attrs,
11582								$temp$children = children,
11583								$temp$elementAttrs = remaining;
11584							classes = $temp$classes;
11585							node = $temp$node;
11586							has = $temp$has;
11587							transform = $temp$transform;
11588							styles = $temp$styles;
11589							attrs = $temp$attrs;
11590							children = $temp$children;
11591							elementAttrs = $temp$elementAttrs;
11592							continue gatherAttrRecursive;
11593						} else {
11594							if (A2($mdgriffith$elm_ui$Internal$Model$skippable, flag, style)) {
11595								var $temp$classes = $mdgriffith$elm_ui$Internal$Model$getStyleName(style) + (' ' + classes),
11596									$temp$node = node,
11597									$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has),
11598									$temp$transform = transform,
11599									$temp$styles = styles,
11600									$temp$attrs = attrs,
11601									$temp$children = children,
11602									$temp$elementAttrs = remaining;
11603								classes = $temp$classes;
11604								node = $temp$node;
11605								has = $temp$has;
11606								transform = $temp$transform;
11607								styles = $temp$styles;
11608								attrs = $temp$attrs;
11609								children = $temp$children;
11610								elementAttrs = $temp$elementAttrs;
11611								continue gatherAttrRecursive;
11612							} else {
11613								var $temp$classes = $mdgriffith$elm_ui$Internal$Model$getStyleName(style) + (' ' + classes),
11614									$temp$node = node,
11615									$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has),
11616									$temp$transform = transform,
11617									$temp$styles = A2($elm$core$List$cons, style, styles),
11618									$temp$attrs = attrs,
11619									$temp$children = children,
11620									$temp$elementAttrs = remaining;
11621								classes = $temp$classes;
11622								node = $temp$node;
11623								has = $temp$has;
11624								transform = $temp$transform;
11625								styles = $temp$styles;
11626								attrs = $temp$attrs;
11627								children = $temp$children;
11628								elementAttrs = $temp$elementAttrs;
11629								continue gatherAttrRecursive;
11630							}
11631						}
11632					case 10:
11633						var flag = attribute.a;
11634						var component = attribute.b;
11635						var $temp$classes = classes,
11636							$temp$node = node,
11637							$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has),
11638							$temp$transform = A2($mdgriffith$elm_ui$Internal$Model$composeTransformation, transform, component),
11639							$temp$styles = styles,
11640							$temp$attrs = attrs,
11641							$temp$children = children,
11642							$temp$elementAttrs = remaining;
11643						classes = $temp$classes;
11644						node = $temp$node;
11645						has = $temp$has;
11646						transform = $temp$transform;
11647						styles = $temp$styles;
11648						attrs = $temp$attrs;
11649						children = $temp$children;
11650						elementAttrs = $temp$elementAttrs;
11651						continue gatherAttrRecursive;
11652					case 7:
11653						var width = attribute.a;
11654						if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$width, has)) {
11655							var $temp$classes = classes,
11656								$temp$node = node,
11657								$temp$has = has,
11658								$temp$transform = transform,
11659								$temp$styles = styles,
11660								$temp$attrs = attrs,
11661								$temp$children = children,
11662								$temp$elementAttrs = remaining;
11663							classes = $temp$classes;
11664							node = $temp$node;
11665							has = $temp$has;
11666							transform = $temp$transform;
11667							styles = $temp$styles;
11668							attrs = $temp$attrs;
11669							children = $temp$children;
11670							elementAttrs = $temp$elementAttrs;
11671							continue gatherAttrRecursive;
11672						} else {
11673							switch (width.$) {
11674								case 0:
11675									var px = width.a;
11676									var $temp$classes = ($mdgriffith$elm_ui$Internal$Style$classes.ez + (' width-px-' + $elm$core$String$fromInt(px))) + (' ' + classes),
11677										$temp$node = node,
11678										$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has),
11679										$temp$transform = transform,
11680										$temp$styles = A2(
11681										$elm$core$List$cons,
11682										A3(
11683											$mdgriffith$elm_ui$Internal$Model$Single,
11684											'width-px-' + $elm$core$String$fromInt(px),
11685											'width',
11686											$elm$core$String$fromInt(px) + 'px'),
11687										styles),
11688										$temp$attrs = attrs,
11689										$temp$children = children,
11690										$temp$elementAttrs = remaining;
11691									classes = $temp$classes;
11692									node = $temp$node;
11693									has = $temp$has;
11694									transform = $temp$transform;
11695									styles = $temp$styles;
11696									attrs = $temp$attrs;
11697									children = $temp$children;
11698									elementAttrs = $temp$elementAttrs;
11699									continue gatherAttrRecursive;
11700								case 1:
11701									var $temp$classes = classes + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.c0),
11702										$temp$node = node,
11703										$temp$has = A2(
11704										$mdgriffith$elm_ui$Internal$Flag$add,
11705										$mdgriffith$elm_ui$Internal$Flag$widthContent,
11706										A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)),
11707										$temp$transform = transform,
11708										$temp$styles = styles,
11709										$temp$attrs = attrs,
11710										$temp$children = children,
11711										$temp$elementAttrs = remaining;
11712									classes = $temp$classes;
11713									node = $temp$node;
11714									has = $temp$has;
11715									transform = $temp$transform;
11716									styles = $temp$styles;
11717									attrs = $temp$attrs;
11718									children = $temp$children;
11719									elementAttrs = $temp$elementAttrs;
11720									continue gatherAttrRecursive;
11721								case 2:
11722									var portion = width.a;

11723									if (portion === 1) {
11724										var $temp$classes = classes + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.c1),
11725											$temp$node = node,
11726											$temp$has = A2(
11727											$mdgriffith$elm_ui$Internal$Flag$add,
11728											$mdgriffith$elm_ui$Internal$Flag$widthFill,
11729											A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)),
11730											$temp$transform = transform,
11731											$temp$styles = styles,
11732											$temp$attrs = attrs,
11733											$temp$children = children,
11734											$temp$elementAttrs = remaining;
11735										classes = $temp$classes;
11736										node = $temp$node;
11737										has = $temp$has;
11738										transform = $temp$transform;
11739										styles = $temp$styles;
11740										attrs = $temp$attrs;
11741										children = $temp$children;
11742										elementAttrs = $temp$elementAttrs;
11743										continue gatherAttrRecursive;
11744									} else {
11745										var $temp$classes = classes + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.eA + (' width-fill-' + $elm$core$String$fromInt(portion)))),
11746											$temp$node = node,
11747											$temp$has = A2(
11748											$mdgriffith$elm_ui$Internal$Flag$add,
11749											$mdgriffith$elm_ui$Internal$Flag$widthFill,
11750											A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)),
11751											$temp$transform = transform,
11752											$temp$styles = A2(
11753											$elm$core$List$cons,
11754											A3(
11755												$mdgriffith$elm_ui$Internal$Model$Single,
11756												$mdgriffith$elm_ui$Internal$Style$classes.eQ + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.ab + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot(
11757													'width-fill-' + $elm$core$String$fromInt(portion))))),
11758												'flex-grow',
11759												$elm$core$String$fromInt(portion * 100000)),
11760											styles),
11761											$temp$attrs = attrs,
11762											$temp$children = children,
11763											$temp$elementAttrs = remaining;
11764										classes = $temp$classes;
11765										node = $temp$node;
11766										has = $temp$has;
11767										transform = $temp$transform;
11768										styles = $temp$styles;
11769										attrs = $temp$attrs;
11770										children = $temp$children;
11771										elementAttrs = $temp$elementAttrs;
11772										continue gatherAttrRecursive;
11773									}
11774								default:
11775									var _v4 = $mdgriffith$elm_ui$Internal$Model$renderWidth(width);
11776									var addToFlags = _v4.a;
11777									var newClass = _v4.b;
11778									var newStyles = _v4.c;
11779									var $temp$classes = classes + (' ' + newClass),
11780										$temp$node = node,
11781										$temp$has = A2(
11782										$mdgriffith$elm_ui$Internal$Flag$merge,
11783										addToFlags,
11784										A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)),
11785										$temp$transform = transform,
11786										$temp$styles = _Utils_ap(newStyles, styles),
11787										$temp$attrs = attrs,
11788										$temp$children = children,
11789										$temp$elementAttrs = remaining;
11790									classes = $temp$classes;
11791									node = $temp$node;
11792									has = $temp$has;
11793									transform = $temp$transform;
11794									styles = $temp$styles;
11795									attrs = $temp$attrs;
11796									children = $temp$children;
11797									elementAttrs = $temp$elementAttrs;
11798									continue gatherAttrRecursive;
11799							}
11800						}
11801					case 8:
11802						var height = attribute.a;
11803						if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$height, has)) {
11804							var $temp$classes = classes,
11805								$temp$node = node,
11806								$temp$has = has,
11807								$temp$transform = transform,
11808								$temp$styles = styles,
11809								$temp$attrs = attrs,
11810								$temp$children = children,
11811								$temp$elementAttrs = remaining;
11812							classes = $temp$classes;
11813							node = $temp$node;
11814							has = $temp$has;
11815							transform = $temp$transform;
11816							styles = $temp$styles;
11817							attrs = $temp$attrs;
11818							children = $temp$children;
11819							elementAttrs = $temp$elementAttrs;
11820							continue gatherAttrRecursive;
11821						} else {
11822							switch (height.$) {
11823								case 0:
11824									var px = height.a;
11825									var val = $elm$core$String$fromInt(px) + 'px';
11826									var name = 'height-px-' + val;
11827									var $temp$classes = $mdgriffith$elm_ui$Internal$Style$classes.dw + (' ' + (name + (' ' + classes))),
11828										$temp$node = node,
11829										$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has),
11830										$temp$transform = transform,
11831										$temp$styles = A2(
11832										$elm$core$List$cons,
11833										A3($mdgriffith$elm_ui$Internal$Model$Single, name, 'height ', val),
11834										styles),
11835										$temp$attrs = attrs,
11836										$temp$children = children,
11837										$temp$elementAttrs = remaining;
11838									classes = $temp$classes;
11839									node = $temp$node;
11840									has = $temp$has;
11841									transform = $temp$transform;
11842									styles = $temp$styles;
11843									attrs = $temp$attrs;
11844									children = $temp$children;
11845									elementAttrs = $temp$elementAttrs;
11846									continue gatherAttrRecursive;
11847								case 1:
11848									var $temp$classes = $mdgriffith$elm_ui$Internal$Style$classes.cg + (' ' + classes),
11849										$temp$node = node,
11850										$temp$has = A2(
11851										$mdgriffith$elm_ui$Internal$Flag$add,

11852										$mdgriffith$elm_ui$Internal$Flag$heightContent,
11853										A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)),
11854										$temp$transform = transform,
11855										$temp$styles = styles,
11856										$temp$attrs = attrs,
11857										$temp$children = children,
11858										$temp$elementAttrs = remaining;
11859									classes = $temp$classes;
11860									node = $temp$node;
11861									has = $temp$has;
11862									transform = $temp$transform;
11863									styles = $temp$styles;
11864									attrs = $temp$attrs;
11865									children = $temp$children;
11866									elementAttrs = $temp$elementAttrs;
11867									continue gatherAttrRecursive;
11868								case 2:
11869									var portion = height.a;
11870									if (portion === 1) {
11871										var $temp$classes = $mdgriffith$elm_ui$Internal$Style$classes.ch + (' ' + classes),
11872											$temp$node = node,
11873											$temp$has = A2(
11874											$mdgriffith$elm_ui$Internal$Flag$add,
11875											$mdgriffith$elm_ui$Internal$Flag$heightFill,
11876											A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)),
11877											$temp$transform = transform,
11878											$temp$styles = styles,
11879											$temp$attrs = attrs,
11880											$temp$children = children,
11881											$temp$elementAttrs = remaining;
11882										classes = $temp$classes;
11883										node = $temp$node;
11884										has = $temp$has;
11885										transform = $temp$transform;
11886										styles = $temp$styles;
11887										attrs = $temp$attrs;
11888										children = $temp$children;
11889										elementAttrs = $temp$elementAttrs;
11890										continue gatherAttrRecursive;
11891									} else {
11892										var $temp$classes = classes + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.dx + (' height-fill-' + $elm$core$String$fromInt(portion)))),
11893											$temp$node = node,
11894											$temp$has = A2(
11895											$mdgriffith$elm_ui$Internal$Flag$add,
11896											$mdgriffith$elm_ui$Internal$Flag$heightFill,
11897											A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)),
11898											$temp$transform = transform,
11899											$temp$styles = A2(
11900											$elm$core$List$cons,
11901											A3(
11902												$mdgriffith$elm_ui$Internal$Model$Single,
11903												$mdgriffith$elm_ui$Internal$Style$classes.eQ + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.ao + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot(
11904													'height-fill-' + $elm$core$String$fromInt(portion))))),
11905												'flex-grow',
11906												$elm$core$String$fromInt(portion * 100000)),
11907											styles),
11908											$temp$attrs = attrs,
11909											$temp$children = children,
11910											$temp$elementAttrs = remaining;
11911										classes = $temp$classes;
11912										node = $temp$node;
11913										has = $temp$has;
11914										transform = $temp$transform;
11915										styles = $temp$styles;
11916										attrs = $temp$attrs;
11917										children = $temp$children;
11918										elementAttrs = $temp$elementAttrs;
11919										continue gatherAttrRecursive;
11920									}
11921								default:
11922									var _v6 = $mdgriffith$elm_ui$Internal$Model$renderHeight(height);
11923									var addToFlags = _v6.a;
11924									var newClass = _v6.b;
11925									var newStyles = _v6.c;
11926									var $temp$classes = classes + (' ' + newClass),
11927										$temp$node = node,
11928										$temp$has = A2(
11929										$mdgriffith$elm_ui$Internal$Flag$merge,
11930										addToFlags,
11931										A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)),
11932										$temp$transform = transform,
11933										$temp$styles = _Utils_ap(newStyles, styles),
11934										$temp$attrs = attrs,
11935										$temp$children = children,
11936										$temp$elementAttrs = remaining;
11937									classes = $temp$classes;
11938									node = $temp$node;
11939									has = $temp$has;
11940									transform = $temp$transform;
11941									styles = $temp$styles;
11942									attrs = $temp$attrs;
11943									children = $temp$children;
11944									elementAttrs = $temp$elementAttrs;
11945									continue gatherAttrRecursive;
11946							}
11947						}
11948					case 2:
11949						var description = attribute.a;
11950						switch (description.$) {
11951							case 0:
11952								var $temp$classes = classes,
11953									$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'main', node),
11954									$temp$has = has,
11955									$temp$transform = transform,
11956									$temp$styles = styles,
11957									$temp$attrs = attrs,
11958									$temp$children = children,
11959									$temp$elementAttrs = remaining;
11960								classes = $temp$classes;
11961								node = $temp$node;
11962								has = $temp$has;
11963								transform = $temp$transform;
11964								styles = $temp$styles;
11965								attrs = $temp$attrs;
11966								children = $temp$children;
11967								elementAttrs = $temp$elementAttrs;
11968								continue gatherAttrRecursive;
11969							case 1:
11970								var $temp$classes = classes,
11971									$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'nav', node),
11972									$temp$has = has,
11973									$temp$transform = transform,
11974									$temp$styles = styles,
11975									$temp$attrs = attrs,
11976									$temp$children = children,
11977									$temp$elementAttrs = remaining;
11978								classes = $temp$classes;
11979								node = $temp$node;
11980								has = $temp$has;
11981								transform = $temp$transform;
11982								styles = $temp$styles;
11983								attrs = $temp$attrs;
11984								children = $temp$children;
11985								elementAttrs = $temp$elementAttrs;
11986								continue gatherAttrRecursive;
11987							case 2:
11988								var $temp$classes = classes,
11989									$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'footer', node),
11990									$temp$has = has,
11991									$temp$transform = transform,
11992									$temp$styles = styles,
11993									$temp$attrs = attrs,
11994									$temp$children = children,
11995									$temp$elementAttrs = remaining;
11996								classes = $temp$classes;
11997								node = $temp$node;
11998								has = $temp$has;
11999								transform = $temp$transform;
12000								styles = $temp$styles;
12001								attrs = $temp$attrs;
12002								children = $temp$children;
12003								elementAttrs = $temp$elementAttrs;
12004								continue gatherAttrRecursive;
12005							case 3:
12006								var $temp$classes = classes,
12007									$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'aside', node),
12008									$temp$has = has,
12009									$temp$transform = transform,
12010									$temp$styles = styles,
12011									$temp$attrs = attrs,
12012									$temp$children = children,
12013									$temp$elementAttrs = remaining;
12014								classes = $temp$classes;
12015								node = $temp$node;
12016								has = $temp$has;
12017								transform = $temp$transform;
12018								styles = $temp$styles;
12019								attrs = $temp$attrs;
12020								children = $temp$children;
12021								elementAttrs = $temp$elementAttrs;
12022								continue gatherAttrRecursive;
12023							case 4:
12024								var i = description.a;
12025								if (i <= 1) {
12026									var $temp$classes = classes,
12027										$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'h1', node),
12028										$temp$has = has,
12029										$temp$transform = transform,
12030										$temp$styles = styles,
12031										$temp$attrs = attrs,
12032										$temp$children = children,
12033										$temp$elementAttrs = remaining;
12034									classes = $temp$classes;
12035									node = $temp$node;
12036									has = $temp$has;
12037									transform = $temp$transform;
12038									styles = $temp$styles;
12039									attrs = $temp$attrs;
12040									children = $temp$children;
12041									elementAttrs = $temp$elementAttrs;
12042									continue gatherAttrRecursive;
12043								} else {
12044									if (i < 7) {
12045										var $temp$classes = classes,
12046											$temp$node = A2(
12047											$mdgriffith$elm_ui$Internal$Model$addNodeName,
12048											'h' + $elm$core$String$fromInt(i),
12049											node),
12050											$temp$has = has,
12051											$temp$transform = transform,
12052											$temp$styles = styles,
12053											$temp$attrs = attrs,
12054											$temp$children = children,
12055											$temp$elementAttrs = remaining;
12056										classes = $temp$classes;
12057										node = $temp$node;
12058										has = $temp$has;
12059										transform = $temp$transform;
12060										styles = $temp$styles;
12061										attrs = $temp$attrs;
12062										children = $temp$children;
12063										elementAttrs = $temp$elementAttrs;
12064										continue gatherAttrRecursive;
12065									} else {
12066										var $temp$classes = classes,
12067											$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'h6', node),
12068											$temp$has = has,
12069											$temp$transform = transform,
12070											$temp$styles = styles,
12071											$temp$attrs = attrs,
12072											$temp$children = children,
12073											$temp$elementAttrs = remaining;
12074										classes = $temp$classes;
12075										node = $temp$node;
12076										has = $temp$has;
12077										transform = $temp$transform;
12078										styles = $temp$styles;
12079										attrs = $temp$attrs;
12080										children = $temp$children;
12081										elementAttrs = $temp$elementAttrs;
12082										continue gatherAttrRecursive;
12083									}
12084								}
12085							case 9:
12086								var $temp$classes = classes,
12087									$temp$node = node,
12088									$temp$has = has,
12089									$temp$transform = transform,
12090									$temp$styles = styles,
12091									$temp$attrs = attrs,
12092									$temp$children = children,
12093									$temp$elementAttrs = remaining;
12094								classes = $temp$classes;
12095								node = $temp$node;
12096								has = $temp$has;
12097								transform = $temp$transform;
12098								styles = $temp$styles;
12099								attrs = $temp$attrs;
12100								children = $temp$children;
12101								elementAttrs = $temp$elementAttrs;
12102								continue gatherAttrRecursive;
12103							case 8:
12104								var $temp$classes = classes,
12105									$temp$node = node,
12106									$temp$has = has,
12107									$temp$transform = transform,
12108									$temp$styles = styles,
12109									$temp$attrs = A2(
12110									$elm$core$List$cons,
12111									A2($elm$virtual_dom$VirtualDom$attribute, 'role', 'button'),
12112									attrs),
12113									$temp$children = children,
12114									$temp$elementAttrs = remaining;
12115								classes = $temp$classes;
12116								node = $temp$node;
12117								has = $temp$has;
12118								transform = $temp$transform;
12119								styles = $temp$styles;
12120								attrs = $temp$attrs;
12121								children = $temp$children;
12122								elementAttrs = $temp$elementAttrs;
12123								continue gatherAttrRecursive;
12124							case 5:
12125								var label = description.a;
12126								var $temp$classes = classes,
12127									$temp$node = node,
12128									$temp$has = has,
12129									$temp$transform = transform,
12130									$temp$styles = styles,
12131									$temp$attrs = A2(
12132									$elm$core$List$cons,
12133									A2($elm$virtual_dom$VirtualDom$attribute, 'aria-label', label),
12134									attrs),
12135									$temp$children = children,
12136									$temp$elementAttrs = remaining;
12137								classes = $temp$classes;
12138								node = $temp$node;
12139								has = $temp$has;
12140								transform = $temp$transform;
12141								styles = $temp$styles;
12142								attrs = $temp$attrs;
12143								children = $temp$children;
12144								elementAttrs = $temp$elementAttrs;
12145								continue gatherAttrRecursive;
12146							case 6:
12147								var $temp$classes = classes,
12148									$temp$node = node,
12149									$temp$has = has,
12150									$temp$transform = transform,
12151									$temp$styles = styles,
12152									$temp$attrs = A2(
12153									$elm$core$List$cons,
12154									A2($elm$virtual_dom$VirtualDom$attribute, 'aria-live', 'polite'),
12155									attrs),
12156									$temp$children = children,
12157									$temp$elementAttrs = remaining;
12158								classes = $temp$classes;
12159								node = $temp$node;
12160								has = $temp$has;
12161								transform = $temp$transform;
12162								styles = $temp$styles;
12163								attrs = $temp$attrs;
12164								children = $temp$children;
12165								elementAttrs = $temp$elementAttrs;
12166								continue gatherAttrRecursive;
12167							default:
12168								var $temp$classes = classes,
12169									$temp$node = node,
12170									$temp$has = has,
12171									$temp$transform = transform,
12172									$temp$styles = styles,
12173									$temp$attrs = A2(
12174									$elm$core$List$cons,
12175									A2($elm$virtual_dom$VirtualDom$attribute, 'aria-live', 'assertive'),
12176									attrs),
12177									$temp$children = children,
12178									$temp$elementAttrs = remaining;
12179								classes = $temp$classes;
12180								node = $temp$node;
12181								has = $temp$has;
12182								transform = $temp$transform;
12183								styles = $temp$styles;
12184								attrs = $temp$attrs;
12185								children = $temp$children;
12186								elementAttrs = $temp$elementAttrs;
12187								continue gatherAttrRecursive;
12188						}
12189					case 9:
12190						var location = attribute.a;
12191						var elem = attribute.b;
12192						var newStyles = function () {
12193							switch (elem.$) {
12194								case 3:
12195									return styles;
12196								case 2:
12197									var str = elem.a;
12198									return styles;
12199								case 0:
12200									var html = elem.a;
12201									return styles;
12202								default:
12203									var styled = elem.a;
12204									return _Utils_ap(styles, styled.gP);
12205							}
12206						}();
12207						var $temp$classes = classes,
12208							$temp$node = node,
12209							$temp$has = has,
12210							$temp$transform = transform,
12211							$temp$styles = newStyles,
12212							$temp$attrs = attrs,
12213							$temp$children = A3($mdgriffith$elm_ui$Internal$Model$addNearbyElement, location, elem, children),
12214							$temp$elementAttrs = remaining;
12215						classes = $temp$classes;
12216						node = $temp$node;
12217						has = $temp$has;
12218						transform = $temp$transform;
12219						styles = $temp$styles;
12220						attrs = $temp$attrs;
12221						children = $temp$children;
12222						elementAttrs = $temp$elementAttrs;
12223						continue gatherAttrRecursive;
12224					case 6:
12225						var x = attribute.a;
12226						if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$xAlign, has)) {
12227							var $temp$classes = classes,
12228								$temp$node = node,
12229								$temp$has = has,
12230								$temp$transform = transform,
12231								$temp$styles = styles,
12232								$temp$attrs = attrs,
12233								$temp$children = children,
12234								$temp$elementAttrs = remaining;
12235							classes = $temp$classes;
12236							node = $temp$node;
12237							has = $temp$has;
12238							transform = $temp$transform;
12239							styles = $temp$styles;
12240							attrs = $temp$attrs;
12241							children = $temp$children;
12242							elementAttrs = $temp$elementAttrs;
12243							continue gatherAttrRecursive;
12244						} else {
12245							var $temp$classes = $mdgriffith$elm_ui$Internal$Model$alignXName(x) + (' ' + classes),
12246								$temp$node = node,
12247								$temp$has = function (flags) {
12248								switch (x) {
12249									case 1:
12250										return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$centerX, flags);
12251									case 2:
12252										return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$alignRight, flags);
12253									default:
12254										return flags;
12255								}
12256							}(
12257								A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$xAlign, has)),
12258								$temp$transform = transform,
12259								$temp$styles = styles,
12260								$temp$attrs = attrs,
12261								$temp$children = children,
12262								$temp$elementAttrs = remaining;
12263							classes = $temp$classes;
12264							node = $temp$node;
12265							has = $temp$has;
12266							transform = $temp$transform;
12267							styles = $temp$styles;
12268							attrs = $temp$attrs;
12269							children = $temp$children;
12270							elementAttrs = $temp$elementAttrs;
12271							continue gatherAttrRecursive;
12272						}
12273					default:
12274						var y = attribute.a;
12275						if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$yAlign, has)) {
12276							var $temp$classes = classes,
12277								$temp$node = node,
12278								$temp$has = has,
12279								$temp$transform = transform,
12280								$temp$styles = styles,
12281								$temp$attrs = attrs,
12282								$temp$children = children,
12283								$temp$elementAttrs = remaining;
12284							classes = $temp$classes;
12285							node = $temp$node;
12286							has = $temp$has;
12287							transform = $temp$transform;
12288							styles = $temp$styles;
12289							attrs = $temp$attrs;
12290							children = $temp$children;
12291							elementAttrs = $temp$elementAttrs;
12292							continue gatherAttrRecursive;
12293						} else {
12294							var $temp$classes = $mdgriffith$elm_ui$Internal$Model$alignYName(y) + (' ' + classes),
12295								$temp$node = node,
12296								$temp$has = function (flags) {
12297								switch (y) {
12298									case 1:
12299										return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$centerY, flags);
12300									case 2:
12301										return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$alignBottom, flags);
12302									default:
12303										return flags;
12304								}
12305							}(
12306								A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$yAlign, has)),
12307								$temp$transform = transform,
12308								$temp$styles = styles,
12309								$temp$attrs = at

12309trs,
12310								$temp$children = children,
12311								$temp$elementAttrs = remaining;
12312							classes = $temp$classes;
12313							node = $temp$node;
12314							has = $temp$has;
12315							transform = $temp$transform;
12316							styles = $temp$styles;
12317							attrs = $temp$attrs;
12318							children = $temp$children;
12319							elementAttrs = $temp$elementAttrs;
12320							continue gatherAttrRecursive;
12321						}
12322				}
12323			}
12324		}
12325	});
12326var $mdgriffith$elm_ui$Internal$Model$Untransformed = {$: 0};
12327var $mdgriffith$elm_ui$Internal$Model$untransformed = $mdgriffith$elm_ui$Internal$Model$Untransformed;
12328var $mdgriffith$elm_ui$Internal$Model$element = F4(
12329	function (context, node, attributes, children) {
12330		return A3(
12331			$mdgriffith$elm_ui$Internal$Model$createElement,
12332			context,
12333			children,
12334			A8(
12335				$mdgriffith$elm_ui$Internal$Model$gatherAttrRecursive,
12336				$mdgriffith$elm_ui$Internal$Model$contextClasses(context),
12337				node,
12338				$mdgriffith$elm_ui$Internal$Flag$none,
12339				$mdgriffith$elm_ui$Internal$Model$untransformed,
12340				_List_Nil,
12341				_List_Nil,
12342				$mdgriffith$elm_ui$Internal$Model$NoNearbyChildren,
12343				$elm$core$List$reverse(attributes)));
12344	});
12345var $mdgriffith$elm_ui$Internal$Model$Height = function (a) {
12346	return {$: 8, a: a};
12347};
12348var $mdgriffith$elm_ui$Element$height = $mdgriffith$elm_ui$Internal$Model$Height;
12349var $mdgriffith$elm_ui$Internal$Model$Content = {$: 1};
12350var $mdgriffith$elm_ui$Element$shrink = $mdgriffith$elm_ui$Internal$Model$Content;
12351var $mdgriffith$elm_ui$Internal$Model$Width = function (a) {
12352	return {$: 7, a: a};
12353};
12354var $mdgriffith$elm_ui$Element$width = $mdgriffith$elm_ui$Internal$Model$Width;
12355var $mdgriffith$elm_ui$Element$el = F2(
12356	function (attrs, child) {
12357		return A4(
12358			$mdgriffith$elm_ui$Internal$Model$element,
12359			$mdgriffith$elm_ui$Internal$Model$asEl,
12360			$mdgriffith$elm_ui$Internal$Model$div,
12361			A2(
12362				$elm$core$List$cons,
12363				$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink),
12364				A2(
12365					$elm$core$List$cons,
12366					$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink),
12367					attrs)),
12368			$mdgriffith$elm_ui$Internal$Model$Unkeyed(
12369				_List_fromArray(
12370					[child])));
12371	});
12372var $mdgriffith$elm_ui$Internal$Model$Fill = function (a) {
12373	return {$: 2, a: a};
12374};
12375var $mdgriffith$elm_ui$Element$fill = $mdgriffith$elm_ui$Internal$Model$Fill(1);
12376var $elm$html$Html$h3 = _VirtualDom_node('h3');
12377var $elm$html$Html$Attributes$href = function (url) {
12378	return A2(
12379		$elm$html$Html$Attributes$stringProperty,
12380		'href',
12381		_VirtualDom_noJavaScriptUri(url));
12382};
12383var $mdgriffith$elm_ui$Internal$Model$Attr = function (a) {
12384	return {$: 1, a: a};
12385};
12386var $mdgriffith$elm_ui$Element$htmlAttribute = $mdgriffith$elm_ui$Internal$Model$Attr;
12387var $elm$html$Html$Attributes$id = $elm$html$Html$Attributes$stringProperty('id');
12388var $mdgriffith$elm_ui$Internal$Model$InFront = 4;
12389var $mdgriffith$elm_ui$Internal$Model$Nearby = F2(
12390	function (a, b) {
12391		return {$: 9, a: a, b: b};
12392	});
12393var $mdgriffith$elm_ui$Internal$Model$NoAttribute = {$: 0};
12394var $mdgriffith$elm_ui$Element$createNearby = F2(
12395	function (loc, element) {
12396		if (element.$ === 3) {
12397			return $mdgriffith$elm_ui$Internal$Model$NoAttribute;
12398		} else {
12399			return A2($mdgriffith$elm_ui$Internal$Model$Nearby, loc, element);
12400		}
12401	});
12402var $mdgriffith$elm_ui$Element$inFront = function (element) {
12403	return A2($mdgriffith$elm_ui$Element$createNearby, 4, element);
12404};
12405var $mdgriffith$elm_ui$Internal$Model$htmlClass = function (cls) {
12406	return $mdgriffith$elm_ui$Internal$Model$Attr(
12407		$elm$html$Html$Attributes$class(cls));
12408};
12409var $mdgriffith$elm_ui$Internal$Model$OnlyDynamic = F2(
12410	function (a, b) {
12411		return {$: 2, a: a, b: b};
12412	});
12413var $mdgriffith$elm_ui$Internal$Model$StaticRootAndDynamic = F2(
12414	function (a, b) {
12415		return {$: 1, a: a, b: b};
12416	});
12417var $mdgriffith$elm_ui$Internal$Model$AllowHover = 1;
12418var $mdgriffith$elm_ui$Internal$Model$Layout = 0;
12419var $mdgriffith$elm_ui$Internal$Model$focusDefaultStyle = {
12420	eV: $elm$core$Maybe$Nothing,
12421	e1: $elm$core$Maybe$Nothing,
12422	gA: $elm$core$Maybe$Just(
12423		{
12424			e_: 0,
12425			fj: A4($mdgriffith$elm_ui$Internal$Model$Rgba, 155 / 255, 203 / 255, 1, 1),
12426			f9: _Utils_Tuple2(0, 0),
12427			gC: 3
12428		})
12429};
12430var $mdgriffith$elm_ui$Internal$Model$optionsToRecord = function (options) {
12431	var combine = F2(
12432		function (opt, record) {
12433			switch (opt.$) {
12434				case 0:
12435					var hoverable = opt.a;
12436					var _v4 = record.fK;
12437					if (_v4.$ === 1) {
12438						return _Utils_update(
12439							record,
12440							{
12441								fK: $elm$core$Maybe$Just(hoverable)
12442							});
12443					} else {
12444						return record;
12445					}
12446				case 1:
12447					var focusStyle = opt.a;
12448					var _v5 = record.fC;
12449					if (_v5.$ === 1) {
12450						return _Utils_update(
12451							record,
12452							{
12453								fC: $elm$core$Maybe$Just(focusStyle)
12454							});
12455					} else {
12456						return record;
12457					}
12458				default:
12459					var renderMode = opt.a;
12460					var _v6 = record.f5;
12461					if (_v6.$ === 1) {
12462						return _Utils_update(
12463							record,
12464							{
12465								f5: $elm$core$Maybe$Just(renderMode)
12466							});
12467					} else {
12468						return record;
12469					}
12470			}
12471		});
12472	var andFinally = function (record) {
12473		return {
12474			fC: function () {
12475				var _v0 = record.fC;
12476				if (_v0.$ === 1) {
12477					return $mdgriffith$elm_ui$Internal$Model$focusDefaultStyle;
12478				} else {
12479					var focusable = _v0.a;
12480					return focusable;
12481				}
12482			}(),
12483			fK: function () {
12484				var _v1 = record.fK;
12485				if (_v1.$ === 1) {
12486					return 1;
12487				} else {
12488					var hoverable = _v1.a;
12489					return hoverable;
12490				}
12491			}(),
12492			f5: function () {
12493				var _v2 = record.f5;
12494				if (_v2.$ === 1) {
12495					return 0;
12496				} else {
12497					var actualMode = _v2.a;
12498					return actualMode;
12499				}
12500			}()
12501		};
12502	};
12503	return andFinally(
12504		A3(
12505			$elm$core$List$foldr,
12506			combine,
12507			{fC: $elm$core$Maybe$Nothing, fK: $elm$core$Maybe$Nothing, f5: $elm$core$Maybe$Nothing},
12508			options));
12509};
12510var $mdgriffith$elm_ui$Internal$Model$toHtml = F2(
12511	function (mode, el) {
12512		switch (el.$) {
12513			case 0:
12514				var html = el.a;
12515				return html($mdgriffith$elm_ui$Internal$Model$asEl);
12516			case 1:
12517				var styles = el.a.gP;
12518				var html = el.a.fL;
12519				return A2(
12520					html,
12521					mode(styles),
12522					$mdgriffith$elm_ui$Internal$Model$asEl);
12523			case 2:
12524				var text = el.a;
12525				return $mdgriffith$elm_ui$Internal$Model$textElement(text);
12526			default:
12527				return $mdgriffith$elm_ui$Internal$Model$textElement('');
12528		}
12529	});
12530var $mdgriffith$elm_ui$Internal$Model$renderRoot = F3(
12531	function (optionList, attributes, child) {
12532		var options = $mdgriffith$elm_ui$Internal$Model$optionsToRecord(optionList);
12533		var embedStyle = function () {
12534			var _v0 = options.f5;
12535			if (_v0 === 1) {
12536				return $mdgriffith$elm_ui$Internal$Model$OnlyDynamic(options);
12537			} else {
12538				return $mdgriffith$elm_ui$Internal$Model$StaticRootAndDynamic(options);
12539			}
12540		}();
12541		return A2(
12542			$mdgriffith$elm_ui$Internal$Model$toHtml,
12543			embedStyle,
12544			A4(
12545				$mdgriffith$elm_ui$Internal$Model$element,
12546				$mdgriffith$elm_ui$Internal$Model$asEl,
12547				$mdgriffith$elm_ui$Internal$Model$div,
12548				attributes,
12549				$mdgriffith$elm_ui$Internal$Model$Unkeyed(
12550					_List_fromArray(
12551						[child]))));
12552	});
12553var $mdgriffith$elm_ui$Internal$Model$FontFamily = F2(
12554	function (a, b) {
12555		return {$: 1, a: a, b: b};
12556	});
12557var $mdgriffith$elm_ui$Internal$Model$FontSize = function (a) {
12558	return {$: 2, a: a};
12559};
12560var $mdgriffith$elm_ui$Internal$Model$SansSerif = {$: 1};
12561var $mdgriffith$elm_ui$Internal$Model$Typeface = function (a) {
12562	return {$: 3, a: a};
12563};
12564var $mdgriffith$elm_ui$Internal$Flag$fontColor = $mdgriffith$elm_ui$Internal$Flag$flag(14);
12565var $mdgriffith$elm_ui$Internal$Flag$fontFamily = $mdgriffith$elm_ui$Internal$Flag$flag(5);
12566var $mdgriffith$elm_ui$Internal$Flag$fontSize = $mdgriffith$elm_ui$Internal$Flag$flag(4);
12567var $elm$core$String$words = _String_words;
12568var $mdgriffith$elm_ui$Internal$Model$renderFontClassName = F2(
12569	function (font, current) {
12570		return _Utils_ap(
12571			current,
12572			function () {
12573				switch (font.$) {
12574					case 0:
12575						return 'serif';
12576					case 1:
12577						return 'sans-serif';
12578					case 2:
12579						return 'monospace';
12580					case 3:
12581						var name = font.a;
12582						return A2(
12583							$elm$core$String$join,
12584							'-',
12585							$elm$core$String$words(
12586								$elm$core$String$toLower(name)));
12587					case 4:
12588						var name = font.a;
12589						var url = font.b;
12590						return A2(
12591							$elm$core$String$join,
12592							'-',
12593							$elm$core$String$words(
12594								$elm$core$String$toLower(name)));
12595					default:
12596						var name = font.a.d_;
12597						return A2(
12598							$elm$core$String$join,
12599							'-',
12600							$elm$core$String$words(
12601								$elm$core$String$toLower(name)));
12602				}
12603			}());
12604	});
12605var $mdgriffith$elm_ui$Internal$Model$rootStyle = function () {
12606	var families = _List_fromArray(
12607		[
12608			$mdgriffith$elm_ui$Internal$Model$Typeface('Open Sans'),
12609			$mdgriffith$elm_ui$Internal$Model$Typeface('Helvetica'),
12610			$mdgriffith$elm_ui$Internal$Model$Typeface('Verdana'),
12611			$mdgriffith$elm_ui$Internal$Model$SansSerif
12612		]);
12613	return _List_fromArray(
12614		[
12615			A2(
12616			$mdgriffith$elm_ui$Internal$Model$StyleClass,
12617			$mdgriffith$elm_ui$Internal$Flag$bgColor,
12618			A3(
12619				$mdgriffith$elm_ui$Internal$Model$Colored,
12620				'bg-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(
12621					A4($mdgriffith$elm_ui$Internal$Model$Rgba, 1, 1, 1, 0)),
12622				'background-color',
12623				A4($mdgriffith$elm_ui$Internal$Model$Rgba, 1, 1, 1, 0))),
12624			A2(
12625			$mdgriffith$elm_ui$Internal$Model$StyleClass,
12626			$mdgriffith$elm_ui$Internal$Flag$fontColor,
12627			A3(
12628				$mdgriffith$elm_ui$Internal$Model$Colored,
12629				'fc-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(
12630					A4($mdgriffith$elm_ui$Internal$Model$Rgba, 0, 0, 0, 1)),
12631				'color',
12632				A4($mdgriffith$elm_ui$Internal$Model$Rgba, 0, 0, 0, 1))),
12633			A2(
12634			$mdgriffith$elm_ui$Internal$Model$StyleClass,
12635			$mdgriffith$elm_ui$Internal$Flag$fontSize,
12636			$mdgriffith$elm_ui$Internal$Model$FontSize(20)),
12637			A2(
12638			$mdgriffith$elm_ui$Internal$Model$StyleClass,
12639			$mdgriffith$elm_ui$Internal$Flag$fontFamily,
12640			A2(
12641				$mdgriffith$elm_ui$Internal$Model$FontFamily,
12642				A3($elm$core$List$foldl, $mdgriffith$elm_ui$Internal$Model$renderFontClassName, 'font-', families),
12643				families))
12644		]);
12645}();
12646var $mdgriffith$elm_ui$Element$layoutWith = F3(
12647	function (_v0, attrs, child) {
12648		var options = _v0.d2;
12649		return A3(
12650			$mdgriffith$elm_ui$Internal$Model$renderRoot,
12651			options,
12652			A2(
12653				$elm$core$List$cons,
12654				$mdgriffith$elm_ui$Internal$Model$htmlClass(
12655					A2(
12656						$elm$core$String$join,
12657						' ',
12658						_List_fromArray(
12659							[$mdgriffith$elm_ui$Internal$Style$classes.gr, $mdgriffith$elm_ui$Internal$Style$classes.eQ, $mdgriffith$elm_ui$Internal$Style$classes.gB]))),
12660				_Utils_ap($mdgriffith$elm_ui$Internal$Model$rootStyle, attrs)),
12661			child);
12662	});
12663var $mdgriffith$elm_ui$Element$layout = $mdgriffith$elm_ui$Element$layoutWith(
12664	{d2: _List_Nil});
12665var $mdgriffith$elm_ui$Internal$Model$Empty = {$: 3};
12666var $mdgriffith$elm_ui$Element$none = $mdgriffith$elm_ui$Internal$Model$Empty;
12667var $elm$core$Basics$composeL = F3(
12668	function (g, f, x) {
12669		return g(
12670			f(x));
12671	});
12672var $elm$virtual_dom$VirtualDom$Normal = function (a) {
12673	return {$: 0, a: a};
12674};
12675var $elm$virtual_dom$VirtualDom$on = _VirtualDom_on;
12676var $elm$html$Html$Events$on = F2(
12677	function (event, decoder) {
12678		return A2(
12679			$elm$virtual_dom$VirtualDom$on,
12680			event,
12681			$elm$virtual_dom$VirtualDom$Normal(decoder));
12682	});
12683var $elm$html$Html$Events$onClick = function (msg) {
12684	return A2(
12685		$elm$html$Html$Events$on,
12686		'click',
12687		$elm$json$Json$Decode$succeed(msg));
12688};
12689var $mdgriffith$elm_ui$Element$Events$onClick = A2($elm$core$Basics$composeL, $mdgriffith$elm_ui$Internal$Model$Attr, $elm$html$Html$Events$onClick);
12690var $mdgriffith$elm_ui$Element$rgba = $mdgriffith$elm_ui$Internal$Model$Rgba;
12691var $mdgriffith$elm_ui$Element$Font$size = function (i) {
12692	return A2(
12693		$mdgriffith$elm_ui$Internal$Model$StyleClass,
12694		$mdgriffith$elm_ui$Internal$Flag$fontSize,
12695		$mdgriffith$elm_ui$Internal$Model$FontSize(i));
12696};
12697var $author$project$Main$InternalLinkClicked = function (a) {
12698	return {$: 1, a: a};
12699};
12700var $mdgriffith$elm_ui$Internal$Flag$borderColor = $mdgriffith$elm_ui$Internal$Flag$flag(28);
12701var $mdgriffith$elm_ui$Element$Border$color = function (clr) {
12702	return A2(
12703		$mdgriffith$elm_ui$Internal$Model$StyleClass,
12704		$mdgriffith$elm_ui$Internal$Flag$borderColor,
12705		A3(
12706			$mdgriffith$elm_ui$Internal$Model$Colored,
12707			'bc-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(clr),
12708			'border-color',
12709			clr));
12710};
12711var $mdgriffith$elm_ui$Internal$Model$Min = F2(
12712	function (a, b) {
12713		return {$: 3, a: a, b: b};
12714	});
12715var $mdgriffith$elm_ui$Element$minimum = F2(
12716	function (i, l) {
12717		return A2($mdgriffith$elm_ui$Internal$Model$Min, i, l);
12718	});
12719var $mdgriffith$elm_ui$Internal$Model$Hover = 1;
12720var $mdgriffith$elm_ui$Internal$Model$PseudoSelector = F2(
12721	function (a, b) {
12722		return {$: 11, a: a, b: b};
12723	});
12724var $mdgriffith$elm_ui$Internal$Flag$hover = $mdgriffith$elm_ui$Internal$Flag$flag(33);
12725var $mdgriffith$elm_ui$Internal$Model$AlignX = function (a) {
12726	return {$: 6, a: a};
12727};
12728var $mdgriffith$elm_ui$Internal$Model$AlignY = function (a) {
12729	return {$: 5, a: a};
12730};
12731var $mdgriffith$elm_ui$Internal$Model$Class = F2(
12732	function (a, b) {
12733		return {$: 3, a: a, b: b};
12734	});
12735var $mdgriffith$elm_ui$Internal$Model$Describe = function (a) {
12736	return {$: 2, a: a};
12737};
12738var $mdgriffith$elm_ui$Internal$Model$TransformComponent = F2(
12739	function (a, b) {
12740		return {$: 10, a: a, b: b};
12741	});
12742var $mdgriffith$elm_ui$Internal$Model$Text = function (a) {
12743	return {$: 2, a: a};
12744};
12745var $elm$virtual_dom$VirtualDom$map = _VirtualDom_map;
12746var $mdgriffith$elm_ui$Internal$Model$map = F2(
12747	function (fn, el) {
12748		switch (el.$) {
12749			case 1:
12750				var styled = el.a;
12751				return $mdgriffith$elm_ui$Internal$Model$Styled(
12752					{
12753						fL: F2(
12754							function (add, context) {
12755								return A2(
12756									$elm$virtual_dom$VirtualDom$map,
12757									fn,
12758									A2(styled.fL, add, context));
12759							}),
12760						gP: styled.gP
12761					});
12762			case 0:
12763				var html = el.a;
12764				return $mdgriffith$elm_ui$Internal$Model$Unstyled(
12765					A2(
12766						$elm$core$Basics$composeL,
12767						$elm$virtual_dom$VirtualDom$map(fn),
12768						html));
12769			case 2:
12770				var str = el.a;
12771				return $mdgriffith$elm_ui$Internal$Model$Text(str);
12772			default:
12773				return $mdgriffith$elm_ui$Internal$Model$Empty;
12774		}
12775	});
12776var $elm$virtual_dom$VirtualDom$mapAttribute = _VirtualDom_mapAttribute;
12777var $mdgriffith$elm_ui$Internal$Model$mapAttrFromStyle = F2(
12778	function (fn, attr) {
12779		switch (attr.$) {
12780			case 0:
12781				return $mdgriffith$elm_ui$Internal$Model$NoAttribute;
12782			case 2:
12783				var description = attr.a;
12784				return $mdgriffith$elm_ui$Internal$Model$Describe(description);
12785			case 6:
12786				var x = attr.a;
12787				return $mdgriffith$elm_ui$Internal$Model$AlignX(x);
12788			case 5:
12789				var y = attr.a;
12790				return $mdgriffith$elm_ui$Internal$Model$AlignY(y);
12791			case 7:
12792				var x = attr.a;
12793				return $mdgriffith$elm_ui$Internal$Model$Width(x);
12794			case 8:
12795				var x = attr.a;
12796				return $mdgriffith$elm_ui$Internal$Model$Height(x);
12797			case 3:
12798				var x = attr.a;
12799				var y = attr.b;
12800				return A2($mdgriffith$elm_ui$Internal$Model$Class, x, y);
12801			case 4:
12802				var flag = attr.a;
12803				var style = attr.b;
12804				return A2($mdgriffith$elm_ui$Internal$Model$StyleClass, flag, style);
12805			case 9:
12806				var location = attr.a;
12807				var elem = attr.b;
12808				return A2(
12809					$mdgriffith$elm_ui$Internal$Model$Nearby,
12810					location,
12811					A2($mdgriffith$elm_ui$Internal$Model$map, fn, elem));
12812			case 1:
12813				var htmlAttr = attr.a;
12814				return $mdgriffith$elm_ui$Internal$Model$Attr(
12815					A2($elm$virtual_dom$VirtualDom$mapAttribute, fn, htmlAttr));
12816			default:
12817				var fl = attr.a;
12818				var trans = attr.b;
12819				return A2($mdgriffith$elm_ui$Internal$Model$TransformComponent, fl, trans);
12820		}
12821	});
12822var $mdgriffith$elm_ui$Internal$Model$removeNever = function (style) {
12823	return A2($mdgriffith$elm_ui$Internal$Model$mapAttrFromStyle, $elm$core$Basics$never, style);
12824};
12825var $mdgriffith$elm_ui$Internal$Model$unwrapDecsHelper = F2(
12826	function (attr, _v0) {
12827		var styles = _v0.a;
12828		var trans = _v0.b;
12829		var _v1 = $mdgriffith$elm_ui$Internal$Model$removeNever(attr);
12830		switch (_v1.$) {
12831			case 4:
12832				var style = _v1.b;
12833				return _Utils_Tuple2(
12834					A2($elm$core$List$cons, style, styles),
12835					trans);
12836			case 10:
12837				var flag = _v1.a;
12838				var component = _v1.b;
12839				return _Utils_Tuple2(
12840					styles,
12841					A2($mdgriffith$elm_ui$Internal$Model$composeTransformation, trans, component));
12842			default:
12843				return _Utils_Tuple2(styles, trans);
12844		}
12845	});
12846var $mdgriffith$elm_ui$Intern

12846al$Model$unwrapDecorations = function (attrs) {
12847	var _v0 = A3(
12848		$elm$core$List$foldl,
12849		$mdgriffith$elm_ui$Internal$Model$unwrapDecsHelper,
12850		_Utils_Tuple2(_List_Nil, $mdgriffith$elm_ui$Internal$Model$Untransformed),
12851		attrs);
12852	var styles = _v0.a;
12853	var transform = _v0.b;
12854	return A2(
12855		$elm$core$List$cons,
12856		$mdgriffith$elm_ui$Internal$Model$Transform(transform),
12857		styles);
12858};
12859var $mdgriffith$elm_ui$Element$mouseOver = function (decs) {
12860	return A2(
12861		$mdgriffith$elm_ui$Internal$Model$StyleClass,
12862		$mdgriffith$elm_ui$Internal$Flag$hover,
12863		A2(
12864			$mdgriffith$elm_ui$Internal$Model$PseudoSelector,
12865			1,
12866			$mdgriffith$elm_ui$Internal$Model$unwrapDecorations(decs)));
12867};
12868var $mdgriffith$elm_ui$Internal$Model$MoveY = function (a) {
12869	return {$: 1, a: a};
12870};
12871var $mdgriffith$elm_ui$Internal$Flag$moveY = $mdgriffith$elm_ui$Internal$Flag$flag(26);
12872var $mdgriffith$elm_ui$Element$moveUp = function (y) {
12873	return A2(
12874		$mdgriffith$elm_ui$Internal$Model$TransformComponent,
12875		$mdgriffith$elm_ui$Internal$Flag$moveY,
12876		$mdgriffith$elm_ui$Internal$Model$MoveY(-y));
12877};
12878var $mdgriffith$elm_ui$Internal$Model$boxShadowClass = function (shadow) {
12879	return $elm$core$String$concat(
12880		_List_fromArray(
12881			[
12882				shadow.dA ? 'box-inset' : 'box-',
12883				$mdgriffith$elm_ui$Internal$Model$floatClass(shadow.f9.a) + 'px',
12884				$mdgriffith$elm_ui$Internal$Model$floatClass(shadow.f9.b) + 'px',
12885				$mdgriffith$elm_ui$Internal$Model$floatClass(shadow.e_) + 'px',
12886				$mdgriffith$elm_ui$Internal$Model$floatClass(shadow.gC) + 'px',
12887				$mdgriffith$elm_ui$Internal$Model$formatColorClass(shadow.fj)
12888			]));
12889};
12890var $mdgriffith$elm_ui$Internal$Flag$shadows = $mdgriffith$elm_ui$Internal$Flag$flag(19);
12891var $mdgriffith$elm_ui$Element$Border$shadow = function (almostShade) {
12892	var shade = {e_: almostShade.e_, fj: almostShade.fj, dA: false, f9: almostShade.f9, gC: almostShade.gC};
12893	return A2(
12894		$mdgriffith$elm_ui$Internal$Model$StyleClass,
12895		$mdgriffith$elm_ui$Internal$Flag$shadows,
12896		A3(
12897			$mdgriffith$elm_ui$Internal$Model$Single,
12898			$mdgriffith$elm_ui$Internal$Model$boxShadowClass(shade),
12899			'box-shadow',
12900			$mdgriffith$elm_ui$Internal$Model$formatBoxShadow(shade)));
12901};
12902var $mdgriffith$elm_ui$Internal$Model$Bottom = 2;
12903var $mdgriffith$elm_ui$Element$alignBottom = $mdgriffith$elm_ui$Internal$Model$AlignY(2);
12904var $mdgriffith$elm_ui$Internal$Flag$fontWeight = $mdgriffith$elm_ui$Internal$Flag$flag(13);
12905var $mdgriffith$elm_ui$Element$Font$bold = A2($mdgriffith$elm_ui$Internal$Model$Class, $mdgriffith$elm_ui$Internal$Flag$fontWeight, $mdgriffith$elm_ui$Internal$Style$classes.e0);
12906var $mdgriffith$elm_ui$Internal$Flag$fontAlignment = $mdgriffith$elm_ui$Internal$Flag$flag(12);
12907var $mdgriffith$elm_ui$Element$Font$center = A2($mdgriffith$elm_ui$Internal$Model$Class, $mdgriffith$elm_ui$Internal$Flag$fontAlignment, $mdgriffith$elm_ui$Internal$Style$classes.gS);
12908var $mdgriffith$elm_ui$Element$Font$color = function (fontColor) {
12909	return A2(
12910		$mdgriffith$elm_ui$Internal$Model$StyleClass,
12911		$mdgriffith$elm_ui$Internal$Flag$fontColor,
12912		A3(
12913			$mdgriffith$elm_ui$Internal$Model$Colored,
12914			'fc-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(fontColor),
12915			'color',
12916			fontColor));
12917};
12918var $mdgriffith$elm_ui$Internal$Model$AsColumn = 1;
12919var $mdgriffith$elm_ui$Internal$Model$asColumn = 1;
12920var $mdgriffith$elm_ui$Element$column = F2(
12921	function (attrs, children) {
12922		return A4(
12923			$mdgriffith$elm_ui$Internal$Model$element,
12924			$mdgriffith$elm_ui$Internal$Model$asColumn,
12925			$mdgriffith$elm_ui$Internal$Model$div,
12926			A2(
12927				$elm$core$List$cons,
12928				$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.fk + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.a6)),
12929				A2(
12930					$elm$core$List$cons,
12931					$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink),
12932					A2(
12933						$elm$core$List$cons,
12934						$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink),
12935						attrs))),
12936			$mdgriffith$elm_ui$Internal$Model$Unkeyed(children));
12937	});
12938var $mdgriffith$elm_ui$Internal$Flag$bgGradient = $mdgriffith$elm_ui$Internal$Flag$flag(10);

12939var $mdgriffith$elm_ui$Element$Background$gradient = function (_v0) {
12940	var angle = _v0.eP;
12941	var steps = _v0.gN;
12942	if (!steps.b) {
12943		return $mdgriffith$elm_ui$Internal$Model$NoAttribute;
12944	} else {
12945		if (!steps.b.b) {
12946			var clr = steps.a;
12947			return A2(
12948				$mdgriffith$elm_ui$Internal$Model$StyleClass,
12949				$mdgriffith$elm_ui$Internal$Flag$bgColor,
12950				A3(
12951					$mdgriffith$elm_ui$Internal$Model$Colored,
12952					'bg-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(clr),
12953					'background-color',
12954					clr));
12955		} else {
12956			return A2(
12957				$mdgriffith$elm_ui$Internal$Model$StyleClass,
12958				$mdgriffith$elm_ui$Internal$Flag$bgGradient,
12959				A3(
12960					$mdgriffith$elm_ui$Internal$Model$Single,
12961					'bg-grad-' + A2(
12962						$elm$core$String$join,
12963						'-',
12964						A2(
12965							$elm$core$List$cons,
12966							$mdgriffith$elm_ui$Internal$Model$floatClass(angle),
12967							A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$formatColorClass, steps))),
12968					'background-image',
12969					'linear-gradient(' + (A2(
12970						$elm$core$String$join,
12971						', ',
12972						A2(
12973							$elm$core$List$cons,
12974							$elm$core$String$fromFloat(angle) + 'rad',
12975							A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$formatColor, steps))) + ')')));
12976		}
12977	}
12978};
12979var $elm$virtual_dom$VirtualDom$style = _VirtualDom_style;
12980var $mdgriffith$elm_ui$Element$Background$image = function (src) {
12981	return $mdgriffith$elm_ui$Internal$Model$Attr(
12982		A2($elm$virtual_dom$VirtualDom$style, 'background', 'url(\"' + (src + '\") center / cover no-repeat')));
12983};
12984var $author$project$Projects$Project$imagesLocation = '/lucamug/images/';
12985var $mdgriffith$elm_ui$Internal$Model$PaddingStyle = F5(
12986	function (a, b, c, d, e) {
12987		return {$: 7, a: a, b: b, c: c, d: d, e: e};
12988	});
12989var $mdgriffith$elm_ui$Internal$Flag$padding = $mdgriffith$elm_ui$Internal$Flag$flag(2);
12990var $mdgriffith$elm_ui$Element$padding = function (x) {
12991	var f = x;
12992	return A2(
12993		$mdgriffith$elm_ui$Internal$Model$StyleClass,
12994		$mdgriffith$elm_ui$Internal$Flag$padding,
12995		A5(
12996			$mdgriffith$elm_ui$Internal$Model$PaddingStyle,
12997			'p-' + $elm$core$String$fromInt(x),
12998			f,
12999			f,
13000			f,
13001			f));
13002};
13003var $mdgriffith$elm_ui$Internal$Model$Paragraph = {$: 9};
13004var $mdgriffith$elm_ui$Internal$Model$SpacingStyle = F3(
13005	function (a, b, c) {
13006		return {$: 5, a: a, b: b, c: c};
13007	});
13008var $mdgriffith$elm_ui$Internal$Flag$spacing = $mdgriffith$elm_ui$Internal$Flag$flag(3);
13009var $mdgriffith$elm_ui$Internal$Model$spacingName = F2(
13010	function (x, y) {
13011		return 'spacing-' + ($elm$core$String$fromInt(x) + ('-' + $elm$core$String$fromInt(y)));
13012	});
13013var $mdgriffith$elm_ui$Element$spacing = function (x) {
13014	return A2(
13015		$mdgriffith$elm_ui$Internal$Model$StyleClass,
13016		$mdgriffith$elm_ui$Internal$Flag$spacing,
13017		A3(
13018			$mdgriffith$elm_ui$Internal$Model$SpacingStyle,
13019			A2($mdgriffith$elm_ui$Internal$Model$spacingName, x, x),
13020			x,
13021			x));
13022};
13023var $mdgriffith$elm_ui$Element$paragraph = F2(
13024	function (attrs, children) {
13025		return A4(
13026			$mdgriffith$elm_ui$Internal$Model$element,
13027			$mdgriffith$elm_ui$Internal$Model$asParagraph,
13028			$mdgriffith$elm_ui$Internal$Model$div,
13029			A2(
13030				$elm$core$List$cons,
13031				$mdgriffith$elm_ui$Internal$Model$Describe($mdgriffith$elm_ui$Internal$Model$Paragraph),
13032				A2(
13033					$elm$core$List$cons,
13034					$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
13035					A2(
13036						$elm$core$List$cons,
13037						$mdgriffith$elm_ui$Element$spacing(5),
13038						attrs))),
13039			$mdgriffith$elm_ui$Internal$Model$Unkeyed(children));
13040	});
13041var $mdgriffith$elm_ui$Element$text = function (content) {
13042	return $mdgriffith$elm_ui$Internal$Model$Text(content);
13043};
13044var $author$project$Projects$Project$viewCard = function (project) {
13045	return A2(
13046		$mdgriffith$elm_ui$Element$el,
13047		_Utils_ap(
13048			_List_fromArray(
13049				[
13050					$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill)
13051				]),
13052			$elm$core$String$isEmpty(project.a) ? _List_Nil : _List_fromArray(
13053				[
13054					$mdgriffith$elm_ui$Element$Background$image(
13055					_Utils_ap($author$project$Projects$Project$imagesLocation, project.a))
13056				])),
13057		A2(
13058			$mdgriffith$elm_ui$Element$column,
13059			_List_fromArray(
13060				[
13061					$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
13062					$mdgriffith$elm_ui$Element$height(
13063					A2($mdgriffith$elm_ui$Element$minimum, 150, $mdgriffith$elm_ui$Element$fill)),

13064					$mdgriffith$elm_ui$Element$Background$gradient(
13065					{
13066						eP: 0,
13067						gN: _List_fromArray(
13068							[
13069								A4($mdgriffith$elm_ui$Element$rgba, 0, 0, 0, 0.5),
13070								A4($mdgriffith$elm_ui$Element$rgba, 0, 0, 0, 0)
13071							])
13072					})
13073				]),
13074			_List_fromArray(
13075				[
13076					A2(
13077					$mdgriffith$elm_ui$Element$paragraph,
13078					_List_fromArray(
13079						[
13080							$mdgriffith$elm_ui$Element$padding(15),
13081							$mdgriffith$elm_ui$Element$Font$center,
13082							$mdgriffith$elm_ui$Element$Font$bold,
13083							$mdgriffith$elm_ui$Element$Font$size(20),
13084							$mdgriffith$elm_ui$Element$Font$color(
13085							A3($mdgriffith$elm_ui$Element$rgb, 1, 1, 1)),
13086							$mdgriffith$elm_ui$Element$alignBottom
13087						]),
13088					_List_fromArray(
13089						[
13090							$mdgriffith$elm_ui$Element$text(project.g5)
13091						]))
13092				])));
13093};
13094var $author$project$Projects$Project$cardWrapper = F4(
13095	function (linkInternal, index, item, url) {
13096		return A2(
13097			$mdgriffith$elm_ui$Element$el,
13098			_List_fromArray(
13099				[
13100					$mdgriffith$elm_ui$Element$width(
13101					A2($mdgriffith$elm_ui$Element$minimum, 250, $mdgriffith$elm_ui$Element$fill)),
13102					$mdgriffith$elm_ui$Element$htmlAttribute(
13103					$elm$html$Html$Attributes$class('card')),
13104					$mdgriffith$elm_ui$Element$mouseOver(
13105					_List_fromArray(
13106						[
13107							$mdgriffith$elm_ui$Element$Border$shadow(
13108							{
13109								e_: 10,
13110								fj: A4($mdgriffith$elm_ui$Element$rgba, 0, 0, 0, 0.1),
13111								f9: _Utils_Tuple2(0, 20),
13112								gC: 5
13113							}),
13114							$mdgriffith$elm_ui$Element$Border$color(
13115							A4($mdgriffith$elm_ui$Element$rgba, 0, 0, 0, 0.1)),
13116							$mdgriffith$elm_ui$Element$Background$color(
13117							A3($mdgriffith$elm_ui$Element$rgb, 0.3, 0.5, 0.3)),
13118							$mdgriffith$elm_ui$Element$moveUp(10)
13119						]))
13120				]),
13121			A2(
13122				linkInternal,
13123				_List_fromArray(
13124					[
13125						$mdgriffith$elm_ui$Element$Background$color(
13126						A4($mdgriffith$elm_ui$Element$rgba, 0, 0, 0, 0.0)),
13127						$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$fill),
13128						$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill)
13129					]),
13130				{
13131					cn: $author$project$Projects$Project$viewCard(item),
13132					bT: url
13133				}));
13134	});
13135var $author$project$Main$css = '\nbody.modal-open {\n    height: 100vh;\n    overflow-y: hidden;\n}\n\n.card {\n    transition: 1s;\n    letter-spacing: 0.5px;\n}\n\n.card:hover {\n    transition: 0.1s;\n}\n\n.skip-link {\n  position: absolute;\n  top: -40px;\n  left: 0;\n  background: #000000;\n  color: white;\n  padding: 8px;\n  z-index: 100;\n}\n\n.skip-link:focus {\n  top: 0;\n}';
13136var $elm$core$Basics$always = F2(
13137	function (a, _v0) {
13138		return a;
13139	});
13140var $mdgriffith$elm_ui$Internal$Model$unstyled = A2($elm$core$Basics$composeL, $mdgriffith$elm_ui$Internal$Model$Unstyled, $elm$core$Basics$always);
13141var $mdgriffith$elm_ui$Element$html = $mdgriffith$elm_ui$Internal$Model$unstyled;
13142var $elm$html$Html$Attributes$rel = _VirtualDom_attribute('rel');
13143var $mdgriffith$elm_ui$Element$link = F2(
13144	function (attrs, _v0) {
13145		var url = _v0.bT;
13146		var label = _v0.cn;
13147		return A4(
13148			$mdgriffith$elm_ui$Internal$Model$element,
13149			$mdgriffith$elm_ui$Internal$Model$asEl,
13150			$mdgriffith$elm_ui$Internal$Model$NodeName('a'),
13151			A2(
13152				$elm$core$List$cons,
13153				$mdgriffith$elm_ui$Internal$Model$Attr(
13154					$elm$html$Html$Attributes$href(url)),
13155				A2(
13156					$elm$core$List$cons,
13157					$mdgriffith$elm_ui$Internal$Model$Attr(
13158						$elm$html$Html$Attributes$rel('noopener noreferrer')),
13159					A2(
13160						$elm$core$List$cons,
13161						$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink),
13162						A2(
13163							$elm$core$List$cons,
13164							$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink),
13165							A2(
13166								$elm$core$List$cons,
13167								$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.bA + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.ap + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.f_)))),
13168								attrs))))),
13169			$mdgriffith$elm_ui$Internal$Model$Unkeyed(
13170				_List_fromArray(
13171					[label])));
13172	});
13173var $elm$virtual_dom$VirtualDom$MayPreventDefault = function (a) {
13174	return {$: 2, a: a};
13175};
13176var $elm$html$Html$Events$preventDefaultOn = F2(
13177	function (event, decoder) {
13178		return A2(
13179			$elm$virtual_dom$VirtualDom$on,
13180			event,
13181			$elm$virtual_dom$VirtualDom$MayPreventDefault(decoder));
13182	});
13183var $author$project$Main$preventDefault = function (msg) {
13184	return A2(
13185		$elm$html$Html$Events$preventDefaultOn,
13186		'click',
13187		$elm$json$Json$Decode$succeed(
13188			_Utils_Tuple2(msg, true)));
13189};
13190var $author$project$Main$linkInternal = F3(
13191	function (internalLinkClicked, attrs, args) {
13192		return A2(
13193			$mdgriffith$elm_ui$Element$link,
13194			A2(
13195				$elm$core$List$cons,
13196				$mdgriffith$elm_ui$Element$htmlAttribute(
13197					$author$project$Main$preventDefault(
13198						internalLinkClicked(args.bT))),
13199				attrs),
13200			args);
13201	});

13202var $elm$html$Html$node = $elm$virtual_dom$VirtualDom$node;
13203var $mdgriffith$elm_ui$Element$Font$family = function (families) {
13204	return A2(
13205		$mdgriffith$elm_ui$Internal$Model$StyleClass,
13206		$mdgriffith$elm_ui$Internal$Flag$fontFamily,
13207		A2(
13208			$mdgriffith$elm_ui$Internal$Model$FontFamily,
13209			A3($elm$core$List$foldl, $mdgriffith$elm_ui$Internal$Model$renderFontClassName, 'ff-', families),
13210			families));
13211};
13212var $elm$svg$Svg$Attributes$d = _VirtualDom_attribute('d');
13213var $elm$svg$Svg$trustedNode = _VirtualDom_nodeNS('http://www.w3.org/2000/svg');
13214var $elm$svg$Svg$path = $elm$svg$Svg$trustedNode('path');
13215var $elm$html$Html$Attributes$attribute = $elm$virtual_dom$VirtualDom$attribute;
13216var $elm$svg$Svg$desc = $elm$svg$Svg$trustedNode('desc');
13217var $elm$svg$Svg$Attributes$height = _VirtualDom_attribute('height');
13218var $elm$svg$Svg$Attributes$id = _VirtualDom_attribute('id');
13219var $elm$svg$Svg$Attributes$preserveAspectRatio = _VirtualDom_attribute('preserveAspectRatio');
13220var $elm$svg$Svg$svg = $elm$svg$Svg$trustedNode('svg');
13221var $elm$svg$Svg$text = $elm$virtual_dom$VirtualDom$text;
13222var $elm$svg$Svg$title = $elm$svg$Svg$trustedNode('title');
13223var $elm$svg$Svg$Attributes$viewBox = _VirtualDom_attribute('viewBox');
13224var $elm$svg$Svg$Attributes$xmlSpace = A2(_VirtualDom_attributeNS, 'http://www.w3.org/XML/1998/namespace', 'xml:space');
13225var $author$project$Utils$Utils$wrapperWithViewbox_ = F3(
13226	function (viewbox, size, listSvg) {
13227		return A2(
13228			$elm$svg$Svg$svg,
13229			_List_fromArray(
13230				[
13231					$elm$svg$Svg$Attributes$xmlSpace('http://www.w3.org/2000/svg'),
13232					$elm$svg$Svg$Attributes$preserveAspectRatio('xMinYMin slice'),
13233					$elm$svg$Svg$Attributes$viewBox(viewbox),
13234					$elm$svg$Svg$Attributes$height(
13235					$elm$core$String$fromInt(size)),
13236					A2($elm$html$Html$Attributes$attribute, 'role', 'img'),
13237					A2($elm$html$Html$Attributes$attribute, 'aria-labelledby', 'catTitle catDesc')
13238				]),
13239			_Utils_ap(
13240				_List_fromArray(
13241					[
13242						A2(
13243						$elm$svg$Svg$title,
13244						_List_fromArray(
13245							[
13246								$elm$svg$Svg$Attributes$id('catTitle')
13247							]),
13248						_List_fromArray(
13249							[
13250								$elm$svg$Svg$text('')
13251							])),
13252						A2(
13253						$elm$svg$Svg$desc,
13254						_List_fromArray(
13255							[
13256								$elm$svg$Svg$Attributes$id('catDesc')
13257							]),
13258						_List_fromArray(
13259							[
13260								$elm$svg$Svg$text('')
13261							]))
13262					]),
13263				listSvg));
13264	});
13265var $author$project$Utils$Utils$wrapperWithViewbox = F3(
13266	function (viewbox, size, listSvg) {
13267		return $mdgriffith$elm_ui$Element$html(
13268			A3($author$project$Utils$Utils$wrapperWithViewbox_, viewbox, size, listSvg));
13269	});
13270var $author$project$Utils$Utils$logoDev = function (size) {
13271	return A3(
13272		$author$project$Utils$Utils$wrapperWithViewbox,
13273		'0 0 132 65',
13274		size,
13275		_List_fromArray(
13276			[
13277				A2(
13278				$elm$svg$Svg$path,
13279				_List_fromArray(
13280					[
13281						$elm$svg$Svg$Attributes$d('M0 33v32h11.3c12.5 0 17.7-1.6 21.5-6.5 3.8-4.8 4.4-9 4-28-.3-16.8-.5-18.2-2.7-21.8C30.3 2.5 26.1 1 12 1H0v32zm23.1-19.1c2.3 1.9 2.4 2.3 2.4 18.5 0 15.7-.1 16.7-2.2 18.8-1.7 1.6-3.5 2.2-7 2.2l-4.8.1-.3-20.8L11 12h4.9c3.3 0 5.6.6 7.2 1.9zm23-10.3c-2 2.6-2.1 3.9-2.1 29.6v26.9l2.5 2.4c2.3 2.4 2.9 2.5 16 2.5H76V54.1l-10.2-.3-10.3-.3v-15l6.3-.3 6.2-.3V27H55V12h21V1H62.1c-13.9 0-14 0-16 2.6zM87 15.2L94.6 44c3.2 12.3 4.3 15 7 17.7 1.9 2 4.2 3.3 5.7 3.3 3.1 0 7.1-3.1 8.5-6.7 1-2.6 15.2-55.6 15.2-56.8 0-.3-2.8-.5-6.2-.3l-6.3.3-5.6 21.5c-3.5 13.6-5.8 20.8-6.2 19.5C105.9 40 96 1.9 96 1.4c0-.2-2.9-.4-6.4-.4h-6.4L87 15.2z')
13282					]),
13283				_List_Nil)
13284			]));
13285};
13286var $elm$svg$Svg$Attributes$fill = _VirtualDom_attribute('fill');
13287var $author$project$Utils$Utils$logoGithub = function (size) {
13288	return A3(
13289		$author$project$Utils$Utils$wrapperWithViewbox,
13290		'0 0 256 250',
13291		size,
13292		_List_fromArray(
13293			[
13294				A2(
13295				$elm$svg$Svg$path,
13296				_List_fromArray(
13297					[
13298						$elm$svg$Svg$Attributes$fill('#161614'),
13299						$elm$svg$Svg$Attributes$d('M128 0a128 128 0 00-40.5 249.5c6.4 1.1 8.8-2.8 8.8-6.2l-.2-23.8C60.5 227.2 53 204.4 53 204.4c-5.8-14.8-14.2-18.8-14.2-18.8-11.6-7.9.8-7.7.8-7.7 12.9.9 19.7 13.1 19.7 13.1 11.4 19.6 30 14 37.2 10.7 1.2-8.3 4.5-14 8.1-17.1-28.4-3.3-58.3-14.2-58.3-63.3 0-14 5-25.4 13.2-34.3a46 46 0 011.3-34S71.5 49.7 96 66.3a122.7 122.7 0 0164 0c24.5-16.6 35.2-13.1 35.2-13.1a46 46 0 011.3 33.9c8.2 9 13.2 20.3 13.2 34.3 0 49.2-30 60-58.5 63.2 4.6 4 8.7 11.7 8.7 23.7l-.2 35.1c0 3.4 2.4 7.4 8.8 6.1A128 128 0 00128 0zM48 182.3c-.3.7-1.3.9-2.3.4-.9-.4-1.4-1.3-1.

132991-1.9.3-.6 1.3-.8 2.2-.4 1 .4 1.5 1.3 1.1 2zm6.2 5.7c-.6.5-1.8.3-2.6-.6-.8-1-1-2.1-.4-2.7.7-.6 1.8-.3 2.7.6.8.9 1 2 .3 2.7zm4.4 7.1c-.8.6-2.1 0-2.9-1-.8-1.2-.8-2.6 0-3.1.8-.6 2 0 2.9 1 .8 1.2.8 2.6 0 3.1zm7.3 8.4c-.7.7-2.2.5-3.3-.5-1.1-1-1.5-2.5-.8-3.3.8-.8 2.3-.5 3.4.5 1 1 1.4 2.5.7 3.3zm9.4 2.8c-.3 1-1.7 1.4-3.2 1-1.4-.4-2.4-1.6-2.1-2.6.3-1 1.7-1.5 3.2-1 1.5.4 2.4 1.6 2.1 2.6zm10.7 1.2c0 1-1.1 1.9-2.7 2-1.5 0-2.7-.9-2.8-2 0-1 1.2-1.9 2.8-1.9 1.5 0 2.7.8 2.7 1.9zm10.6-.4c.2 1-.9 2-2.4 2.3-1.5.3-2.8-.3-3-1.3-.2-1.1.9-2.2 2.3-2.4 1.6-.3 3 .3 3.1 1.4z')
13300					]),
13301				_List_Nil)
13302			]));
13303};
13304var $elm$svg$Svg$circle = $elm$svg$Svg$trustedNode('circle');
13305var $elm$svg$Svg$Attributes$cx = _VirtualDom_attribute('cx');
13306var $elm$svg$Svg$Attributes$cy = _VirtualDom_attribute('cy');
13307var $elm$svg$Svg$Attributes$r = _VirtualDom_attribute('r');
13308var $author$project$Utils$Utils$logoLucamug = function (size) {
13309	return A3(
13310		$author$project$Utils$Utils$wrapperWithViewbox,
13311		'0 0 100 100',
13312		size,
13313		_List_fromArray(
13314			[
13315				A2(
13316				$elm$svg$Svg$path,
13317				_List_fromArray(
13318					[
13319						$elm$svg$Svg$Attributes$fill('none'),
13320						$elm$svg$Svg$Attributes$d('M0 0h100v100H0z')
13321					]),
13322				_List_Nil),
13323				A2(
13324				$elm$svg$Svg$circle,
13325				_List_fromArray(
13326					[
13327						$elm$svg$Svg$Attributes$fill('tomato'),
13328						$elm$svg$Svg$Attributes$cx('50'),
13329						$elm$svg$Svg$Attributes$cy('50'),
13330						$elm$svg$Svg$Attributes$r('50')
13331					]),
13332				_List_Nil),
13333				A2(
13334				$elm$svg$Svg$path,
13335				_List_fromArray(
13336					[
13337						$elm$svg$Svg$Attributes$fill('#1e90ff'),
13338						$elm$svg$Svg$Attributes$d('M7.08 75.56c15.99 26.67 48.3 29.6 67.15 18.12-26.07-5.25-35.78-28.79-38.08-45.75-3.78.16-10.83-.05-15.76.13-3.08 17.08-7.86 21.09-13.3 27.5z')
13339					]),
13340				_List_Nil),
13341				A2(
13342				$elm$svg$Svg$path,
13343				_List_fromArray(
13344					[
13345						$elm$svg$Svg$Attributes$fill('#fff'),
13346						$elm$svg$Svg$Attributes$d('M3 43h15c4 0 4-5 0-5h-5c-1 0-1-1 0-1h22c4 0 4-5 0-5H7c-3 0-3 5 0 5h3c1 0 1 1 0 1l-8.55-.01C1.17 39.25.75 41.02.48 43zM93.84 60.95l-15-.05c-4-.01-4.01 4.99-.01 5l5 .02c1 0 1 1 0 1l-22-.07c-4 0-4.02 5-.02 5l28 .08c3 .01 3.02-4.99.02-5h-3c-1 0-1-1 0-1s5 0 10.6.07c.57-1.86.9-3 1.38-5zM20.21 47.62c-1.18 9.56-3.53 14.69-7.65 21.43 4.4 3.03 8.93-15.48 10.16-14.95 1.68.08-1.97 12.74-.52 12.88 1.58-.1 2.82-8.28 4.8-8.31 1.78.29 2.3 9.16 4.12 8.7 1.85-.31-.07-12.13 2.05-13.07 1.87-.2 5.07 16.32 9.59 14.85-3.63-7.02-5.7-14.78-6.7-21.47-4.54.05-11.69-.04-15.85-.06z')
13347					]),
13348				_List_Nil)
13349			]));
13350};
13351var $author$project$Utils$Utils$logoMedium = function (size) {
13352	return A3(
13353		$author$project$Utils$Utils$wrapperWithViewbox,
13354		'0 0 256 256',
13355		size,
13356		_List_fromArray(
13357			[
13358				A2(
13359				$elm$svg$Svg$path,
13360				_List_fromArray(
13361					[
13362						$elm$svg$Svg$Attributes$fill('#12100E'),
13363						$elm$svg$Svg$Attributes$d('M0 0h256v256H0z')
13364					]),
13365				_List_Nil),
13366				A2(
13367				$elm$svg$Svg$path,
13368				_List_fromArray(
13369					[
13370						$elm$svg$Svg$Attributes$fill('#ffffff'),
13371						$elm$svg$Svg$Attributes$d('M61 86l-2-6-16-19v-3h50l38 84 34-84h48v3l-14 13-2 4v96l2 4 13 13v3h-67v-3l14-13 1-4V96l-38 98h-6L71 96v66c0 2 1 5 3 7l18 22v3H41v-3l18-22c2-2 3-5 2-7V86z')
13372					]),
13373				_List_Nil)
13374			]));
13375};
13376var $author$project$Utils$Utils$logoTwitter = function (size) {
13377	return A3(
13378		$author$project$Utils$Utils$wrapperWithViewbox,
13379		'0 0 24 24',
13380		size,
13381		_List_fromArray(
13382			[
13383				A2(
13384				$elm$svg$Svg$path,
13385				_List_fromArray(
13386					[
13387						$elm$svg$Svg$Attributes$fill('#000000'),
13388						$elm$svg$Svg$Attributes$d('M24 5h-3l2-2-3 1a5 5 0 00-8 4C8 8 4 6 2 3c-2 2-1 5 1 7L1 9c0 2 2 5 4 5H3c0 2 2 3 4 3-2 2-4 3-7 3l8 2c9 0 14-8 14-15l2-2z')
13389					]),
13390				_List_Nil)
13391			]));
13392};
13393var $elm$html$Html$Attributes$target = $elm$html$Html$Attributes$stringProperty('target');
13394var $mdgriffith$elm_ui$Element$newTabLink = F2(
13395	function (attrs, _v0) {
13396		var url = _v0.bT;
13397		var label = _v0.cn;
13398		return A4(
13399			$mdgriffith$elm_ui$Internal$Model$element,
13400			$mdgriffith$elm_ui$Internal$Model$asEl,
13401			$mdgriffith$elm_ui$Internal$Model$NodeName('a'),
13402			A2(
13403				$elm$core$List$cons,
13404				$mdgriffith$elm_ui$Internal$Model$Attr(
13405					$elm$html$Html$Attributes$href(url)),
13406				A2(
13407					$elm$core$List$cons,
13408					$mdgriffith$elm_ui$Internal$Model$Attr(
13409						$elm$html$Html$Attributes$rel('noopener noreferrer')),
13410					A2(
13411						$elm$core$List$cons,
13412						$mdgriffith$elm_ui$Internal$Model$Attr(
13413							$elm$html$Html$Attributes$target('_blank')),
13414						A2(
13415							$elm$core$List$cons,
13416							$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink),
13417							A2(
13418								$elm$core$List$cons,
13419								$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink),
13420								A2(
13421									$elm$core$List$cons,
13422									$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.bA + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.ap + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.f_)))),
13423									attrs)))))),
13424			$mdgriffith$elm_ui$Internal$Model$Unkeyed(
13425				_List_fromArray(
13426					[label])));
13427	});
13428var $mdgriffith$elm_ui$Internal$Model$AsRow = 0;
13429var $mdgriffith$elm_ui$Internal$Model$asRow = 0;
13430var $mdgriffith$elm_ui$Element$row = F2(
13431	function (attrs, children) {
13432		return A4(
13433			$mdgriffith$elm_ui$Internal$Model$element,
13434			$mdgriffith$elm_ui$Internal$Model$asRow,
13435			$mdgriffith$elm_ui$Internal$Model$div,
13436			A2(
13437				$elm$core$List$cons,
13438				$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.a6 + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.ap)),
13439				A2(
13440					$elm$core$List$cons,
13441					$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink),
13442					A2(
13443						$elm$core$List$cons,
13444						$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink),
13445						attrs))),
13446			$mdgriffith$elm_ui$Internal$Model$Unkeyed(children));
13447	});
13448var $mdgriffith$elm_ui$Element$Font$typeface = $mdgriffith$elm_ui$Internal$Model$Typeface;
13449var $author$project$Projects$Project$viewTitle = A2(
13450	$mdgriffith$elm_ui$Element$column,
13451	_List_Nil,
13452	_List_fromArray(
13453		[
13454			A2(
13455			$mdgriffith$elm_ui$Element$el,
13456			_List_fromArray(
13457				[
13458					$mdgriffith$elm_ui$Element$Font$size(80),
13459					$mdgriffith$elm_ui$Element$Font$family(
13460					_List_fromArray(
13461						[
13462							$mdgriffith$elm_ui$Element$Font$typeface('Bad Script')
13463						]))
13464				]),
13465			$mdgriffith$elm_ui$Element$text($author$project$Projects$Project$conf.g5)),
13466			A2(
13467			$mdgriffith$elm_ui$Element$row,
13468			_List_fromArray(
13469				[
13470					$mdgriffith$elm_ui$Element$spacing(20)
13471				]),
13472			_List_fromArray(
13473				[
13474					A2(
13475					$mdgriffith$elm_ui$Element$el,
13476					_List_Nil,
13477					$author$project$Utils$Utils$logoLucamug(30)),
13478					A2(
13479					$mdgriffith$elm_ui$Element$newTabLink,
13480					_List_Nil,
13481					{
13482						cn: $author$project$Utils$Utils$logoTwitter(30),
13483						bT: 'https://twitter.com/luca_mug'
13484					}),
13485					A2(
13486					$mdgriffith$elm_ui$Element$newTabLink,
13487					_List_Nil,
13488					{
13489						cn: $author$project$Utils$Utils$logoMedium(30),
13490						bT: 'https://lucamug.medium.com/'
13491					}),
13492					A2(
13493					$mdgriffith$elm_ui$Element$newTabLink,
13494					_List_Nil,
13495					{
13496						cn: $author$project$Utils$Utils$logoGithub(30),
13497						bT: 'https://github.com/lucamug'
13498					}),
13499					A2(
13500					$mdgriffith$elm_ui$Element$newTabLink,
13501					_List_Nil,
13502					{
13503						cn: $author$project$Utils$Utils$logoDev(30),
13504						bT: 'https://dev.to/lucamug'
13505					})
13506				]))
13507		]));
13508var $mdgriffith$elm_ui$Internal$Model$Padding = F5(
13509	function (a, b, c, d, e) {

13510		return {$: 0, a: a, b: b, c: c, d: d, e: e};
13511	});
13512var $mdgriffith$elm_ui$Internal$Model$Spaced = F3(
13513	function (a, b, c) {
13514		return {$: 0, a: a, b: b, c: c};
13515	});
13516var $mdgriffith$elm_ui$Internal$Model$extractSpacingAndPadding = function (attrs) {
13517	return A3(
13518		$elm$core$List$foldr,
13519		F2(
13520			function (attr, _v0) {
13521				var pad = _v0.a;
13522				var spacing = _v0.b;
13523				return _Utils_Tuple2(
13524					function () {
13525						if (!pad.$) {
13526							var x = pad.a;
13527							return pad;
13528						} else {
13529							if ((attr.$ === 4) && (attr.b.$ === 7)) {
13530								var _v3 = attr.b;
13531								var name = _v3.a;
13532								var t = _v3.b;
13533								var r = _v3.c;
13534								var b = _v3.d;
13535								var l = _v3.e;
13536								return $elm$core$Maybe$Just(
13537									A5($mdgriffith$elm_ui$Internal$Model$Padding, name, t, r, b, l));
13538							} else {
13539								return $elm$core$Maybe$Nothing;
13540							}
13541						}
13542					}(),
13543					function () {
13544						if (!spacing.$) {
13545							var x = spacing.a;
13546							return spacing;
13547						} else {
13548							if ((attr.$ === 4) && (attr.b.$ === 5)) {
13549								var _v6 = attr.b;
13550								var name = _v6.a;
13551								var x = _v6.b;
13552								var y = _v6.c;
13553								return $elm$core$Maybe$Just(
13554									A3($mdgriffith$elm_ui$Internal$Model$Spaced, name, x, y));
13555							} else {
13556								return $elm$core$Maybe$Nothing;
13557							}
13558						}
13559					}());
13560			}),
13561		_Utils_Tuple2($elm$core$Maybe$Nothing, $elm$core$Maybe$Nothing),
13562		attrs);
13563};
13564var $mdgriffith$elm_ui$Internal$Model$paddingNameFloat = F4(
13565	function (top, right, bottom, left) {
13566		return 'pad-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(top) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(right) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(bottom) + ('-' + $mdgriffith$elm_ui$Internal$Model$floatClass(left)))))));
13567	});
13568var $elm$html$Html$Attributes$style = $elm$virtual_dom$VirtualDom$style;
13569var $mdgriffith$elm_ui$Element$wrappedRow = F2(
13570	function (attrs, children) {
13571		var _v0 = $mdgriffith$elm_ui$Internal$Model$extractSpacingAndPadding(attrs);
13572		var padded = _v0.a;
13573		var spaced = _v0.b;
13574		if (spaced.$ === 1) {
13575			return A4(
13576				$mdgriffith$elm_ui$Internal$Model$element,
13577				$mdgriffith$elm_ui$Internal$Model$asRow,
13578				$mdgriffith$elm_ui$Internal$Model$div,
13579				A2(
13580					$elm$core$List$cons,
13581					$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.a6 + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.ap + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.c3)))),
13582					A2(
13583						$elm$core$List$cons,
13584						$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink),
13585						A2(
13586							$elm$core$List$cons,
13587							$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink),
13588							attrs))),
13589				$mdgriffith$elm_ui$Internal$Model$Unkeyed(children));
13590		} else {
13591			var _v2 = spaced.a;
13592			var spaceName = _v2.a;
13593			var x = _v2.b;
13594			var y = _v2.c;
13595			var newPadding = function () {
13596				if (!padded.$) {
13597					var _v5 = padded.a;
13598					var name = _v5.a;
13599					var t = _v5.b;
13600					var r = _v5.c;
13601					var b = _v5.d;
13602					var l = _v5.e;
13603					if ((_Utils_cmp(r, x / 2) > -1) && (_Utils_cmp(b, y / 2) > -1)) {
13604						var newTop = t - (y / 2);
13605						var newRight = r - (x / 2);
13606						var newLeft = l - (x / 2);
13607						var newBottom = b - (y / 2);
13608						return $elm$core$Maybe$Just(
13609							A2(
13610								$mdgriffith$elm_ui$Internal$Model$StyleClass,
13611								$mdgriffith$elm_ui$Internal$Flag$padding,
13612								A5(
13613									$mdgriffith$elm_ui$Internal$Model$PaddingStyle,
13614									A4($mdgriffith$elm_ui$Internal$Model$paddingNameFloat, newTop, newRight, newBottom, newLeft),
13615									newTop,
13616									newRight,
13617									newBottom,
13618									newLeft)));
13619					} else {
13620						return $elm$core$Maybe$Nothing;
13621					}
13622				} else {
13623					return $elm$core$Maybe$Nothing;
13624				}
13625			}();
13626			if (!newPadding.$) {
13627				var pad = newPadding.a;
13628				return A4(
13629					$mdgriffith$elm_ui$Internal$Model$element,
13630					$mdgriffith$elm_ui$Internal$Model$asRow,
13631					$mdgriffith$elm_ui$Internal$Model$div,
13632					A2(
13633						$elm$core$List$cons,
13634						$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.a6 + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.ap + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.c3)))

13634),
13635						A2(
13636							$elm$core$List$cons,
13637							$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink),
13638							A2(
13639								$elm$core$List$cons,
13640								$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink),
13641								_Utils_ap(
13642									attrs,
13643									_List_fromArray(
13644										[pad]))))),
13645					$mdgriffith$elm_ui$Internal$Model$Unkeyed(children));
13646			} else {
13647				var halfY = -(y / 2);
13648				var halfX = -(x / 2);
13649				return A4(
13650					$mdgriffith$elm_ui$Internal$Model$element,
13651					$mdgriffith$elm_ui$Internal$Model$asEl,
13652					$mdgriffith$elm_ui$Internal$Model$div,
13653					attrs,
13654					$mdgriffith$elm_ui$Internal$Model$Unkeyed(
13655						_List_fromArray(
13656							[
13657								A4(
13658								$mdgriffith$elm_ui$Internal$Model$element,
13659								$mdgriffith$elm_ui$Internal$Model$asRow,
13660								$mdgriffith$elm_ui$Internal$Model$div,
13661								A2(
13662									$elm$core$List$cons,
13663									$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.a6 + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.ap + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.c3)))),
13664									A2(
13665										$elm$core$List$cons,
13666										$mdgriffith$elm_ui$Internal$Model$Attr(
13667											A2(
13668												$elm$html$Html$Attributes$style,
13669												'margin',
13670												$elm$core$String$fromFloat(halfY) + ('px' + (' ' + ($elm$core$String$fromFloat(halfX) + 'px'))))),
13671										A2(
13672											$elm$core$List$cons,
13673											$mdgriffith$elm_ui$Internal$Model$Attr(
13674												A2(
13675													$elm$html$Html$Attributes$style,
13676													'width',
13677													'calc(100% + ' + ($elm$core$String$fromInt(x) + 'px)'))),
13678											A2(
13679												$elm$core$List$cons,
13680												$mdgriffith$elm_ui$Internal$Model$Attr(
13681													A2(
13682														$elm$html$Html$Attributes$style,
13683														'height',
13684														'calc(100% + ' + ($elm$core$String$fromInt(y) + 'px)'))),
13685												A2(
13686													$elm$core$List$cons,
13687													A2(
13688														$mdgriffith$elm_ui$Internal$Model$StyleClass,
13689														$mdgriffith$elm_ui$Internal$Flag$spacing,
13690														A3($mdgriffith$elm_ui$Internal$Model$SpacingStyle, spaceName, x, y)),
13691													_List_Nil))))),
13692								$mdgriffith$elm_ui$Internal$Model$Unkeyed(children))
13693							])));
13694			}
13695		}
13696	});
13697var $author$project$Main$viewMainPage = function (model) {
13698	var _v0 = model.W;
13699	return A2(
13700		$mdgriffith$elm_ui$Element$column,
13701		_List_fromArray(
13702			[
13703				$mdgriffith$elm_ui$Element$padding($author$project$Projects$Project$conf.cU),
13704				$mdgriffith$elm_ui$Element$spacing($author$project$Projects$Project$conf.cU),
13705				$mdgriffith$elm_ui$Element$Background$color($author$project$Projects$Project$conf.eV),
13706				$mdgriffith$elm_ui$Element$Font$color($author$project$Projects$Project$conf.fD),
13707				$mdgriffith$elm_ui$Element$htmlAttribute(
13708				$elm$html$Html$Attributes$id('main'))
13709			]),
13710		_List_fromArray(
13711			[
13712				$mdgriffith$elm_ui$Element$html(
13713				A3(
13714					$elm$html$Html$node,
13715					'style',
13716					_List_Nil,
13717					_List_fromArray(
13718						[
13719							$elm$html$Html$text($author$project$Main$css)
13720						]))),
13721				A2(
13722				$mdgriffith$elm_ui$Element$column,
13723				_List_Nil,
13724				_List_fromArray(
13725					[$author$project$Projects$Project$viewTitle])),
13726				A2(
13727				$mdgriffith$elm_ui$Element$wrappedRow,
13728				_List_fromArray(
13729					[
13730						$mdgriffith$elm_ui$Element$spacing($author$project$Projects$Project$conf.cU)
13731					]),
13732				A2(
13733					$elm$core$List$indexedMap,
13734					F2(
13735						function (index, item) {
13736							return A4(
13737								$author$project$Projects$Project$cardWrapper,
13738								$author$project$Main$linkInternal($author$project$Main$InternalLinkClicked),
13739								index,
13740								item,
13741								$author$project$Main$urlBuilder(
13742									$author$project$Projects$Project$id(item)));
13743						}),
13744					$author$project$Projects$Project$items))
13745			]));
13746};
13747var $mdgriffith$elm_ui$Internal$Model$Left = 0;
13748var $mdgriffith$elm_ui$Element$alignLeft = $mdgriffith$elm_ui$Internal$Model$AlignX(0);
13749var $mdgriffith$elm_ui$Internal$Model$Right = 2;
13750var $mdgriffith$elm_ui$Element$alignRight = $mdgriffith$elm_ui$Internal$Model$AlignX(2);
13751var $mdgriffith$elm_ui$Internal$Model$CenterX = 1;
13752var $mdgriffith$elm_ui$Element$centerX = $mdgriffith$elm_ui$Internal$Model$AlignX(1);
13753var $mdgriffith$elm_ui$Internal$Model$CenterY = 1;
13754var $mdgriffith$elm_ui$Element$centerY = $mdgriffith$elm_ui$Internal$Model$AlignY(1);
13755var $author$project$Utils$Utils$iconLeft = F2(
13756	function (cl, size) {
13757		return A3(

13758			$author$project$Utils$Utils$wrapperWithViewbox,
13759			'0 0 443.5 443.5',
13760			size,
13761			_List_fromArray(
13762				[
13763					A2(
13764					$elm$svg$Svg$path,
13765					_List_fromArray(
13766						[
13767							$elm$svg$Svg$Attributes$fill(cl),
13768							$elm$svg$Svg$Attributes$d('M143 222L336 29a17 17 0 00-24-24L107 210c-6 6-6 17 0 24l205 205a17 17 0 0024-24L143 222z')
13769						]),
13770					_List_Nil)
13771				]));
13772	});
13773var $author$project$Utils$Utils$iconRight = F2(
13774	function (cl, size) {
13775		return A3(
13776			$author$project$Utils$Utils$wrapperWithViewbox,
13777			'0 0 512 512',
13778			size,
13779			_List_fromArray(
13780				[
13781					A2(
13782					$elm$svg$Svg$path,
13783					_List_fromArray(
13784						[
13785							$elm$svg$Svg$Attributes$fill(cl),
13786							$elm$svg$Svg$Attributes$d('M388 242L152 6a20 20 0 00-28 28l222 222-222 222a20 20 0 1028 28l236-236a20 20 0 000-28z')
13787						]),
13788					_List_Nil)
13789				]));
13790	});
13791var $author$project$Utils$Utils$iconX = F2(
13792	function (cl, size) {
13793		return A3(
13794			$author$project$Utils$Utils$wrapperWithViewbox,
13795			'0 0 32 32',
13796			size,
13797			_List_fromArray(
13798				[
13799					A2(
13800					$elm$svg$Svg$path,
13801					_List_fromArray(
13802						[
13803							$elm$svg$Svg$Attributes$fill('none'),
13804							$elm$svg$Svg$Attributes$d('M0 0h32v32H0z')
13805						]),
13806					_List_Nil),
13807					A2(
13808					$elm$svg$Svg$path,
13809					_List_fromArray(
13810						[
13811							$elm$svg$Svg$Attributes$fill(cl),
13812							$elm$svg$Svg$Attributes$d('M27 6.5L25.5 5 16 14.5 6.5 5 5 6.5l9.5 9.5L5 25.5 6.5 27l9.5-9.5 9.5 9.5 1.5-1.5-9.5-9.5L27 6.5z')
13813						]),
13814					_List_Nil)
13815				]));
13816	});
13817var $mdgriffith$elm_ui$Element$moveDown = function (y) {
13818	return A2(
13819		$mdgriffith$elm_ui$Internal$Model$TransformComponent,
13820		$mdgriffith$elm_ui$Internal$Flag$moveY,
13821		$mdgriffith$elm_ui$Internal$Model$MoveY(y));
13822};
13823var $mdgriffith$elm_ui$Internal$Model$MoveX = function (a) {
13824	return {$: 0, a: a};
13825};
13826var $mdgriffith$elm_ui$Internal$Flag$moveX = $mdgriffith$elm_ui$Internal$Flag$flag(25);
13827var $mdgriffith$elm_ui$Element$moveLeft = function (x) {
13828	return A2(
13829		$mdgriffith$elm_ui$Internal$Model$TransformComponent,
13830		$mdgriffith$elm_ui$Internal$Flag$moveX,
13831		$mdgriffith$elm_ui$Internal$Model$MoveX(-x));
13832};
13833var $mdgriffith$elm_ui$Element$moveRight = function (x) {
13834	return A2(
13835		$mdgriffith$elm_ui$Internal$Model$TransformComponent,
13836		$mdgriffith$elm_ui$Internal$Flag$moveX,
13837		$mdgriffith$elm_ui$Internal$Model$MoveX(x));
13838};
13839var $elm$html$Html$Attributes$name = $elm$html$Html$Attributes$stringProperty('name');
13840var $mdgriffith$elm_ui$Internal$Flag$borderRound = $mdgriffith$elm_ui$Internal$Flag$flag(17);
13841var $mdgriffith$elm_ui$Element$Border$roundEach = function (_v0) {
13842	var topLeft = _v0.g7;
13843	var topRight = _v0.g8;
13844	var bottomLeft = _v0.e6;
13845	var bottomRight = _v0.e7;
13846	return A2(
13847		$mdgriffith$elm_ui$Internal$Model$StyleClass,
13848		$mdgriffith$elm_ui$Internal$Flag$borderRound,
13849		A3(
13850			$mdgriffith$elm_ui$Internal$Model$Single,
13851			'br-' + ($elm$core$String$fromInt(topLeft) + ('-' + ($elm$core$String$fromInt(topRight) + ($elm$core$String$fromInt(bottomLeft) + ('-' + $elm$core$String$fromInt(bottomRight)))))),
13852			'border-radius',
13853			$elm$core$String$fromInt(topLeft) + ('px ' + ($elm$core$String$fromInt(topRight) + ('px ' + ($elm$core$String$fromInt(bottomRight) + ('px ' + ($elm$core$String$fromInt(bottomLeft) + 'px'))))))));
13854};
13855var $mdgriffith$elm_ui$Element$Border$rounded = function (radius) {
13856	return A2(
13857		$mdgriffith$elm_ui$Internal$Model$StyleClass,
13858		$mdgriffith$elm_ui$Internal$Flag$borderRound,
13859		A3(
13860			$mdgriffith$elm_ui$Internal$Model$Single,
13861			'br-' + $elm$core$String$fromInt(radius),
13862			'border-radius',
13863			$elm$core$String$fromInt(radius) + 'px'));
13864};
13865var $mdgriffith$elm_ui$Internal$Flag$overflow = $mdgriffith$elm_ui$Internal$Flag$flag(20);
13866var $mdgriffith$elm_ui$Element$scrollbarY = A2($mdgriffith$elm_ui$Internal$Model$Class, $mdgriffith$elm_ui$Internal$Flag$overflow, $mdgriffith$elm_ui$Internal$Style$classes.gx);
13867var $elm$html$Html$Attributes$title = $elm$html$Html$Attributes$stringProperty('title');
13868var $elm$svg$Svg$Attributes$fillRule = _VirtualDom_attribute('fill-rule');
13869var $author$project$Utils$Utils$iconOpenNewWindow = F2(
13870	function (cl, size) {
13871		return A3(

13872			$author$project$Utils$Utils$wrapperWithViewbox,
13873			'0 0 100 100',
13874			size,
13875			_List_fromArray(
13876				[
13877					A2(
13878					$elm$svg$Svg$path,
13879					_List_fromArray(
13880						[
13881							$elm$svg$Svg$Attributes$fill(cl),
13882							$elm$svg$Svg$Attributes$fillRule('evenodd'),
13883							$elm$svg$Svg$Attributes$d('M76 18L47 47a4 4 0 006 6l29-29v10a4 4 0 008 0V14a4 4 0 00-4-4H66a4 4 0 000 8h10zm14 40V39v41c0 6-4 10-9 10H19c-5 0-9-4-9-10V20c0-6 4-10 9-10h43-20a4 4 0 110 8H20c-1 0-2 1-2 3v58c0 2 1 3 2 3h60c1 0 2-1 2-3V58a4 4 0 118 0z')
13884						]),
13885					_List_Nil)
13886				]));
13887	});
13888var $mdgriffith$elm_ui$Internal$Model$BorderWidth = F5(
13889	function (a, b, c, d, e) {
13890		return {$: 6, a: a, b: b, c: c, d: d, e: e};
13891	});
13892var $mdgriffith$elm_ui$Element$Border$width = function (v) {
13893	return A2(
13894		$mdgriffith$elm_ui$Internal$Model$StyleClass,
13895		$mdgriffith$elm_ui$Internal$Flag$borderWidth,
13896		A5(
13897			$mdgriffith$elm_ui$Internal$Model$BorderWidth,
13898			'b-' + $elm$core$String$fromInt(v),
13899			v,
13900			v,
13901			v,
13902			v));
13903};
13904var $author$project$Projects$Project$linkAttrs = _List_fromArray(
13905	[
13906		$mdgriffith$elm_ui$Element$Font$color(
13907		A3($mdgriffith$elm_ui$Element$rgb, 0, 0.2, 0.8)),
13908		$mdgriffith$elm_ui$Element$Border$width(1),
13909		$mdgriffith$elm_ui$Element$Border$rounded(10),
13910		$mdgriffith$elm_ui$Element$padding(10)
13911	]);
13912var $author$project$Projects$Project$createLinkIfNotEmpty = F2(
13913	function (url, label) {
13914		return $elm$core$String$isEmpty(url) ? _List_Nil : _List_fromArray(
13915			[
13916				A2(
13917				$mdgriffith$elm_ui$Element$newTabLink,
13918				$author$project$Projects$Project$linkAttrs,
13919				{
13920					cn: A2(
13921						$mdgriffith$elm_ui$Element$row,
13922						_List_fromArray(
13923							[
13924								$mdgriffith$elm_ui$Element$spacing(10)
13925							]),
13926						_List_fromArray(
13927							[
13928								$mdgriffith$elm_ui$Element$text(label),
13929								A2(
13930								$mdgriffith$elm_ui$Element$el,
13931								_List_Nil,
13932								A2($author$project$Utils$Utils$iconOpenNewWindow, '#0030d0', 16))
13933							])),
13934					bT: url
13935				})
13936			]);
13937	});
13938var $elm$html$Html$br = _VirtualDom_node('br');
13939var $author$project$Utils$SimpleMarkdown$elementBoldGenerator = function (string) {
13940	return A2(
13941		$mdgriffith$elm_ui$Element$el,
13942		_List_fromArray(
13943			[$mdgriffith$elm_ui$Element$Font$bold]),
13944		$mdgriffith$elm_ui$Element$text(string));
13945};
13946var $author$project$Utils$SimpleMarkdown$elementLabelGenerator = function (string) {
13947	return A2(
13948		$mdgriffith$elm_ui$Element$paragraph,
13949		_List_Nil,
13950		_List_fromArray(
13951			[
13952				$mdgriffith$elm_ui$Element$text(string + ' '),
13953				A2($author$project$Utils$Utils$iconOpenNewWindow, '#0030d0', 13)
13954			]));
13955};
13956var $author$project$Utils$SimpleMarkdown$elementLinkGeneratorAdvanced = F3(
13957	function (attrs, linkLabel, url) {
13958		return A2(
13959			$mdgriffith$elm_ui$Element$newTabLink,
13960			attrs.f_,
13961			{
13962				cn: $author$project$Utils$SimpleMarkdown$elementLabelGenerator(linkLabel),
13963				bT: url
13964			});
13965	});
13966var $author$project$Utils$SimpleMarkdown$elementTextGenerator = function (string) {
13967	return $mdgriffith$elm_ui$Element$text(string);
13968};
13969var $author$project$Utils$SimpleMarkdown$MarkDownText = function (a) {
13970	return {$: 0, a: a};
13971};
13972var $elm$regex$Regex$Match = F4(
13973	function (match, index, number, submatches) {
13974		return {fP: index, dW: match, f7: number, el: submatches};
13975	});
13976var $elm$regex$Regex$find = _Regex_findAtMost(_Regex_infinity);
13977var $elm$core$Array$fromListHelp = F3(
13978	function (list, nodeList, nodeListSize) {
13979		fromListHelp:
13980		while (true) {
13981			var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, list);
13982			var jsArray = _v0.a;
13983			var remainingItems = _v0.b;
13984			if (_Utils_cmp(
13985				$elm$core$Elm$JsArray$length(jsArray),
13986				$elm$core$Array$branchFactor) < 0) {
13987				return A2(
13988					$elm$core$Array$builderToArray,
13989					true,
13990					{A: nodeList, t: nodeListSize, x: jsArray});
13991			} else {
13992				var $temp$list = remainingItems,
13993					$temp$nodeList = A2(
13994					$elm$core$List$cons,
13995					$elm$core$Array$Leaf(jsArray),
13996					nodeList),
13997					$temp$nodeListSize = nodeListSize + 1;
13998				list = $temp$list;
13999				nodeList = $temp$nodeList;
14000				nodeListSize = $temp$nodeListSize;
14001				continue fromListHelp;
14002			}
14003		}
14004	});
14005var $elm$core$Array$fromList = function (list) {
14006	if (!list.b) {
14007		return $elm$core$Array$empty;
14008	} else {
14009		return A3($elm$core$Array$fromListHelp, list, _List_Nil, 0);
14010	}
14011};
14012var $elm$core$Bitwise$shiftRightZfBy = _Bitwise_shiftRightZfBy;
14013var $elm$core$Array$bitMask = 4294967295 >>> (32 - $elm$core$Array$shiftStep);
14014var $elm$core$Elm$JsArray$unsafeGet = _JsArray_unsafeGet;
14015var $elm$core$Array$getHelp = F3(
14016	function (shift, index, tree) {
14017		getHelp:
14018		while (true) {
14019			var pos = $elm$core$Array$bitMask & (index >>> shift);
14020			var _v0 = A2($elm$core$Elm$JsArray$unsafeGet, pos, tree);
14021			if (!_v0.$) {
14022				var subTree = _v0.a;
14023				var $temp$shift = shift - $elm$core$Array$shiftStep,
14024					$temp$index = index,
14025					$temp$tree = subTree;
14026				shift = $temp$shift;
14027				index = $temp$index;
14028				tree = $temp$tree;
14029				continue getHelp;
14030			} else {
14031				var values = _v0.a;
14032				return A2($elm$core$Elm$JsArray$unsafeGet, $elm$core$Array$bitMask & index, values);
14033			}
14034		}
14035	});
14036var $elm$core$Array$tailIndex = function (len) {
14037	return (len >>> 5) << 5;
14038};
14039var $elm$core$Array$get = F2(
14040	function (index, _v0) {
14041		var len = _v0.a;
14042		var startShift = _v0.b;
14043		var tree = _v0.c;
14044		var tail = _v0.d;
14045		return ((index < 0) || (_Utils_cmp(index, len) > -1)) ? $elm$core$Maybe$Nothing : ((_Utils_cmp(
14046			index,
14047			$elm$core$Array$tailIndex(len)) > -1) ? $elm$core$Maybe$Just(
14048			A2($elm$core$Elm$JsArray$unsafeGet, $elm$core$Array$bitMask & index, tail)) : $elm$core$Maybe$Just(
14049			A3($elm$core$Array$getHelp, startShift, index, tree)));
14050	});
14051var $author$project$Utils$SimpleMarkdown$MarkDownBold = function (a) {
14052	return {$: 2, a: a};
14053};
14054var $author$project$Utils$SimpleMarkdown$markDownParseBoldData = function (data) {
14055	var text1 = A2(
14056		$elm$core$Maybe$withDefault,
14057		'',
14058		$elm$core$List$head(data));
14059	return $author$project$Utils$SimpleMarkdown$MarkDownBold(text1);
14060};
14061var $elm$regex$Regex$fromStringWith = _Regex_fromStringWith;
14062var $elm$regex$Regex$fromString = function (string) {
14063	return A2(
14064		$elm$regex$Regex$fromStringWith,
14065		{fa: false, f6: false},
14066		string);
14067};
14068var $author$project$Utils$SimpleMarkdown$maybeRegexForBold = $elm$regex$Regex$fromString('\\*([^*]+)\\*');
14069var $elm$regex$Regex$split = _Regex_splitAtMost(_Regex_infinity);
14070var $author$project$Utils$SimpleMarkdown$parseTextForBold = function (text) {
14071	var _v0 = function () {
14072		var _v1 = $author$project$Utils$SimpleMarkdown$maybeRegexForBold;
14073		if (!_v1.$) {
14074			var regex = _v1.a;
14075			return _Utils_Tuple2(
14076				A2($elm$regex$Regex$find, regex, text),
14077				A2($elm$regex$Regex$split, regex, text));
14078		} else {
14079			return _Utils_Tuple2(_List_Nil, _List_Nil);
14080		}
14081	}();
14082	var find = _v0.a;
14083	var split = _v0.b;
14084	return $elm$core$List$concat(
14085		A2(
14086			$elm$core$List$indexedMap,
14087			F2(
14088				function (index, splitted) {
14089					var maybeGetFinding = function () {
14090						var _v3 = A2(
14091							$elm$core$Array$get,
14092							index,
14093							$elm$core$Array$fromList(find));
14094						if (!_v3.$) {
14095							var match = _v3.a;
14096							return $elm$core$Maybe$Just(
14097								A2(
14098									$elm$core$List$map,
14099									function (item_) {
14100										if (!item_.$) {
14101											var i = item_.a;
14102											return i;
14103										} else {
14104											return '';
14105										}
14106									},
14107									match.el));
14108						} else {
14109							return $elm$core$Maybe$Nothing;
14110						}
14111					}();
14112					if (!maybeGetFinding.$) {
14113						var getFinding = maybeGetFinding.a;
14114						return _List_fromArray(
14115							[
14116								$author$project$Utils$SimpleMarkdown$MarkDownText(splitted),
14117								$author$project$Utils$SimpleMarkdown$markDownParseBoldData(getFinding)
14118							]);
14119					} else {
14120						return _List_fromArray(
14121							[
14122								$author$project$Utils$SimpleMarkdown$MarkDownText(splitted)
14123							]);
14124					}
14125				}),
14126			split));
14127};
14128var $author$project$Utils$SimpleMarkdown$MarkDownLink = F2(
14129	function (a, b) {
14130		return {$: 1, a: a, b: b};
14131	});
14132var $elm$core$List$tail = function (list) {
14133	if (list.b) {
14134		var x = list.a;
14135		var xs = list.b;
14136		return $elm$core$Maybe$Just(xs);
14137	} else {
14138		return $elm$core$Maybe$Nothing;
14139	}
14140};
14141var $author$project$Utils$SimpleMarkdown$markDownParseLinkData = function (data) {
14142	var text2 = A2(
14143		$elm$core$Maybe$withDefault,
14144		'',
14145		$elm$core$List$head(
14146			A2(
14147				$elm$core$Maybe$withDefault,
14148				_List_Nil,
14149				$elm$core$List$tail(data))));
14150	var text1 = A2(
14151		$elm$core$Maybe$withDefault,
14152		'',
14153		$elm$core$List$head(data));
14154	return A2($author$project$Utils$SimpleMarkdown$MarkDownLink, text1, text2);
14155};
14156var $author$project$Utils$SimpleMarkdown$maybeRegexForLinks = $elm$regex$Regex$fromString('\\[([^\\[\\]]+)\\]\\(([^()]+)\\)');
14157var $author$project$Utils$SimpleMarkdown$parseTextForLinks = function (text) {
14158	var _v0 = function () {
14159		var _v1 = $author$project$Utils$SimpleMarkdown$maybeRegexForLinks;
14160		if (!_v1.$) {
14161			var regex = _v1.a;
14162			return _Utils_Tuple2(
14163				A2($elm$regex$Regex$find, regex, text),
14164				A2($elm$regex$Regex$split, regex, text));
14165		} else {
14166			return _Utils_Tuple2(_List_Nil, _List_Nil);
14167		}
14168	}();
14169	var find = _v0.a;
14170	var split = _v0.b;
14171	return $elm$core$List$concat(
14172		A2(
14173			$elm$core$List$indexedMap,
14174			F2(
14175				function (index, splitted) {
14176					var maybeGetFinding = function () {
14177						var _v3 = A2(
14178							$elm$core$Array$get,
14179							index,
14180							$elm$core$Array$fromList(find));
14181						if (!_v3.$) {
14182							var match = _v3.a;
14183							return $elm$core$Maybe$Just(
14184								A2(
14185									$elm$core$List$map,
14186									function (item_) {
14187										if (!item_.$) {
14188											var i = item_.a;
14189											return i;
14190										} else {
14191											return '';
14192										}
14193									},
14194									match.el));
14195						} else {
14196							return $elm$core$Maybe$Nothing;
14197						}
14198					}();
14199					if (!maybeGetFinding.$) {
14200						var getFinding = maybeGetFinding.a;
14201						return _List_fromArray(
14202							[
14203								$author$project$Utils$SimpleMarkdown$MarkDownText(splitted),
14204								$author$project$Utils$SimpleMarkdown$markDownParseLinkData(getFinding)
14205							]);
14206					} else {
14207						return _List_fromArray(
14208							[
14209								$author$project$Utils$SimpleMarkdown$MarkDownText(splitted)
14210							]);
14211					}
14212				}),
14213			split));
14214};
14215var $author$project$Utils$SimpleMarkdown$markdown = F4(
14216	function (boldGenerator, textGenerator, linkGenerator, string) {
14217		var step1 = $author$project$Utils$SimpleMarkdown$parseTextForLinks(string);
14218		var step2 = $elm$core$List$concat(
14219			A2(
14220				$elm$core$List$map,
14221				function (item) {
14222					if (!item.$) {
14223						var string_ = item.a;
14224						return $author$project$Utils$SimpleMarkdown$parseTextForBold(string_);
14225					} else {
14226						return _List_fromArray(
14227							[item]);
14228					}
14229				},
14230				step1));
14231		return A2(
14232			$elm$core$List$map,
14233			function (item) {
14234				switch (item.$) {
14235					case 0:
14236						var text = item.a;
14237						return textGenerator(text);
14238					case 2:
14239						var text = item.a;
14240						return boldGenerator(text);
14241					default:
14242						var linkLabel = item.a;
14243						var url = item.b;
14244						return A2(linkGenerator, linkLabel, url);
14245				}
14246			},
14247			step2);
14248	});
14249var $author$project$Utils$SimpleMarkdown$elementMarkdownAdvanced = F2(
14250	function (attrs, string) {
14251		var parts = A2($elm$core$String$split, '\n', string);
14252		return $elm$core$List$concat(
14253			A2(
14254				$elm$core$List$map,
14255				function (part) {
14256					return _Utils_ap(
14257						A4(
14258							$author$project$Utils$SimpleMarkdown$markdown,
14259							$author$project$Utils$SimpleMarkdown$elementBoldGenerator,
14260							$author$project$Utils$SimpleMarkdown$elementTextGenerator,
14261							$author$project$Utils$SimpleMarkdown$elementLinkGeneratorAdvanced(attrs),
14262							part),
14263						_List_fromArray(
14264							[
14265								$mdgriffith$elm_ui$Element$html(
14266								A2($elm$html$Html$br, _List_Nil, _List_Nil))
14267							]));
14268				},
14269				parts));
14270	});
14271var $elm$html$Html$Attributes$alt = $elm$html$Html$Attributes$stringProperty('alt');
14272var $elm$html$Html$Attributes$src = function (url) {
14273	return A2(
14274		$elm$html$Html$Attributes$stringProperty,
14275		'src',
14276		_VirtualDom_noJavaScriptOrHtmlUri(url));
14277};
14278var $mdgriffith$elm_ui$Element$image = F2(
14279	function (attrs, _v0) {
14280		var src = _v0.gI;
14281		var description = _v0.dl;
14282		var imageAttributes = A2(
14283			$elm$core$List$filter,
14284			function (a) {
14285				switch (a.$) {
14286					case 7:
14287						return true;
14288					case 8:
14289						return true;
14290					default:
14291						return false;

14292				}
14293			},
14294			attrs);
14295		return A4(
14296			$mdgriffith$elm_ui$Internal$Model$element,
14297			$mdgriffith$elm_ui$Internal$Model$asEl,
14298			$mdgriffith$elm_ui$Internal$Model$div,
14299			A2(
14300				$elm$core$List$cons,
14301				$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.fM),
14302				attrs),
14303			$mdgriffith$elm_ui$Internal$Model$Unkeyed(
14304				_List_fromArray(
14305					[
14306						A4(
14307						$mdgriffith$elm_ui$Internal$Model$element,
14308						$mdgriffith$elm_ui$Internal$Model$asEl,
14309						$mdgriffith$elm_ui$Internal$Model$NodeName('img'),
14310						_Utils_ap(
14311							_List_fromArray(
14312								[
14313									$mdgriffith$elm_ui$Internal$Model$Attr(
14314									$elm$html$Html$Attributes$src(src)),
14315									$mdgriffith$elm_ui$Internal$Model$Attr(
14316									$elm$html$Html$Attributes$alt(description))
14317								]),
14318							imageAttributes),
14319						$mdgriffith$elm_ui$Internal$Model$Unkeyed(_List_Nil))
14320					])));
14321	});
14322var $mdgriffith$elm_ui$Internal$Model$Max = F2(
14323	function (a, b) {
14324		return {$: 4, a: a, b: b};
14325	});
14326var $mdgriffith$elm_ui$Element$maximum = F2(
14327	function (i, l) {
14328		return A2($mdgriffith$elm_ui$Internal$Model$Max, i, l);
14329	});
14330var $author$project$Projects$Project$viewDetails = function (project) {
14331	return A2(
14332		$mdgriffith$elm_ui$Element$column,
14333		_List_fromArray(
14334			[
14335				$mdgriffith$elm_ui$Element$width(
14336				A2($mdgriffith$elm_ui$Element$maximum, 600, $mdgriffith$elm_ui$Element$fill))
14337			]),
14338		_List_fromArray(
14339			[
14340				$elm$core$String$isEmpty(project.a) ? $mdgriffith$elm_ui$Element$none : A2(
14341				$mdgriffith$elm_ui$Element$image,
14342				_List_fromArray(
14343					[
14344						$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill)
14345					]),
14346				{
14347					dl: project.g5,
14348					gI: _Utils_ap($author$project$Projects$Project$imagesLocation, project.a)
14349				}),
14350				A2(
14351				$mdgriffith$elm_ui$Element$column,
14352				_List_fromArray(
14353					[
14354						$mdgriffith$elm_ui$Element$padding(20),
14355						$mdgriffith$elm_ui$Element$spacing(20)
14356					]),
14357				_Utils_ap(
14358					_List_Nil,
14359					_Utils_ap(
14360						_List_fromArray(
14361							[
14362								A2(
14363								$mdgriffith$elm_ui$Element$paragraph,
14364								_List_fromArray(
14365									[
14366										$mdgriffith$elm_ui$Element$Font$size(30),
14367										$mdgriffith$elm_ui$Element$Font$bold
14368									]),
14369								_List_fromArray(
14370									[
14371										$mdgriffith$elm_ui$Element$text(project.g5)
14372									]))
14373							]),
14374						_Utils_ap(
14375							_List_fromArray(
14376								[
14377									A2(
14378									$mdgriffith$elm_ui$Element$wrappedRow,
14379									_List_fromArray(
14380										[
14381											$mdgriffith$elm_ui$Element$spacing(20)
14382										]),
14383									_Utils_ap(
14384										_List_Nil,
14385										_Utils_ap(
14386											A2($author$project$Projects$Project$createLinkIfNotEmpty, project.bT, 'Link'),
14387											_Utils_ap(
14388												A2($author$project$Projects$Project$createLinkIfNotEmpty, project.c, 'Code'),
14389												A2($author$project$Projects$Project$createLinkIfNotEmpty, project.d, 'Demo')))))
14390								]),
14391							$elm$core$String$isEmpty(project.b) ? _List_Nil : _List_fromArray(
14392								[
14393									A2(
14394									$mdgriffith$elm_ui$Element$paragraph,
14395									_List_fromArray(
14396										[
14397											$mdgriffith$elm_ui$Element$spacing(7)
14398										]),
14399									A2(
14400										$author$project$Utils$SimpleMarkdown$elementMarkdownAdvanced,
14401										{f_: $author$project$Projects$Project$linkAttrs},
14402										project.b))
14403								])))))
14404			]));
14405};
14406var $author$project$Main$viewOverlay = function (id) {
14407	var item = $author$project$Main$idToItem(id);
14408	var _v0 = $author$project$Main$previousNext(id);
14409	var previous_ = _v0.a;
14410	var next_ = _v0.b;
14411	var next = function () {
14412		if (!next_.$) {
14413			var url = next_.a;
14414			return A3(
14415				$author$project$Main$linkInternal,
14416				$author$project$Main$InternalLinkClicked,
14417				_List_fromArray(
14418					[
14419						$mdgriffith$elm_ui$Element$alignRight,
14420						$mdgriffith$elm_ui$Element$centerY,
14421						$mdgriffith$elm_ui$Element$moveLeft(10),
14422						$mdgriffith$elm_ui$Element$padding(20),
14423						$mdgriffith$elm_ui$Element$Background$color(
14424						A4($mdgriffith$elm_ui$Element$rgba, 1, 1, 1, 0.5)),
14425						$mdgriffith$elm_ui$Element$Border$rounded(50),
14426						$mdgriffith$elm_ui$Element$htmlAttribute(
14427						$elm$html$Html$Attributes$name('Next'))
14428					]),
14429				{
14430					cn: A2($author$project$Utils$Utils$iconRight, '#000', 48),
14431					bT: url
14432				});
14433		} else {
14434			return $mdgriffith$elm_ui$Element$none;
14435		}
14436	}();
14437	var previous = function () {
14438		if (!previous_.$) {
14439			var url = previous_.a;
14440			return A3(
14441				$author$project$Main$linkInternal,
14442				$author$project$Main$InternalLinkClicked,
14443				_List_fromArray(
14444					[
14445						$mdgriffith$elm_ui$Element$alignLeft,
14446						$mdgriffith$elm_ui$Element$centerY,
14447						$mdgriffith$elm_ui$Element$moveRight(10),
14448						$mdgriffith$elm_ui$Element$padding(20),

14449						$mdgriffith$elm_ui$Element$Background$color(
14450						A4($mdgriffith$elm_ui$Element$rgba, 1, 1, 1, 0.5)),
14451						$mdgriffith$elm_ui$Element$Border$rounded(50),
14452						$mdgriffith$elm_ui$Element$htmlAttribute(
14453						$elm$html$Html$Attributes$name('Previous'))
14454					]),
14455				{
14456					cn: A2($author$project$Utils$Utils$iconLeft, '#000', 48),
14457					bT: url
14458				});
14459		} else {
14460			return $mdgriffith$elm_ui$Element$none;
14461		}
14462	}();
14463	return _List_fromArray(
14464		[
14465			$mdgriffith$elm_ui$Element$inFront(
14466			A2(
14467				$mdgriffith$elm_ui$Element$el,
14468				_List_fromArray(
14469					[
14470						$mdgriffith$elm_ui$Element$centerX,
14471						$mdgriffith$elm_ui$Element$moveDown(20),
14472						$mdgriffith$elm_ui$Element$htmlAttribute(
14473						A2($elm$html$Html$Attributes$style, 'height', 'calc(100vh - 40px)')),
14474						$mdgriffith$elm_ui$Element$htmlAttribute(
14475						A2($elm$html$Html$Attributes$style, 'max-width', 'min(600px, calc(100vw - 40px))')),
14476						$mdgriffith$elm_ui$Element$Border$rounded(10),
14477						$mdgriffith$elm_ui$Element$Border$shadow(
14478						{
14479							e_: 10,
14480							fj: A4($mdgriffith$elm_ui$Element$rgba, 0, 0, 0, 0.2),
14481							f9: _Utils_Tuple2(0, 4),
14482							gC: 0
14483						}),
14484						$mdgriffith$elm_ui$Element$scrollbarY,
14485						$mdgriffith$elm_ui$Element$Background$color(
14486						A3($mdgriffith$elm_ui$Element$rgb, 1, 1, 1))
14487					]),
14488				$author$project$Projects$Project$viewDetails(item))),
14489			$mdgriffith$elm_ui$Element$inFront(previous),
14490			$mdgriffith$elm_ui$Element$inFront(next),
14491			$mdgriffith$elm_ui$Element$inFront(
14492			A3(
14493				$author$project$Main$linkInternal,
14494				$author$project$Main$InternalLinkClicked,
14495				_List_fromArray(
14496					[
14497						$mdgriffith$elm_ui$Element$alignRight,
14498						$mdgriffith$elm_ui$Element$htmlAttribute(
14499						$elm$html$Html$Attributes$name('Close')),
14500						$mdgriffith$elm_ui$Element$htmlAttribute(
14501						$elm$html$Html$Attributes$title('Close'))
14502					]),
14503				{
14504					cn: A2(
14505						$mdgriffith$elm_ui$Element$el,
14506						_List_fromArray(
14507							[
14508								$mdgriffith$elm_ui$Element$padding(20),
14509								$mdgriffith$elm_ui$Element$Background$color(
14510								A4($mdgriffith$elm_ui$Element$rgba, 1, 1, 1, 0.5)),
14511								$mdgriffith$elm_ui$Element$Border$roundEach(
14512								{e6: 20, e7: 0, g7: 0, g8: 0})
14513							]),
14514						A2($author$project$Utils$Utils$iconX, '', 30)),
14515					bT: '/'
14516				}))
14517		]);
14518};
14519var $author$project$Main$view = function (model) {
14520	return A2(
14521		$elm$html$Html$div,
14522		_List_fromArray(
14523			[
14524				$elm$html$Html$Attributes$id('elm')
14525			]),
14526		function () {
14527			var _v0 = model.W;
14528			if (_v0.$ === 1) {
14529				return A2(
14530					$elm$core$List$indexedMap,
14531					F2(
14532						function (index, item) {
14533							return A2(
14534								$elm$html$Html$div,
14535								_List_Nil,
14536								_List_fromArray(
14537									[
14538										A2(
14539										$elm$html$Html$h3,
14540										_List_Nil,
14541										_List_fromArray(
14542											[
14543												$elm$html$Html$text(
14544												$elm$core$String$fromInt(index + 1) + ('. ' + item.g5))
14545											])),
14546										A2(
14547										$elm$html$Html$p,
14548										_List_Nil,
14549										_List_fromArray(
14550											[
14551												$elm$html$Html$text(item.gp)
14552											]))
14553									]));
14554						}),
14555					$author$project$Projects$Project$items);
14556			} else {
14557				return _List_fromArray(
14558					[
14559						A2(
14560						$elm$html$Html$a,
14561						_List_fromArray(
14562							[
14563								$elm$html$Html$Attributes$class('skip-link'),
14564								$elm$html$Html$Attributes$href('#main')
14565							]),
14566						_List_fromArray(
14567							[
14568								$elm$html$Html$text('Skip to main')
14569							])),
14570						A2(
14571						$mdgriffith$elm_ui$Element$layout,
14572						_Utils_ap(
14573							_List_fromArray(
14574								[
14575									$mdgriffith$elm_ui$Element$Font$size(16),
14576									function () {
14577									var _v1 = $author$project$Main$isItemShowing(model.W);
14578									if (_v1.$ === 1) {
14579										return $mdgriffith$elm_ui$Element$htmlAttribute(
14580											$elm$html$Html$Attributes$class(''));
14581									} else {
14582										return $mdgriffith$elm_ui$Element$htmlAttribute(
14583											$elm$html$Html$Attributes$class('modal-open'));
14584									}
14585								}(),
14586									function () {
14587									var _v2 = $author$project$Main$isItemShowing(model.W);
14588									if (_v2.$ === 1) {
14589										return $mdgriffith$elm_ui$Element$inFront($mdgriffith$elm_ui$Element$none);
14590									} else {
14591										return $mdgriffith$elm_ui$Element$inFront(
14592											A2(
14593												$mdgriffith$elm_ui$Element$el,
14594												_List_fromArray(
14595													[

14596														$mdgriffith$elm_ui$Element$Background$color(
14597														A4($mdgriffith$elm_ui$Element$rgba, 0, 0, 0, 0.3)),
14598														$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
14599														$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$fill),
14600														$mdgriffith$elm_ui$Element$Events$onClick($author$project$Main$CloseModal)
14601													]),
14602												$mdgriffith$elm_ui$Element$none));
14603									}
14604								}()
14605								]),
14606							function () {
14607								var _v3 = $author$project$Main$isItemShowing(model.W);
14608								if (_v3.$ === 1) {
14609									return _List_Nil;
14610								} else {
14611									var id = _v3.a;
14612									return $author$project$Main$viewOverlay(id);
14613								}
14614							}()),
14615						$author$project$Main$viewMainPage(model))
14616					]);
14617			}
14618		}());
14619};
14620var $author$project$Main$main = $elm$browser$Browser$element(
14621	{fQ: $author$project$Main$init, gQ: $author$project$Main$subscriptions, ha: $author$project$Main$update, hd: $author$project$Main$view});
14622_Platform_export({'Main':{'init':$author$project$Main$main(
14623	A2(
14624		$elm$json$Json$Decode$andThen,
14625		function (locationHref) {
14626			return $elm$json$Json$Decode$succeed(
14627				{cw: locationHref});
14628		},
14629		A2($elm$json$Json$Decode$field, 'locationHref', $elm$json$Json$Decode$string)))(0)}});}(this));