https://elm-book-in-elm-book.netlify.app/index.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
80console.warn('Compiled in DEV mode. Follow the advice at https://elm-lang.org/0.19.0/optimize for better performance and smaller assets.');
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_UNUSED = F2(function(tag, value)
238{
239	return value;
240});
241
242var _Debug_log = 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_UNUSED(value)
269{
270	return '<internals>';
271}
272
273function _Debug_toString(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_UNUSED(identifier)
459{
460	throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');
461}
462
463
464function _Debug_crash(identifier, fact1, fact2, fact3, fact4)
465{
466	switch(identifier)
467	{
468		case 0:
469			throw new Error('What node should I take over? In JavaScript I need something like:\n\n    Elm.Main.init({\n        node: document.getElementById("elm-node")\n    })\n\nYou need to do this with any Browser.sandbox or Browser.element program.');
470
471		case 1:
472			throw new Error('Browser.application programs cannot handle URLs like this:\n\n    ' + document.location.href + '\n\nWhat is the root? The root of your file system? Try looking at this program with `elm reactor` or some other server.');
473
474		case 2:
475			var jsonErrorString = fact1;
476			throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString);
477
478		case 3:
479			var portName = fact1;
480			throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.');
481
482		case 4:
483			var portName = fact1;
484			var problem = fact2;
485			throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem);
486
487		case 5:
488			throw new Error('Trying to use `(==)` on functions.\nThere is no way to know if functions are "the same" in the Elm sense.\nRead more about this at https://package.elm-lang.org/packages/elm/core/latest/Basics#== which describes why it is this way and what the better version will look like.');
489
490		case 6:
491			var moduleName = fact1;
492			throw new Error('Your page is loading multiple Elm scripts with a module named ' + moduleName + '. Maybe a duplicate script is getting loaded accidentally? If not, rename one of them so I know which is which!');
493
494		case 8:
495			var moduleName = fact1;
496			var region = fact2;
497			var message = fact3;
498			throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message);
499
500		case 9:
501			var moduleName = fact1;
502			var region = fact2;
503			var value = fact3;
504			var message = fact4;
505			throw new Error(
506				'TODO in module `' + moduleName + '` from the `case` expression '
507				+ _Debug_regionToString(region) + '\n\nIt received the following value:\n\n    '
508				+ _Debug_toString(value).replace('\n', '\n    ')
509				+ '\n\nBut the branch that handles it says:\n\n    ' + message.replace('\n', '\n    ')
510			);
511
512		case 10:
513			throw new Error('Bug in https://github.com/elm/virtual-dom/issues');
514
515		case 11:
516			throw new Error('Cannot perform mod 0. Division by zero error.');
517	}
518}
519
520function _Debug_regionToString(region)
521{
522	if (region.start.line === region.end.line)
523	{
524		return 'on line ' + region.start.line;
525	}
526	return 'on lines ' + region.start.line + ' through ' + region.end.line;
527}
528
529
530
531// EQUALITY
532
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	/**/
565	if (x.$ === 'Set_elm_builtin')
566	{
567		x = elm$core$Set$toList(x);
568		y = elm$core$Set$toList(y);
569	}
570	if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')
571	{
572		x = elm$core$Dict$toList(x);
573		y = elm$core$Dict$toList(y);
574	}
575	//*/
576
577	/**_UNUSED/
578	if (x.$ < 0)
579	{
580		x = elm$core$Dict$toList(x);
581		y = elm$core$Dict$toList(y);
582	}
583	//*/
584
585	for (var key in x)
586	{
587		if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))
588		{
589			return false;
590		}
591	}
592	return true;
593}
594
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	/**/
613	if (x instanceof String)
614	{
615		var a = x.valueOf();
616		var b = y.valueOf();
617		return a === b ? 0 : a < b ? -1 : 1;
618	}
619	//*/
620
621	/**_UNUSED/
622	if (typeof x.$ === 'undefined')
623	//*/
624	/**/
625	if (x.$[0] === '#')
626	//*/
627	{
628		return (ord = _Utils_cmp(x.a, y.a))
629			? ord
630			: (ord = _Utils_cmp(x.b, y.b))
631				? ord
632				: _Utils_cmp(x.c, y.c);
633	}
634
635	// traverse conses until end of a list or a mismatch
636	for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES
637	return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);
638}
639
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_UNUSED = 0;
655var _Utils_Tuple0 = { $: '#0' };
656
657function _Utils_Tuple2_UNUSED(a, b) { return { a: a, b: b }; }
658function _Utils_Tuple2(a, b) { return { $: '#2', a: a, b: b }; }
659
660function _Utils_Tuple3_UNUSED(a, b, c) { return { a: a, b: b, c: c }; }
661function _Utils_Tuple3(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }
662
663function _Utils_chr_UNUSED(c) { return c; }
664function _Utils_chr(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_UNUSED = { $: 0 };
716var _List_Nil = { $: '[]' };
717
718function _List_Cons_UNUSED(hd, tl) { return { $: 1, a: hd, b: tl }; }
719function _List_Cons(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 _Bitwise_and = F2(function(a, b)
857{
858	return a & b;
859});
860
861var _Bitwise_or = F2(function(a, b)
862{
863	return a | b;
864});
865
866var _Bitwise_xor = F2(function(a, b)
867{
868	return a ^ b;
869});
870
871function _Bitwise_complement(a)
872{
873	return ~a;
874};
875
876var _Bitwise_shiftLeftBy = F2(function(offset, a)
877{
878	return a << offset;
879});
880
881var _Bitwise_shiftRightBy = F2(function(offset, a)
882{
883	return a >> offset;
884});
885
886var _Bitwise_shiftRightZfBy = F2(function(offset, a)
887{
888	return a >>> offset;
889});
890
891
892
893// TASKS
894
895function _Scheduler_succeed(value)
896{
897	return {
898		$: 0,
899		a: value
900	};
901}
902
903function _Scheduler_fail(error)
904{
905	return {
906		$: 1,
907		a: error
908	};
909}
910
911function _Scheduler_binding(callback)
912{
913	return {
914		$: 2,
915		b: callback,
916		c: null
917	};
918}
919
920var _Scheduler_andThen = F2(function(callback, task)
921{
922	return {
923		$: 3,
924		b: callback,
925		d: task
926	};
927});
928
929var _Scheduler_onError = F2(function(callback, task)
930{
931	return {
932		$: 4,
933		b: callback,
934		d: task
935	};
936});
937
938function _Scheduler_receive(callback)
939{
940	return {
941		$: 5,
942		b: callback
943	};
944}
945
946
947// PROCESSES
948
949var _Scheduler_guid = 0;
950
951function _Scheduler_rawSpawn(task)
952{
953	var proc = {
954		$: 0,
955		e: _Scheduler_guid++,
956		f: task,
957		g: null,
958		h: []
959	};
960
961	_Scheduler_enqueue(proc);
962
963	return proc;
964}
965
966function _Scheduler_spawn(task)
967{
968	return _Scheduler_binding(function(callback) {
969		callback(_Scheduler_succeed(_Scheduler_rawSpawn(task)));
970	});
971}
972
973function _Scheduler_rawSend(proc, msg)
974{
975	proc.h.push(msg);
976	_Scheduler_enqueue(proc);
977}
978
979var _Scheduler_send = F2(function(proc, msg)
980{
981	return _Scheduler_binding(function(callback) {
982		_Scheduler_rawSend(proc, msg);
983		callback(_Scheduler_succeed(_Utils_Tuple0));
984	});
985});
986
987function _Scheduler_kill(proc)
988{
989	return _Scheduler_binding(function(callback) {
990		var task = proc.f;
991		if (task.$ === 2 && task.c)
992		{
993			task.c();
994		}
995
996		proc.f = null;
997
998		callback(_Scheduler_succeed(_Utils_Tuple0));
999	});
1000}
1001
1002
1003/* STEP PROCESSES
1004
1005type alias Process =
1006  { $ : tag
1007  , id : unique_id
1008  , root : Task
1009  , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack }
1010  , mailbox : [msg]
1011  }
1012
1013*/
1014
1015
1016var _Scheduler_working = false;
1017var _Scheduler_queue = [];
1018
1019
1020function _Scheduler_enqueue(proc)
1021{
1022	_Scheduler_queue.push(proc);
1023	if (_Scheduler_working)
1024	{
1025		return;
1026	}
1027	_Scheduler_working = true;
1028	while (proc = _Scheduler_queue.shift())
1029	{
1030		_Scheduler_step(proc);
1031	}
1032	_Scheduler_working = false;
1033}
1034
1035
1036function _Scheduler_step(proc)
1037{
1038	while (proc.f)
1039	{
1040		var rootTag = proc.f.$;
1041		if (rootTag === 0 || rootTag === 1)
1042		{
1043			while (proc.g && proc.g.$ !== rootTag)
1044			{
1045				proc.g = proc.g.i;
1046			}
1047			if (!proc.g)
1048			{
1049				return;
1050			}
1051			proc.f = proc.g.b(proc.f.a);
1052			proc.g = proc.g.i;
1053		}
1054		else if (rootTag === 2)
1055		{
1056			proc.f.c = proc.f.b(function(newRoot) {
1057				proc.f = newRoot;
1058				_Scheduler_enqueue(proc);
1059			});
1060			return;
1061		}
1062		else if (rootTag === 5)
1063		{
1064			if (proc.h.length === 0)
1065			{
1066				return;
1067			}
1068			proc.f = proc.f.b(proc.h.shift());
1069		}
1070		else // if (rootTag === 3 || rootTag === 4)
1071		{
1072			proc.g = {
1073				$: rootTag === 3 ? 0 : 1,
1074				b: proc.f.b,
1075				i: proc.g
1076			};
1077			proc.f = proc.f.d;
1078		}
1079	}
1080}
1081
1082
1083
1084function _Char_toCode(char)
1085{
1086	var code = char.charCodeAt(0);
1087	if (0xD800 <= code && code <= 0xDBFF)
1088	{
1089		return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000
1090	}
1091	return code;
1092}
1093
1094function _Char_fromCode(code)
1095{
1096	return _Utils_chr(
1097		(code < 0 || 0x10FFFF < code)
1098			? '\uFFFD'
1099			:
1100		(code <= 0xFFFF)
1101			? String.fromCharCode(code)
1102			:
1103		(code -= 0x10000,
1104			String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)
1105		)
1106	);
1107}
1108
1109function _Char_toUpper(char)
1110{

1111	return _Utils_chr(char.toUpperCase());
1112}
1113
1114function _Char_toLower(char)
1115{
1116	return _Utils_chr(char.toLowerCase());
1117}
1118
1119function _Char_toLocaleUpper(char)
1120{
1121	return _Utils_chr(char.toLocaleUpperCase());
1122}
1123
1124function _Char_toLocaleLower(char)
1125{
1126	return _Utils_chr(char.toLocaleLowerCase());
1127}
1128
1129
1130
1131var _String_cons = F2(function(chr, str)
1132{
1133	return chr + str;
1134});
1135
1136function _String_uncons(string)
1137{
1138	var word = string.charCodeAt(0);
1139	return !isNaN(word)
1140		? elm$core$Maybe$Just(
1141			0xD800 <= word && word <= 0xDBFF
1142				? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))
1143				: _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))
1144		)
1145		: elm$core$Maybe$Nothing;
1146}
1147
1148var _String_append = F2(function(a, b)
1149{
1150	return a + b;
1151});
1152
1153function _String_length(str)
1154{
1155	return str.length;
1156}
1157
1158var _String_map = F2(function(func, string)
1159{
1160	var len = string.length;
1161	var array = new Array(len);
1162	var i = 0;
1163	while (i < len)
1164	{
1165		var word = string.charCodeAt(i);
1166		if (0xD800 <= word && word <= 0xDBFF)
1167		{
1168			array[i] = func(_Utils_chr(string[i] + string[i+1]));
1169			i += 2;
1170			continue;
1171		}
1172		array[i] = func(_Utils_chr(string[i]));
1173		i++;
1174	}
1175	return array.join('');
1176});
1177
1178var _String_filter = F2(function(isGood, str)
1179{
1180	var arr = [];
1181	var len = str.length;
1182	var i = 0;
1183	while (i < len)
1184	{
1185		var char = str[i];
1186		var word = str.charCodeAt(i);
1187		i++;
1188		if (0xD800 <= word && word <= 0xDBFF)
1189		{
1190			char += str[i];
1191			i++;
1192		}
1193
1194		if (isGood(_Utils_chr(char)))
1195		{
1196			arr.push(char);
1197		}
1198	}
1199	return arr.join('');
1200});
1201
1202function _String_reverse(str)
1203{
1204	var len = str.length;
1205	var arr = new Array(len);
1206	var i = 0;
1207	while (i < len)
1208	{
1209		var word = str.charCodeAt(i);
1210		if (0xD800 <= word && word <= 0xDBFF)
1211		{
1212			arr[len - i] = str[i + 1];
1213			i++;
1214			arr[len - i] = str[i - 1];
1215			i++;
1216		}
1217		else
1218		{
1219			arr[len - i] = str[i];
1220			i++;
1221		}
1222	}
1223	return arr.join('');
1224}
1225
1226var _String_foldl = F3(function(func, state, string)
1227{
1228	var len = string.length;
1229	var i = 0;
1230	while (i < len)
1231	{
1232		var char = string[i];
1233		var word = string.charCodeAt(i);
1234		i++;
1235		if (0xD800 <= word && word <= 0xDBFF)
1236		{
1237			char += string[i];
1238			i++;
1239		}
1240		state = A2(func, _Utils_chr(char), state);
1241	}
1242	return state;
1243});
1244
1245var _String_foldr = F3(function(func, state, string)
1246{
1247	var i = string.length;
1248	while (i--)
1249	{
1250		var char = string[i];
1251		var word = string.charCodeAt(i);
1252		if (0xDC00 <= word && word <= 0xDFFF)
1253		{
1254			i--;
1255			char = string[i] + char;
1256		}
1257		state = A2(func, _Utils_chr(char), state);
1258	}
1259	return state;
1260});
1261
1262var _String_split = F2(function(sep, str)
1263{
1264	return str.split(sep);
1265});
1266
1267var _String_join = F2(function(sep, strs)
1268{
1269	return strs.join(sep);
1270});
1271
1272var _String_slice = F3(function(start, end, str) {
1273	return str.slice(start, end);
1274});
1275
1276function _String_trim(str)
1277{
1278	return str.trim();
1279}
1280
1281function _String_trimLeft(str)
1282{
1283	return str.replace(/^\s+/, '');
1284}
1285
1286function _String_trimRight(str)
1287{
1288	return str.replace(/\s+$/, '');
1289}
1290
1291function _String_words(str)
1292{
1293	return _List_fromArray(str.trim().split(/\s+/g));
1294}
1295
1296function _String_lines(str)
1297{
1298	return _List_fromArray(str.split(/\r\n|\r|\n/g));
1299}
1300
1301function _String_toUpper(str)
1302{
1303	return str.toUpperCase();
1304}
1305
1306function _String_toLower(str)
1307{
1308	return str.toLowerCase();
1309}
1310
1311var _String_any = F2(function(isGood, string)
1312{
1313	var i = string.length;
1314	while (i--)
1315	{
1316		var char = string[i];
1317		var word = string.charCodeAt(i);
1318		if (0xDC00 <= word && word <= 0xDFFF)
1319		{
1320			i--;
1321			char = string[i] + char;
1322		}
1323		if (isGood(_Utils_chr(char)))
1324		{
1325			return true;
1326		}
1327	}
1328	return false;
1329});
1330
1331var _String_all = F2(function(isGood, string)
1332{
1333	var i = string.length;
1334	while (i--)
1335	{
1336		var char = string[i];
1337		var word = string.charCodeAt(i);
1338		if (0xDC00 <= word && word <= 0xDFFF)
1339		{
1340			i--;
1341			char = string[i] + char;
1342		}
1343		if (!isGood(_Utils_chr(char)))
1344		{
1345			return false;
1346		}
1347	}
1348	return true;
1349});
1350
1351var _String_contains = F2(function(sub, str)
1352{
1353	return str.indexOf(sub) > -1;
1354});
1355
1356var _String_startsWith = F2(function(sub, str)
1357{
1358	return str.indexOf(sub) === 0;
1359});
1360
1361var _String_endsWith = F2(function(sub, str)
1362{
1363	return str.length >= sub.length &&
1364		str.lastIndexOf(sub) === str.length - sub.length;
1365});
1366
1367var _String_indexes = F2(function(sub, str)
1368{
1369	var subLen = sub.length;
1370
1371	if (subLen < 1)
1372	{
1373		return _List_Nil;
1374	}
1375
1376	var i = 0;
1377	var is = [];
1378
1379	while ((i = str.indexOf(sub, i)) > -1)
1380	{
1381		is.push(i);
1382		i = i + subLen;
1383	}
1384
1385	return _List_fromArray(is);
1386});
1387
1388
1389// TO STRING
1390
1391function _String_fromNumber(number)
1392{
1393	return number + '';
1394}
1395
1396
1397// INT CONVERSIONS
1398
1399function _String_toInt(str)
1400{
1401	var total = 0;
1402	var code0 = str.charCodeAt(0);
1403	var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;
1404
1405	for (var i = start; i < str.length; ++i)
1406	{
1407		var code = str.charCodeAt(i);
1408		if (code < 0x30 || 0x39 < code)
1409		{
1410			return elm$core$Maybe$Nothing;
1411		}
1412		total = 10 * total + code - 0x30;
1413	}
1414
1415	return i == start
1416		? elm$core$Maybe$Nothing
1417		: elm$core$Maybe$Just(code0 == 0x2D ? -total : total);
1418}
1419
1420
1421// FLOAT CONVERSIONS
1422

1423function _String_toFloat(s)
1424{
1425	// check if it is a hex, octal, or binary number
1426	if (s.length === 0 || /[\sxbo]/.test(s))
1427	{
1428		return elm$core$Maybe$Nothing;
1429	}
1430	var n = +s;
1431	// faster isNaN check
1432	return n === n ? elm$core$Maybe$Just(n) : elm$core$Maybe$Nothing;
1433}
1434
1435function _String_fromList(chars)
1436{
1437	return _List_toArray(chars).join('');
1438}
1439
1440
1441
1442
1443/**/
1444function _Json_errorToString(error)
1445{
1446	return elm$json$Json$Decode$errorToString(error);
1447}
1448//*/
1449
1450
1451// CORE DECODERS
1452
1453function _Json_succeed(msg)
1454{
1455	return {
1456		$: 0,
1457		a: msg
1458	};
1459}
1460
1461function _Json_fail(msg)
1462{
1463	return {
1464		$: 1,
1465		a: msg
1466	};
1467}
1468
1469function _Json_decodePrim(decoder)
1470{
1471	return { $: 2, b: decoder };
1472}
1473
1474var _Json_decodeInt = _Json_decodePrim(function(value) {
1475	return (typeof value !== 'number')
1476		? _Json_expecting('an INT', value)
1477		:
1478	(-2147483647 < value && value < 2147483647 && (value | 0) === value)
1479		? elm$core$Result$Ok(value)
1480		:
1481	(isFinite(value) && !(value % 1))
1482		? elm$core$Result$Ok(value)
1483		: _Json_expecting('an INT', value);
1484});
1485
1486var _Json_decodeBool = _Json_decodePrim(function(value) {
1487	return (typeof value === 'boolean')
1488		? elm$core$Result$Ok(value)
1489		: _Json_expecting('a BOOL', value);
1490});
1491
1492var _Json_decodeFloat = _Json_decodePrim(function(value) {
1493	return (typeof value === 'number')
1494		? elm$core$Result$Ok(value)
1495		: _Json_expecting('a FLOAT', value);
1496});
1497
1498var _Json_decodeValue = _Json_decodePrim(function(value) {
1499	return elm$core$Result$Ok(_Json_wrap(value));
1500});
1501
1502var _Json_decodeString = _Json_decodePrim(function(value) {
1503	return (typeof value === 'string')
1504		? elm$core$Result$Ok(value)
1505		: (value instanceof String)
1506			? elm$core$Result$Ok(value + '')
1507			: _Json_expecting('a STRING', value);
1508});
1509
1510function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }
1511function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }
1512
1513function _Json_decodeNull(value) { return { $: 5, c: value }; }
1514
1515var _Json_decodeField = F2(function(field, decoder)
1516{
1517	return {
1518		$: 6,
1519		d: field,
1520		b: decoder
1521	};
1522});
1523
1524var _Json_decodeIndex = F2(function(index, decoder)
1525{
1526	return {
1527		$: 7,
1528		e: index,
1529		b: decoder
1530	};
1531});
1532
1533function _Json_decodeKeyValuePairs(decoder)
1534{
1535	return {
1536		$: 8,
1537		b: decoder
1538	};
1539}
1540
1541function _Json_mapMany(f, decoders)
1542{
1543	return {
1544		$: 9,
1545		f: f,
1546		g: decoders
1547	};
1548}
1549
1550var _Json_andThen = F2(function(callback, decoder)
1551{
1552	return {
1553		$: 10,
1554		b: decoder,
1555		h: callback
1556	};
1557});
1558
1559function _Json_oneOf(decoders)
1560{
1561	return {
1562		$: 11,
1563		g: decoders
1564	};
1565}
1566
1567
1568// DECODING OBJECTS
1569
1570var _Json_map1 = F2(function(f, d1)
1571{
1572	return _Json_mapMany(f, [d1]);
1573});
1574
1575var _Json_map2 = F3(function(f, d1, d2)
1576{
1577	return _Json_mapMany(f, [d1, d2]);
1578});
1579
1580var _Json_map3 = F4(function(f, d1, d2, d3)
1581{
1582	return _Json_mapMany(f, [d1, d2, d3]);
1583});
1584
1585var _Json_map4 = F5(function(f, d1, d2, d3, d4)
1586{
1587	return _Json_mapMany(f, [d1, d2, d3, d4]);
1588});
1589
1590var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)
1591{
1592	return _Json_mapMany(f, [d1, d2, d3, d4, d5]);
1593});
1594
1595var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)
1596{
1597	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);
1598});
1599
1600var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)
1601{
1602	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
1603});
1604
1605var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)
1606{
1607	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
1608});
1609
1610
1611// DECODE
1612
1613var _Json_runOnString = F2(function(decoder, string)
1614{
1615	try
1616	{
1617		var value = JSON.parse(string);
1618		return _Json_runHelp(decoder, value);
1619	}
1620	catch (e)
1621	{
1622		return elm$core$Result$Err(A2(elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string)));
1623	}
1624});
1625
1626var _Json_run = F2(function(decoder, value)
1627{
1628	return _Json_runHelp(decoder, _Json_unwrap(value));
1629});
1630
1631function _Json_runHelp(decoder, value)
1632{
1633	switch (decoder.$)
1634	{
1635		case 2:
1636			return decoder.b(value);
1637
1638		case 5:
1639			return (value === null)
1640				? elm$core$Result$Ok(decoder.c)
1641				: _Json_expecting('null', value);
1642
1643		case 3:
1644			if (!_Json_isArray(value))
1645			{
1646				return _Json_expecting('a LIST', value);
1647			}
1648			return _Json_runArrayDecoder(decoder.b, value, _List_fromArray);
1649
1650		case 4:
1651			if (!_Json_isArray(value))
1652			{
1653				return _Json_expecting('an ARRAY', value);
1654			}
1655			return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);
1656
1657		case 6:
1658			var field = decoder.d;
1659			if (typeof value !== 'object' || value === null || !(field in value))
1660			{
1661				return _Json_expecting('an OBJECT with a field named `' + field + '`', value);
1662			}
1663			var result = _Json_runHelp(decoder.b, value[field]);
1664			return (elm$core$Result$isOk(result)) ? result : elm$core$Result$Err(A2(elm$json$Json$Decode$Field, field, result.a));
1665
1666		case 7:
1667			var index = decoder.e;
1668			if (!_Json_isArray(value))
1669			{
1670				return _Json_expecting('an ARRAY', value);
1671			}
1672			if (index >= value.length)
1673			{
1674				return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);
1675			}
1676			var result = _Json_runHelp(decoder.b, value[index]);
1677			return (elm$core$Result$isOk(result)) ? result : elm$core$Result$Err(A2(elm$json$Json$Decode$Index, index, result.a));
1678
1679		case 8:
1680			if (typeof value !== 'object' || value === null || _Json_isArray(value))
1681			{
1682				return _Json_expecting('an OBJECT', value);
1683			}
1684
1685			var keyValuePairs = _List_Nil;
1686			// TODO test perf of Object.keys and switch when support is good enough
1687			for (var key in value)
1688			{
1689				if (value.hasOwnProperty(key))
1690				{
1691					var result = _Json_runHelp(decoder.b, value[key]);
1692					if (!elm$core$Result$isOk(result))
1693					{
1694						return elm$core$Result$Err(A2(elm$json$Json$Decode$Field, key, result.a));
1695					}

1696					keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);
1697				}
1698			}
1699			return elm$core$Result$Ok(elm$core$List$reverse(keyValuePairs));
1700
1701		case 9:
1702			var answer = decoder.f;
1703			var decoders = decoder.g;
1704			for (var i = 0; i < decoders.length; i++)
1705			{
1706				var result = _Json_runHelp(decoders[i], value);
1707				if (!elm$core$Result$isOk(result))
1708				{
1709					return result;
1710				}
1711				answer = answer(result.a);
1712			}
1713			return elm$core$Result$Ok(answer);
1714
1715		case 10:
1716			var result = _Json_runHelp(decoder.b, value);
1717			return (!elm$core$Result$isOk(result))
1718				? result
1719				: _Json_runHelp(decoder.h(result.a), value);
1720
1721		case 11:
1722			var errors = _List_Nil;
1723			for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS
1724			{
1725				var result = _Json_runHelp(temp.a, value);
1726				if (elm$core$Result$isOk(result))
1727				{
1728					return result;
1729				}
1730				errors = _List_Cons(result.a, errors);
1731			}
1732			return elm$core$Result$Err(elm$json$Json$Decode$OneOf(elm$core$List$reverse(errors)));
1733
1734		case 1:
1735			return elm$core$Result$Err(A2(elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));
1736
1737		case 0:
1738			return elm$core$Result$Ok(decoder.a);
1739	}
1740}
1741
1742function _Json_runArrayDecoder(decoder, value, toElmValue)
1743{
1744	var len = value.length;
1745	var array = new Array(len);
1746	for (var i = 0; i < len; i++)
1747	{
1748		var result = _Json_runHelp(decoder, value[i]);
1749		if (!elm$core$Result$isOk(result))
1750		{
1751			return elm$core$Result$Err(A2(elm$json$Json$Decode$Index, i, result.a));
1752		}
1753		array[i] = result.a;
1754	}
1755	return elm$core$Result$Ok(toElmValue(array));
1756}
1757
1758function _Json_isArray(value)
1759{
1760	return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);
1761}
1762
1763function _Json_toElmArray(array)
1764{
1765	return A2(elm$core$Array$initialize, array.length, function(i) { return array[i]; });
1766}
1767
1768function _Json_expecting(type, value)
1769{
1770	return elm$core$Result$Err(A2(elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));
1771}
1772
1773
1774// EQUALITY
1775
1776function _Json_equality(x, y)
1777{
1778	if (x === y)
1779	{
1780		return true;
1781	}
1782
1783	if (x.$ !== y.$)
1784	{
1785		return false;
1786	}
1787
1788	switch (x.$)
1789	{
1790		case 0:
1791		case 1:
1792			return x.a === y.a;
1793
1794		case 2:
1795			return x.b === y.b;
1796
1797		case 5:
1798			return x.c === y.c;
1799
1800		case 3:
1801		case 4:
1802		case 8:
1803			return _Json_equality(x.b, y.b);
1804
1805		case 6:
1806			return x.d === y.d && _Json_equality(x.b, y.b);
1807
1808		case 7:
1809			return x.e === y.e && _Json_equality(x.b, y.b);
1810
1811		case 9:
1812			return x.f === y.f && _Json_listEquality(x.g, y.g);
1813
1814		case 10:
1815			return x.h === y.h && _Json_equality(x.b, y.b);
1816
1817		case 11:
1818			return _Json_listEquality(x.g, y.g);
1819	}
1820}
1821
1822function _Json_listEquality(aDecoders, bDecoders)
1823{
1824	var len = aDecoders.length;
1825	if (len !== bDecoders.length)
1826	{
1827		return false;
1828	}
1829	for (var i = 0; i < len; i++)
1830	{
1831		if (!_Json_equality(aDecoders[i], bDecoders[i]))
1832		{
1833			return false;
1834		}
1835	}
1836	return true;
1837}
1838
1839
1840// ENCODE
1841
1842var _Json_encode = F2(function(indentLevel, value)
1843{
1844	return JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';
1845});
1846
1847function _Json_wrap(value) { return { $: 0, a: value }; }
1848function _Json_unwrap(value) { return value.a; }
1849
1850function _Json_wrap_UNUSED(value) { return value; }
1851function _Json_unwrap_UNUSED(value) { return value; }
1852
1853function _Json_emptyArray() { return []; }
1854function _Json_emptyObject() { return {}; }
1855
1856var _Json_addField = F3(function(key, value, object)
1857{
1858	object[key] = _Json_unwrap(value);
1859	return object;
1860});
1861
1862function _Json_addEntry(func)
1863{
1864	return F2(function(entry, array)
1865	{
1866		array.push(_Json_unwrap(func(entry)));
1867		return array;
1868	});
1869}
1870
1871var _Json_encodeNull = _Json_wrap(null);
1872
1873
1874
1875function _Process_sleep(time)
1876{
1877	return _Scheduler_binding(function(callback) {
1878		var id = setTimeout(function() {
1879			callback(_Scheduler_succeed(_Utils_Tuple0));
1880		}, time);
1881
1882		return function() { clearTimeout(id); };
1883	});
1884}
1885
1886
1887
1888
1889// PROGRAMS
1890
1891
1892var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args)
1893{
1894	return _Platform_initialize(
1895		flagDecoder,
1896		args,
1897		impl.init,
1898		impl.update,
1899		impl.subscriptions,
1900		function() { return function() {} }
1901	);
1902});
1903
1904
1905
1906// INITIALIZE A PROGRAM
1907
1908
1909function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder)
1910{
1911	var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined));
1912	elm$core$Result$isOk(result) || _Debug_crash(2 /**/, _Json_errorToString(result.a) /**/);
1913	var managers = {};
1914	var initPair = init(result.a);
1915	var model = initPair.a;
1916	var stepper = stepperBuilder(sendToApp, model);
1917	var ports = _Platform_setupEffects(managers, sendToApp);
1918
1919	function sendToApp(msg, viewMetadata)
1920	{
1921		var pair = A2(update, msg, model);
1922		stepper(model = pair.a, viewMetadata);
1923		_Platform_enqueueEffects(managers, pair.b, subscriptions(model));
1924	}
1925
1926	_Platform_enqueueEffects(managers, initPair.b, subscriptions(model));
1927
1928	return ports ? { ports: ports } : {};
1929}
1930
1931
1932
1933// TRACK PRELOADS
1934//
1935// This is used by code in elm/browser and elm/http
1936// to register any HTTP requests that are triggered by init.
1937//
1938
1939
1940var _Platform_preload;
1941
1942
1943function _Platform_registerPreload(url)
1944{
1945	_Platform_preload.add(url);
1946}
1947
1948
1949
1950// EFFECT MANAGERS
1951
1952
1953var _Platform_effectManagers = {};
1954
1955
1956function _Platform_setupEffects(managers, sendToApp)
1957{
1958	var ports;
1959
1960	// setup all necessary effect managers
1961	for (var key in _Platform_effectManagers)
1962	{
1963		var manager = _Platform_effectManagers[key];
1964
1965		if (manager.a)
1966		{
1967			ports = ports || {};
1968			ports[key] = manager.a(key, sendToApp);
1969		}
1970
1971		managers[key] = _Platform_instantiateManager(manager, sendToApp);
1972	}
1973
1974	return ports;
1975}
1976
1977
1978function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap)
1979{
1980	return {
1981		b: init,
1982		c: onEffects,
1983		d: onSelfMsg,
1984		e: cmdMap,
1985		f: subMap
1986	};
1987}
1988
1989
1990function _Platform_instantiateManager(info, sendToApp)
1991{
1992	var router = {
1993		g: sendToApp,
1994		h: undefined
1995	};
1996
1997	var onEffects = info.c;
1998	var onSelfMsg = info.d;
1999	var cmdMap = info.e;
2000	var subMap = info.f;

2001
2002	function loop(state)
2003	{
2004		return A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg)
2005		{
2006			var value = msg.a;
2007
2008			if (msg.$ === 0)
2009			{
2010				return A3(onSelfMsg, router, value, state);
2011			}
2012
2013			return cmdMap && subMap
2014				? A4(onEffects, router, value.i, value.j, state)
2015				: A3(onEffects, router, cmdMap ? value.i : value.j, state);
2016		}));
2017	}
2018
2019	return router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b));
2020}
2021
2022
2023
2024// ROUTING
2025
2026
2027var _Platform_sendToApp = F2(function(router, msg)
2028{
2029	return _Scheduler_binding(function(callback)
2030	{
2031		router.g(msg);
2032		callback(_Scheduler_succeed(_Utils_Tuple0));
2033	});
2034});
2035
2036
2037var _Platform_sendToSelf = F2(function(router, msg)
2038{
2039	return A2(_Scheduler_send, router.h, {
2040		$: 0,
2041		a: msg
2042	});
2043});
2044
2045
2046
2047// BAGS
2048
2049
2050function _Platform_leaf(home)
2051{
2052	return function(value)
2053	{
2054		return {
2055			$: 1,
2056			k: home,
2057			l: value
2058		};
2059	};
2060}
2061
2062
2063function _Platform_batch(list)
2064{
2065	return {
2066		$: 2,
2067		m: list
2068	};
2069}
2070
2071
2072var _Platform_map = F2(function(tagger, bag)
2073{
2074	return {
2075		$: 3,
2076		n: tagger,
2077		o: bag
2078	}
2079});
2080
2081
2082
2083// PIPE BAGS INTO EFFECT MANAGERS
2084//
2085// Effects must be queued!
2086//
2087// Say your init contains a synchronous command, like Time.now or Time.here
2088//
2089//   - This will produce a batch of effects (FX_1)
2090//   - The synchronous task triggers the subsequent `update` call
2091//   - This will produce a batch of effects (FX_2)
2092//
2093// If we just start dispatching FX_2, subscriptions from FX_2 can be processed
2094// before subscriptions from FX_1. No good! Earlier versions of this code had
2095// this problem, leading to these reports:
2096//
2097//   https://github.com/elm/core/issues/980
2098//   https://github.com/elm/core/pull/981
2099//   https://github.com/elm/compiler/issues/1776
2100//
2101// The queue is necessary to avoid ordering issues for synchronous commands.
2102
2103
2104// Why use true/false here? Why not just check the length of the queue?
2105// The goal is to detect "are we currently dispatching effects?" If we
2106// are, we need to bail and let the ongoing while loop handle things.
2107//
2108// Now say the queue has 1 element. When we dequeue the final element,
2109// the queue will be empty, but we are still actively dispatching effects.
2110// So you could get queue jumping in a really tricky category of cases.
2111//
2112var _Platform_effectsQueue = [];
2113var _Platform_effectsActive = false;
2114
2115
2116function _Platform_enqueueEffects(managers, cmdBag, subBag)
2117{
2118	_Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag });
2119
2120	if (_Platform_effectsActive) return;
2121
2122	_Platform_effectsActive = true;
2123	for (var fx; fx = _Platform_effectsQueue.shift(); )
2124	{
2125		_Platform_dispatchEffects(fx.p, fx.q, fx.r);
2126	}
2127	_Platform_effectsActive = false;
2128}
2129
2130
2131function _Platform_dispatchEffects(managers, cmdBag, subBag)
2132{
2133	var effectsDict = {};
2134	_Platform_gatherEffects(true, cmdBag, effectsDict, null);
2135	_Platform_gatherEffects(false, subBag, effectsDict, null);
2136
2137	for (var home in managers)
2138	{
2139		_Scheduler_rawSend(managers[home], {
2140			$: 'fx',
2141			a: effectsDict[home] || { i: _List_Nil, j: _List_Nil }
2142		});
2143	}
2144}
2145
2146
2147function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers)
2148{
2149	switch (bag.$)
2150	{
2151		case 1:
2152			var home = bag.k;
2153			var effect = _Platform_toEffect(isCmd, home, taggers, bag.l);
2154			effectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]);
2155			return;
2156
2157		case 2:
2158			for (var list = bag.m; list.b; list = list.b) // WHILE_CONS
2159			{
2160				_Platform_gatherEffects(isCmd, list.a, effectsDict, taggers);
2161			}
2162			return;
2163
2164		case 3:
2165			_Platform_gatherEffects(isCmd, bag.o, effectsDict, {
2166				s: bag.n,
2167				t: taggers
2168			});
2169			return;
2170	}
2171}
2172
2173
2174function _Platform_toEffect(isCmd, home, taggers, value)
2175{
2176	function applyTaggers(x)
2177	{
2178		for (var temp = taggers; temp; temp = temp.t)
2179		{
2180			x = temp.s(x);
2181		}
2182		return x;
2183	}
2184
2185	var map = isCmd
2186		? _Platform_effectManagers[home].e
2187		: _Platform_effectManagers[home].f;
2188
2189	return A2(map, applyTaggers, value)
2190}
2191
2192
2193function _Platform_insert(isCmd, newEffect, effects)
2194{
2195	effects = effects || { i: _List_Nil, j: _List_Nil };
2196
2197	isCmd
2198		? (effects.i = _List_Cons(newEffect, effects.i))
2199		: (effects.j = _List_Cons(newEffect, effects.j));
2200
2201	return effects;
2202}
2203
2204
2205
2206// PORTS
2207
2208
2209function _Platform_checkPortName(name)
2210{
2211	if (_Platform_effectManagers[name])
2212	{
2213		_Debug_crash(3, name)
2214	}
2215}
2216
2217
2218
2219// OUTGOING PORTS
2220
2221
2222function _Platform_outgoingPort(name, converter)
2223{
2224	_Platform_checkPortName(name);
2225	_Platform_effectManagers[name] = {
2226		e: _Platform_outgoingPortMap,
2227		u: converter,
2228		a: _Platform_setupOutgoingPort
2229	};
2230	return _Platform_leaf(name);
2231}
2232
2233
2234var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; });
2235
2236
2237function _Platform_setupOutgoingPort(name)
2238{
2239	var subs = [];
2240	var converter = _Platform_effectManagers[name].u;
2241
2242	// CREATE MANAGER
2243
2244	var init = _Process_sleep(0);
2245
2246	_Platform_effectManagers[name].b = init;
2247	_Platform_effectManagers[name].c = F3(function(router, cmdList, state)
2248	{
2249		for ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS
2250		{
2251			// grab a separate reference to subs in case unsubscribe is called
2252			var currentSubs = subs;
2253			var value = _Json_unwrap(converter(cmdList.a));
2254			for (var i = 0; i < currentSubs.length; i++)
2255			{
2256				currentSubs[i](value);
2257			}
2258		}
2259		return init;
2260	});
2261
2262	// PUBLIC API
2263
2264	function subscribe(callback)
2265	{
2266		subs.push(callback);
2267	}
2268
2269	function unsubscribe(callback)
2270	{
2271		// copy subs into a new array in case unsubscribe is called within a
2272		// subscribed callback
2273		subs = subs.slice();
2274		var index = subs.indexOf(callback);
2275		if (index >= 0)
2276		{
2277			subs.splice(index, 1);
2278		}
2279	}
2280
2281	return {
2282		subscribe: subscribe,
2283		unsubscribe: unsubscribe
2284	};
2285}
2286
2287
2288
2289// INCOMING PORTS
2290
2291
2292function _Platform_incomingPort(name, converter)
2293{
2294	_Platform_checkPortName(name);
2295	_Platform_effectManagers[name] = {
2296		f: _Platform_incomingPortMap,
2297		u: converter,
2298		a: _Platform_setupIncomingPort
2299	};
2300	return _Platform_leaf(name);
2301}
2302
2303
2304var _Platform_incomingPortMap = F2(function(tagger, finalTagger)
2305{
2306	return function(value)
2307	{
2308		return tagger(finalTagger(value));
2309	};
2310});
2311
2312
2313function _Platform_setupIncomingPort(name, sendToApp)
2314{
2315	var subs = _List_Nil;
2316	var converter = _Platform_effectManagers[name].u;
2317
2318	// CREATE MANAGER
2319
2320	var init = _Scheduler_succeed(null);
2321
2322	_Platform_effectManagers[name].b = init;
2323	_Platform_effectManagers[name].c = F3(function(router, subList, state)
2324	{
2325		subs = subList;
2326		return init;
2327	});
2328
2329	// PUBLIC API
2330
2331	function send(incomingValue)
2332	{
2333		var result = A2(_Json_run, converter, _Json_wrap(incomingValue));
2334
2335		elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a);
2336
2337		var value = result.a;
2338		for (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS
2339		{
2340			sendToApp(temp.a(value));
2341		}
2342	}
2343
2344	return { send: send };
2345}
2346
2347
2348
2349// EXPORT ELM MODULES
2350//

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

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

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

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

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

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

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

4219			callback(_Scheduler_succeed(Date.now()));
4220		});
4221
4222		return function() {
4223			_Browser_cancelAnimationFrame(id);
4224		};
4225	});
4226}
4227
4228
4229function _Browser_now()
4230{
4231	return _Scheduler_binding(function(callback)
4232	{
4233		callback(_Scheduler_succeed(Date.now()));
4234	});
4235}
4236
4237
4238
4239// DOM STUFF
4240
4241
4242function _Browser_withNode(id, doStuff)
4243{
4244	return _Scheduler_binding(function(callback)
4245	{
4246		_Browser_requestAnimationFrame(function() {
4247			var node = document.getElementById(id);
4248			callback(node
4249				? _Scheduler_succeed(doStuff(node))
4250				: _Scheduler_fail(elm$browser$Browser$Dom$NotFound(id))
4251			);
4252		});
4253	});
4254}
4255
4256
4257function _Browser_withWindow(doStuff)
4258{
4259	return _Scheduler_binding(function(callback)
4260	{
4261		_Browser_requestAnimationFrame(function() {
4262			callback(_Scheduler_succeed(doStuff()));
4263		});
4264	});
4265}
4266
4267
4268// FOCUS and BLUR
4269
4270
4271var _Browser_call = F2(function(functionName, id)
4272{
4273	return _Browser_withNode(id, function(node) {
4274		node[functionName]();
4275		return _Utils_Tuple0;
4276	});
4277});
4278
4279
4280
4281// WINDOW VIEWPORT
4282
4283
4284function _Browser_getViewport()
4285{
4286	return {
4287		scene: _Browser_getScene(),
4288		viewport: {
4289			x: _Browser_window.pageXOffset,
4290			y: _Browser_window.pageYOffset,
4291			width: _Browser_doc.documentElement.clientWidth,
4292			height: _Browser_doc.documentElement.clientHeight
4293		}
4294	};
4295}
4296
4297function _Browser_getScene()
4298{
4299	var body = _Browser_doc.body;
4300	var elem = _Browser_doc.documentElement;
4301	return {
4302		width: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth),
4303		height: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight)
4304	};
4305}
4306
4307var _Browser_setViewport = F2(function(x, y)
4308{
4309	return _Browser_withWindow(function()
4310	{
4311		_Browser_window.scroll(x, y);
4312		return _Utils_Tuple0;
4313	});
4314});
4315
4316
4317
4318// ELEMENT VIEWPORT
4319
4320
4321function _Browser_getViewportOf(id)
4322{
4323	return _Browser_withNode(id, function(node)
4324	{
4325		return {
4326			scene: {
4327				width: node.scrollWidth,
4328				height: node.scrollHeight
4329			},
4330			viewport: {
4331				x: node.scrollLeft,
4332				y: node.scrollTop,
4333				width: node.clientWidth,
4334				height: node.clientHeight
4335			}
4336		};
4337	});
4338}
4339
4340
4341var _Browser_setViewportOf = F3(function(id, x, y)
4342{
4343	return _Browser_withNode(id, function(node)
4344	{
4345		node.scrollLeft = x;
4346		node.scrollTop = y;
4347		return _Utils_Tuple0;
4348	});
4349});
4350
4351
4352
4353// ELEMENT
4354
4355
4356function _Browser_getElement(id)
4357{
4358	return _Browser_withNode(id, function(node)
4359	{
4360		var rect = node.getBoundingClientRect();
4361		var x = _Browser_window.pageXOffset;
4362		var y = _Browser_window.pageYOffset;
4363		return {
4364			scene: _Browser_getScene(),
4365			viewport: {
4366				x: x,
4367				y: y,
4368				width: _Browser_doc.documentElement.clientWidth,
4369				height: _Browser_doc.documentElement.clientHeight
4370			},
4371			element: {
4372				x: x + rect.left,
4373				y: y + rect.top,
4374				width: rect.width,
4375				height: rect.height
4376			}
4377		};
4378	});
4379}
4380
4381
4382
4383// LOAD and RELOAD
4384
4385
4386function _Browser_reload(skipCache)
4387{
4388	return A2(elm$core$Task$perform, elm$core$Basics$never, _Scheduler_binding(function(callback)
4389	{
4390		_VirtualDom_doc.location.reload(skipCache);
4391	}));
4392}
4393
4394function _Browser_load(url)
4395{
4396	return A2(elm$core$Task$perform, elm$core$Basics$never, _Scheduler_binding(function(callback)
4397	{
4398		try
4399		{
4400			_Browser_window.location = url;
4401		}
4402		catch(err)
4403		{
4404			// Only Firefox can throw a NS_ERROR_MALFORMED_URI exception here.
4405			// Other browsers reload the page, so let's be consistent about that.
4406			_VirtualDom_doc.location.reload(false);
4407		}
4408	}));
4409}
4410
4411
4412
4413
4414// STRINGS
4415
4416
4417var _Parser_isSubString = F5(function(smallString, offset, row, col, bigString)
4418{
4419	var smallLength = smallString.length;
4420	var isGood = offset + smallLength <= bigString.length;
4421
4422	for (var i = 0; isGood && i < smallLength; )
4423	{
4424		var code = bigString.charCodeAt(offset);
4425		isGood =
4426			smallString[i++] === bigString[offset++]
4427			&& (
4428				code === 0x000A /* \n */
4429					? ( row++, col=1 )
4430					: ( col++, (code & 0xF800) === 0xD800 ? smallString[i++] === bigString[offset++] : 1 )
4431			)
4432	}
4433

4434	return _Utils_Tuple3(isGood ? offset : -1, row, col);
4435});
4436
4437
4438
4439// CHARS
4440
4441
4442var _Parser_isSubChar = F3(function(predicate, offset, string)
4443{
4444	return (
4445		string.length <= offset
4446			? -1
4447			:
4448		(string.charCodeAt(offset) & 0xF800) === 0xD800
4449			? (predicate(_Utils_chr(string.substr(offset, 2))) ? offset + 2 : -1)
4450			:
4451		(predicate(_Utils_chr(string[offset]))
4452			? ((string[offset] === '\n') ? -2 : (offset + 1))
4453			: -1
4454		)
4455	);
4456});
4457
4458
4459var _Parser_isAsciiCode = F3(function(code, offset, string)
4460{
4461	return string.charCodeAt(offset) === code;
4462});
4463
4464
4465
4466// NUMBERS
4467
4468
4469var _Parser_chompBase10 = F2(function(offset, string)
4470{
4471	for (; offset < string.length; offset++)
4472	{
4473		var code = string.charCodeAt(offset);
4474		if (code < 0x30 || 0x39 < code)
4475		{
4476			return offset;
4477		}
4478	}
4479	return offset;
4480});
4481
4482
4483var _Parser_consumeBase = F3(function(base, offset, string)
4484{
4485	for (var total = 0; offset < string.length; offset++)
4486	{
4487		var digit = string.charCodeAt(offset) - 0x30;
4488		if (digit < 0 || base <= digit) break;
4489		total = base * total + digit;
4490	}
4491	return _Utils_Tuple2(offset, total);
4492});
4493
4494
4495var _Parser_consumeBase16 = F2(function(offset, string)
4496{
4497	for (var total = 0; offset < string.length; offset++)
4498	{
4499		var code = string.charCodeAt(offset);
4500		if (0x30 <= code && code <= 0x39)
4501		{
4502			total = 16 * total + code - 0x30;
4503		}
4504		else if (0x41 <= code && code <= 0x46)
4505		{
4506			total = 16 * total + code - 55;
4507		}
4508		else if (0x61 <= code && code <= 0x66)
4509		{
4510			total = 16 * total + code - 87;
4511		}
4512		else
4513		{
4514			break;
4515		}
4516	}
4517	return _Utils_Tuple2(offset, total);
4518});
4519
4520
4521
4522// FIND STRING
4523
4524
4525var _Parser_findSubString = F5(function(smallString, offset, row, col, bigString)
4526{
4527	var newOffset = bigString.indexOf(smallString, offset);
4528	var target = newOffset < 0 ? bigString.length : newOffset + smallString.length;
4529
4530	while (offset < target)
4531	{
4532		var code = bigString.charCodeAt(offset++);
4533		code === 0x000A /* \n */
4534			? ( col=1, row++ )
4535			: ( col++, (code & 0xF800) === 0xD800 && offset++ )
4536	}
4537
4538	return _Utils_Tuple3(newOffset, row, col);
4539});
4540
4541
4542// CREATE
4543
4544var _Regex_never = /.^/;
4545
4546var _Regex_fromStringWith = F2(function(options, string)
4547{
4548	var flags = 'g';
4549	if (options.multiline) { flags += 'm'; }
4550	if (options.caseInsensitive) { flags += 'i'; }
4551
4552	try
4553	{
4554		return elm$core$Maybe$Just(new RegExp(string, flags));
4555	}
4556	catch(error)
4557	{
4558		return elm$core$Maybe$Nothing;
4559	}
4560});
4561
4562
4563// USE
4564
4565var _Regex_contains = F2(function(re, string)
4566{
4567	return string.match(re) !== null;
4568});
4569
4570
4571var _Regex_findAtMost = F3(function(n, re, str)
4572{
4573	var out = [];
4574	var number = 0;
4575	var string = str;
4576	var lastIndex = re.lastIndex;
4577	var prevLastIndex = -1;
4578	var result;
4579	while (number++ < n && (result = re.exec(string)))
4580	{
4581		if (prevLastIndex == re.lastIndex) break;
4582		var i = result.length - 1;
4583		var subs = new Array(i);
4584		while (i > 0)
4585		{
4586			var submatch = result[i];
4587			subs[--i] = submatch
4588				? elm$core$Maybe$Just(submatch)
4589				: elm$core$Maybe$Nothing;
4590		}
4591		out.push(A4(elm$regex$Regex$Match, result[0], result.index, number, _List_fromArray(subs)));
4592		prevLastIndex = re.lastIndex;
4593	}
4594	re.lastIndex = lastIndex;
4595	return _List_fromArray(out);
4596});
4597
4598
4599var _Regex_replaceAtMost = F4(function(n, re, replacer, string)
4600{
4601	var count = 0;
4602	function jsReplacer(match)
4603	{
4604		if (count++ >= n)
4605		{
4606			return match;
4607		}
4608		var i = arguments.length - 3;
4609		var submatches = new Array(i);
4610		while (i > 0)
4611		{
4612			var submatch = arguments[i];
4613			submatches[--i] = submatch
4614				? elm$core$Maybe$Just(submatch)
4615				: elm$core$Maybe$Nothing;
4616		}
4617		return replacer(A4(elm$regex$Regex$Match, match, arguments[arguments.length - 2], count, _List_fromArray(submatches)));
4618	}
4619	return string.replace(re, jsReplacer);
4620});
4621
4622var _Regex_splitAtMost = F3(function(n, re, str)
4623{
4624	var string = str;
4625	var out = [];
4626	var start = re.lastIndex;
4627	var restoreLastIndex = re.lastIndex;
4628	while (n--)
4629	{
4630		var result = re.exec(string);
4631		if (!result) break;
4632		out.push(string.slice(start, result.index));
4633		start = re.lastIndex;
4634	}
4635	out.push(string.slice(start));
4636	re.lastIndex = restoreLastIndex;
4637	return _List_fromArray(out);
4638});
4639
4640var _Regex_infinity = Infinity;
4641
4642
4643function _Url_percentEncode(string)
4644{
4645	return encodeURIComponent(string);
4646}
4647
4648function _Url_percentDecode(string)
4649{
4650	try
4651	{
4652		return elm$core$Maybe$Just(decodeURIComponent(string));
4653	}
4654	catch (e)
4655	{
4656		return elm$core$Maybe$Nothing;
4657	}
4658}var dtwrks$elm_book$ElmBook$Internal$Book$BookBuilder = function (a) {
4659	return {$: 'BookBuilder', a: a};
4660};
4661var elm$core$Basics$False = {$: 'False'};
4662var dtwrks$elm_book$ElmBook$Internal$Chapter$defaultOptions = {hiddenTitle: false};
4663var dtwrks$elm_book$ElmBook$Internal$ComponentOptions$Card = {$: 'Card'};
4664var dtwrks$elm_book$ElmBook$Internal$ComponentOptions$defaultOptions = {background: '', display: dtwrks$elm_book$ElmBook$Internal$ComponentOptions$Card, fullWidth: false, hiddenLabel: false};
4665var elm$core$Basics$identity = function (x) {
4666	return x;
4667};
4668var elm$core$Maybe$Nothing = {$: 'Nothing'};
4669var elm$core$Basics$EQ = {$: 'EQ'};
4670var elm$core$Basics$LT = {$: 'LT'};
4671var elm$core$Elm$JsArray$foldr = _JsArray_foldr;
4672var elm$core$Array$foldr = F3(
4673	function (func, baseCase, _n0) {
4674		var tree = _n0.c;
4675		var tail = _n0.d;
4676		var helper = F2(
4677			function (node, acc) {
4678				if (node.$ === 'SubTree') {
4679					var subTree = node.a;
4680					return A3(elm$core$Elm$JsArray$foldr, helper, acc, subTree);
4681				} else {
4682					var values = node.a;
4683					return A3(elm$core$Elm$JsArray$foldr, func, acc, values);
4684				}
4685			});
4686		return A3(
4687			elm$core$Elm$JsArray$foldr,
4688			helper,
4689			A3(elm$core$Elm$JsArray$foldr, func, baseCase, tail),
4690			tree);
4691	});
4692var elm$core$List$cons = _List_cons;
4693var elm$core$Array$toList = function (array) {
4694	return A3(elm$core$Array$foldr, elm$core$List$cons, _List_Nil, array);
4695};
4696var elm$core$Basics$GT = {$: 'GT'};
4697var elm$core$Dict$foldr = F3(
4698	function (func, acc, t) {
4699		foldr:
4700		while (true) {
4701			if (t.$ === 'RBEmpty_elm_builtin') {
4702				return acc;
4703			} else {
4704				var key = t.b;
4705				var value = t.c;
4706				var left = t.d;
4707				var right = t.e;
4708				var $temp$func = func,
4709					$temp$acc = A3(
4710					func,
4711					key,
4712					value,
4713					A3(elm$core$Dict$foldr, func, acc, right)),
4714					$temp$t = left;
4715				func = $temp$func;
4716				acc = $temp$acc;
4717				t = $temp$t;
4718				continue foldr;
4719			}
4720		}
4721	});
4722var elm$core$Dict$toList = function (dict) {
4723	return A3(
4724		elm$core$Dict$foldr,
4725		F3(
4726			function (key, value, list) {
4727				return A2(
4728					elm$core$List$cons,
4729					_Utils_Tuple2(key, value),
4730					list);
4731			}),
4732		_List_Nil,
4733		dict);
4734};
4735var elm$core$Dict$keys = function (dict) {
4736	return A3(
4737		elm$core$Dict$foldr,
4738		F3(
4739			function (key, value, keyList) {

4740				return A2(elm$core$List$cons, key, keyList);
4741			}),
4742		_List_Nil,
4743		dict);
4744};
4745var elm$core$Set$toList = function (_n0) {
4746	var dict = _n0.a;
4747	return elm$core$Dict$keys(dict);
4748};
4749var dtwrks$elm_book$ElmBook$Internal$StatefulOptions$defaultOptions = {
4750	initialState: elm$core$Maybe$Nothing,
4751	onDarkModeChange: function (_n0) {
4752		return elm$core$Basics$identity;
4753	},
4754	subscriptions: _List_Nil
4755};
4756var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultAccent = '#ffffff';
4757var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultBackgroundEnd = '#56cfff';
4758var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultBackgroundStart = '#0087cf';
4759var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultNavAccent = '#bdecff';
4760var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultNavAccentHighlight = '#ffffff';
4761var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultNavBackground = '#ffffff';
4762var elm$core$Basics$append = _Utils_append;
4763var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultTheme = {accent: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultAccent, background: 'linear-gradient(150deg, ' + (dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultBackgroundStart + (' 0%, ' + (dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultBackgroundEnd + ' 100%)'))), fontMonospace: 'Fira Code', fontSans: 'IBM Plex Sans', fontSerif: 'IBM Plex Serif', globals: elm$core$Maybe$Nothing, hashBasedNavigation: false, header: elm$core$Maybe$Nothing, logo: elm$core$Maybe$Nothing, navAccent: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultNavAccent, navAccentHighlight: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultNavAccentHighlight, navBackground: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultNavBackground, preferDarkMode: false, routePrefix: '', subtitle: elm$core$Maybe$Nothing};
4764var dtwrks$elm_book$ElmBook$Custom$customBook = F2(
4765	function (toHtml, title) {
4766		return dtwrks$elm_book$ElmBook$Internal$Book$BookBuilder(
4767			{chapterOptions: dtwrks$elm_book$ElmBook$Internal$Chapter$defaultOptions, componentOptions: dtwrks$elm_book$ElmBook$Internal$ComponentOptions$defaultOptions, statefulOptions: dtwrks$elm_book$ElmBook$Internal$StatefulOptions$defaultOptions, themeOptions: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultTheme, title: title, toHtml: toHtml});
4768	});
4769var dtwrks$elm_book$ElmBook$book = dtwrks$elm_book$ElmBook$Custom$customBook(elm$core$Basics$identity);
4770var elm$core$Basics$apR = F2(
4771	function (x, f) {
4772		return f(x);
4773	});
4774var elm$core$Maybe$withDefault = F2(
4775	function (_default, maybe) {
4776		if (maybe.$ === 'Just') {
4777			var value = maybe.a;
4778			return value;
4779		} else {
4780			return _default;
4781		}
4782	});
4783var dtwrks$elm_book$ElmBook$Internal$Application$extractPath = F2(
4784	function (hashBasedNavigation, url) {
4785		return hashBasedNavigation ? A2(elm$core$Maybe$withDefault, '/', url.fragment) : url.path;
4786	});
4787var elm$core$Array$branchFactor = 32;
4788var elm$core$Basics$ceiling = _Basics_ceiling;
4789var elm$core$Basics$fdiv = _Basics_fdiv;
4790var elm$core$Basics$logBase = F2(
4791	function (base, number) {
4792		return _Basics_log(number) / _Basics_log(base);
4793	});
4794var elm$core$Basics$toFloat = _Basics_toFloat;
4795var elm$core$Array$shiftStep = elm$core$Basics$ceiling(
4796	A2(elm$core$Basics$logBase, 2, elm$core$Array$branchFactor));
4797var elm$core$Basics$sub = _Basics_sub;
4798var elm$core$Bitwise$shiftRightZfBy = _Bitwise_shiftRightZfBy;
4799var elm$core$Array$bitMask = 4294967295 >>> (32 - elm$core$Array$shiftStep);
4800var elm$core$Basics$apL = F2(
4801	function (f, x) {
4802		return f(x);
4803	});
4804var elm$core$Bitwise$and = _Bitwise_and;
4805var elm$core$Elm$JsArray$unsafeGet = _JsArray_unsafeGet;
4806var elm$core$Array$getHelp = F3(
4807	function (shift, index, tree) {
4808		getHelp:
4809		while (true) {
4810			var pos = elm$core$Array$bitMask & (index >>> shift);
4811			var _n0 = A2(elm$core$Elm$JsArray$unsafeGet, pos, tree);
4812			if (_n0.$ === 'SubTree') {
4813				var subTree = _n0.a;
4814				var $temp$shift = shift - elm$core$Array$shiftStep,
4815					$temp$index = index,
4816					$temp$tree = subTree;
4817				shift = $temp$shift;
4818				index = $temp$index;
4819				tree = $temp$tree;
4820				continue getHelp;
4821			} else {
4822				var values = _n0.a;
4823				return A2(elm$core$Elm$JsArray$unsafeGet, elm$core$Array$bitMask & index, values);
4824			}
4825		}
4826	});
4827var elm$core$Bitwise$shiftLeftBy = _Bitwise_shiftLeftBy;
4828var elm$core$Array$tailIndex = function (len) {
4829	return (len >>> 5) << 5;
4830};
4831var elm$core$Basics$ge = _Utils_ge;
4832var elm$core$Basics$lt = _Utils_lt;
4833var elm$core$Basics$or = _Basics_or;
4834var elm$core$Maybe$Just = function (a) {
4835	return {$: 'Just', a: a};
4836};
4837var elm$core$Array$get = F2(
4838	function (index, _n0) {
4839		var len = _n0.a;
4840		var startShift = _n0.b;
4841		var tree = _n0.c;
4842		var tail = _n0.d;
4843		return ((index < 0) || (_Utils_cmp(index, len) > -1)) ? elm$core$Maybe$Nothing : ((_Utils_cmp(
4844			index,
4845			elm$core$Array$tailIndex(len)) > -1) ? elm$core$Maybe$Just(
4846			A2(elm$core$Elm$JsArray$unsafeGet, elm$core$Array$bitMask & index, tail)) : elm$core$Maybe$Just(
4847			A3(elm$core$Array$getHelp, startShift, index, tree)));
4848	});
4849var elm$core$Basics$compare = _Utils_compare;
4850var elm$core$Dict$get = F2(
4851	function (targetKey, dict) {
4852		get:
4853		while (true) {
4854			if (dict.$ === 'RBEmpty_elm_builtin') {
4855				return elm$core$Maybe$Nothing;
4856			} else {
4857				var key = dict.b;
4858				var value = dict.c;
4859				var left = dict.d;
4860				var right = dict.e;

4861				var _n1 = A2(elm$core$Basics$compare, targetKey, key);
4862				switch (_n1.$) {
4863					case 'LT':
4864						var $temp$targetKey = targetKey,
4865							$temp$dict = left;
4866						targetKey = $temp$targetKey;
4867						dict = $temp$dict;
4868						continue get;
4869					case 'EQ':
4870						return elm$core$Maybe$Just(value);
4871					default:
4872						var $temp$targetKey = targetKey,
4873							$temp$dict = right;
4874						targetKey = $temp$targetKey;
4875						dict = $temp$dict;
4876						continue get;
4877				}
4878			}
4879		}
4880	});
4881var elm$core$Maybe$andThen = F2(
4882	function (callback, maybeValue) {
4883		if (maybeValue.$ === 'Just') {
4884			var value = maybeValue.a;
4885			return callback(value);
4886		} else {
4887			return elm$core$Maybe$Nothing;
4888		}
4889	});
4890var dtwrks$elm_book$ElmBook$Internal$Book$chapterFromUrl = F2(
4891	function (config, url) {
4892		return A2(
4893			elm$core$Maybe$andThen,
4894			function (i) {
4895				return A2(elm$core$Array$get, i, config.chapters);
4896			},
4897			A2(elm$core$Dict$get, url, config.chapterByUrl));
4898	});
4899var elm$core$Basics$and = _Basics_and;
4900var dtwrks$elm_book$ElmBook$Internal$Chapter$chapterNavUrl = F2(
4901	function (hashBasedNavigation, _n0) {
4902		var url = _n0.a.url;
4903		var internal = _n0.a.internal;
4904		return (internal && hashBasedNavigation) ? ('#' + url) : url;
4905	});
4906var dtwrks$elm_book$ElmBook$Internal$Chapter$init = function (_n0) {
4907	var chapter = _n0.a;
4908	return chapter.init;
4909};
4910var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultOverrides = {accent: elm$core$Maybe$Nothing, background: elm$core$Maybe$Nothing, navAccent: elm$core$Maybe$Nothing, navAccentHighlight: elm$core$Maybe$Nothing, navBackground: elm$core$Maybe$Nothing};
4911var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$hashBasedNavigation = function ($) {
4912	return $.hashBasedNavigation;
4913};
4914var elm$browser$Browser$External = function (a) {
4915	return {$: 'External', a: a};
4916};
4917var elm$browser$Browser$Internal = function (a) {
4918	return {$: 'Internal', a: a};
4919};
4920var elm$browser$Browser$Dom$NotFound = function (a) {
4921	return {$: 'NotFound', a: a};
4922};
4923var elm$core$Basics$never = function (_n0) {
4924	never:
4925	while (true) {
4926		var nvr = _n0.a;
4927		var $temp$_n0 = nvr;
4928		_n0 = $temp$_n0;
4929		continue never;
4930	}
4931};
4932var elm$core$Basics$True = {$: 'True'};
4933var elm$core$Result$isOk = function (result) {
4934	if (result.$ === 'Ok') {
4935		return true;
4936	} else {
4937		return false;
4938	}
4939};
4940var elm$core$Task$Perform = function (a) {
4941	return {$: 'Perform', a: a};
4942};
4943var elm$core$Task$succeed = _Scheduler_succeed;
4944var elm$core$Task$init = elm$core$Task$succeed(_Utils_Tuple0);
4945var elm$core$Basics$add = _Basics_add;
4946var elm$core$Basics$gt = _Utils_gt;
4947var elm$core$List$foldl = F3(
4948	function (func, acc, list) {
4949		foldl:
4950		while (true) {
4951			if (!list.b) {
4952				return acc;
4953			} else {
4954				var x = list.a;
4955				var xs = list.b;
4956				var $temp$func = func,
4957					$temp$acc = A2(func, x, acc),
4958					$temp$list = xs;
4959				func = $temp$func;
4960				acc = $temp$acc;
4961				list = $temp$list;
4962				continue foldl;
4963			}
4964		}
4965	});
4966var elm$core$List$reverse = function (list) {
4967	return A3(elm$core$List$foldl, elm$core$List$cons, _List_Nil, list);
4968};
4969var elm$core$List$foldrHelper = F4(
4970	function (fn, acc, ctr, ls) {
4971		if (!ls.b) {
4972			return acc;
4973		} else {
4974			var a = ls.a;
4975			var r1 = ls.b;
4976			if (!r1.b) {
4977				return A2(fn, a, acc);
4978			} else {
4979				var b = r1.a;
4980				var r2 = r1.b;
4981				if (!r2.b) {
4982					return A2(
4983						fn,
4984						a,
4985						A2(fn, b, acc));
4986				} else {
4987					var c = r2.a;
4988					var r3 = r2.b;
4989					if (!r3.b) {
4990						return A2(
4991							fn,
4992							a,
4993							A2(
4994								fn,
4995								b,
4996								A2(fn, c, acc)));
4997					} else {
4998						var d = r3.a;
4999						var r4 = r3.b;
5000						var res = (ctr > 500) ? A3(
5001							elm$core$List$foldl,
5002							fn,
5003							acc,
5004							elm$core$List$reverse(r4)) : A4(elm$core$List$foldrHelper, fn, acc, ctr + 1, r4);
5005						return A2(
5006							fn,
5007							a,
5008							A2(
5009								fn,
5010								b,
5011								A2(
5012									fn,
5013									c,
5014									A2(fn, d, res))));
5015					}
5016				}
5017			}
5018		}
5019	});
5020var elm$core$List$foldr = F3(
5021	function (fn, acc, ls) {
5022		return A4(elm$core$List$foldrHelper, fn, acc, 0, ls);
5023	});
5024var elm$core$List$map = F2(
5025	function (f, xs) {
5026		return A3(
5027			elm$core$List$foldr,
5028			F2(
5029				function (x, acc) {
5030					return A2(
5031						elm$core$List$cons,
5032						f(x),
5033						acc);
5034				}),
5035			_List_Nil,
5036			xs);
5037	});
5038var elm$core$Task$andThen = _Scheduler_andThen;
5039var elm$core$Task$map = F2(
5040	function (func, taskA) {
5041		return A2(
5042			elm$core$Task$andThen,
5043			function (a) {
5044				return elm$core$Task$succeed(
5045					func(a));
5046			},
5047			taskA);
5048	});
5049var elm$core$Task$map2 = F3(
5050	function (func, taskA, taskB) {
5051		return A2(
5052			elm$core$Task$andThen,
5053			function (a) {
5054				return A2(
5055					elm$core$Task$andThen,
5056					function (b) {
5057						return elm$core$Task$succeed(
5058							A2(func, a, b));
5059					},
5060					taskB);
5061			},
5062			taskA);
5063	});
5064var elm$core$Task$sequence = function (tasks) {
5065	return A3(
5066		elm$core$List$foldr,
5067		elm$core$Task$map2(elm$core$List$cons),
5068		elm$core$Task$succeed(_List_Nil),
5069		tasks);
5070};
5071var elm$core$Array$Array_elm_builtin = F4(
5072	function (a, b, c, d) {

5073		return {$: 'Array_elm_builtin', a: a, b: b, c: c, d: d};
5074	});
5075var elm$core$Elm$JsArray$empty = _JsArray_empty;
5076var 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);
5077var elm$core$Array$Leaf = function (a) {
5078	return {$: 'Leaf', a: a};
5079};
5080var elm$core$Array$SubTree = function (a) {
5081	return {$: 'SubTree', a: a};
5082};
5083var elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;
5084var elm$core$Array$compressNodes = F2(
5085	function (nodes, acc) {
5086		compressNodes:
5087		while (true) {
5088			var _n0 = A2(elm$core$Elm$JsArray$initializeFromList, elm$core$Array$branchFactor, nodes);
5089			var node = _n0.a;
5090			var remainingNodes = _n0.b;
5091			var newAcc = A2(
5092				elm$core$List$cons,
5093				elm$core$Array$SubTree(node),
5094				acc);
5095			if (!remainingNodes.b) {
5096				return elm$core$List$reverse(newAcc);
5097			} else {
5098				var $temp$nodes = remainingNodes,
5099					$temp$acc = newAcc;
5100				nodes = $temp$nodes;
5101				acc = $temp$acc;
5102				continue compressNodes;
5103			}
5104		}
5105	});
5106var elm$core$Basics$eq = _Utils_equal;
5107var elm$core$Tuple$first = function (_n0) {
5108	var x = _n0.a;
5109	return x;
5110};
5111var elm$core$Array$treeFromBuilder = F2(
5112	function (nodeList, nodeListSize) {
5113		treeFromBuilder:
5114		while (true) {
5115			var newNodeSize = elm$core$Basics$ceiling(nodeListSize / elm$core$Array$branchFactor);
5116			if (newNodeSize === 1) {
5117				return A2(elm$core$Elm$JsArray$initializeFromList, elm$core$Array$branchFactor, nodeList).a;
5118			} else {
5119				var $temp$nodeList = A2(elm$core$Array$compressNodes, nodeList, _List_Nil),
5120					$temp$nodeListSize = newNodeSize;
5121				nodeList = $temp$nodeList;
5122				nodeListSize = $temp$nodeListSize;
5123				continue treeFromBuilder;
5124			}
5125		}
5126	});
5127var elm$core$Basics$floor = _Basics_floor;
5128var elm$core$Basics$max = F2(
5129	function (x, y) {
5130		return (_Utils_cmp(x, y) > 0) ? x : y;
5131	});
5132var elm$core$Basics$mul = _Basics_mul;
5133var elm$core$Elm$JsArray$length = _JsArray_length;
5134var elm$core$Array$builderToArray = F2(
5135	function (reverseNodeList, builder) {
5136		if (!builder.nodeListSize) {
5137			return A4(
5138				elm$core$Array$Array_elm_builtin,
5139				elm$core$Elm$JsArray$length(builder.tail),
5140				elm$core$Array$shiftStep,
5141				elm$core$Elm$JsArray$empty,
5142				builder.tail);
5143		} else {
5144			var treeLen = builder.nodeListSize * elm$core$Array$branchFactor;
5145			var depth = elm$core$Basics$floor(
5146				A2(elm$core$Basics$logBase, elm$core$Array$branchFactor, treeLen - 1));
5147			var correctNodeList = reverseNodeList ? elm$core$List$reverse(builder.nodeList) : builder.nodeList;
5148			var tree = A2(elm$core$Array$treeFromBuilder, correctNodeList, builder.nodeListSize);
5149			return A4(
5150				elm$core$Array$Array_elm_builtin,
5151				elm$core$Elm$JsArray$length(builder.tail) + treeLen,
5152				A2(elm$core$Basics$max, 5, depth * elm$core$Array$shiftStep),
5153				tree,
5154				builder.tail);
5155		}
5156	});
5157var elm$core$Basics$idiv = _Basics_idiv;
5158var elm$core$Elm$JsArray$initialize = _JsArray_initialize;
5159var elm$core$Array$initializeHelp = F5(
5160	function (fn, fromIndex, len, nodeList, tail) {
5161		initializeHelp:
5162		while (true) {
5163			if (fromIndex < 0) {
5164				return A2(
5165					elm$core$Array$builderToArray,
5166					false,
5167					{nodeList: nodeList, nodeListSize: (len / elm$core$Array$branchFactor) | 0, tail: tail});
5168			} else {
5169				var leaf = elm$core$Array$Leaf(
5170					A3(elm$core$Elm$JsArray$initialize, elm$core$Array$branchFactor, fromIndex, fn));
5171				var $temp$fn = fn,
5172					$temp$fromIndex = fromIndex - elm$core$Array$branchFactor,
5173					$temp$len = len,
5174					$temp$nodeList = A2(elm$core$List$cons, leaf, nodeList),
5175					$temp$tail = tail;
5176				fn = $temp$fn;
5177				fromIndex = $temp$fromIndex;
5178				len = $temp$len;
5179				nodeList = $temp$nodeList;
5180				tail = $temp$tail;
5181				continue initializeHelp;
5182			}
5183		}
5184	});
5185var elm$core$Basics$le = _Utils_le;
5186var elm$core$Basics$remainderBy = _Basics_remainderBy;
5187var elm$core$Array$initialize = F2(
5188	function (len, fn) {
5189		if (len <= 0) {
5190			return elm$core$Array$empty;
5191		} else {
5192			var tailLen = len % elm$core$Array$branchFactor;
5193			var tail = A3(elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn);

5194			var initialFromIndex = (len - tailLen) - elm$core$Array$branchFactor;
5195			return A5(elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);
5196		}
5197	});
5198var elm$core$Result$Err = function (a) {
5199	return {$: 'Err', a: a};
5200};
5201var elm$core$Result$Ok = function (a) {
5202	return {$: 'Ok', a: a};
5203};
5204var elm$json$Json$Decode$Failure = F2(
5205	function (a, b) {
5206		return {$: 'Failure', a: a, b: b};
5207	});
5208var elm$json$Json$Decode$Field = F2(
5209	function (a, b) {
5210		return {$: 'Field', a: a, b: b};
5211	});
5212var elm$json$Json$Decode$Index = F2(
5213	function (a, b) {
5214		return {$: 'Index', a: a, b: b};
5215	});
5216var elm$json$Json$Decode$OneOf = function (a) {
5217	return {$: 'OneOf', a: a};
5218};
5219var elm$core$Char$toCode = _Char_toCode;
5220var elm$core$Char$isLower = function (_char) {
5221	var code = elm$core$Char$toCode(_char);
5222	return (97 <= code) && (code <= 122);
5223};
5224var elm$core$Char$isUpper = function (_char) {
5225	var code = elm$core$Char$toCode(_char);
5226	return (code <= 90) && (65 <= code);
5227};
5228var elm$core$Char$isAlpha = function (_char) {
5229	return elm$core$Char$isLower(_char) || elm$core$Char$isUpper(_char);
5230};
5231var elm$core$Char$isDigit = function (_char) {
5232	var code = elm$core$Char$toCode(_char);
5233	return (code <= 57) && (48 <= code);
5234};
5235var elm$core$Char$isAlphaNum = function (_char) {
5236	return elm$core$Char$isLower(_char) || (elm$core$Char$isUpper(_char) || elm$core$Char$isDigit(_char));
5237};
5238var elm$core$List$length = function (xs) {
5239	return A3(
5240		elm$core$List$foldl,
5241		F2(
5242			function (_n0, i) {
5243				return i + 1;
5244			}),
5245		0,
5246		xs);
5247};
5248var elm$core$List$map2 = _List_map2;
5249var elm$core$List$rangeHelp = F3(
5250	function (lo, hi, list) {
5251		rangeHelp:
5252		while (true) {
5253			if (_Utils_cmp(lo, hi) < 1) {
5254				var $temp$lo = lo,
5255					$temp$hi = hi - 1,
5256					$temp$list = A2(elm$core$List$cons, hi, list);
5257				lo = $temp$lo;
5258				hi = $temp$hi;
5259				list = $temp$list;
5260				continue rangeHelp;
5261			} else {
5262				return list;
5263			}
5264		}
5265	});
5266var elm$core$List$range = F2(
5267	function (lo, hi) {
5268		return A3(elm$core$List$rangeHelp, lo, hi, _List_Nil);
5269	});
5270var elm$core$List$indexedMap = F2(
5271	function (f, xs) {
5272		return A3(
5273			elm$core$List$map2,
5274			f,
5275			A2(
5276				elm$core$List$range,
5277				0,
5278				elm$core$List$length(xs) - 1),
5279			xs);
5280	});
5281var elm$core$String$all = _String_all;

5282var elm$core$String$fromInt = _String_fromNumber;
5283var elm$core$String$join = F2(
5284	function (sep, chunks) {
5285		return A2(
5286			_String_join,
5287			sep,
5288			_List_toArray(chunks));
5289	});
5290var elm$core$String$uncons = _String_uncons;
5291var elm$core$String$split = F2(
5292	function (sep, string) {
5293		return _List_fromArray(
5294			A2(_String_split, sep, string));
5295	});
5296var elm$json$Json$Decode$indent = function (str) {
5297	return A2(
5298		elm$core$String$join,
5299		'\n    ',
5300		A2(elm$core$String$split, '\n', str));
5301};
5302var elm$json$Json$Encode$encode = _Json_encode;
5303var elm$json$Json$Decode$errorOneOf = F2(
5304	function (i, error) {
5305		return '\n\n(' + (elm$core$String$fromInt(i + 1) + (') ' + elm$json$Json$Decode$indent(
5306			elm$json$Json$Decode$errorToString(error))));
5307	});
5308var elm$json$Json$Decode$errorToString = function (error) {
5309	return A2(elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);
5310};
5311var elm$json$Json$Decode$errorToStringHelp = F2(
5312	function (error, context) {
5313		errorToStringHelp:
5314		while (true) {
5315			switch (error.$) {
5316				case 'Field':
5317					var f = error.a;
5318					var err = error.b;
5319					var isSimple = function () {
5320						var _n1 = elm$core$String$uncons(f);
5321						if (_n1.$ === 'Nothing') {
5322							return false;
5323						} else {
5324							var _n2 = _n1.a;
5325							var _char = _n2.a;
5326							var rest = _n2.b;
5327							return elm$core$Char$isAlpha(_char) && A2(elm$core$String$all, elm$core$Char$isAlphaNum, rest);
5328						}
5329					}();
5330					var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']'));
5331					var $temp$error = err,
5332						$temp$context = A2(elm$core$List$cons, fieldName, context);
5333					error = $temp$error;
5334					context = $temp$context;
5335					continue errorToStringHelp;
5336				case 'Index':
5337					var i = error.a;
5338					var err = error.b;
5339					var indexName = '[' + (elm$core$String$fromInt(i) + ']');
5340					var $temp$error = err,
5341						$temp$context = A2(elm$core$List$cons, indexName, context);
5342					error = $temp$error;
5343					context = $temp$context;
5344					continue errorToStringHelp;
5345				case 'OneOf':
5346					var errors = error.a;
5347					if (!errors.b) {
5348						return 'Ran into a Json.Decode.oneOf with no possibilities' + function () {
5349							if (!context.b) {
5350								return '!';
5351							} else {
5352								return ' at json' + A2(
5353									elm$core$String$join,
5354									'',
5355									elm$core$List$reverse(context));
5356							}
5357						}();
5358					} else {
5359						if (!errors.b.b) {
5360							var err = errors.a;
5361							var $temp$error = err,
5362								$temp$context = context;
5363							error = $temp$error;
5364							context = $temp$context;
5365							continue errorToStringHelp;
5366						} else {
5367							var starter = function () {
5368								if (!context.b) {
5369									return 'Json.Decode.oneOf';
5370								} else {
5371									return 'The Json.Decode.oneOf at json' + A2(
5372										elm$core$String$join,
5373										'',
5374										elm$core$List$reverse(context));
5375								}
5376							}();
5377							var introduction = starter + (' failed in the following ' + (elm$core$String$fromInt(
5378								elm$core$List$length(errors)) + ' ways:'));
5379							return A2(
5380								elm$core$String$join,
5381								'\n\n',
5382								A2(
5383									elm$core$List$cons,
5384									introduction,
5385									A2(elm$core$List$indexedMap, elm$json$Json$Decode$errorOneOf, errors)));
5386						}
5387					}
5388				default:
5389					var msg = error.a;
5390					var json = error.b;
5391					var introduction = function () {
5392						if (!context.b) {
5393							return 'Problem with the given value:\n\n';
5394						} else {
5395							return 'Problem with the value at json' + (A2(
5396								elm$core$String$join,
5397								'',
5398								elm$core$List$reverse(context)) + ':\n\n    ');
5399						}
5400					}();
5401					return introduction + (elm$json$Json$Decode$indent(
5402						A2(elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg));
5403			}
5404		}
5405	});
5406var elm$core$Platform$sendToApp = _Platform_sendToApp;
5407var elm$core$Task$spawnCmd = F2(
5408	function (router, _n0) {
5409		var task = _n0.a;
5410		return _Scheduler_spawn(
5411			A2(
5412				elm$core$Task$andThen,
5413				elm$core$Platform$sendToApp(router),
5414				task));
5415	});
5416var elm$core$Task$onEffects = F3(
5417	function (router, commands, state) {
5418		return A2(
5419			elm$core$Task$map,
5420			function (_n0) {
5421				return _Utils_Tuple0;
5422			},
5423			elm$core$Task$sequence(
5424				A2(
5425					elm$core$List$map,
5426					elm$core$Task$spawnCmd(router),
5427					commands)));
5428	});
5429var elm$core$Task$onSelfMsg = F3(
5430	function (_n0, _n1, _n2) {
5431		return elm$core$Task$succeed(_Utils_Tuple0);
5432	});
5433var elm$core$Task$cmdMap = F2(
5434	function (tagger, _n0) {
5435		var task = _n0.a;
5436		return elm$core$Task$Perform(
5437			A2(elm$core$Task$map, tagger, task));
5438	});
5439_Platform_effectManagers['Task'] = _Platform_createManager(elm$core$Task$init, elm$core$Task$onEffects, elm$core$Task$onSelfMsg, elm$core$Task$cmdMap);
5440var elm$core$Task$command = _Platform_leaf('Task');
5441var elm$core$Task$perform = F2(
5442	function (toMessage, task) {
5443		return elm$core$Task$command(
5444			elm$core$Task$Perform(
5445				A2(elm$core$Task$map, toMessage, task)));
5446	});
5447var elm$json$Json$Decode$map = _Json_map1;
5448var elm$json$Json$Decode$map2 = _Json_map2;
5449var elm$json$Json$Decode$succeed = _Json_succeed;
5450var elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) {
5451	switch (handler.$) {
5452		case 'Normal':
5453			return 0;
5454		case 'MayStopPropagation':
5455			return 1;
5456		case 'MayPreventDefault':
5457			return 2;
5458		default:
5459			return 3;
5460	}
5461};
5462var elm$core$String$length = _String_length;
5463var elm$core$String$slice = _String_slice;
5464var elm$core$String$dropLeft = F2(
5465	function (n, string) {
5466		return (n < 1) ? string : A3(
5467			elm$core$String$slice,
5468			n,
5469			elm$core$String$length(string),
5470			string);
5471	});
5472var elm$core$String$startsWith = _String_startsWith;
5473var elm$url$Url$Http = {$: 'Http'};
5474var elm$url$Url$Https = {$: 'Https'};
5475var elm$core$String$indexes = _String_indexes;
5476var elm$core$String$isEmpty = function (string) {
5477	return string === '';
5478};
5479var elm$core$String$left = F2(
5480	function (n, string) {
5481		return (n < 1) ? '' : A3(elm$core$String$slice, 0, n, string);
5482	});
5483var elm$core$String$contains = _String_contains;

5484var elm$core$String$toInt = _String_toInt;
5485var elm$url$Url$Url = F6(
5486	function (protocol, host, port_, path, query, fragment) {
5487		return {fragment: fragment, host: host, path: path, port_: port_, protocol: protocol, query: query};
5488	});
5489var elm$url$Url$chompBeforePath = F5(
5490	function (protocol, path, params, frag, str) {
5491		if (elm$core$String$isEmpty(str) || A2(elm$core$String$contains, '@', str)) {
5492			return elm$core$Maybe$Nothing;
5493		} else {
5494			var _n0 = A2(elm$core$String$indexes, ':', str);
5495			if (!_n0.b) {
5496				return elm$core$Maybe$Just(
5497					A6(elm$url$Url$Url, protocol, str, elm$core$Maybe$Nothing, path, params, frag));
5498			} else {
5499				if (!_n0.b.b) {
5500					var i = _n0.a;
5501					var _n1 = elm$core$String$toInt(
5502						A2(elm$core$String$dropLeft, i + 1, str));
5503					if (_n1.$ === 'Nothing') {
5504						return elm$core$Maybe$Nothing;
5505					} else {
5506						var port_ = _n1;
5507						return elm$core$Maybe$Just(
5508							A6(
5509								elm$url$Url$Url,
5510								protocol,
5511								A2(elm$core$String$left, i, str),
5512								port_,
5513								path,
5514								params,
5515								frag));
5516					}
5517				} else {
5518					return elm$core$Maybe$Nothing;
5519				}
5520			}
5521		}
5522	});
5523var elm$url$Url$chompBeforeQuery = F4(
5524	function (protocol, params, frag, str) {
5525		if (elm$core$String$isEmpty(str)) {
5526			return elm$core$Maybe$Nothing;
5527		} else {
5528			var _n0 = A2(elm$core$String$indexes, '/', str);
5529			if (!_n0.b) {
5530				return A5(elm$url$Url$chompBeforePath, protocol, '/', params, frag, str);
5531			} else {
5532				var i = _n0.a;
5533				return A5(
5534					elm$url$Url$chompBeforePath,
5535					protocol,
5536					A2(elm$core$String$dropLeft, i, str),
5537					params,
5538					frag,
5539					A2(elm$core$String$left, i, str));
5540			}
5541		}
5542	});
5543var elm$url$Url$chompBeforeFragment = F3(
5544	function (protocol, frag, str) {
5545		if (elm$core$String$isEmpty(str)) {
5546			return elm$core$Maybe$Nothing;
5547		} else {
5548			var _n0 = A2(elm$core$String$indexes, '?', str);
5549			if (!_n0.b) {
5550				return A4(elm$url$Url$chompBeforeQuery, protocol, elm$core$Maybe$Nothing, frag, str);
5551			} else {
5552				var i = _n0.a;
5553				return A4(
5554					elm$url$Url$chompBeforeQuery,
5555					protocol,
5556					elm$core$Maybe$Just(
5557						A2(elm$core$String$dropLeft, i + 1, str)),
5558					frag,
5559					A2(elm$core$String$left, i, str));
5560			}
5561		}
5562	});
5563var elm$url$Url$chompAfterProtocol = F2(
5564	function (protocol, str) {
5565		if (elm$core$String$isEmpty(str)) {
5566			return elm$core$Maybe$Nothing;
5567		} else {
5568			var _n0 = A2(elm$core$String$indexes, '#', str);
5569			if (!_n0.b) {
5570				return A3(elm$url$Url$chompBeforeFragment, protocol, elm$core$Maybe$Nothing, str);
5571			} else {
5572				var i = _n0.a;
5573				return A3(
5574					elm$url$Url$chompBeforeFragment,
5575					protocol,
5576					elm$core$Maybe$Just(
5577						A2(elm$core$String$dropLeft, i + 1, str)),
5578					A2(elm$core$String$left, i, str));
5579			}
5580		}
5581	});
5582var elm$url$Url$fromString = function (str) {
5583	return A2(elm$core$String$startsWith, 'http://', str) ? A2(
5584		elm$url$Url$chompAfterProtocol,
5585		elm$url$Url$Http,
5586		A2(elm$core$String$dropLeft, 7, str)) : (A2(elm$core$String$startsWith, 'https://', str) ? A2(
5587		elm$url$Url$chompAfterProtocol,
5588		elm$url$Url$Https,
5589		A2(elm$core$String$dropLeft, 8, str)) : elm$core$Maybe$Nothing);
5590};
5591var elm$browser$Browser$Navigation$replaceUrl = _Browser_replaceUrl;
5592var elm$core$Basics$composeL = F3(
5593	function (g, f, x) {
5594		return g(
5595			f(x));
5596	});
5597var elm$core$Maybe$map = F2(
5598	function (f, maybe) {
5599		if (maybe.$ === 'Just') {
5600			var value = maybe.a;
5601			return elm$core$Maybe$Just(
5602				f(value));
5603		} else {
5604			return elm$core$Maybe$Nothing;
5605		}
5606	});
5607var elm$core$Maybe$map2 = F3(
5608	function (func, ma, mb) {
5609		if (ma.$ === 'Nothing') {
5610			return elm$core$Maybe$Nothing;
5611		} else {
5612			var a = ma.a;
5613			if (mb.$ === 'Nothing') {
5614				return elm$core$Maybe$Nothing;
5615			} else {
5616				var b = mb.a;
5617				return elm$core$Maybe$Just(
5618					A2(func, a, b));
5619			}
5620		}
5621	});
5622var elm$core$Platform$Cmd$batch = _Platform_batch;
5623var elm$core$Platform$Cmd$none = elm$core$Platform$Cmd$batch(_List_Nil);
5624var elm$core$Tuple$mapFirst = F2(
5625	function (func, _n0) {
5626		var x = _n0.a;
5627		var y = _n0.b;
5628		return _Utils_Tuple2(
5629			func(x),
5630			y);
5631	});
5632var dtwrks$elm_book$ElmBook$Internal$Application$init = F4(
5633	function (config, _n0, url_, navKey) {
5634		var url = A2(dtwrks$elm_book$ElmBook$Internal$Application$extractPath, c

5634onfig.themeOptions.hashBasedNavigation, url_);
5635		var hashBasedNavigation_ = dtwrks$elm_book$ElmBook$Internal$ThemeOptions$hashBasedNavigation(config.themeOptions);
5636		var darkMode = config.themeOptions.preferDarkMode;
5637		var initialState = A2(
5638			elm$core$Maybe$map,
5639			config.statefulOptions.onDarkModeChange(darkMode),
5640			config.statefulOptions.initialState);
5641		var activeChapter = A2(
5642			dtwrks$elm_book$ElmBook$Internal$Book$chapterFromUrl,
5643			config,
5644			A2(dtwrks$elm_book$ElmBook$Internal$Application$extractPath, hashBasedNavigation_, url_));
5645		var _n1 = A2(
5646			elm$core$Maybe$withDefault,
5647			_Utils_Tuple2(initialState, elm$core$Platform$Cmd$none),
5648			A2(
5649				elm$core$Maybe$andThen,
5650				function (chapter) {
5651					return A2(
5652						elm$core$Maybe$map,
5653						elm$core$Tuple$mapFirst(elm$core$Maybe$Just),
5654						A3(
5655							elm$core$Maybe$map2,
5656							F2(
5657								function (state_, chapterInit) {
5658									return chapterInit(state_);
5659								}),
5660							initialState,
5661							dtwrks$elm_book$ElmBook$Internal$Chapter$init(chapter)));
5662				},
5663				activeChapter));
5664		var initialState_ = _n1.a;
5665		var cmd = _n1.b;
5666		return _Utils_Tuple2(
5667			{actionLog: _List_Nil, actionLogModal: false, backCompatibility: elm$core$Maybe$Nothing, chapterPreSelected: 0, darkMode: darkMode, isMenuOpen: false, isMetaPressed: false, isSearching: false, isShiftPressed: false, navKey: navKey, search: '', state: initialState_, themeOverrides: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultOverrides, url: url},
5668			function () {
5669				if (activeChapter.$ === 'Just') {
5670					return cmd;
5671				} else {
5672					return A2(
5673						elm$core$Maybe$withDefault,
5674						A2(elm$browser$Browser$Navigation$replaceUrl, navKey, '/'),
5675						A2(
5676							elm$core$Maybe$map,
5677							A2(
5678								elm$core$Basics$composeL,
5679								elm$browser$Browser$Navigation$replaceUrl(navKey),
5680								dtwrks$elm_book$ElmBook$Internal$Chapter$chapterNavUrl(hashBasedNavigation_)),
5681							A2(elm$core$Array$get, 0, config.chapters)));
5682				}
5683			}());
5684	});
5685var dtwrks$elm_book$ElmBook$Internal$Msg$DoNothing = {$: 'DoNothing'};
5686var dtwrks$elm_book$ElmBook$Internal$Msg$KeyArrowDown = {$: 'KeyArrowDown'};
5687var dtwrks$elm_book$ElmBook$Internal$Msg$KeyArrowUp = {$: 'KeyArrowUp'};
5688var dtwrks$elm_book$ElmBook$Internal$Msg$KeyEnter = {$: 'KeyEnter'};
5689var dtwrks$elm_book$ElmBook$Internal$Msg$KeyK = {$: 'KeyK'};
5690var dtwrks$elm_book$ElmBook$Internal$Msg$KeyMetaOn = {$: 'KeyMetaOn'};
5691var dtwrks$elm_book$ElmBook$Internal$Msg$KeyShiftOn = {$: 'KeyShiftOn'};
5692var elm$core$String$toLower = _String_toLower;
5693var elm$json$Json$Decode$field = _Json_decodeField;
5694var elm$json$Json$Decode$string = _Json_decodeString;
5695var dtwrks$elm_book$ElmBook$Internal$Application$keyDownDecoder = A2(
5696	elm$json$Json$Decode$map,
5697	function (string) {
5698		var _n0 = elm$core$String$toLower(string);
5699		switch (_n0) {
5700			case 'arrowdown':
5701				return dtwrks$elm_book$ElmBook$Internal$Msg$KeyArrowDown;
5702			case 'arrowup':
5703				return dtwrks$elm_book$ElmBook$Internal$Msg$KeyArrowUp;
5704			case 'shift':
5705				return dtwrks$elm_book$ElmBook$Internal$Msg$KeyShiftOn;
5706			case 'meta':
5707				return dtwrks$elm_book$ElmBook$Internal$Msg$KeyMetaOn;
5708			case 'enter':
5709				return dtwrks$elm_book$ElmBook$Internal$Msg$KeyEnter;
5710			case 'k':
5711				return dtwrks$elm_book$ElmBook$Internal$Msg$KeyK;
5712			default:
5713				return dtwrks$elm_book$ElmBook$Internal$Msg$DoNothing;
5714		}
5715	},
5716	A2(elm$json$Json$Decode$field, 'key', elm$json$Json$Decode$string));
5717var dtwrks$elm_book$ElmBook$Internal$Msg$KeyMetaOff = {$: 'KeyMetaOff'};
5718var dtwrks$elm_book$ElmBook$Internal$Msg$KeyShiftOff = {$: 'KeyShiftOff'};
5719var dtwrks$elm_book$ElmBook$Internal$Application$keyUpDecoder = A2(
5720	elm$json$Json$Decode$map,
5721	function (string) {
5722		var _n0 = elm$core$String$toLower(string);
5723		switch (_n0) {
5724			case 'shift':
5725				return dtwrks$elm_book$ElmBook$Internal$Msg$KeyShiftOff;
5726			case 'meta':
5727				return dtwrks$elm_book$ElmBook$Internal$Msg$KeyMetaOff;
5728			default:
5729				return dtwrks$elm_book$ElmBook$Internal$Msg$DoNothing;
5730		}
5731	},
5732	A2(elm$json$Json$Decode$field, 'key', elm$json$Json$Decode$string));
5733var dtwrks$elm_book$ElmBook$Internal$Application$updateThemeOverrides = F2(
5734	function (model, fn) {
5735		return _Utils_Tuple2(
5736			_Utils_update(
5737				model,
5738				{
5739					themeOverrides: fn(model.themeOverrides)
5740				}),
5741			elm$core$Platform$Cmd$none);
5742	});
5743var dtwrks$elm_book$ElmBook$Internal$Chapter$chapterInternal = function (_n0) {
5744	var internal = _n0.a.internal;
5745	return internal;
5746};
5747var dtwrks$elm_book$ElmBook$Internal$Chapter$chapterTitle = function (_n0) {
5748	var title = _n0.a.title;
5749	return title;
5750};
5751var dtwrks$elm_book$ElmBook$Internal$Chapter$chapterUrl = function (_n0) {
5752	var url = _n0.a.url;
5753	return url;
5754};
5755var elm$browser$Browser$Dom$focus = _Browser_call('focus');
5756var elm$browser$Browser$Dom$setViewportOf = _Browser_setViewportOf;
5757var elm$browser$Browser$Navigation$load = _Browser_load;
5758var elm$browser$Browser$Navigation$pushUrl = _Browser_pushUrl;
5759var elm$core$Array$length = function (_n0) {
5760	var len = _n0.a;
5761	return len;
5762};
5763var elm$core$Basics$modBy = _Basics_modBy;
5764var elm$core$Basics$not = _Basics_not;
5765var elm$core$String$replace = F3(
5766	function (before, after, string) {
5767		return A2(
5768			elm$core$String$join,
5769			after,
5770			A2(elm$core$String$split, before, string));
5771	});
5772var elm$core$Task$onError = _Scheduler_onError;
5773var elm$core$Task$attempt = F2(
5774	function (resultToMessage, task) {
5775		return elm$core$Task$command(
5776			elm$core$Task$Perform(
5777				A2(
5778					elm$core$Task$onError,
5779					A2(
5780						elm$core$Basics$composeL,
5781						A2(elm$core$Basics$composeL, elm$core$Task$succeed, resultToMessage),

5782						elm$core$Result$Err),
5783					A2(
5784						elm$core$Task$andThen,
5785						A2(
5786							elm$core$Basics$composeL,
5787							A2(elm$core$Basics$composeL, elm$core$Task$succeed, resultToMessage),
5788							elm$core$Result$Ok),
5789						task))));
5790	});
5791var elm$url$Url$addPort = F2(
5792	function (maybePort, starter) {
5793		if (maybePort.$ === 'Nothing') {
5794			return starter;
5795		} else {
5796			var port_ = maybePort.a;
5797			return starter + (':' + elm$core$String$fromInt(port_));
5798		}
5799	});
5800var elm$url$Url$addPrefixed = F3(
5801	function (prefix, maybeSegment, starter) {
5802		if (maybeSegment.$ === 'Nothing') {
5803			return starter;
5804		} else {
5805			var segment = maybeSegment.a;
5806			return _Utils_ap(
5807				starter,
5808				_Utils_ap(prefix, segment));
5809		}
5810	});
5811var elm$url$Url$toString = function (url) {
5812	var http = function () {
5813		var _n0 = url.protocol;
5814		if (_n0.$ === 'Http') {
5815			return 'http://';
5816		} else {
5817			return 'https://';
5818		}
5819	}();
5820	return A3(
5821		elm$url$Url$addPrefixed,
5822		'#',
5823		url.fragment,
5824		A3(
5825			elm$url$Url$addPrefixed,
5826			'?',
5827			url.query,
5828			_Utils_ap(
5829				A2(
5830					elm$url$Url$addPort,
5831					url.port_,
5832					_Utils_ap(http, url.host)),
5833				url.path)));
5834};
5835var dtwrks$elm_book$ElmBook$Internal$Application$update = F3(
5836	function (config, msg, model) {
5837		var logAction_ = F2(
5838			function (context, action) {
5839				return _Utils_Tuple2(
5840					_Utils_update(
5841						model,
5842						{
5843							actionLog: A2(
5844								elm$core$List$cons,
5845								_Utils_Tuple2(context, action),
5846								model.actionLog)
5847						}),
5848					elm$core$Platform$Cmd$none);
5849			});
5850		var hashBasedNavigation_ = dtwrks$elm_book$ElmBook$Internal$ThemeOptions$hashBasedNavigation(config.themeOptions);
5851		var activeChapter = A2(dtwrks$elm_book$ElmBook$Internal$Book$chapterFromUrl, config, model.url);
5852		var defaultLogContext = A2(
5853			elm$core$Maybe$withDefault,
5854			'',
5855			A2(
5856				elm$core$Maybe$map,
5857				function (s) {
5858					return s + ' / ';
5859				},
5860				A2(elm$core$Maybe$map, dtwrks$elm_book$ElmBook$Internal$Chapter$chapterTitle, activeChapter)));
5861		switch (msg.$) {
5862			case 'OnUrlRequest':
5863				var request = msg.a;
5864				if (request.$ === 'External') {
5865					var url = request.a;
5866					return _Utils_Tuple2(
5867						model,
5868						elm$browser$Browser$Navigation$load(url));
5869				} else {
5870					var url = request.a;
5871					return A2(elm$core$String$contains, '/logAction', url.path) ? A2(
5872						logAction_,
5873						defaultLogContext,
5874						'Navigate to: ' + A3(elm$core$String$replace, '/logAction', '', url.path)) : _Utils_Tuple2(
5875						model,
5876						A2(
5877							elm$browser$Browser$Navigation$pushUrl,
5878							model.navKey,
5879							elm$url$Url$toString(url)));
5880				}
5881			case 'OnUrlChange':
5882				var url_ = msg.a;
5883				var url = A2(dtwrks$elm_book$ElmBook$Internal$Application$extractPath, hashBasedNavigation_, url_);
5884				if (url === '/') {
5885					return A2(
5886						elm$core$Maybe$withDefault,
5887						_Utils_Tuple2(
5888							_Utils_update(
5889								model,
5890								{url: '/'}),
5891							elm$core$Platform$Cmd$none),
5892						A2(
5893							elm$core$Maybe$map,
5894							function (fallback) {
5895								return _Utils_Tuple2(
5896									model,
5897									A2(
5898										elm$browser$Browser$Navigation$pushUrl,
5899										model.navKey,
5900										dtwrks$elm_book$ElmBook$Internal$Chapter$chapterUrl(fallback)));
5901							},
5902							A2(elm$core$Array$get, 0, config.chapters)));
5903				} else {
5904					var urlChapter = A2(
5905						elm$core$Maybe$andThen,
5906						function (i) {
5907							return A2(elm$core$Array$get, i, config.chapters);
5908						},
5909						A2(elm$core$Dict$get, url, config.chapterByUrl));
5910					if (urlChapter.$ === 'Just') {
5911						var chapter = urlChapter.a;
5912						var _n4 = A2(
5913							elm$core$Maybe$withDefault,
5914							_Utils_Tuple2(model.state, elm$core$Platform$Cmd$none),
5915							A2(
5916								elm$core$Maybe$map,
5917								elm$core$Tuple$mapFirst(elm$core$Maybe$Just),
5918								A3(
5919									elm$core$Maybe$map2,
5920									F2(
5921										function (state_, chapterInit) {
5922											return chapterInit(state_);
5923										}),
5924									model.state,
5925									dtwrks$elm_book$ElmBook$Internal$Chapter$init(chapter))));
5926						var state = _n4.a;
5927						var cmd = _n4.b;
5928						return _Utils_Tuple2(
5929							_Utils_update(
5930								model,
5931								{isMenuOpen: false, state: state, url: url}),
5932							elm$core$Platform$Cmd$batch(
5933								_List_fromArray(
5934									[
5935										cmd,
5936										A2(
5937										elm$core$Task$attempt,
5938										function (_n5) {
5939											return dtwrks$elm_book$ElmBook$Internal$Msg$DoNothing;
5940										},
5941										A3(elm$browser$Browser$Dom$setViewportOf, 'elm-book-main', 0, 0

5941))
5942									])));
5943					} else {
5944						return _Utils_Tuple2(
5945							_Utils_update(
5946								model,
5947								{isMenuOpen: false, url: url}),
5948							A2(
5949								elm$browser$Browser$Navigation$replaceUrl,
5950								model.navKey,
5951								hashBasedNavigation_ ? '#/' : '/'));
5952					}
5953				}
5954			case 'ToggleDarkMode':
5955				var darkMode = !model.darkMode;
5956				return _Utils_Tuple2(
5957					_Utils_update(
5958						model,
5959						{
5960							darkMode: darkMode,
5961							state: A2(
5962								elm$core$Maybe$map,
5963								config.statefulOptions.onDarkModeChange(darkMode),
5964								model.state)
5965						}),
5966					elm$core$Platform$Cmd$none);
5967			case 'UpdateState':
5968				var fn = msg.a;
5969				return A2(
5970					elm$core$Maybe$withDefault,
5971					_Utils_Tuple2(model, elm$core$Platform$Cmd$none),
5972					A2(
5973						elm$core$Maybe$map,
5974						elm$core$Tuple$mapFirst(
5975							function (s) {
5976								return _Utils_update(
5977									model,
5978									{
5979										state: elm$core$Maybe$Just(s)
5980									});
5981							}),
5982						A2(elm$core$Maybe$map, fn, model.state)));
5983			case 'LogAction':
5984				var context = msg.a;
5985				var action = msg.b;
5986				return A2(logAction_, context, action);
5987			case 'ActionLogShow':
5988				return _Utils_Tuple2(
5989					_Utils_update(
5990						model,
5991						{actionLogModal: true}),
5992					elm$core$Platform$Cmd$none);
5993			case 'ActionLogHide':
5994				return _Utils_Tuple2(
5995					_Utils_update(
5996						model,
5997						{actionLogModal: false}),
5998					elm$core$Platform$Cmd$none);
5999			case 'SearchFocus':
6000				return _Utils_Tuple2(
6001					_Utils_update(
6002						model,
6003						{chapterPreSelected: 0, isSearching: true}),
6004					elm$core$Platform$Cmd$none);
6005			case 'SearchBlur':
6006				return _Utils_Tuple2(model, elm$core$Platform$Cmd$none);
6007			case 'Search':
6008				var value = msg.a;
6009				return _Utils_Tuple2(
6010					_Utils_update(
6011						model,
6012						{chapterPreSelected: 0, search: value}),
6013					elm$core$Platform$Cmd$none);
6014			case 'ToggleMenu':
6015				return _Utils_Tuple2(
6016					_Utils_update(
6017						model,
6018						{isMenuOpen: !model.isMenuOpen}),
6019					elm$core$Platform$Cmd$none);
6020			case 'KeyArrowDown':
6021				return _Utils_Tuple2(
6022					_Utils_update(
6023						model,
6024						{chapterPreSelected: model.chapterPreSelected + 1}),
6025					elm$core$Platform$Cmd$none);
6026			case 'KeyArrowUp':
6027				return _Utils_Tuple2(
6028					_Utils_update(
6029						model,
6030						{chapterPreSelected: model.chapterPreSelected - 1}),
6031					elm$core$Platform$Cmd$none);
6032			case 'KeyShiftOn':
6033				return _Utils_Tuple2(
6034					_Utils_update(
6035						model,
6036						{isShiftPressed: true}),
6037					elm$core$Platform$Cmd$none);
6038			case 'KeyShiftOff':
6039				return _Utils_Tuple2(
6040					_Utils_update(
6041						model,
6042						{isShiftPressed: false}),
6043					elm$core$Platform$Cmd$none);
6044			case 'KeyMetaOn':
6045				return _Utils_Tuple2(
6046					_Utils_update(
6047						model,
6048						{isMetaPressed: true}),
6049					elm$core$Platform$Cmd$none);
6050			case 'KeyMetaOff':
6051				return _Utils_Tuple2(
6052					_Utils_update(
6053						model,
6054						{isMetaPressed: false}),
6055					elm$core$Platform$Cmd$none);
6056			case 'KeyK':
6057				return model.isMetaPressed ? _Utils_Tuple2(
6058					model,
6059					A2(
6060						elm$core$Task$attempt,
6061						function (_n6) {
6062							return dtwrks$elm_book$ElmBook$Internal$Msg$DoNothing;
6063						},
6064						elm$browser$Browser$Dom$focus('elm-book-search'))) : _Utils_Tuple2(model, elm$core$Platform$Cmd$none);
6065			case 'KeyEnter':
6066				if (!model.isSearching) {
6067					return _Utils_Tuple2(model, elm$core$Platform$Cmd$none);
6068				} else {
6069					var preSelectedIndex = A2(
6070						elm$core$Basics$modBy,
6071						elm$core$Array$length(config.chapters),
6072						model.chapterPreSelected);
6073					var targetChapter = A2(elm$core$Array$get, preSelectedIndex, config.chapters);
6074					if (targetChapter.$ === 'Just') {
6075						var chapter_ = targetChapter.a;
6076						return dtwrks$elm_book$ElmBook$Internal$Chapter$chapterInternal(chapter_) ? _Utils_Tuple2(
6077							model,
6078							A2(
6079								elm$browser$Browser$Navigation$pushUrl,
6080								model.navKey,
6081								A2(dtwrks$elm_book$ElmBook$Internal$Chapter$chapterNavUrl, hashBasedNavigation_, chapter_))) : _Utils_Tuple2(
6082							model,
6083							elm$browser$Browser$Navigation$load(
6084								dtwrks$elm_book$ElmBook$Internal$Chapter$chapterUrl(chapter_)));
6085					} else {
6086						return _Utils_Tuple2(model, elm$core$Platform$Cmd$none);
6087					}
6088				}

6089			case 'SetThemeBackgroundGradient':
6090				var startColor = msg.a;
6091				var endColor = msg.b;
6092				return A2(
6093					dtwrks$elm_book$ElmBook$Internal$Application$updateThemeOverrides,
6094					model,
6095					function (t) {
6096						return _Utils_update(
6097							t,
6098							{
6099								background: elm$core$Maybe$Just('linear-gradient(150deg, ' + (startColor + (' 0%, ' + (endColor + ' 100%)'))))
6100							});
6101					});
6102			case 'SetThemeBackground':
6103				var background = msg.a;
6104				return A2(
6105					dtwrks$elm_book$ElmBook$Internal$Application$updateThemeOverrides,
6106					model,
6107					function (t) {
6108						return _Utils_update(
6109							t,
6110							{
6111								background: elm$core$Maybe$Just(background)
6112							});
6113					});
6114			case 'SetThemeAccent':
6115				var accent = msg.a;
6116				return A2(
6117					dtwrks$elm_book$ElmBook$Internal$Application$updateThemeOverrides,
6118					model,
6119					function (t) {
6120						return _Utils_update(
6121							t,
6122							{
6123								accent: elm$core$Maybe$Just(accent)
6124							});
6125					});
6126			case 'SetThemeNavBackground':
6127				var navBackground = msg.a;
6128				return A2(
6129					dtwrks$elm_book$ElmBook$Internal$Application$updateThemeOverrides,
6130					model,
6131					function (t) {
6132						return _Utils_update(
6133							t,
6134							{
6135								navBackground: elm$core$Maybe$Just(navBackground)
6136							});
6137					});
6138			case 'SetThemeNavAccent':
6139				var navAccent = msg.a;
6140				return A2(
6141					dtwrks$elm_book$ElmBook$Internal$Application$updateThemeOverrides,
6142					model,
6143					function (t) {
6144						return _Utils_update(
6145							t,
6146							{
6147								navAccent: elm$core$Maybe$Just(navAccent)
6148							});
6149					});
6150			case 'SetThemeNavAccentHighlight':
6151				var navAccentHighlight = msg.a;
6152				return A2(
6153					dtwrks$elm_book$ElmBook$Internal$Application$updateThemeOverrides,
6154					model,
6155					function (t) {
6156						return _Utils_update(
6157							t,
6158							{
6159								navAccentHighlight: elm$core$Maybe$Just(navAccentHighlight)
6160							});
6161					});
6162			default:
6163				return _Utils_Tuple2(model, elm$core$Platform$Cmd$none);
6164		}
6165	});
6166var elm$virtual_dom$VirtualDom$text = _VirtualDom_text;
6167var elm$html$Html$text = elm$virtual_dom$VirtualDom$text;
6168var dtwrks$elm_book$ElmBook$Internal$Application$componentView = F3(
6169	function (toHtml, state_, componentView_) {
6170		if (componentView_.$ === 'ChapterComponentViewStateless') {
6171			var html = componentView_.a;
6172			return toHtml(html);
6173		} else {
6174			var html = componentView_.a;
6175			return A2(
6176				elm$core$Maybe$withDefault,
6177				elm$html$Html$text(''),
6178				A2(
6179					elm$core$Maybe$map,
6180					A2(elm$core$Basics$composeL, toHtml, html),
6181					state_));
6182		}
6183	});
6184var elm$core$Array$fromListHelp = F3(
6185	function (list, nodeList, nodeListSize) {
6186		fromListHelp:
6187		while (true) {
6188			var _n0 = A2(elm$core$Elm$JsArray$initializeFromList, elm$core$Array$branchFactor, list);
6189			var jsArray = _n0.a;
6190			var remainingItems = _n0.b;
6191			if (_Utils_cmp(
6192				elm$core$Elm$JsArray$length(jsArray),
6193				elm$core$Array$branchFactor) < 0) {
6194				return A2(
6195					elm$core$Array$builderToArray,
6196					true,
6197					{nodeList: nodeList, nodeListSize: nodeListSize, tail: jsArray});
6198			} else {
6199				var $temp$list = remainingItems,
6200					$temp$nodeList = A2(
6201					elm$core$List$cons,
6202					elm$core$Array$Leaf(jsArray),
6203					nodeList),
6204					$temp$nodeListSize = nodeListSize + 1;
6205				list = $temp$list;
6206				nodeList = $temp$nodeList;
6207				nodeListSize = $temp$nodeListSize;
6208				continue fromListHelp;
6209			}
6210		}
6211	});
6212var elm$core$Array$fromList = function (list) {
6213	if (!list.b) {
6214		return elm$core$Array$empty;
6215	} else {
6216		return A3(elm$core$Array$fromListHelp, list, _List_Nil, 0);
6217	}
6218};
6219var elm$core$Array$filter = F2(
6220	function (isGood, array) {
6221		return elm$core$Array$fromList(
6222			A3(
6223				elm$core$Array$foldr,
6224				F2(
6225					function (x, xs) {
6226						return isGood(x) ? A2(elm$core$List$cons, x, xs) : xs;
6227					}),
6228				_List_Nil,
6229				array));
6230	});

6231var dtwrks$elm_book$ElmBook$Internal$Application$searchChapters = F2(
6232	function (search, chapters) {
6233		if (search === '') {
6234			return chapters;
6235		} else {
6236			var searchLowerCase = elm$core$String$toLower(search);
6237			var titleMatchesSearch = function (_n1) {
6238				var title = _n1.a.title;
6239				return A2(
6240					elm$core$String$contains,
6241					searchLowerCase,
6242					elm$core$String$toLower(title));
6243			};
6244			return A2(elm$core$Array$filter, titleMatchesSearch, chapters);
6245		}
6246	});
6247var dtwrks$elm_book$ElmBook$Internal$Chapter$chapterBreadcrumb = function (_n0) {
6248	var chapter = _n0.a;
6249	return function (t) {
6250		return _Utils_ap(t, chapter.title);
6251	}(
6252		A2(
6253			elm$core$Maybe$withDefault,
6254			'',
6255			A2(
6256				elm$core$Maybe$map,
6257				function (t) {
6258					return t + ' / ';
6259				},
6260				chapter.groupTitle)));
6261};
6262var dtwrks$elm_book$ElmBook$Internal$Chapter$toValidOptions = F2(
6263	function (valid, _n0) {
6264		var options = _n0.a;
6265		return {
6266			hiddenTitle: A2(elm$core$Maybe$withDefault, valid.hiddenTitle, options.hiddenTitle)
6267		};
6268	});
6269var dtwrks$elm_book$ElmBook$Internal$ComponentOptions$toValidOptions = F2(
6270	function (validSettings, _n0) {
6271		var settings = _n0.a;
6272		return {
6273			background: A2(elm$core$Maybe$withDefault, validSettings.background, settings.background),
6274			display: A2(elm$core$Maybe$withDefault, validSettings.display, settings.display),
6275			fullWidth: A2(elm$core$Maybe$withDefault, validSettings.fullWidth, settings.fullWidth),
6276			hiddenLabel: A2(elm$core$Maybe$withDefault, validSettings.hiddenLabel, settings.hiddenLabel)
6277		};
6278	});
6279var dtwrks$elm_book$ElmBook$Internal$Msg$ActionLogHide = {$: 'ActionLogHide'};
6280var dtwrks$elm_book$ElmBook$Internal$Msg$ActionLogShow = {$: 'ActionLogShow'};
6281var dtwrks$elm_book$ElmBook$Internal$Msg$Search = function (a) {
6282	return {$: 'Search', a: a};
6283};
6284var dtwrks$elm_book$ElmBook$Internal$Msg$SearchBlur = {$: 'SearchBlur'};
6285var dtwrks$elm_book$ElmBook$Internal$Msg$SearchFocus = {$: 'SearchFocus'};
6286var dtwrks$elm_book$ElmBook$Internal$Msg$ToggleDarkMode = {$: 'ToggleDarkMode'};
6287var dtwrks$elm_book$ElmBook$Internal$Msg$ToggleMenu = {$: 'ToggleMenu'};
6288var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$applyOverrides = F2(
6289	function (theme, overrides) {
6290		return _Utils_update(
6291			theme,
6292			{
6293				accent: A2(elm$core$Maybe$withDefault, theme.accent, overrides.accent),
6294				background: A2(elm$core$Maybe$withDefault, theme.background, overrides.background),
6295				navAccent: A2(elm$core$Maybe$withDefault, theme.navAccent, overrides.navAccent),
6296				navAccentHighlight: A2(elm$core$Maybe$withDefault, theme.navAccentHighlight, overrides.navAccentHighlight),
6297				navBackground: A2(elm$core$Maybe$withDefault, theme.navBackground, overrides.navBackground)
6298			});
6299	});
6300var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$subtitle = function (theme) {
6301	return theme.subtitle;
6302};
6303var elm$html$Html$div = _VirtualDom_node('div');
6304var elm$html$Html$p = _VirtualDom_node('p');
6305var elm$json$Json$Encode$string = _Json_wrap;
6306var elm$html$Html$Attributes$stringProperty = F2(
6307	function (key, string) {
6308		return A2(
6309			_VirtualDom_property,
6310			key,
6311			elm$json$Json$Encode$string(string));
6312	});
6313var elm$html$Html$Attributes$class = elm$html$Html$Attributes$stringProperty('className');
6314var dtwrks$elm_book$ElmBook$UI$ActionLog$item = F2(
6315	function (index, _n0) {
6316		var preffix = _n0.a;
6317		var label = _n0.b;
6318		return A2(
6319			elm$html$Html$div,
6320			_List_fromArray(
6321				[
6322					elm$html$Html$Attributes$class('elm-book-wrapper elm-book-action-log-item-wrapper elm-book-monospace')
6323				]),
6324			_List_fromArray(
6325				[
6326					A2(
6327					elm$html$Html$p,
6328					_List_fromArray(
6329						[
6330							elm$html$Html$Attributes$class('elm-book-action-log-item-index')
6331						]),
6332					_List_fromArray(
6333						[
6334							elm$html$Html$text(
6335							'(' + (elm$core$String$fromInt(index + 1) + ')'))
6336						])),
6337					A2(
6338					elm$html$Html$div,
6339					_List_fromArray(
6340						[
6341							elm$html$Html$Attributes$class('elm-book-action-log__main')
6342						]),
6343					_List_fromArray(
6344						[
6345							A2(
6346							elm$html$Html$p,
6347							_List_fromArray(
6348								[
6349									elm$html$Html$Attributes$class('elm-book-action-log-item-preffix')
6350								]),
6351							_List_fromArray(
6352								[
6353									elm$html$Html$text(preffix)
6354								])),
6355							A2(
6356							elm$html$Html$p,
6357							_List_fromArray(
6358								[
6359									elm$html$Html$Attributes$class('elm-book-action-log-item-label')
6360								]),
6361							_List_fromArray(
6362								[
6363									elm$html$Html$text(label)
6364								]))
6365						]))
6366				]));
6367	});

6368var dtwrks$elm_book$ElmBook$UI$Helpers$themeBackgroundVar = '--elm-book-background';
6369var dtwrks$elm_book$ElmBook$UI$Helpers$var_ = function (v) {
6370	return 'var(' + (v + ')');
6371};
6372var dtwrks$elm_book$ElmBook$UI$Helpers$themeBackground = dtwrks$elm_book$ElmBook$UI$Helpers$var_(dtwrks$elm_book$ElmBook$UI$Helpers$themeBackgroundVar);
6373var elm$html$Html$li = _VirtualDom_node('li');
6374var elm$html$Html$ul = _VirtualDom_node('ul');
6375var elm$virtual_dom$VirtualDom$style = _VirtualDom_style;
6376var elm$html$Html$Attributes$style = elm$virtual_dom$VirtualDom$style;
6377var dtwrks$elm_book$ElmBook$UI$ActionLog$list = function (props) {
6378	return A2(
6379		elm$html$Html$div,
6380		_List_fromArray(
6381			[
6382				elm$html$Html$Attributes$class('elm-book elm-book-action-log-list-wrapper')
6383			]),
6384		_List_fromArray(
6385			[
6386				A2(
6387				elm$html$Html$p,
6388				_List_fromArray(
6389					[
6390						elm$html$Html$Attributes$class('elm-book elm-book-action-log-list-header elm-book-sans'),
6391						A2(elm$html$Html$Attributes$style, 'background', dtwrks$elm_book$ElmBook$UI$Helpers$themeBackgroun

6391d)
6392					]),
6393				_List_fromArray(
6394					[
6395						elm$html$Html$text('Action log')
6396					])),
6397				A2(
6398				elm$html$Html$ul,
6399				_List_fromArray(
6400					[
6401						elm$html$Html$Attributes$class('elm-book elm-book-action-log-list')
6402					]),
6403				A2(
6404					elm$core$List$map,
6405					function (item_) {
6406						return A2(
6407							elm$html$Html$li,
6408							_List_fromArray(
6409								[
6410									elm$html$Html$Attributes$class('elm-book elm-book-action-log-list-item')
6411								]),
6412							_List_fromArray(
6413								[item_]));
6414					},
6415					elm$core$List$reverse(
6416						A2(elm$core$List$indexedMap, dtwrks$elm_book$ElmBook$UI$ActionLog$item, props))))
6417			]));
6418};
6419var elm$html$Html$button = _VirtualDom_node('button');
6420var elm$virtual_dom$VirtualDom$Normal = function (a) {
6421	return {$: 'Normal', a: a};
6422};
6423var elm$virtual_dom$VirtualDom$on = _VirtualDom_on;
6424var elm$html$Html$Events$on = F2(
6425	function (event, decoder) {
6426		return A2(
6427			elm$virtual_dom$VirtualDom$on,
6428			event,
6429			elm$virtual_dom$VirtualDom$Normal(decoder));
6430	});
6431var elm$html$Html$Events$onClick = function (msg) {
6432	return A2(
6433		elm$html$Html$Events$on,
6434		'click',
6435		elm$json$Json$Decode$succeed(msg));
6436};
6437var dtwrks$elm_book$ElmBook$UI$ActionLog$preview = function (props) {
6438	return A2(
6439		elm$html$Html$div,
6440		_List_fromArray(
6441			[
6442				elm$html$Html$Attributes$class('elm-book-action-log-preview-wrapper')
6443			]),
6444		_List_fromArray(
6445			[
6446				A2(
6447				elm$html$Html$button,
6448				_List_fromArray(
6449					[
6450						elm$html$Html$Attributes$class('elm-book-action-log-preview'),
6451						elm$html$Html$Events$onClick(props.onClick)
6452					]),
6453				_List_fromArray(
6454					[
6455						A2(dtwrks$elm_book$ElmBook$UI$ActionLog$item, props.lastActionIndex, props.lastAction)
6456					]))
6457			]));
6458};
6459var dtwrks$elm_book$ElmBook$UI$ActionLog$previewEmpty = A2(
6460	elm$html$Html$div,
6461	_List_fromArray(
6462		[
6463			elm$html$Html$Attributes$class('elm-book-monospace elm-book-action-log-preview-empty-wrapper')
6464		]),
6465	_List_fromArray(
6466		[
6467			A2(
6468			elm$html$Html$div,
6469			_List_fromArray(
6470				[
6471					elm$html$Html$Attributes$class('elm-book-action-log-preview-empty')
6472				]),
6473			_List_fromArray(
6474				[
6475					elm$html$Html$text('Your logged actions will appear here.')
6476				]))
6477		]));
6478var dillonkearns$elm_markdown$Whitespace$isLineEnd = function (_char) {
6479	switch (_char.valueOf()) {
6480		case '\n':
6481			return true;
6482		case '\r':
6483			return true;
6484		default:
6485			return false;
6486	}
6487};
6488var elm$parser$Parser$Advanced$Parser = function (a) {
6489	return {$: 'Parser', a: a};
6490};
6491var elm$core$Basics$negate = function (n) {
6492	return -n;
6493};
6494var elm$parser$Parser$Advanced$Good = F3(
6495	function (a, b, c) {
6496		return {$: 'Good', a: a, b: b, c: c};
6497	});
6498var elm$parser$Parser$Advanced$isSubChar = _Parser_isSubChar;
6499var elm$parser$Parser$Advanced$chompWhileHelp = F5(
6500	function (isGood, offset, row, col, s0) {
6501		chompWhileHelp:
6502		while (true) {
6503			var newOffset = A3(elm$parser$Parser$Advanced$isSubChar, isGood, offset, s0.src);
6504			if (_Utils_eq(newOffset, -1)) {
6505				return A3(
6506					elm$parser$Parser$Advanced$Good,
6507					_Utils_cmp(s0.offset, offset) < 0,
6508					_Utils_Tuple0,
6509					{col: col, context: s0.context, indent: s0.indent, offset: offset, row: row, src: s0.src});
6510			} else {
6511				if (_Utils_eq(newOffset, -2)) {
6512					var $temp$isGood = isGood,
6513						$temp$offset = offset + 1,
6514						$temp$row = row + 1,
6515						$temp$col = 1,
6516						$temp$s0 = s0;
6517					isGood = $temp$isGood;
6518					offset = $temp$offset;
6519					row = $temp$row;
6520					col = $temp$col;
6521					s0 = $temp$s0;
6522					continue chompWhileHelp;
6523				} else {
6524					var $temp$isGood = isGood,
6525						$temp$offset = newOffset,
6526						$temp$row = row,
6527						$temp$col = col + 1,
6528						$temp$s0 = s0;
6529					isGood = $temp$isGood;
6530					offset = $temp$offset;
6531					row = $temp$row;
6532					col = $temp$col;
6533					s0 = $temp$s0;
6534					continue chompWhileHelp;
6535				}
6536			}
6537		}
6538	});
6539var elm$parser$Parser$Advanced$chompWhile = function (isGood) {
6540	return elm$parser$Parser$Advanced$Parser(
6541		function (s) {
6542			return A5(elm$parser$Parser$Advanced$chompWhileHelp, isGood, s.offset, s.row, s.col, s);
6543		});
6544};
6545var dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd = elm$parser$Parser$Advanced$chompWhile(
6546	A2(elm$core$Basics$composeL, elm$core$Basics$not, dillonkearns$elm_markdown$Whitespace$isLineEnd));
6547var elm$parser$Parser$Expecting = function (a) {
6548	return {$: 'Expecting', a: a};
6549};
6550var elm$parser$Parser$Advanced$Bad = F2(
6551	function (a, b) {
6552		return {$: 'Bad', a: a, b: b};
6553	});
6554var elm$parser$Parser$Advanced$AddRight = F2(
6555	function (a, b) {
6556		return {$: 'AddRight', a: a, b: b};
6557	});
6558var elm$parser$Parser$Advanced$DeadEnd = F4(
6559	function (row, col, problem, contextStack) {
6560		return {col: col, contextStack: contextStack, problem: problem, row: row};
6561	});
6562var elm$parser$Parser$Advanced$Empty = {$: 'Empty'};
6563var elm$parser$Parser$Advanced$fromState = F2(
6564	function (s, x) {
6565		return A2(
6566			elm$parser$Parser$Advanced$AddRight,
6567			elm$parser$Parser$Advanced$Empty,
6568			A4(elm$parser$Parser$Advanced$DeadEnd, s.row, s.col, x, s.context));
6569	});
6570var elm$parser$Parser$Advanced$end = function (x) {
6571	return elm$parser$Parser$Advanced$Parser(
6572		function (s) {
6573			return _Utils_eq(
6574				elm$core$String$length(s.src),
6575				s.offset) ? A3(elm$parser$Parser$Advanced$Good, false, _Utils_Tuple0, s) : A2(
6576				elm$parser$Parser$Advanced$Bad,
6577				false,
6578				A2(elm$parser$Parser$Advanced$fromState, s, x));
6579		});
6580};
6581var dillonkearns$elm_markdown$Helpers$endOfFile = elm$parser$Parser$Advanced$end(
6582	elm$parser$Parser$Expecting('the end of the input'));
6583var elm$parser$Parser$Advanced$Token = F2(
6584	function (a, b) {
6585		return {$: 'Token', a: a, b: b};
6586	});
6587var dillonkearns$elm_markdown$Parser$Token$carriageReturn = A2(
6588	elm$parser$Parser$Advanced$Token,
6589	'\r',
6590	elm$parser$Parser$Expecting('a carriage return'));
6591var dillonkearns$elm_markdown$Parser$Token$newline = A2(
6592	elm$parser$Parser$Advanced$Token,
6593	'\n',
6594	elm$parser$Parser$Expecting('a newline'));
6595var elm$core$Basics$always = F2(
6596	function (a, _n0) {
6597		return a;
6598	});
6599var elm$parser$Parser$Advanced$map2 = F3(
6600	function (func, _n0, _n1) {
6601		var parseA = _n0.a;
6602		var parseB = _n1.a;
6603		return elm$parser$Parser$Advanced$Parser(
6604			function (s0) {
6605				var _n2 = parseA(s0);
6606				if (_n2.$ === 'Bad') {
6607					var p = _n2.a;
6608					var x = _n2.b;
6609					return A2(elm$parser$Parser$Advanced$Bad, p, x);
6610				} else {
6611					var p1 = _n2.a;
6612					var a = _n2.b;
6613					var s1 = _n2.c;
6614					var _n3 = parseB(s1);
6615					if (_n3.$ === 'Bad') {
6616						var p2 = _n3.a;
6617						var x = _n3.b;
6618						return A2(elm$parser$Parser$Advanced$Bad, p1 || p2, x);
6619					} else {
6620						var p2 = _n3.a;
6621						var b = _n3.b;
6622						var s2 = _n3.c;
6623						return A3(
6624							elm$parser$Parser$Advanced$Good,
6625							p1 || p2,
6626							A2(func, a, b),
6627							s2);
6628					}
6629				}
6630			});
6631	});
6632var elm$parser$Parser$Advanced$ignorer = F2(
6633	function (keepParser, ignoreParser) {
6634		return A3(elm$parser$Parser$Advanced$map2, elm$core$Basics$always, keepParser, ignoreParser);
6635	});
6636var elm$parser$Parser$Advanced$Append = F2(
6637	function (a, b) {
6638		return {$: 'Append', a: a, b: b};
6639	});
6640var elm$parser$Parser$Advanced$oneOfHelp = F3(
6641	function (s0, bag, parsers) {
6642		oneOfHelp:
6643		while (true) {
6644			if (!parsers.b) {
6645				return A2(elm$parser$Parser$Advanced$Bad, false, bag);
6646			} else {
6647				var parse = parsers.a.a;
6648				var remainingParsers = parsers.b;
6649				var _n1 = parse(s0);
6650				if (_n1.$ === 'Good') {
6651					var step = _n1;
6652					return step;
6653				} else {
6654					var step = _n1;
6655					var p = step.a;
6656					var x = step.b;
6657					if (p) {
6658						return step;
6659					} else {
6660						var $temp$s0 = s0,
6661							$temp$bag = A2(elm$parser$Parser$Advanced$Append, bag, x),
6662							$temp$parsers = remainingParsers;
6663						s0 = $temp$s0;
6664						bag = $temp$bag;
6665						parsers = $temp$parsers;
6666						continue oneOfHelp;
6667					}
6668				}
6669			}
6670		}
6671	});
6672var elm$parser$Parser$Advanced$oneOf = function (parsers) {
6673	return elm$parser$Parser$Advanced$Parser(
6674		function (s) {
6675			return A3(elm$parser$Parser$Advanced$oneOfHelp, s, elm$parser$Parser$Advanced$Empty, parsers);
6676		});
6677};
6678var elm$parser$Parser$Advanced$succeed = function (a) {
6679	return elm$parser$Parser$Advanced$Parser(
6680		function (s) {
6681			return A3(elm$parser$Parser$Advanced$Good, false, a, s);
6682		});
6683};
6684var elm$parser$Parser$Advanced$isSubString = _Parser_isSubString;
6685var elm$parser$Parser$Advanced$token = function (_n0) {
6686	var str = _n0.a;
6687	var expecting = _n0.b;
6688	var progress = !elm$core$String$isEmpty(str);
6689	return elm$parser$Parser$Advanced$Parser(
6690		function (s) {
6691			var _n1 = A5(elm$parser$Parser$Advanced$isSubString, str, s.offset, s.row, s.col, s.src);
6692			var newOffset = _n1.a;
6693			var newRow = _n1.b;
6694			var newCol = _n1.c;
6695			return _Utils_eq(newOffset, -1) ? A2(
6696				elm$parser$Parser$Advanced$Bad,
6697				false,
6698				A2(elm$parser$Parser$Advanced$fromState, s, expecting)) : A3(
6699				elm$parser$Parser$Advanced$Good,
6700				progress,
6701				_Utils_Tuple0,
6702				{col: newCol, context: s.context, indent: s.indent, offset: newOffset, row: newRow, src: s.src});
6703		});
6704};
6705var dillonkearns$elm_markdown$Whitespace$lineEnd = elm$parser$Parser$Advanced$oneOf(
6706	_List_fromArray(
6707		[
6708			elm$parser$Parser$Advanced$token(dillonkearns$elm_markdown$Parser$Token$newline),
6709			A2(
6710			elm$parser$Parser$Advanced$ignorer,
6711			elm$parser$Parser$Advanced$token(dillonkearns$elm_markdown$Parser$Token$carriageReturn),
6712			elm$parser$Parser$Advanced$oneOf(
6713				_List_fromArray(
6714					[
6715						elm$parser$Parser$Advanced$token(dillonkearns$elm_markdown$Parser$Token$newline),
6716						elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
6717					])))
6718		]));
6719var dillonkearns$elm_markdown$Helpers$lineEndOrEnd = elm$parser$Parser$Advanced$oneOf(
6720	_List_fromArray(
6721		[dillonkearns$elm_markdown$Whitespace$lineEnd, dillonkearns$elm_markdown$Helpers$endOfFile]));
6722var dillonkearns$elm_markdown$HtmlParser$Cdata = function (a) {
6723	return {$: 'Cdata', a: a};
6724};
6725var dillonkearns$elm_markdown$HtmlParser$Element = F3(
6726	function (a, b, c) {

6727		return {$: 'Element', a: a, b: b, c: c};
6728	});
6729var dillonkearns$elm_markdown$HtmlParser$Text = function (a) {
6730	return {$: 'Text', a: a};
6731};
6732var dillonkearns$elm_markdown$HtmlParser$expectTagNameCharacter = elm$parser$Parser$Expecting('at least 1 tag name character');
6733var dillonkearns$elm_markdown$HtmlParser$tagNameCharacter = function (c) {
6734	switch (c.valueOf()) {
6735		case ' ':
6736			return false;
6737		case '\r':
6738			return false;
6739		case '\n':
6740			return false;
6741		case '\t':
6742			return false;
6743		case '/':
6744			return false;
6745		case '<':
6746			return false;
6747		case '>':
6748			return false;
6749		case '\"':
6750			return false;
6751		case '\'':
6752			return false;
6753		case '=':
6754			return false;
6755		default:
6756			return true;
6757	}
6758};
6759var elm$parser$Parser$Advanced$chompIf = F2(
6760	function (isGood, expecting) {
6761		return elm$parser$Parser$Advanced$Parser(
6762			function (s) {
6763				var newOffset = A3(elm$parser$Parser$Advanced$isSubChar, isGood, s.offset, s.src);
6764				return _Utils_eq(newOffset, -1) ? A2(
6765					elm$parser$Parser$Advanced$Bad,
6766					false,
6767					A2(elm$parser$Parser$Advanced$fromState, s, expecting)) : (_Utils_eq(newOffset, -2) ? A3(
6768					elm$parser$Parser$Advanced$Good,
6769					true,
6770					_Utils_Tuple0,
6771					{col: 1, context: s.context, indent: s.indent, offset: s.offset + 1, row: s.row + 1, src: s.src}) : A3(
6772					elm$parser$Parser$Advanced$Good,
6773					true,
6774					_Utils_Tuple0,
6775					{col: s.col + 1, context: s.context, indent: s.indent, offset: newOffset, row: s.row, src: s.src}));
6776			});
6777	});
6778var elm$parser$Parser$Advanced$mapChompedString = F2(
6779	function (func, _n0) {
6780		var parse = _n0.a;
6781		return elm$parser$Parser$Advanced$Parser(
6782			function (s0) {
6783				var _n1 = parse(s0);
6784				if (_n1.$ === 'Bad') {
6785					var p = _n1.a;
6786					var x = _n1.b;
6787					return A2(elm$parser$Parser$Advanced$Bad, p, x);
6788				} else {
6789					var p = _n1.a;
6790					var a = _n1.b;
6791					var s1 = _n1.c;
6792					return A3(
6793						elm$parser$Parser$Advanced$Good,
6794						p,
6795						A2(
6796							func,
6797							A3(elm$core$String$slice, s0.offset, s1.offset, s0.src),
6798							a),
6799						s1);
6800				}
6801			});
6802	});
6803var dillonkearns$elm_markdown$HtmlParser$tagName = A2(
6804	elm$parser$Parser$Advanced$mapChompedString,
6805	F2(
6806		function (name, _n0) {
6807			return elm$core$String$toLower(name);
6808		}),
6809	A2(
6810		elm$parser$Parser$Advanced$ignorer,
6811		A2(elm$parser$Parser$Advanced$chompIf, dillonkearns$elm_markdown$HtmlParser$tagNameCharacter, dillonkearns$elm_markdown$HtmlParser$expectTagNameCharacter),
6812		elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$HtmlParser$tagNameCharacter)));
6813var dillonkearns$elm_markdown$HtmlParser$attributeName = dillonkearns$elm_markdown$HtmlParser$tagName;
6814var elm$parser$Parser$ExpectingSymbol = function (a) {
6815	return {$: 'ExpectingSymbol', a: a};
6816};
6817var dillonkearns$elm_markdown$HtmlParser$symbol = function (str) {
6818	return elm$parser$Parser$Advanced$token(
6819		A2(
6820			elm$parser$Parser$Advanced$Token,
6821			str,
6822			elm$parser$Parser$ExpectingSymbol(str)));
6823};
6824var elm$core$Dict$RBEmpty_elm_builtin = {$: 'RBEmpty_elm_builtin'};
6825var elm$core$Dict$empty = elm$core$Dict$RBEmpty_elm_builtin;
6826var elm$core$Dict$Black = {$: 'Black'};
6827var elm$core$Dict$RBNode_elm_builtin = F5(
6828	function (a, b, c, d, e) {
6829		return {$: 'RBNode_elm_builtin', a: a, b: b, c: c, d: d, e: e};
6830	});
6831var elm$core$Dict$Red = {$: 'Red'};
6832var elm$core$Dict$balance = F5(
6833	function (color, key, value, left, right) {
6834		if ((right.$ === 'RBNode_elm_builtin') && (right.a.$ === 'Red')) {
6835			var _n1 = right.a;
6836			var rK = right.b;
6837			var rV = right.c;
6838			var rLeft = right.d;
6839			var rRight = right.e;
6840			if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) {
6841				var _n3 = left.a;
6842				var lK = left.b;
6843				var lV = left.c;
6844				var lLeft = left.d;
6845				var lRight = left.e;
6846				return A5(
6847					elm$core$Dict$RBNode_elm_builtin,
6848					elm$core$Dict$Red,
6849					key,
6850					value,
6851					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Black, lK, lV, lLeft, lRight),
6852					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Black, rK, rV, rLeft, rRight));
6853			} else {
6854				return A5(
6855					elm$core$Dict$RBNode_elm_builtin,
6856					color,
6857					rK,
6858					rV,
6859					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, key, value, left, rLeft),
6860					rRight);
6861			}
6862		} else {
6863			if ((((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) && (left.d.$ === 'RBNode_elm_builtin')) && (left.d.a.$ === 'Red')) {
6864				var _n5 = left.a;
6865				var lK = left.b;
6866				var lV = left.c;
6867				var _n6 = left.d;
6868				var _n7 = _n6.a;
6869				var llK = _n6.b;
6870				var llV = _n6.c;
6871				var llLeft = _n6.d;
6872				var llRight = _n6.e;
6873				var lRight = left.e;
6874				return A5(
6875					elm$core$Dict$RBNode_elm_builtin,
6876					elm$core$Dict$Red,
6877					lK,
6878					lV,
6879					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Black, llK, llV, llLeft, llRight),
6880					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Black, key, value, lRight, right));
6881			} else {
6882				return A5(elm$core$Dict$RBNode_elm_builtin, color, key, value, left, right);
6883			}
6884		}
6885	});
6886var elm$core$Dict$insertHelp = F3(
6887	function (key, value, dict) {
6888		if (dict.$ === 'RBEmpty_elm_builtin') {
6889			return A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, key, value, elm$core$Dict$RBEmpty_elm_builtin, elm$core$Dict$RBEmpty_elm_builtin);
6890		} else {
6891			var nColor = dict.a;
6892			var nKey = dict.b;
6893			var nValue = dict.c;
6894			var nLeft = dict.d;
6895			var nRight = dict.e;
6896			var _n1 = A2(elm$core$Basics$compare, key, nKey);
6897			switch (_n1.$) {
6898				case 'LT':
6899					return A5(
6900						elm$core$Dict$balance,
6901						nColor,
6902						nKey,
6903						nValue,
6904						A3(elm$core$Dict$insertHelp, key, value, nLeft),
6905						nRight);
6906				case 'EQ':
6907					return A5(elm$core$Dict$RBNode_elm_builtin, nColor, nKey, value, nLeft, nRight);
6908				default:
6909					return A5(
6910						elm$core$Dict$balance,
6911						nColor,
6912						nKey,
6913						nValue,
6914						nLeft,
6915						A3(elm$core$Dict$insertHelp, key, value, nRight));
6916			}
6917		}
6918	});
6919var elm$core$Dict$insert = F3(
6920	function (key, value, dict) {
6921		var _n0 = A3(elm$core$Dict$insertHelp, key, value, dict);
6922		if ((_n0.$ === 'RBNode_elm_builtin') && (_n0.a.$ === 'Red')) {
6923			var _n1 = _n0.a;
6924			var k = _n0.b;
6925			var v = _n0.c;
6926			var l = _n0.d;
6927			var r = _n0.e;
6928			return A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Black, k, v, l, r);
6929		} else {
6930			var x = _n0;
6931			return x;
6932		}
6933	});
6934var elm$core$Dict$fromList = function (assocs) {
6935	return A3(
6936		elm$core$List$foldl,
6937		F2(
6938			function (_n0, dict) {
6939				var key = _n0.a;
6940				var value = _n0.b;
6941				return A3(elm$core$Dict$insert, key, value, dict);
6942			}),
6943		elm$core$Dict$empty,
6944		assocs);
6945};
6946var dillonkearns$elm_markdown$HtmlParser$entities = elm$core$Dict$fromList(
6947	_List_fromArray(
6948		[
6949			_Utils_Tuple2(
6950			'amp',
6951			_Utils_chr('&')),
6952			_Utils_Tuple2(
6953			'lt',
6954			_Utils_chr('<')),
6955			_Utils_Tuple2(
6956			'gt',
6957			_Utils_chr('>')),
6958			_Utils_Tuple2(
6959			'apos',
6960			_Utils_chr('\'')),
6961			_Utils_Tuple2(
6962			'quot',
6963			_Utils_chr('\"'))
6964		]));
6965var elm$core$Char$fromCode = _Char_fromCode;
6966var elm$core$Result$fromMaybe = F2(
6967	function (err, maybe) {
6968		if (maybe.$ === 'Just') {
6969			var v = maybe.a;
6970			return elm$core$Result$Ok(v);
6971		} else {
6972			return elm$core$Result$Err(err);
6973		}
6974	});
6975var elm$core$Result$map = F2(
6976	function (func, ra) {
6977		if (ra.$ === 'Ok') {
6978			var a = ra.a;
6979			return elm$core$Result$Ok(
6980				func(a));
6981		} else {
6982			var e = ra.a;
6983			return elm$core$Result$Err(e);
6984		}
6985	});
6986var elm$core$Result$mapError = F2(
6987	function (f, result) {
6988		if (result.$ === 'Ok') {
6989			var v = result.a;
6990			return elm$core$Result$Ok(v);
6991		} else {
6992			var e = result.a;
6993			return elm$core$Result$Err(
6994				f(e));
6995		}
6996	});
6997var elm$parser$Parser$Problem = function (a) {
6998	return {$: 'Problem', a: a};
6999};
7000var elm$core$List$tail = function (list) {
7001	if (list.b) {
7002		var x = list.a;
7003		var xs = list.b;
7004		return elm$core$Maybe$Just(xs);
7005	} else {
7006		return elm$core$Maybe$Nothing;
7007	}
7008};

7009var elm$core$String$foldr = _String_foldr;
7010var elm$core$String$toList = function (string) {
7011	return A3(elm$core$String$foldr, elm$core$List$cons, _List_Nil, string);
7012};
7013var elm$core$Basics$pow = _Basics_pow;
7014var elm$core$String$cons = _String_cons;
7015var elm$core$String$fromChar = function (_char) {
7016	return A2(elm$core$String$cons, _char, '');
7017};
7018var rtfeldman$elm_hex$Hex$fromStringHelp = F3(
7019	function (position, chars, accumulated) {
7020		fromStringHelp:
7021		while (true) {
7022			if (!chars.b) {
7023				return elm$core$Result$Ok(accumulated);
7024			} else {
7025				var _char = chars.a;
7026				var rest = chars.b;
7027				switch (_char.valueOf()) {
7028					case '0':
7029						var $temp$position = position - 1,
7030							$temp$chars = rest,
7031							$temp$accumulated = accumulated;
7032						position = $temp$position;
7033						chars = $temp$chars;
7034						accumulated = $temp$accumulated;
7035						continue fromStringHelp;
7036					case '1':
7037						var $temp$position = position - 1,
7038							$temp$chars = rest,
7039							$temp$accumulated = accumulated + A2(elm$core$Basics$pow, 16, position);
7040						position = $temp$position;
7041						chars = $temp$chars;
7042						accumulated = $temp$accumulated;
7043						continue fromStringHelp;
7044					case '2':
7045						var $temp$position = position - 1,
7046							$temp$chars = rest,
7047							$temp$accumulated = accumulated + (2 * A2(elm$core$Basics$pow, 16, position));
7048						position = $temp$position;
7049						chars = $temp$chars;
7050						accumulated = $temp$accumulated;
7051						continue fromStringHelp;
7052					case '3':
7053						var $temp$position = position - 1,
7054							$temp$chars = rest,
7055							$temp$accumulated = accumulated + (3 * A2(elm$core$Basics$pow, 16, position));
7056						position = $temp$position;
7057						chars = $temp$chars;
7058						accumulated = $temp$accumulated;
7059						continue fromStringHelp;
7060					case '4':
7061						var $temp$position = position - 1,
7062							$temp$chars = rest,
7063							$temp$accumulated = accumulated + (4 * A2(elm$core$Basics$pow, 16, position));
7064						position = $temp$position;
7065						chars = $temp$chars;
7066						accumulated = $temp$accumulated;
7067						continue fromStringHelp;
7068					case '5':
7069						var $temp$position = position - 1,
7070							$temp$chars = rest,
7071							$temp$accumulated = accumulated + (5 * A2(elm$core$Basics$pow, 16, position));
7072						position = $temp$position;
7073						chars = $temp$chars;
7074						accumulated = $temp$accumulated;
7075						continue fromStringHelp;
7076					case '6':
7077						var $temp$position = position - 1,
7078							$temp$chars = rest,
7079							$temp$accumulated = accumulated + (6 * A2(elm$core$Basics$pow, 16, position));
7080						position = $temp$position;
7081						chars = $temp$chars;
7082						accumulated = $temp$accumulated;
7083						continue fromStringHelp;
7084					case '7':
7085						var $temp$position = position - 1,
7086							$temp$chars = rest,
7087							$temp$accumulated = accumulated + (7 * A2(elm$core$Basics$pow, 16, position));
7088						position = $temp$position;
7089						chars = $temp$chars;
7090						accumulated = $temp$accumulated;
7091						continue fromStringHelp;
7092					case '8':
7093						var $temp$position = position - 1,
7094							$temp$chars = rest,
7095							$temp$accumulated = accumulated + (8 * A2(elm$core$Basics$pow, 16, position));
7096						position = $temp$position;
7097						chars = $temp$chars;
7098						accumulated = $temp$accumulated;
7099						continue fromStringHelp;
7100					case '9':
7101						var $temp$position = position - 1,
7102							$temp$chars = rest,
7103							$temp$accumulated = accumulated + (9 * A2(elm$core$Basics$pow, 16, position));
7104						position = $temp$position;
7105						chars = $temp$chars;
7106						accumulated = $temp$accumulated;
7107						continue fromStringHelp;
7108					case 'a':
7109						var $temp$position = position - 1,
7110							$temp$chars = rest,
7111							$temp$accumulated = accumulated + (10 * A2(elm$core$Basics$pow, 16, position));
7112						position = $temp$position;
7113						chars = $temp$chars;
7114						accumulated = $temp$accumulated;
7115						continue fromStringHelp;
7116					case 'b':
7117						var $temp$position = position - 1,
7118							$temp$chars = rest,
7119							$temp$accumulated = accumulated + (11 * A2(elm$core$Basics$pow, 16, position));
7120						position = $temp$position;
7121						chars = $temp$chars;
7122						accumulated = $temp$accumulated;
7123						continue fromStringHelp;
7124					case 'c':
7125						var $temp$position = position - 1,
7126							$temp$chars = rest,
7127							$temp$accumulated = accumulated + (12 * A2(elm$core$Basics$pow, 16, position));
7128						position = $temp$position;
7129						chars = $temp$chars;
7130						accumulated = $temp$accumulated;
7131						continue fromStringHelp;
7132					case 'd':
7133						var $temp$position = position - 1,
7134							$temp$chars = rest,
7135							$temp$accumulated = accumulated + (13 * A2(elm$core$Basics$pow, 16, position));
7136						position = $temp$position;
7137						chars = $temp$chars;
7138						accumulated = $temp$accumulated;
7139						continue fromStringHelp;
7140					case 'e':
7141						var $temp$position = position - 1,
7142							$temp$chars = rest,
7143							$temp$accumulated = accumulated + (14 * A2(elm$core$Basics$pow, 16, position));
7144						position = $temp$position;
7145						chars = $temp$chars;
7146						accumulated = $temp$accumulated;
7147						continue fromStringHelp;
7148					case 'f':
7149						var $temp$position = position - 1,
7150							$temp$chars = rest,
7151							$temp$accumulated = accumulated + (15 * A2(elm$core$Basics$pow, 16, position));
7152						position = $temp$position;
7153						chars = $temp$chars;
7154						accumulated = $temp$accumulated;
7155						continue fromStringHelp;
7156					default:
7157						var nonHex = _char;
7158						return elm$core$Result$Err(
7159							elm$core$String$fromChar(nonHex) + ' is not a valid hexadecimal character.');
7160				}
7161			}
7162		}
7163	});
7164var rtfeldman$elm_hex$Hex$fromString = function (str) {
7165	if (elm$core$String$isEmpty(str)) {
7166		return elm$core$Result$Err('Empty strings are not valid hexadecimal strings.');
7167	} else {
7168		var result = function () {
7169			if (A2(elm$core$String$startsWith, '-', str)) {
7170				var list = A2(
7171					elm$core$Maybe$withDefault,
7172					_List_Nil,
7173					elm$core$List$tail(
7174						elm$core$String$toList(str)));
7175				return A2(
7176					elm$core$Result$map,
7177					elm$core$Basics$negate,
7178					A3(
7179						rtfeldman$elm_hex$Hex$fromStringHelp,
7180						elm$core$List$length(list) - 1,
7181						list,
7182						0));
7183			} else {
7184				return A3(
7185					rtfeldman$elm_hex$Hex$fromStringHelp,
7186					elm$core$String$length(str) - 1,
7187					elm$core$String$toList(str),
7188					0);
7189			}
7190		}();
7191		var formatError = function (err) {
7192			return A2(
7193				elm$core$String$join,
7194				' ',
7195				_List_fromArray(
7196					['\"' + (str + '\"'), 'is not a valid hexadecimal string because', err]));
7197		};
7198		return A2(elm$core$Result$mapError, formatError, result);
7199	}
7200};
7201var dillonkearns$elm_markdown$HtmlParser$decodeEscape = function (s) {
7202	return A2(elm$core$String$startsWith, '#x', s) ? A2(
7203		elm$core$Result$mapError,
7204		elm$parser$Parser$Problem,
7205		A2(
7206			elm$core$Result$map,
7207			elm$core$Char$fromCode,
7208			rtfeldman$elm_hex$Hex$fromString(
7209				A2(elm$core$String$dropLeft, 2, s)))) : (A2(elm$core$String$startsWith, '#', s) ? A2(
7210		elm$core$Result$fromMaybe,
7211		elm$parser$Parser$Problem('Invalid escaped character: ' + s),
7212		A2(
7213			elm$core$Maybe$map,
7214			elm$core$Char$fromCode,
7215			elm$core$String$toInt(
7216				A2(elm$core$String$dropLeft, 1, s)))) : A2(
7217		elm$core$Result$fromMaybe,
7218		elm$parser$Parser$Problem('No entity named \"&' + (s + ';\" found.')),
7219		A2(elm$core$Dict$get, s, dillonkearns$elm_markdown$HtmlParser$entities)));
7220};
7221var elm$core$Basics$neq = _Utils_notEqual;
7222var elm$parser$Parser$Advanced$andThen = F2(
7223	function (callback, _n0) {
7224		var parseA = _n0.a;
7225		return elm$parser$Parser$Advanced$Parser(
7226			function (s0) {
7227				var _n1 = parseA(s0);
7228				if (_n1.$ === 'Bad') {
7229					var p = _n1.a;
7230					var x = _n1.b;
7231					return A2(elm$parser$Parser$Advanced$Bad, p, x);
7232				} else {
7233					var p1 = _n1.a;
7234					var a = _n1.b;
7235					var s1 = _n1.c;
7236					var _n2 = callback(a);
7237					var parseB = _n2.a;
7238					var _n3 = parseB(s1);
7239					if (_n3.$ === 'Bad') {
7240						var p2 = _n3.a;
7241						var x = _n3.b;
7242						return A2(elm$parser$Parser$Advanced$Bad, p1 || p2, x);
7243					} else {
7244						var p2 = _n3.a;
7245						var b = _n3.b;
7246						var s2 = _n3.c;
7247						return A3(elm$parser$Parser$Advanced$Good, p1 || p2, b, s2);
7248					}
7249				}
7250			});
7251	});
7252var elm$parser$Parser$Advanced$getChompedString = function (parser) {
7253	return A2(elm$parser$Parser$Advanced$mapChompedString, elm$core$Basics$always, parser);
7254};
7255var elm$parser$Parser$Advanced$keeper = F2(
7256	function (parseFunc, parseArg) {
7257		return A3(elm$parser$Parser$Advanced$map2, elm$core$Basics$apL, parseFunc, parseArg);
7258	});
7259var elm$parser$Parser$Advanced$problem = function (x) {
7260	return elm$parser$Parser$Advanced$Parser(
7261		function (s) {
7262			return A2(
7263				elm$parser$Parser$Advanced$Bad,
7264				false,
7265				A2(elm$parser$Parser$Advanced$fromState, s, x));
7266		});
7267};
7268var dillonkearns$elm_markdown$HtmlParser$escapedChar = function (end_) {
7269	var process = function (entityStr) {
7270		var _n0 = dillonkearns$elm_markdown$HtmlParser$decodeEscape(entityStr);
7271		if (_n0.$ === 'Ok') {
7272			var c = _n0.a;
7273			return elm$parser$Parser$Advanced$succeed(c);
7274		} else {
7275			var e = _n0.a;
7276			return elm$parser$Parser$Advanced$problem(e);
7277		}
7278	};
7279	var isEntityChar = function (c) {
7280		return (!_Utils_eq(c, end_)) && (!_Utils_eq(
7281			c,
7282			_Utils_chr(';')));
7283	};
7284	return A2(
7285		elm$parser$Parser$Advanced$keeper,
7286		A2(
7287			elm$parser$Parser$Advanced$ignorer,
7288			elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
7289			dillonkearns$elm_markdown$HtmlParser$symbol('&')),
7290		A2(
7291			elm$parser$Parser$Advanced$ignorer,
7292			A2(
7293				elm$parser$Parser$Advanced$andThen,
7294				process,
7295				elm$parser$Parser$Advanced$getChompedString(
7296					A2(
7297						elm$parser$Parser$Advanced$ignorer,
7298						A2(
7299							elm$parser$Parser$Advanced$chompIf,
7300							isEntityChar,
7301							elm$parser$Parser$Expecting('an entity character')),
7302						elm$parser$Parser$Advanced$chompWhile(isEntityChar)))),
7303			dillonkearns$elm_markdown$HtmlParser$symbol(';')));
7304};
7305var elm$parser$Parser$Advanced$Done = function (a) {
7306	return {$: 'Done', a: a};
7307};
7308var elm$parser$Parser$Advanced$Loop = function (a) {
7309	return {$: 'Loop', a: a};
7310};
7311var elm$parser$Parser$Advanced$map = F2(
7312	function (func, _n0) {
7313		var parse = _n0.a;
7314		return elm$parser$Parser$Advanced$Parser(
7315			function (s0) {
7316				var _n1 = parse(s0);
7317				if (_n1.$ === 'Good') {
7318					var p = _n1.a;
7319					var a = _n1.b;
7320					var s1 = _n1.c;
7321					return A3(
7322						elm$parser$Parser$Advanced$Good,
7323						p,
7324						func(a),
7325						s1);
7326				} else {
7327					var p = _n1.a;
7328					var x = _n1.b;
7329					return A2(elm$parser$Parser$Advanced$Bad, p, x);
7330				}
7331			});
7332	});
7333var dillonkearns$elm_markdown$HtmlParser$textStringStep = F3(
7334	function (closingChar, predicate, accum) {
7335		return A2(
7336			elm$parser$Parser$Advanced$andThen,
7337			function (soFar) {
7338				return elm$parser$Parser$Advanced$oneOf(
7339					_List_fromArray(
7340						[
7341							A2(
7342							elm$parser$Parser$Advanced$map,
7343							function (escaped) {
7344								return elm$parser$Parser$Advanced$Loop(
7345									_Utils_ap(
7346										accum,
7347										_Utils_ap(
7348											soFar,

7349											elm$core$String$fromChar(escaped))));
7350							},
7351							dillonkearns$elm_markdown$HtmlParser$escapedChar(closingChar)),
7352							elm$parser$Parser$Advanced$succeed(
7353							elm$parser$Parser$Advanced$Done(
7354								_Utils_ap(accum, soFar)))
7355						]));
7356			},
7357			elm$parser$Parser$Advanced$getChompedString(
7358				elm$parser$Parser$Advanced$chompWhile(predicate)));
7359	});
7360var elm$parser$Parser$Advanced$loopHelp = F4(
7361	function (p, state, callback, s0) {
7362		loopHelp:
7363		while (true) {
7364			var _n0 = callback(state);
7365			var parse = _n0.a;
7366			var _n1 = parse(s0);
7367			if (_n1.$ === 'Good') {
7368				var p1 = _n1.a;
7369				var step = _n1.b;
7370				var s1 = _n1.c;
7371				if (step.$ === 'Loop') {
7372					var newState = step.a;
7373					var $temp$p = p || p1,
7374						$temp$state = newState,
7375						$temp$callback = callback,
7376						$temp$s0 = s1;
7377					p = $temp$p;
7378					state = $temp$state;
7379					callback = $temp$callback;
7380					s0 = $temp$s0;
7381					continue loopHelp;
7382				} else {
7383					var result = step.a;
7384					return A3(elm$parser$Parser$Advanced$Good, p || p1, result, s1);
7385				}
7386			} else {
7387				var p1 = _n1.a;
7388				var x = _n1.b;
7389				return A2(elm$parser$Parser$Advanced$Bad, p || p1, x);
7390			}
7391		}
7392	});
7393var elm$parser$Parser$Advanced$loop = F2(
7394	function (state, callback) {
7395		return elm$parser$Parser$Advanced$Parser(
7396			function (s) {
7397				return A4(elm$parser$Parser$Advanced$loopHelp, false, state, callback, s);
7398			});
7399	});
7400var dillonkearns$elm_markdown$HtmlParser$textString = function (closingChar) {
7401	var predicate = function (c) {
7402		return (!_Utils_eq(c, closingChar)) && (!_Utils_eq(
7403			c,
7404			_Utils_chr('&')));
7405	};
7406	return A2(
7407		elm$parser$Parser$Advanced$loop,
7408		'',
7409		A2(dillonkearns$elm_markdown$HtmlParser$textStringStep, closingChar, predicate));
7410};
7411var dillonkearns$elm_markdown$HtmlParser$attributeValue = elm$parser$Parser$Advanced$oneOf(
7412	_List_fromArray(
7413		[
7414			A2(
7415			elm$parser$Parser$Advanced$keeper,
7416			A2(
7417				elm$parser$Parser$Advanced$ignorer,
7418				elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
7419				dillonkearns$elm_markdown$HtmlParser$symbol('\"')),
7420			A2(
7421				elm$parser$Parser$Advanced$ignorer,
7422				dillonkearns$elm_markdown$HtmlParser$textString(
7423					_Utils_chr('\"')),
7424				dillonkearns$elm_markdown$HtmlParser$symbol('\"'))),
7425			A2(
7426			elm$parser$Parser$Advanced$keeper,
7427			A2(
7428				elm$parser$Parser$Advanced$ignorer,
7429				elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
7430				dillonkearns$elm_markdown$HtmlParser$symbol('\'')),
7431			A2(
7432				elm$parser$Parser$Advanced$ignorer,
7433				dillonkearns$elm_markdown$HtmlParser$textString(
7434					_Utils_chr('\'')),
7435				dillonkearns$elm_markdown$HtmlParser$symbol('\'')))
7436		]));
7437var dillonkearns$elm_markdown$HtmlParser$keepOldest = F2(
7438	function (_new, mValue) {
7439		if (mValue.$ === 'Just') {
7440			var v = mValue.a;
7441			return elm$core$Maybe$Just(v);
7442		} else {
7443			return elm$core$Maybe$Just(_new);
7444		}
7445	});
7446var dillonkearns$elm_markdown$HtmlParser$isWhitespace = function (c) {
7447	switch (c.valueOf()) {
7448		case ' ':
7449			return true;
7450		case '\r':
7451			return true;
7452		case '\n':
7453			return true;
7454		case '\t':
7455			return true;
7456		default:
7457			return false;
7458	}
7459};
7460var dillonkearns$elm_markdown$HtmlParser$whiteSpace = elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$HtmlParser$isWhitespace);
7461var elm$core$Dict$getMin = function (dict) {
7462	getMin:
7463	while (true) {
7464		if ((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) {
7465			var left = dict.d;
7466			var $temp$dict = left;
7467			dict = $temp$dict;
7468			continue getMin;
7469		} else {
7470			return dict;
7471		}
7472	}
7473};
7474var elm$core$Dict$moveRedLeft = function (dict) {
7475	if (((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) && (dict.e.$ === 'RBNode_elm_builtin')) {
7476		if ((dict.e.d.$ === 'RBNode_elm_builtin') && (dict.e.d.a.$ === 'Red')) {
7477			var clr = dict.a;
7478			var k = dict.b;
7479			var v = dict.c;
7480			var _n1 = dict.d;
7481			var lClr = _n1.a;
7482			var lK = _n1.b;
7483			var lV = _n1.c;
7484			var lLeft = _n1.d;
7485			var lRight = _n1.e;
7486			var _n2 = dict.e;
7487			var rClr = _n2.a;
7488			var rK = _n2.b;
7489			var rV = _n2.c;
7490			var rLeft = _n2.d;
7491			var _n3 = rLeft.a;
7492			var rlK = rLeft.b;
7493			var rlV = rLeft.c;
7494			var rlL = rLeft.d;
7495			var rlR = rLeft.e;
7496			var rRight = _n2.e;
7497			return A5(
7498				elm$core$Dict$RBNode_elm_builtin,
7499				elm$core$Dict$Red,
7500				rlK,
7501				rlV,
7502				A5(
7503					elm$core$Dict$RBNode_elm_builtin,
7504					elm$core$Dict$Black,
7505					k,
7506					v,
7507					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, lK, lV, lLeft, lRight),
7508					rlL),
7509				A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Black, rK, rV, rlR, rRight));
7510		} else {
7511			var clr = dict.a;
7512			var k = dict.b;
7513			var v = dict.c;
7514			var _n4 = dict.d;
7515			var lClr = _n4.a;
7516			var lK = _n4.b;
7517			var lV = _n4.c;
7518			var lLeft = _n4.d;
7519			var lRight = _n4.e;
7520			var _n5 = dict.e;
7521			var rClr = _n5.a;
7522			var rK = _n5.b;
7523			var rV = _n5.c;
7524			var rLeft = _n5.d;
7525			var rRight = _n5.e;
7526			if (clr.$ === 'Black') {
7527				return A5(
7528					elm$core$Dict$RBNode_elm_builtin,
7529					elm$core$Dict$Black,
7530					k,
7531					v,
7532					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, lK, lV, lLeft, lRight),
7533					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, rK, rV, rLeft, rRight));
7534			} else {
7535				return A5(
7536					elm$core$Dict$RBNode_elm_builtin,
7537					elm$core$Dict$Black,
7538					k,
7539					v,
7540					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, lK, lV, lLeft, lRight),
7541					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, rK, rV, rLeft, rRight));
7542			}
7543		}
7544	} else {
7545		return dict;
7546	}
7547};
7548var elm$core$Dict$moveRedRight = function (dict) {
7549	if (((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) && (dict.e.$ === 'RBNode_elm_builtin')) {
7550		if ((dict.d.d.$ === 'RBNode_elm_builtin') && (dict.d.d.a.$ === 'Red')) {
7551			var clr = dict.a;
7552			var k = dict.b;
7553			var v = dict.c;
7554			var _n1 = dict.d;
7555			var lClr = _n1.a;
7556			var lK = _n1.b;
7557			var lV = _n1.c;
7558			var _n2 = _n1.d;
7559			var _n3 = _n2.a;
7560			var llK = _n2.b;
7561			var llV = _n2.c;
7562			var llLeft = _n2.d;
7563			var llRight = _n2.e;
7564			var lRight = _n1.e;
7565			var _n4 = dict.e;
7566			var rClr = _n4.a;
7567			var rK = _n4.b;
7568			var rV = _n4.c;
7569			var rLeft = _n4.d;
7570			var rRight = _n4.e;
7571			return A5(
7572				elm$core$Dict$RBNode_elm_builtin,
7573				elm$core$Dict$Red,
7574				lK,
7575				lV,
7576				A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Black, llK, llV, llLeft, llRight),
7577				A5(
7578					elm$core$Dict$RBNode_elm_builtin,
7579					elm$core$Dict$Black,
7580					k,
7581					v,
7582					lRight,
7583					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, rK, rV, rLeft, rRight)));
7584		} else {
7585			var clr = dict.a;
7586			var k = dict.b;
7587			var v = dict.c;
7588			var _n5 = dict.d;
7589			var lClr = _n5.a;
7590			var lK = _n5.b;
7591			var lV = _n5.c;
7592			var lLeft = _n5.d;
7593			var lRight = _n5.e;
7594			var _n6 = dict.e;
7595			var rClr = _n6.a;
7596			var rK = _n6.b;
7597			var rV = _n6.c;
7598			var rLeft = _n6.d;
7599			var rRight = _n6.e;
7600			if (clr.$ === 'Black') {
7601				return A5(
7602					elm$core$Dict$RBNode_elm_builtin,
7603					elm$core$Dict$Black,
7604					k,
7605					v,
7606					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, lK, lV, lLeft, lRight),
7607					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, rK, rV, rLeft, rRight));
7608			} else {
7609				return A5(
7610					elm$core$Dict$RBNode_elm_builtin,
7611					elm$core$Dict$Black,
7612					k,
7613					v,
7614					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, lK, lV, lLeft, lRight),
7615					A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, rK, rV, rLeft, rRight));
7616			}
7617		}
7618	} else {
7619		return dict;
7620	}
7621};
7622var elm$core$Dict$removeHelpPrepEQGT = F7(
7623	function (targetKey, dict, color, key, value, left, right) {
7624		if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) {
7625			var _n1 = left.a;
7626			var lK = left.b;
7627			var lV = left.c;
7628			var lLeft = left.d;
7629			var lRight = left.e;
7630			return A5(
7631				elm$core$Dict$RBNode_elm_builtin,
7632				color,
7633				lK,
7634				lV,
7635				lLeft,
7636				A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Red, key, value, lRight, right));
7637		} else {
7638			_n2$2:
7639			while (true) {
7640				if ((right.$ === 'RBNode_elm_builtin') && (right.a.$ === 'Black')) {
7641					if (right.d.$ === 'RBNode_elm_builtin') {
7642						if (right.d.a.$ === 'Black') {
7643							var _n3 = right.a;
7644							var _n4 = right.d;
7645							var _n5 = _n4.a;
7646							return elm$core$Dict$moveRedRight(dict);
7647						} else {
7648							break _n2$2;
7649						}
7650					} else {
7651						var _n6 = right.a;
7652						var _n7 = right.d;
7653						return elm$core$Dict$moveRedRight(dict);
7654					}
7655				} else {
7656					break _n2$2;
7657				}
7658			}
7659			return dict;
7660		}
7661	});
7662var elm$core$Dict$removeMin = function (dict) {
7663	if ((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) {
7664		var color = dict.a;
7665		var key = dict.b;
7666		var value = dict.c;
7667		var left = dict.d;
7668		var lColor = left.a;
7669		var lLeft = left.d;
7670		var right = dict.e;
7671		if (lColor.$ === 'Black') {
7672			if ((lLeft.$ === 'RBNode_elm_builtin') && (lLeft.a.$ === 'Red')) {
7673				var _n3 = lLeft.a;
7674				return A5(
7675					elm$core$Dict$RBNode_elm_builtin,
7676					color,
7677					key,
7678					value,
7679					elm$core$Dict$removeMin(left),
7680					right);
7681			} else {
7682				var _n4 = elm$core$Dict$moveRedLeft(dict);
7683				if (_n4.$ === 'RBNode_elm_builtin') {
7684					var nColor = _n4.a;
7685					var nKey = _n4.b;
7686					var nValue = _n4.c;
7687					var nLeft = _n4.d;
7688					var nRight = _n4.e;
7689					return A5(
7690						elm$core$Dict$balance,
7691						nColor,
7692						nKey,
7693						nValue,
7694						elm$core$Dict$removeMin(nLeft),
7695						nRight);
7696				} else {
7697					return elm$core$Dict$RBEmpty_elm_builtin;
7698				}
7699			}
7700		} else {
7701			return A5(
7702				elm$core$Dict$RBNode_elm_builtin,
7703				color,
7704				key,
7705				value,
7706				elm$core$Dict$removeMin(left),
7707				right);
7708		}
7709	} else {
7710		return elm$core$Dict$RBEmpty_elm_builtin;
7711	}
7712};
7713var elm$core$Dict$removeHelp = F2(
7714	function (targetKey, dict) {
7715		if (dict.$ === 'RBEmpty_elm_builtin') {
7716			return elm$core$Dict$RBEmpty_elm_builtin;
7717		} else {
7718			var color = dict.a;
7719			var key = dict.b;
7720			var value = dict.c;
7721			var left = dict.d;
7722			var right = dict.e;

7723			if (_Utils_cmp(targetKey, key) < 0) {
7724				if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Black')) {
7725					var _n4 = left.a;
7726					var lLeft = left.d;
7727					if ((lLeft.$ === 'RBNode_elm_builtin') && (lLeft.a.$ === 'Red')) {
7728						var _n6 = lLeft.a;
7729						return A5(
7730							elm$core$Dict$RBNode_elm_builtin,
7731							color,
7732							key,
7733							value,
7734							A2(elm$core$Dict$removeHelp, targetKey, left),
7735							right);
7736					} else {
7737						var _n7 = elm$core$Dict$moveRedLeft(dict);
7738						if (_n7.$ === 'RBNode_elm_builtin') {
7739							var nColor = _n7.a;
7740							var nKey = _n7.b;
7741							var nValue = _n7.c;
7742							var nLeft = _n7.d;
7743							var nRight = _n7.e;
7744							return A5(
7745								elm$core$Dict$balance,
7746								nColor,
7747								nKey,
7748								nValue,
7749								A2(elm$core$Dict$removeHelp, targetKey, nLeft),
7750								nRight);
7751						} else {
7752							return elm$core$Dict$RBEmpty_elm_builtin;
7753						}
7754					}
7755				} else {
7756					return A5(
7757						elm$core$Dict$RBNode_elm_builtin,
7758						color,
7759						key,
7760						value,
7761						A2(elm$core$Dict$removeHelp, targetKey, left),
7762						right);
7763				}
7764			} else {
7765				return A2(
7766					elm$core$Dict$removeHelpEQGT,
7767					targetKey,
7768					A7(elm$core$Dict$removeHelpPrepEQGT, targetKey, dict, color, key, value, left, right));
7769			}
7770		}
7771	});
7772var elm$core$Dict$removeHelpEQGT = F2(
7773	function (targetKey, dict) {
7774		if (dict.$ === 'RBNode_elm_builtin') {
7775			var color = dict.a;
7776			var key = dict.b;
7777			var value = dict.c;
7778			var left = dict.d;
7779			var right = dict.e;
7780			if (_Utils_eq(targetKey, key)) {
7781				var _n1 = elm$core$Dict$getMin(right);
7782				if (_n1.$ === 'RBNode_elm_builtin') {
7783					var minKey = _n1.b;
7784					var minValue = _n1.c;
7785					return A5(
7786						elm$core$Dict$balance,
7787						color,
7788						minKey,
7789						minValue,
7790						left,
7791						elm$core$Dict$removeMin(right));
7792				} else {
7793					return elm$core$Dict$RBEmpty_elm_builtin;
7794				}
7795			} else {
7796				return A5(
7797					elm$core$Dict$balance,
7798					color,
7799					key,
7800					value,
7801					left,
7802					A2(elm$core$Dict$removeHelp, targetKey, right));
7803			}
7804		} else {
7805			return elm$core$Dict$RBEmpty_elm_builtin;
7806		}
7807	});
7808var elm$core$Dict$remove = F2(
7809	function (key, dict) {
7810		var _n0 = A2(elm$core$Dict$removeHelp, key, dict);
7811		if ((_n0.$ === 'RBNode_elm_builtin') && (_n0.a.$ === 'Red')) {
7812			var _n1 = _n0.a;
7813			var k = _n0.b;
7814			var v = _n0.c;
7815			var l = _n0.d;
7816			var r = _n0.e;
7817			return A5(elm$core$Dict$RBNode_elm_builtin, elm$core$Dict$Black, k, v, l, r);
7818		} else {
7819			var x = _n0;
7820			return x;
7821		}
7822	});
7823var elm$core$Dict$update = F3(
7824	function (targetKey, alter, dictionary) {
7825		var _n0 = alter(
7826			A2(elm$core$Dict$get, targetKey, dictionary));
7827		if (_n0.$ === 'Just') {
7828			var value = _n0.a;
7829			return A3(elm$core$Dict$insert, targetKey, value, dictionary);
7830		} else {
7831			return A2(elm$core$Dict$remove, targetKey, dictionary);
7832		}
7833	});
7834var dillonkearns$elm_markdown$HtmlParser$attributesStep = function (attrs) {
7835	var process = F2(
7836		function (name, value) {
7837			return elm$parser$Parser$Advanced$Loop(
7838				A3(
7839					elm$core$Dict$update,
7840					elm$core$String$toLower(name),
7841					dillonkearns$elm_markdown$HtmlParser$keepOldest(value),
7842					attrs));
7843		});
7844	return elm$parser$Parser$Advanced$oneOf(
7845		_List_fromArray(
7846			[
7847				A2(
7848				elm$parser$Parser$Advanced$keeper,
7849				A2(
7850					elm$parser$Parser$Advanced$keeper,
7851					elm$parser$Parser$Advanced$succeed(process),
7852					A2(
7853						elm$parser$Parser$Advanced$ignorer,
7854						A2(
7855							elm$parser$Parser$Advanced$ignorer,
7856							A2(elm$parser$Parser$Advanced$ignorer, dillonkearns$elm_markdown$HtmlParser$attributeName, dillonkearns$elm_markdown$HtmlParser$whiteSpace),
7857							dillonkearns$elm_markdown$HtmlParser$symbol('=')),
7858						dillonkearns$elm_markdown$HtmlParser$whiteSpace)),
7859				A2(elm$parser$Parser$Advanced$ignorer, dillonkearns$elm_markdown$HtmlParser$attributeValue, dillonkearns$elm_markdown$HtmlParser$whiteSpace)),
7860				elm$parser$Parser$Advanced$succeed(
7861				elm$parser$Parser$Advanced$Done(attrs))
7862			]));
7863};
7864var elm$core$Dict$foldl = F3(
7865	function (func, acc, dict) {
7866		foldl:
7867		while (true) {
7868			if (dict.$ === 'RBEmpty_elm_builtin') {
7869				return acc;
7870			} else {
7871				var key = dict.b;
7872				var value = dict.c;
7873				var left = dict.d;
7874				var right = dict.e;
7875				var $temp$func = func,
7876					$temp$acc = A3(
7877					func,
7878					key,
7879					value,
7880					A3(elm$core$Dict$foldl, func, acc, left)),
7881					$temp$dict = right;
7882				func = $temp$func;
7883				acc = $temp$acc;
7884				dict = $temp$dict;
7885				continue foldl;
7886			}
7887		}
7888	});
7889var dillonkearns$elm_markdown$HtmlParser$attributes = A2(
7890	elm$parser$Parser$Advanced$map,
7891	A2(
7892		elm$core$Dict$foldl,
7893		F3(
7894			function (key, value, accum) {
7895				return A2(
7896					elm$core$List$cons,
7897					{name: key, value: value},
7898					accum);
7899			}),
7900		_List_Nil),
7901	A2(elm$parser$Parser$Advanced$loop, elm$core$Dict$empty, dillonkearns$elm_markdown$HtmlParser$attributesStep));
7902var elm$parser$Parser$Advanced$chompUntilEndOr = function (str) {
7903	return elm$parser$Parser$Advanced$Parser(
7904		function (s) {
7905			var _n0 = A5(_Parser_findSubString, str, s.offset, s.row, s.col, s.src);
7906			var newOffset = _n0.a;
7907			var newRow = _n0.b;
7908			var newCol = _n0.c;
7909			var adjustedOffset = (newOffset < 0) ? elm$core$String$length(s.src) : newOffset;
7910			return A3(
7911				elm$parser$Parser$Advanced$Good,
7912				_Utils_cmp(s.offset, adjustedOffset) < 0,
7913				_Utils_Tuple0,
7914				{col: newCol, context: s.context, indent: s.indent, offset: adjustedOffset, row: newRow, src: s.src});
7915		});
7916};
7917var dillonkearns$elm_markdown$HtmlParser$cdata = A2(
7918	elm$parser$Parser$Advanced$keeper,
7919	A2(
7920		elm$parser$Parser$Advanced$ignorer,
7921		elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
7922		dillonkearns$elm_markdown$HtmlParser$symbol('<![CDATA[')),
7923	A2(
7924		elm$parser$Parser$Advanced$ignorer,
7925		elm$parser$Parser$Advanced$getChompedString(

7926			elm$parser$Parser$Advanced$chompUntilEndOr(']]>')),
7927		dillonkearns$elm_markdown$HtmlParser$symbol(']]>')));
7928var dillonkearns$elm_markdown$HtmlParser$childrenStep = F2(
7929	function (options, accum) {
7930		return A2(
7931			elm$parser$Parser$Advanced$map,
7932			function (f) {
7933				return f(accum);
7934			},
7935			elm$parser$Parser$Advanced$oneOf(options));
7936	});
7937var dillonkearns$elm_markdown$HtmlParser$fail = function (str) {
7938	return elm$parser$Parser$Advanced$problem(
7939		elm$parser$Parser$Problem(str));
7940};
7941var dillonkearns$elm_markdown$HtmlParser$closingTag = function (startTagName) {
7942	var closingTagName = A2(
7943		elm$parser$Parser$Advanced$andThen,
7944		function (endTagName) {
7945			return _Utils_eq(startTagName, endTagName) ? elm$parser$Parser$Advanced$succeed(_Utils_Tuple0) : dillonkearns$elm_markdown$HtmlParser$fail('tag name mismatch: ' + (startTagName + (' and ' + endTagName)));
7946		},
7947		dillonkearns$elm_markdown$HtmlParser$tagName);
7948	return A2(
7949		elm$parser$Parser$Advanced$ignorer,
7950		A2(
7951			elm$parser$Parser$Advanced$ignorer,
7952			A2(
7953				elm$parser$Parser$Advanced$ignorer,
7954				A2(
7955					elm$parser$Parser$Advanced$ignorer,
7956					dillonkearns$elm_markdown$HtmlParser$symbol('</'),
7957					dillonkearns$elm_markdown$HtmlParser$whiteSpace),
7958				closingTagName),
7959			dillonkearns$elm_markdown$HtmlParser$whiteSpace),
7960		dillonkearns$elm_markdown$HtmlParser$symbol('>'));
7961};
7962var dillonkearns$elm_markdown$HtmlParser$Comment = function (a) {
7963	return {$: 'Comment', a: a};
7964};
7965var dillonkearns$elm_markdown$HtmlParser$toToken = function (str) {
7966	return A2(
7967		elm$parser$Parser$Advanced$Token,
7968		str,
7969		elm$parser$Parser$Expecting(str));
7970};
7971var dillonkearns$elm_markdown$HtmlParser$comment = A2(
7972	elm$parser$Parser$Advanced$keeper,
7973	A2(
7974		elm$parser$Parser$Advanced$ignorer,
7975		elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$HtmlParser$Comment),
7976		elm$parser$Parser$Advanced$token(
7977			dillonkearns$elm_markdown$HtmlParser$toToken('<!--'))),
7978	A2(
7979		elm$parser$Parser$Advanced$ignorer,
7980		elm$parser$Parser$Advanced$getChompedString(
7981			elm$parser$Parser$Advanced$chompUntilEndOr('-->')),
7982		elm$parser$Parser$Advanced$token(
7983			dillonkearns$elm_markdown$HtmlParser$toToken('-->'))));
7984var dillonkearns$elm_markdown$HtmlParser$Declaration = F2(
7985	function (a, b) {
7986		return {$: 'Declaration', a: a, b: b};
7987	});
7988var dillonkearns$elm_markdown$HtmlParser$expectUppercaseCharacter = elm$parser$Parser$Expecting('at least 1 uppercase character');
7989var dillonkearns$elm_markdown$HtmlParser$allUppercase = elm$parser$Parser$Advanced$getChompedString(
7990	A2(
7991		elm$parser$Parser$Advanced$ignorer,
7992		A2(elm$parser$Parser$Advanced$chompIf, elm$core$Char$isUpper, dillonkearns$elm_markdown$HtmlParser$expectUppercaseCharacter),
7993		elm$parser$Parser$Advanced$chompWhile(elm$core$Char$isUpper)));
7994var dillonkearns$elm_markdown$HtmlParser$oneOrMoreWhiteSpace = A2(
7995	elm$parser$Parser$Advanced$ignorer,
7996	A2(
7997		elm$parser$Parser$Advanced$chompIf,
7998		dillonkearns$elm_markdown$HtmlParser$isWhitespace,
7999		elm$parser$Parser$Expecting('at least one whitespace')),
8000	elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$HtmlParser$isWhitespace));
8001var dillonkearns$elm_markdown$HtmlParser$docType = A2(
8002	elm$parser$Parser$Advanced$keeper,
8003	A2(
8004		elm$parser$Parser$Advanced$keeper,
8005		A2(
8006			elm$parser$Parser$Advanced$ignorer,
8007			elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$HtmlParser$Declaration),
8008			dillonkearns$elm_markdown$HtmlParser$symbol('<!')),
8009		A2(elm$parser$Parser$Advanced$ignorer, dillonkearns$elm_markdown$HtmlParser$allUppercase, dillonkearns$elm_markdown$HtmlParser$oneOrMoreWhiteSpace)),
8010	A2(
8011		elm$parser$Parser$Advanced$ignorer,
8012		elm$parser$Parser$Advanced$getChompedString(
8013			elm$parser$Parser$Advanced$chompUntilEndOr('>')),
8014		dillonkearns$elm_markdown$HtmlParser$symbol('>')));
8015var dillonkearns$elm_markdown$HtmlParser$ProcessingInstruction = function (a) {
8016	return {$: 'ProcessingInstruction', a: a};
8017};
8018var dillonkearns$elm_markdown$HtmlParser$processingInstruction = A2(
8019	elm$parser$Parser$Advanced$keeper,
8020	A2(
8021		elm$parser$Parser$Advanced$ignorer,
8022		elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$HtmlParser$ProcessingInstruction),
8023		dillonkearns$elm_markdown$HtmlParser$symbol('<?')),
8024	A2(
8025		elm$parser$Parser$Advanced$ignorer,
8026		elm$parser$Parser$Advanced$getChompedString(
8027			elm$parser$Parser$Advanced$chompUntilEndOr('?>')),
8028		dillonkearns$elm_markdown$HtmlParser$symbol('?>')));
8029var dillonkearns$elm_markdown$HtmlParser$isNotTextNodeIgnoreChar = function (c) {
8030	switch (c.valueOf()) {
8031		case '<':
8032			return false;

8033		case '&':
8034			return false;
8035		default:
8036			return true;
8037	}
8038};
8039var dillonkearns$elm_markdown$HtmlParser$textNodeStringStepOptions = _List_fromArray(
8040	[
8041		A2(
8042		elm$parser$Parser$Advanced$map,
8043		function (_n0) {
8044			return elm$parser$Parser$Advanced$Loop(_Utils_Tuple0);
8045		},
8046		A2(
8047			elm$parser$Parser$Advanced$ignorer,
8048			A2(
8049				elm$parser$Parser$Advanced$chompIf,
8050				dillonkearns$elm_markdown$HtmlParser$isNotTextNodeIgnoreChar,
8051				elm$parser$Parser$Expecting('is not & or <')),
8052			elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$HtmlParser$isNotTextNodeIgnoreChar))),
8053		A2(
8054		elm$parser$Parser$Advanced$map,
8055		function (_n1) {
8056			return elm$parser$Parser$Advanced$Loop(_Utils_Tuple0);
8057		},
8058		dillonkearns$elm_markdown$HtmlParser$escapedChar(
8059			_Utils_chr('<'))),
8060		elm$parser$Parser$Advanced$succeed(
8061		elm$parser$Parser$Advanced$Done(_Utils_Tuple0))
8062	]);
8063var dillonkearns$elm_markdown$HtmlParser$textNodeStringStep = function (_n0) {
8064	return elm$parser$Parser$Advanced$oneOf(dillonkearns$elm_markdown$HtmlParser$textNodeStringStepOptions);
8065};
8066var dillonkearns$elm_markdown$HtmlParser$textNodeString = elm$parser$Parser$Advanced$getChompedString(
8067	A2(elm$parser$Parser$Advanced$loop, _Utils_Tuple0, dillonkearns$elm_markdown$HtmlParser$textNodeStringStep));
8068var dillonkearns$elm_markdown$HtmlParser$children = function (startTagName) {
8069	return A2(
8070		elm$parser$Parser$Advanced$loop,
8071		_List_Nil,
8072		dillonkearns$elm_markdown$HtmlParser$childrenStep(
8073			dillonkearns$elm_markdown$HtmlParser$childrenStepOptions(startTagName)));
8074};
8075var dillonkearns$elm_markdown$HtmlParser$childrenStepOptions = function (startTagName) {
8076	return _List_fromArray(
8077		[
8078			A2(
8079			elm$parser$Parser$Advanced$map,
8080			F2(
8081				function (_n1, accum) {
8082					return elm$parser$Parser$Advanced$Done(
8083						elm$core$List$reverse(accum));
8084				}),
8085			dillonkearns$elm_markdown$HtmlParser$closingTag(startTagName)),
8086			A2(
8087			elm$parser$Parser$Advanced$andThen,
8088			function (text) {
8089				return elm$core$String$isEmpty(text) ? A2(
8090					elm$parser$Parser$Advanced$map,
8091					F2(
8092						function (_n2, accum) {
8093							return elm$parser$Parser$Advanced$Done(
8094								elm$core$List$reverse(accum));
8095						}),
8096					dillonkearns$elm_markdown$HtmlParser$closingTag(startTagName)) : elm$parser$Parser$Advanced$succeed(
8097					function (accum) {
8098						return elm$parser$Parser$Advanced$Loop(
8099							A2(
8100								elm$core$List$cons,
8101								dillonkearns$elm_markdown$HtmlParser$Text(text),
8102								accum));
8103					});
8104			},
8105			dillonkearns$elm_markdown$HtmlParser$textNodeString),
8106			A2(
8107			elm$parser$Parser$Advanced$map,
8108			F2(
8109				function (_new, accum) {
8110					return elm$parser$Parser$Advanced$Loop(
8111						A2(elm$core$List$cons, _new, accum));
8112				}),
8113			dillonkearns$elm_markdown$HtmlParser$cyclic$html())
8114		]);
8115};
8116var dillonkearns$elm_markdown$HtmlParser$elementContinuation = function (startTagName) {
8117	return A2(
8118		elm$parser$Parser$Advanced$keeper,
8119		A2(
8120			elm$parser$Parser$Advanced$keeper,
8121			A2(
8122				elm$parser$Parser$Advanced$ignorer,
8123				elm$parser$Parser$Advanced$succeed(
8124					dillonkearns$elm_markdown$HtmlParser$Element(startTagName)),
8125				dillonkearns$elm_markdown$HtmlParser$whiteSpace),
8126			A2(elm$parser$Parser$Advanced$ignorer, dillonkearns$elm_markdown$HtmlParser$attributes, dillonkearns$elm_markdown$HtmlParser$whiteSpace)),
8127		elm$parser$Parser$Advanced$oneOf(
8128			_List_fromArray(
8129				[
8130					A2(
8131					elm$parser$Parser$Advanced$map,
8132					function (_n0) {
8133						return _List_Nil;
8134					},
8135					dillonkearns$elm_markdown$HtmlParser$symbol('/>')),
8136					A2(
8137					elm$parser$Parser$Advanced$keeper,
8138					A2(
8139						elm$parser$Parser$Advanced$ignorer,
8140						elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
8141						dillonkearns$elm_markdown$HtmlParser$symbol('>')),
8142					dillonkearns$elm_markdown$HtmlParser$children(startTagName))
8143				])));
8144};
8145function dillonkearns$elm_markdown$HtmlParser$cyclic$html() {
8146	return elm$parser$Parser$Advanced$oneOf(
8147		_List_fromArray(
8148			[
8149				A2(elm$parser$Parser$Advanced$map, dillonkearns$elm_markdown$HtmlParser$Cdata, dillonkearns$elm_markdown$HtmlParser$cdata),
8150				dillonkearns$elm_markdown$HtmlParser$processingInstruction,
8151				dillonkearns$elm_markdown$HtmlParser$comment,
8152				dillonkearns$elm_markdown$HtmlParser$docType,

8153				dillonkearns$elm_markdown$HtmlParser$cyclic$element()
8154			]));
8155}
8156function dillonkearns$elm_markdown$HtmlParser$cyclic$element() {
8157	return A2(
8158		elm$parser$Parser$Advanced$keeper,
8159		A2(
8160			elm$parser$Parser$Advanced$ignorer,
8161			elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
8162			dillonkearns$elm_markdown$HtmlParser$symbol('<')),
8163		A2(elm$parser$Parser$Advanced$andThen, dillonkearns$elm_markdown$HtmlParser$elementContinuation, dillonkearns$elm_markdown$HtmlParser$tagName));
8164}
8165try {
8166	var dillonkearns$elm_markdown$HtmlParser$html = dillonkearns$elm_markdown$HtmlParser$cyclic$html();
8167	dillonkearns$elm_markdown$HtmlParser$cyclic$html = function () {
8168		return dillonkearns$elm_markdown$HtmlParser$html;
8169	};
8170	var dillonkearns$elm_markdown$HtmlParser$element = dillonkearns$elm_markdown$HtmlParser$cyclic$element();
8171	dillonkearns$elm_markdown$HtmlParser$cyclic$element = function () {
8172		return dillonkearns$elm_markdown$HtmlParser$element;
8173	};
8174} catch ($) {
8175throw 'Some top-level definitions from `HtmlParser` are causing infinite recursion:\n\n  ┌─────┐\n  │    children\n  │     ↓\n  │    childrenStepOptions\n  │     ↓\n  │    html\n  │     ↓\n  │    element\n  │     ↓\n  │    elementContinuation\n  └─────┘\n\nThese errors are very tricky, so read https://elm-lang.org/0.19.0/halting-problem to learn how to fix it!';}
8176var dillonkearns$elm_markdown$Markdown$Block$BlockQuote = function (a) {
8177	return {$: 'BlockQuote', a: a};
8178};
8179var dillonkearns$elm_markdown$Markdown$Block$Cdata = function (a) {
8180	return {$: 'Cdata', a: a};
8181};
8182var dillonkearns$elm_markdown$Markdown$Block$CodeBlock = function (a) {
8183	return {$: 'CodeBlock', a: a};
8184};
8185var dillonkearns$elm_markdown$Markdown$Block$CodeSpan = function (a) {
8186	return {$: 'CodeSpan', a: a};
8187};
8188var dillonkearns$elm_markdown$Markdown$Block$CompletedTask = {$: 'CompletedTask'};
8189var dillonkearns$elm_markdown$Markdown$Block$Emphasis = function (a) {
8190	return {$: 'Emphasis', a: a};
8191};
8192var dillonkearns$elm_markdown$Markdown$Block$HardLineBreak = {$: 'HardLineBreak'};
8193var dillonkearns$elm_markdown$Markdown$Block$Heading = F2(
8194	function (a, b) {
8195		return {$: 'Heading', a: a, b: b};
8196	});
8197var dillonkearns$elm_markdown$Markdown$Block$HtmlBlock = function (a) {
8198	return {$: 'HtmlBlock', a: a};
8199};
8200var dillonkearns$elm_markdown$Markdown$Block$HtmlComment = function (a) {
8201	return {$: 'HtmlComment', a: a};
8202};
8203var dillonkearns$elm_markdown$Markdown$Block$HtmlDeclaration = F2(
8204	function (a, b) {
8205		return {$: 'HtmlDeclaration', a: a, b: b};
8206	});
8207var dillonkearns$elm_markdown$Markdown$Block$HtmlElement = F3(
8208	function (a, b, c) {
8209		return {$: 'HtmlElement', a: a, b: b, c: c};
8210	});
8211var dillonkearns$elm_markdown$Markdown$Block$HtmlInline = function (a) {
8212	return {$: 'HtmlInline', a: a};
8213};
8214var dillonkearns$elm_markdown$Markdown$Block$Image = F3(
8215	function (a, b, c) {
8216		return {$: 'Image', a: a, b: b, c: c};
8217	});
8218var dillonkearns$elm_markdown$Markdown$Block$IncompleteTask = {$: 'IncompleteTask'};
8219var dillonkearns$elm_markdown$Markdown$Block$Link = F3(
8220	function (a, b, c) {
8221		return {$: 'Link', a: a, b: b, c: c};
8222	});
8223var dillonkearns$elm_markdown$Markdown$Block$ListItem = F2(
8224	function (a, b) {
8225		return {$: 'ListItem', a: a, b: b};
8226	});
8227var dillonkearns$elm_markdown$Markdown$Block$NoTask = {$: 'NoTask'};
8228var dillonkearns$elm_markdown$Markdown$Block$OrderedList = F3(
8229	function (a, b, c) {
8230		return {$: 'OrderedList', a: a, b: b, c: c};
8231	});
8232var dillonkearns$elm_markdown$Markdown$Block$Paragraph = function (a) {
8233	return {$: 'Paragraph', a: a};
8234};
8235var dillonkearns$elm_markdown$Markdown$Block$ProcessingInstruction = function (a) {
8236	return {$: 'ProcessingInstruction', a: a};
8237};
8238var dillonkearns$elm_markdown$Markdown$Block$Strikethrough = function (a) {
8239	return {$: 'Strikethrough', a: a};
8240};
8241var dillonkearns$elm_markdown$Markdown$Block$Strong = function (a) {
8242	return {$: 'Strong', a: a};
8243};
8244var dillonkearns$elm_markdown$Markdown$Block$Table = F2(
8245	function (a, b) {
8246		return {$: 'Table', a: a, b: b};
8247	});
8248var dillonkearns$elm_markdown$Markdown$Block$Text = function (a) {
8249	return {$: 'Text', a: a};
8250};
8251var dillonkearns$elm_markdown$Markdown$Block$ThematicBreak = {$: 'ThematicBreak'};
8252var dillonkearns$elm_markdown$Markdown$Block$UnorderedList = F2(
8253	function (a, b) {
8254		return {$: 'UnorderedList', a: a, b: b};
8255	});
8256var dillonkearns$elm_markdown$Markdown$CodeBlock$CodeBlock = F2(
8257	function (language, body) {
8258		return {body: body, language: language};
8259	});
8260var elm$core$String$trim = _String_trim;
8261var dillonkearns$elm_markdown$Markdown$CodeBlock$infoString = function (fenceCharacter) {
8262	var toInfoString = F2(
8263		function (str, _n2) {
8264			var _n1 = elm$core$String$trim(str);
8265			if (_n1 === '') {
8266				return elm$core$Maybe$Nothing;
8267			} else {
8268				var trimmed = _n1;
8269				return elm$core$Maybe$Just(trimmed);
8270			}
8271		});
8272	var _n0 = fenceCharacter.kind;
8273	if (_n0.$ === 'Backtick') {
8274		return A2(
8275			elm$parser$Parser$Advanced$mapChompedString,
8276			toInfoString,
8277			elm$parser$Parser$Advanced$chompWhile(
8278				function (c) {
8279					return (!_Utils_eq(
8280						c,
8281						_Utils_chr('`'))) && (!dillonkearns$elm_markdown$Whitespace$isLineEnd(c));
8282				}));
8283	} else {
8284		return A2(
8285			elm$parser$Parser$Advanced$mapChompedString,
8286			toInfoString,
8287			elm$parser$Parser$Advanced$chompWhile(
8288				A2(elm$core$Basics$composeL, elm$core$Basics$not, dillonkearns$elm_markdown$Whitespace$isLineEnd)));
8289	}
8290};
8291var dillonkearns$elm_markdown$Markdown$CodeBlock$Backtick = {$: 'Backtick'};
8292var dillonkearns$elm_markdown$Parser$Token$backtick = A2(
8293	elm$parser$Parser$Advanced$Token,
8294	'`',
8295	elm$parser$Parser$Expecting('a \'`\''));
8296var dillonkearns$elm_markdown$Markdown$CodeBlock$backtick = {
8297	_char: _Utils_chr('`'),
8298	kind: dillonkearns$elm_markdown$Markdown$CodeBlock$Backtick,
8299	token: dillonkearns$elm_markdown$Parser$Token$backtick
8300};
8301var dillonkearns$elm_markdown$Markdown$CodeBlock$colToIndentation = function (_int) {
8302	switch (_int) {
8303		case 1:
8304			return elm$parser$Parser$Advanced$succeed(0);
8305		case 2:
8306			return elm$parser$Parser$Advanced$succeed(1);
8307		case 3:
8308			return elm$parser$Parser$Advanced$succeed(2);
8309		case 4:
8310			return elm$parser$Parser$Advanced$succeed(3);
8311		default:
8312			return elm$parser$Parser$Advanced$problem(
8313				elm$parser$Parser$Expecting('Fenced code blocks should be indented no more than 3 spaces'));
8314	}
8315};
8316var elm$core$List$repeatHelp = F3(
8317	function (result, n, value) {
8318		repeatHelp:
8319		while (true) {
8320			if (n <= 0) {
8321				return result;
8322			} else {
8323				var $temp$result = A2(elm$core$List$cons, value, result),
8324					$temp$n = n - 1,
8325					$temp$value = value;
8326				result = $temp$result;
8327				n = $temp$n;
8328				value = $temp$value;
8329				continue repeatHelp;
8330			}
8331		}
8332	});
8333var elm$core$List$repeat = F2(
8334	function (n, value) {
8335		return A3(elm$core$List$repeatHelp, _List_Nil, n, value);
8336	});
8337var dillonkearns$elm_markdown$Markdown$CodeBlock$fenceOfAtLeast = F2(
8338	function (minLength, fenceCharacter) {
8339		var builtTokens = A3(
8340			elm$core$List$foldl,
8341			F2(
8342				function (t, p) {
8343					return A2(elm$parser$Parser$Advanced$ignorer, p, t);
8344				}),
8345			elm$parser$Parser$Advanced$succeed(_Utils_Tuple0),
8346			A2(
8347				elm$core$List$repeat,
8348				minLength,
8349				elm$parser$Parser$Advanced$token(fenceCharacter.token)));
8350		return A2(
8351			elm$parser$Parser$Advanced$mapChompedString,
8352			F2(
8353				function (str, _n0) {
8354					return _Utils_Tuple2(
8355						fenceCharacter,
8356						elm$core$String$length(str));
8357				}),
8358			A2(
8359				elm$parser$Parser$Advanced$ignorer,
8360				builtTokens,
8361				elm$parser$Parser$Advanced$chompWhile(
8362					elm$core$Basics$eq(fenceCharacter._char))));
8363	});
8364var dillonkearns$elm_markdown$Markdown$CodeBlock$Tilde = {$: 'Tilde'};
8365var dillonkearns$elm_markdown$Parser$Token$tilde = A2(
8366	elm$parser$Parser$Advanced$Token,
8367	'~',
8368	elm$parser$Parser$Expecting('a `~`'));
8369var dillonkearns$elm_markdown$Markdown$CodeBlock$tilde = {
8370	_char: _Utils_chr('~'),
8371	kind: dillonkearns$elm_markdown$Markdown$CodeBlock$Tilde,
8372	token: dillonkearns$elm_markdown$Parser$Token$tilde
8373};
8374var dillonkearns$elm_markdown$Parser$Token$space = A2(
8375	elm$parser$Parser$Advanced$Token,
8376	' ',
8377	elm$parser$Parser$Expecting('a space'));
8378var dillonkearns$elm_markdown$Whitespace$space = elm$parser$Parser$Advanced$token(dillonkearns$elm_markdown$Parser$Token$space);
8379var dillonkearns$elm_markdown$Whitespace$upToThreeSpaces = elm$parser$Parser$Advanced$oneOf(
8380	_List_fromArray(
8381		[
8382			A2(
8383			elm$parser$Parser$Advanced$ignorer,
8384			A2(
8385				elm$parser$Parser$Advanced$ignorer,
8386				dillonkearns$elm_markdown$Whitespace$space,
8387				elm$parser$Parser$Advanced$oneOf(
8388					_List_fromArray(
8389						[
8390							dillonkearns$elm_markdown$Whitespace$space,
8391							elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
8392						]))),
8393			elm$parser$Parser$Advanced$oneOf(
8394				_List_fromArray(
8395					[
8396						dillonkearns$elm_markdown$Whitespace$space,
8397						elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
8398					]))),
8399			elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
8400		]));
8401var elm$parser$Parser$Advanced$getCol = elm$parser$Parser$Advanced$Parser(
8402	function (s) {
8403		return A3(elm$parser$Parser$Advanced$Good, false, s.col, s);
8404	});
8405var dillonkearns$elm_markdown$Markdown$CodeBlock$openingFence = A2(
8406	elm$parser$Parser$Advanced$keeper,
8407	A2(
8408		elm$parser$Parser$Advanced$keeper,
8409		A2(
8410			elm$parser$Parser$Advanced$ignorer,
8411			elm$parser$Parser$Advanced$succeed(
8412				F2(
8413					function (indent, _n0) {
8414						var character = _n0.a;
8415						var length = _n0.b;
8416						return {character: character, indented: indent, length: length};
8417					})),
8418			dillonkearns$elm_markdown$Whitespace$upToThreeSpaces),
8419		A2(elm$parser$Parser$Advanced$andThen, dillonkearns$elm_markdown$Markdown$CodeBlock$colToIndentation, elm$parser$Parser$Advanced$getCol)),
8420	elm$parser$Parser$Advanced$oneOf(
8421		_List_fromArray(
8422			[
8423				A2(dillonkearns$elm_markdown$Markdown$CodeBlock$fenceOfAtLeast, 3, dillonkearns$elm_markdown$Markdown$CodeBlock$backtick),
8424				A2(dillonkearns$elm_markdown$Markdown$CodeBlock$fenceOfAtLeast, 3, dillonkearns$elm_markdown$Markdown$CodeBlock$tilde)
8425			])));
8426var dillonkearns$elm_markdown$Whitespace$isSpace = elm$core$Basics$eq(
8427	_Utils_chr(' '));
8428var dillonkearns$elm_markdown$Markdown$CodeBlock$closingFence = F2(
8429	function (minLength, fenceCharacter) {
8430		return A2(
8431			elm$parser$Parser$Advanced$ignorer,
8432			A2(
8433				elm$parser$Parser$Advanced$ignorer,
8434				A2(
8435					elm$parser$Parser$Advanced$ignorer,
8436					A2(
8437						elm$parser$Parser$Advanced$ignorer,
8438						elm$parser$Parser$Advanced$succeed(_Utils_Tuple0),
8439						dillonkearns$elm_markdown$Whitespace$upToThreeSpaces),
8440					A2(dillonkearns$elm_markdown$Markdown$CodeBlock$fenceOfAtLeast, minLength, fenceCharacter)),
8441				elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$Whitespace$isSpace)),
8442			dillonkearns$elm_markdown$Helpers$lineEndOrEnd);
8443	});
8444var dillonkearns$elm_markdown$Parser$Extra$upTo = F2(
8445	function (n, parser) {
8446		var _n0 = A2(elm$core$List$repeat, n, parser);
8447		if (!_n0.b) {
8448			return elm$parser$Parser$Advanced$succeed(_Utils_Tuple0);
8449		} else {
8450			var firstParser = _n0.a;
8451			var remainingParsers = _n0.b;
8452			return A3(
8453				elm$core$List$foldl,
8454				F2(
8455					function (p, parsers) {
8456						return elm$parser$Parser$Advanced$oneOf(
8457							_List_fromArray(
8458								[
8459									A2(elm$parser$Parser$Advanced$ignorer, p, parsers),
8460									elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
8461								]));
8462					}),
8463				elm$parser$Parser$Advanced$oneOf(
8464					_List_fromArray(
8465						[
8466							firstParser,
8467							elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
8468						])),
8469				remainingParsers);
8470		}
8471	});
8472var elm$parser$Parser$Advanced$getOffset = elm$parser$Parser$Advanced$Parser(
8473	function (s) {
8474		return A3(elm$parser$Parser$Advanced$Good, false, s.offset, s);
8475	});
8476var dillonkearns$elm_markdown$Markdown$CodeBlock$codeBlockLine = function (indented) {
8477	return A2(
8478		elm$parser$Parser$Advanced$keeper,
8479		A2(
8480			elm$parser$Parser$Advanced$ignorer,
8481			elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
8482			A2(dillonkearns$elm_markdown$Parser$Extra$upTo, indented, dillonkearns$elm_markdown$Whitespace$space)),
8483		A2(
8484			elm$parser$Parser$Advanced$ignorer,
8485			A2(elm$parser$Parser$Advanced$ignorer, elm$parser$Parser$Advanced$getOffset, dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd),
8486			dillonkearns$elm_markdown$Helpers$lineEndOrEnd));
8487};
8488var elm$parser$Parser$ExpectingEnd = {$: 'ExpectingEnd'};
8489var elm$parser$Parser$Advanced$backtrackable = function (_n0) {
8490	var parse = _n0.a;
8491	return elm$parser$Parser$Advanced$Parser(
8492		function (s0) {
8493			var _n1 = parse(s0);
8494			if (_n1.$ === 'Bad') {
8495				var x = _n1.b;
8496				return A2(elm$parser$Parser$Advanced$Bad, false, x);
8497			} else {
8498				var a = _n1.b;
8499				var s1 = _n1.c;
8500				return A3(elm$parser$Parser$Advanced$Good, false, a, s1);
8501			}
8502		});
8503};
8504var elm$parser$Parser$Advanced$getSource = elm$parser$Parser$Advanced$Parser(
8505	function (s) {
8506		return A3(elm$parser$Parser$Advanced$Good, false, s.src, s);
8507	});
8508var dillonkearns$elm_markdown$Markdown$CodeBlock$remainingBlockHelp = function (_n0) {
8509	var fence = _n0.a;
8510	var body = _n0.b;
8511	return elm$parser$Parser$Advanced$oneOf(
8512		_List_fromArray(
8513			[
8514				A2(
8515				elm$parser$Parser$Advanced$ignorer,
8516				elm$parser$Parser$Advanced$succeed(
8517					elm$parser$Parser$Advanced$Done(body)),
8518				elm$parser$Parser$Advanced$end(elm$parser$Parser$ExpectingEnd)),
8519				A2(
8520				elm$parser$Parser$Advanced$mapChompedString,
8521				F2(
8522					function (lineEnd, _n1) {
8523						return elm$parser$Parser$Advanced$Loop(
8524							_Utils_Tuple2(
8525								fence,
8526								_Utils_ap(body, lineEnd)));
8527					}),
8528				dillonkearns$elm_markdown$Whitespace$lineEnd),
8529				elm$parser$Parser$Advanced$backtrackable(
8530				A2(
8531					elm$parser$Parser$Advanced$ignorer,
8532					elm$parser$Parser$Advanced$succeed(
8533						elm$parser$Parser$Advanced$Done(body)),
8534					A2(dillonkearns$elm_markdown$Markdown$CodeBlock$closingFence, fence.length, fence.character))),
8535				A2(
8536				elm$parser$Parser$Advanced$keeper,
8537				A2(
8538					elm$parser$Parser$Advanced$keeper,
8539					A2(
8540						elm$parser$Parser$Advanced$keeper,
8541						elm$parser$Parser$Advanced$succeed(
8542							F3(
8543								function (start, end, source) {
8544									return elm$parser$Parser$Advanced$Loop(
8545										_Utils_Tuple2(
8546											fence,
8547											_Utils_ap(
8548												body,
8549												A3(elm$core$String$slice, start, end, source))));
8550								})),
8551						dillonkearns$elm_markdown$Markdown$CodeBlock$codeBlockLine(fence.indented)),
8552					elm$parser$Parser$Advanced$getOffset),
8553				elm$parser$Parser$Advanced$getSource)
8554			]));
8555};
8556var dillonkearns$elm_markdown$Markdown$CodeBlock$remainingBlock = function (fence) {
8557	return A2(
8558		elm$parser$Parser$Advanced$loop,
8559		_Utils_Tuple2(fence, ''),
8560		dillonkearns$elm_markdown$Markdown$CodeBlock$remainingBlockHelp);
8561};
8562var dillonkearns$elm_markdown$Markdown$CodeBlock$parser = A2(
8563	elm$parser$Parser$Advanced$andThen,
8564	function (fence) {
8565		return A2(
8566			elm$parser$Parser$Advanced$keeper,
8567			A2(
8568				elm$parser$Parser$Advanced$keeper,
8569				elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$CodeBlock$CodeBlock),
8570				A2(
8571					elm$parser$Parser$Advanced$ignorer,
8572					dillonkearns$elm_markdown$Markdown$CodeBlock$infoString(fence.character),
8573					dillonkearns$elm_markdown$Helpers$lineEndOrEnd)),
8574			dillonkearns$elm_markdown$Markdown$CodeBlock$remainingBlock(fence));
8575	},
8576	dillonkearns$elm_markdown$Markdown$CodeBlock$openingFence);
8577var elm$core$String$dropRight = F2(
8578	function (n, string) {
8579		return (n < 1) ? string : A3(elm$core$String$slice, 0, -n, string);
8580	});
8581var elm$core$String$endsWith = _String_endsWith;
8582var dillonkearns$elm_markdown$Markdown$Heading$dropTrailingHashes = function (headingString) {
8583	return A2(elm$core$String$endsWith, '#', headingString) ? dillonkearns$elm_markdown$Markdown$Heading$dropTrailingHashes(
8584		A2(elm$core$String$dropRight, 1, headingString)) : headingString;
8585};

8586var elm$core$String$trimRight = _String_trimRight;
8587var dillonkearns$elm_markdown$Markdown$Heading$dropClosingSequence = function (headingString) {
8588	var droppedTrailingHashesString = dillonkearns$elm_markdown$Markdown$Heading$dropTrailingHashes(headingString);
8589	return (A2(elm$core$String$endsWith, ' ', droppedTrailingHashesString) || elm$core$String$isEmpty(droppedTrailingHashesString)) ? elm$core$String$trimRight(droppedTrailingHashesString) : headingString;
8590};
8591var dillonkearns$elm_markdown$Markdown$Heading$isHash = function (c) {
8592	if ('#' === c.valueOf()) {
8593		return true;
8594	} else {
8595		return false;
8596	}
8597};
8598var dillonkearns$elm_markdown$Markdown$RawBlock$Heading = F2(
8599	function (a, b) {
8600		return {$: 'Heading', a: a, b: b};
8601	});
8602var dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines = function (a) {
8603	return {$: 'UnparsedInlines', a: a};
8604};
8605var dillonkearns$elm_markdown$Parser$Token$hash = A2(
8606	elm$parser$Parser$Advanced$Token,
8607	'#',
8608	elm$parser$Parser$Expecting('a `#`'));
8609var dillonkearns$elm_markdown$Parser$Token$tab = A2(
8610	elm$parser$Parser$Advanced$Token,
8611	'\t',
8612	elm$parser$Parser$Expecting('a tab'));
8613var elm$parser$Parser$Advanced$spaces = elm$parser$Parser$Advanced$chompWhile(
8614	function (c) {
8615		return _Utils_eq(
8616			c,
8617			_Utils_chr(' ')) || (_Utils_eq(
8618			c,
8619			_Utils_chr('\n')) || _Utils_eq(
8620			c,
8621			_Utils_chr('\r')));
8622	});
8623var elm$parser$Parser$Advanced$symbol = elm$parser$Parser$Advanced$token;
8624var dillonkearns$elm_markdown$Markdown$Heading$parser = A2(
8625	elm$parser$Parser$Advanced$keeper,
8626	A2(
8627		elm$parser$Parser$Advanced$keeper,
8628		A2(
8629			elm$parser$Parser$Advanced$ignorer,
8630			A2(
8631				elm$parser$Parser$Advanced$ignorer,
8632				elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$RawBlock$Heading),
8633				A2(
8634					elm$parser$Parser$Advanced$andThen,
8635					function (startingSpaces) {
8636						var startSpace = elm$core$String$length(startingSpaces);
8637						return (startSpace >= 4) ? elm$parser$Parser$Advanced$problem(
8638							elm$parser$Parser$Expecting('heading with < 4 spaces in front')) : elm$parser$Parser$Advanced$succeed(startSpace);
8639					},
8640					elm$parser$Parser$Advanced$getChompedString(elm$parser$Parser$Advanced$spaces))),
8641			elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$hash)),
8642		A2(
8643			elm$parser$Parser$Advanced$andThen,
8644			function (additionalHashes) {
8645				var level = elm$core$String$length(additionalHashes) + 1;
8646				return (level >= 7) ? elm$parser$Parser$Advanced$problem(
8647					elm$parser$Parser$Expecting('heading with < 7 #\'s')) : elm$parser$Parser$Advanced$succeed(level);
8648			},
8649			elm$parser$Parser$Advanced$getChompedString(
8650				elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$Markdown$Heading$isHash)))),
8651	elm$parser$Parser$Advanced$oneOf(
8652		_List_fromArray(
8653			[
8654				A2(
8655				elm$parser$Parser$Advanced$ignorer,
8656				elm$parser$Parser$Advanced$succeed(
8657					dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines('')),
8658				elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$newline)),
8659				A2(
8660				elm$parser$Parser$Advanced$keeper,
8661				A2(
8662					elm$parser$Parser$Advanced$ignorer,
8663					elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
8664					elm$parser$Parser$Advanced$oneOf(
8665						_List_fromArray(
8666							[
8667								elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$space),
8668								elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$tab)
8669							]))),
8670				A2(
8671					elm$parser$Parser$Advanced$mapChompedString,
8672					F2(
8673						function (headingText, _n0) {
8674							return dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines(
8675								dillonkearns$elm_markdown$Markdown$Heading$dropClosingSequence(
8676									elm$core$String$trim(headingText)));
8677						}),
8678					dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd))
8679			])));
8680var dillonkearns$elm_markdown$Markdown$Helpers$isEven = function (_int) {
8681	return !A2(elm$core$Basics$modBy, 2, _int);
8682};
8683var dillonkearns$elm_markdown$Markdown$Inline$Emphasis = F2(
8684	function (a, b) {
8685		return {$: 'Emphasis', a: a, b: b};
8686	});
8687var dillonkearns$elm_markdown$Markdown$Inline$CodeInline = function (a) {
8688	return {$: 'CodeInline', a: a};
8689};
8690var dillonkearns$elm_markdown$Markdown$Inline$HardLineBreak = {$: 'HardLineBreak'};
8691var dillonkearns$elm_markdown$Markdown$Inline$HtmlInline = function (a) {
8692	return {$: 'HtmlInline', a: a};
8693};
8694var dillonkearns$elm_markdown$Markdown$Inline$Image = F3(
8695	function (a, b, c) {

8696		return {$: 'Image', a: a, b: b, c: c};
8697	});
8698var dillonkearns$elm_markdown$Markdown$Inline$Link = F3(
8699	function (a, b, c) {
8700		return {$: 'Link', a: a, b: b, c: c};
8701	});
8702var dillonkearns$elm_markdown$Markdown$Inline$Strikethrough = function (a) {
8703	return {$: 'Strikethrough', a: a};
8704};
8705var dillonkearns$elm_markdown$Markdown$Inline$Text = function (a) {
8706	return {$: 'Text', a: a};
8707};
8708var dillonkearns$elm_markdown$Markdown$InlineParser$matchToInline = function (_n0) {
8709	var match = _n0.a;
8710	var _n1 = match.type_;
8711	switch (_n1.$) {
8712		case 'NormalType':
8713			return dillonkearns$elm_markdown$Markdown$Inline$Text(match.text);
8714		case 'HardLineBreakType':
8715			return dillonkearns$elm_markdown$Markdown$Inline$HardLineBreak;
8716		case 'CodeType':
8717			return dillonkearns$elm_markdown$Markdown$Inline$CodeInline(match.text);
8718		case 'AutolinkType':
8719			var _n2 = _n1.a;
8720			var text = _n2.a;
8721			var url = _n2.b;
8722			return A3(
8723				dillonkearns$elm_markdown$Markdown$Inline$Link,
8724				url,
8725				elm$core$Maybe$Nothing,
8726				_List_fromArray(
8727					[
8728						dillonkearns$elm_markdown$Markdown$Inline$Text(text)
8729					]));
8730		case 'LinkType':
8731			var _n3 = _n1.a;
8732			var url = _n3.a;
8733			var maybeTitle = _n3.b;
8734			return A3(
8735				dillonkearns$elm_markdown$Markdown$Inline$Link,
8736				url,
8737				maybeTitle,
8738				dillonkearns$elm_markdown$Markdown$InlineParser$matchesToInlines(match.matches));
8739		case 'ImageType':
8740			var _n4 = _n1.a;
8741			var url = _n4.a;
8742			var maybeTitle = _n4.b;
8743			return A3(
8744				dillonkearns$elm_markdown$Markdown$Inline$Image,
8745				url,
8746				maybeTitle,
8747				dillonkearns$elm_markdown$Markdown$InlineParser$matchesToInlines(match.matches));
8748		case 'HtmlType':
8749			var model = _n1.a;
8750			return dillonkearns$elm_markdown$Markdown$Inline$HtmlInline(model);
8751		case 'EmphasisType':
8752			var length = _n1.a;
8753			return A2(
8754				dillonkearns$elm_markdown$Markdown$Inline$Emphasis,
8755				length,
8756				dillonkearns$elm_markdown$Markdown$InlineParser$matchesToInlines(match.matches));
8757		default:
8758			return dillonkearns$elm_markdown$Markdown$Inline$Strikethrough(
8759				dillonkearns$elm_markdown$Markdown$InlineParser$matchesToInlines(match.matches));
8760	}
8761};
8762var dillonkearns$elm_markdown$Markdown$InlineParser$matchesToInlines = function (matches) {
8763	return A2(elm$core$List$map, dillonkearns$elm_markdown$Markdown$InlineParser$matchToInline, matches);
8764};
8765var dillonkearns$elm_markdown$Markdown$InlineParser$Match = function (a) {
8766	return {$: 'Match', a: a};
8767};
8768var dillonkearns$elm_markdown$Markdown$InlineParser$prepareChildMatch = F2(
8769	function (parentMatch, childMatch) {
8770		return dillonkearns$elm_markdown$Markdown$InlineParser$Match(
8771			{end: childMatch.end - parentMatch.textStart, matches: childMatch.matches, start: childMatch.start - parentMatch.textStart, text: childMatch.text, textEnd: childMatch.textEnd - parentMatch.textStart, textStart: childMatch.textStart - parentMatch.textStart, type_: childMatch.type_});
8772	});
8773var dillonkearns$elm_markdown$Markdown$InlineParser$addChild = F2(
8774	function (parentMatch, childMatch) {
8775		return dillonkearns$elm_markdown$Markdown$InlineParser$Match(
8776			{
8777				end: parentMatch.end,
8778				matches: A2(
8779					elm$core$List$cons,
8780					A2(dillonkearns$elm_markdown$Markdown$InlineParser$prepareChildMatch, parentMatch, childMatch),
8781					parentMatch.matches),
8782				start: parentMatch.start,
8783				text: parentMatch.text,
8784				textEnd: parentMatch.textEnd,
8785				textStart: parentMatch.textStart,
8786				type_: parentMatch.type_
8787			});
8788	});
8789var elm$core$List$sortBy = _List_sortBy;
8790var dillonkearns$elm_markdown$Markdown$InlineParser$organizeChildren = function (_n4) {
8791	var match = _n4.a;
8792	return dillonkearns$elm_markdown$Markdown$InlineParser$Match(
8793		{
8794			end: match.end,
8795			matches: dillonkearns$elm_markdown$Markdown$InlineParser$organizeMatches(match.matches),
8796			start: match.start,
8797			text: match.text,
8798			textEnd: match.textEnd,
8799			textStart: match.textStart,
8800			type_: match.type_
8801		});
8802};
8803var dillonkearns$elm_markdown$Markdown$InlineParser$organizeMatches = function (matches) {
8804	var _n2 = A2(
8805		elm$core$List$sortBy,
8806		function (_n3) {
8807			var match = _n3.a;
8808			return match.start;
8809		},
8810		matches);
8811	if (!_n2.b) {
8812		return _List_Nil;
8813	} else {
8814		var first = _n2.a;
8815		var rest = _n2.b;
8816		return A3(dillonkearns$elm_markdown$Markdown$InlineParser$organizeMatchesHelp, rest, first, _List_Nil);
8817	}
8818};
8819var dillonkearns$elm_markdown$Markdown$InlineParser$organizeMatchesHelp = F3(
8820	function (remaining, _n0, matchesTail) {
8821		organizeMatchesHelp:
8822		while (true) {
8823			var prevMatch = _n0.a;
8824			if (!remaining.b) {
8825				return A2(
8826					elm$core$List$cons,
8827					dillonkearns$elm_markdown$Markdown$InlineParser$organizeChildren(
8828						dillonkearns$elm_markdown$Markdown$InlineParser$Match(prevMatch)),
8829					matchesTail);
8830			} else {
8831				var match = remaining.a.a;
8832				var rest = remaining.b;
8833				if (_Utils_cmp(prevMatch.end, match.start) < 1) {
8834					var $temp$remaining = rest,
8835						$temp$_n0 = dillonkearns$elm_markdown$Markdown$InlineParser$Match(match),
8836						$temp$matchesTail = A2(
8837						elm$core$List$cons,
8838						dillonkearns$elm_markdown$Markdown$InlineParser$organizeChildren(
8839							dillonkearns$elm_markdown$Markdown$InlineParser$Match(prevMatch)),
8840						matchesTail);
8841					remaining = $temp$remaining;
8842					_n0 = $temp$_n0;
8843					matchesTail = $temp$matchesTail;
8844					continue organizeMatchesHelp;
8845				} else {
8846					if ((_Utils_cmp(prevMatch.start, match.start) < 0) && (_Utils_cmp(prevMatch.end, match.end) > 0)) {
8847						var $temp$remaining = rest,
8848							$temp$_n0 = A2(dillonkearns$elm_markdown$Markdown$InlineParser$addChild, prevMatch, match),
8849							$temp$matchesTail = matchesTail;
8850						remaining = $temp$remaining;
8851						_n0 = $temp$_n0;
8852						matchesTail = $temp$matchesTail;
8853						continue organizeMatchesHelp;
8854					} else {
8855						var $temp$remaining = rest,
8856							$temp$_n0 = dillonkearns$elm_markdown$Markdown$InlineParser$Match(prevMatch),
8857							$temp$matchesTail = matchesTail;
8858						remaining = $temp$remaining;
8859						_n0 = $temp$_n0;
8860						matchesTail = $temp$matchesTail;
8861						continue organizeMatchesHelp;
8862					}
8863				}
8864			}
8865		}
8866	});
8867var elm$regex$Regex$Match = F4(
8868	function (match, index, number, submatches) {
8869		return {index: index, match: match, number: number, submatches: submatches};
8870	});
8871var elm$regex$Regex$fromStringWith = _Regex_fromStringWith;
8872var elm$regex$Regex$fromString = function (string) {
8873	return A2(
8874		elm$regex$Regex$fromStringWith,
8875		{caseInsensitive: false, multiline: false},
8876		string);
8877};
8878var elm$regex$Regex$never = _Regex_never;
8879var dillonkearns$elm_markdown$Markdown$Entity$decimalRegex = A2(
8880	elm$core$Maybe$withDefault,
8881	elm$regex$Regex$never,
8882	elm$regex$Regex$fromString('&#([0-9]{1,8});'));
8883var dillonkearns$elm_markdown$Markdown$Entity$isBadEndUnicode = function (_int) {
8884	var remain_ = A2(elm$core$Basics$modBy, 16, _int);
8885	var remain = A2(elm$core$Basics$modBy, 131070, _int);
8886	return (_int >= 131070) && ((((0 <= remain) && (remain <= 15)) || ((65536 <= remain) && (remain <= 65551))

8886) && ((remain_ === 14) || (remain_ === 15)));
8887};
8888var dillonkearns$elm_markdown$Markdown$Entity$isValidUnicode = function (_int) {
8889	return (_int === 9) || ((_int === 10) || ((_int === 13) || ((_int === 133) || (((32 <= _int) && (_int <= 126)) || (((160 <= _int) && (_int <= 55295)) || (((57344 <= _int) && (_int <= 64975)) || (((65008 <= _int) && (_int <= 65533)) || ((65536 <= _int) && (_int <= 1114109)))))))));
8890};
8891var dillonkearns$elm_markdown$Markdown$Entity$validUnicode = function (_int) {
8892	return (dillonkearns$elm_markdown$Markdown$Entity$isValidUnicode(_int) && (!dillonkearns$elm_markdown$Markdown$Entity$isBadEndUnicode(_int))) ? elm$core$String$fromChar(
8893		elm$core$Char$fromCode(_int)) : elm$core$String$fromChar(
8894		elm$core$Char$fromCode(65533));
8895};
8896var dillonkearns$elm_markdown$Markdown$Entity$replaceDecimal = function (match) {
8897	var _n0 = match.submatches;
8898	if (_n0.b && (_n0.a.$ === 'Just')) {
8899		var first = _n0.a.a;
8900		var _n1 = elm$core$String$toInt(first);
8901		if (_n1.$ === 'Just') {
8902			var v = _n1.a;
8903			return dillonkearns$elm_markdown$Markdown$Entity$validUnicode(v);
8904		} else {
8905			return match.match;
8906		}
8907	} else {
8908		return match.match;
8909	}
8910};
8911var elm$regex$Regex$replace = _Regex_replaceAtMost(_Regex_infinity);
8912var dillonkearns$elm_markdown$Markdown$Entity$replaceDecimals = A2(elm$regex$Regex$replace, dillonkearns$elm_markdown$Markdown$Entity$decimalRegex, dillonkearns$elm_markdown$Markdown$Entity$replaceDecimal);
8913var dillonkearns$elm_markdown$Markdown$Entity$entitiesRegex = A2(
8914	elm$core$Maybe$withDefault,
8915	elm$regex$Regex$never,
8916	elm$regex$Regex$fromString('&([0-9a-zA-Z]+);'));
8917var dillonkearns$elm_markdown$Markdown$Entity$entities = elm$core$Dict$fromList(
8918	_List_fromArray(
8919		[
8920			_Utils_Tuple2('quot', 34),
8921			_Utils_Tuple2('amp', 38),
8922			_Utils_Tuple2('apos', 39),
8923			_Utils_Tuple2('lt', 60),
8924			_Utils_Tuple2('gt', 62),
8925			_Utils_Tuple2('nbsp', 160),
8926			_Utils_Tuple2('iexcl', 161),
8927			_Utils_Tuple2('cent', 162),
8928			_Utils_Tuple2('pound', 163),
8929			_Utils_Tuple2('curren', 164),
8930			_Utils_Tuple2('yen', 165),
8931			_Utils_Tuple2('brvbar', 166),
8932			_Utils_Tuple2('sect', 167),
8933			_Utils_Tuple2('uml', 168),
8934			_Utils_Tuple2('copy', 169),
8935			_Utils_Tuple2('ordf', 170),
8936			_Utils_Tuple2('laquo', 171),
8937			_Utils_Tuple2('not', 172),
8938			_Utils_Tuple2('shy', 173),
8939			_Utils_Tuple2('reg', 174),
8940			_Utils_Tuple2('macr', 175),
8941			_Utils_Tuple2('deg', 176),
8942			_Utils_Tuple2('plusmn', 177),
8943			_Utils_Tuple2('sup2', 178),
8944			_Utils_Tuple2('sup3', 179),
8945			_Utils_Tuple2('acute', 180),
8946			_Utils_Tuple2('micro', 181),
8947			_Utils_Tuple2('para', 182),
8948			_Utils_Tuple2('middot', 183),
8949			_Utils_Tuple2('cedil', 184),
8950			_Utils_Tuple2('sup1', 185),
8951			_Utils_Tuple2('ordm', 186),
8952			_Utils_Tuple2('raquo', 187),
8953			_Utils_Tuple2('frac14', 188),
8954			_Utils_Tuple2('frac12', 189),
8955			_Utils_Tuple2('frac34', 190),
8956			_Utils_Tuple2('iquest', 191),
8957			_Utils_Tuple2('Agrave', 192),
8958			_Utils_Tuple2('Aacute', 193),
8959			_Utils_Tuple2('Acirc', 194),
8960			_Utils_Tuple2('Atilde', 195),
8961			_Utils_Tuple2('Auml', 196),
8962			_Utils_Tuple2('Aring', 197),
8963			_Utils_Tuple2('AElig', 198),
8964			_Utils_Tuple2('Ccedil', 199),
8965			_Utils_Tuple2('Egrave', 200),
8966			_Utils_Tuple2('Eacute', 201),
8967			_Utils_Tuple2('Ecirc', 202),
8968			_Utils_Tuple2('Euml', 203),
8969			_Utils_Tuple2('Igrave', 204),
8970			_Utils_Tuple2('Iacute', 205),
8971			_Utils_Tuple2('Icirc', 206),
8972			_Utils_Tuple2('Iuml', 207),
8973			_Utils_Tuple2('ETH', 208),
8974			_Utils_Tuple2('Ntilde', 209),
8975			_Utils_Tuple2('Ograve', 210),
8976			_Utils_Tuple2('Oacute', 211),
8977			_Utils_Tuple2('Ocirc', 212),
8978			_Utils_Tuple2('Otilde', 213),
8979			_Utils_Tuple2('Ouml', 214),
8980			_Utils_Tuple2('times', 215),
8981			_Utils_Tuple2('Oslash', 216),
8982			_Utils_Tuple2('Ugrave', 217),
8983			_Utils_Tuple2('Uacute', 218),
8984			_Utils_Tuple2('Ucirc', 219),
8985			_Utils_Tuple2('Uuml', 220),
8986			_Utils_Tuple2('Yacute', 221),
8987			_Utils_Tuple2('THORN', 222),
8988			_Utils_Tuple2('szlig', 223),
8989			_Utils_Tuple2('agrave', 224),
8990			_Utils_Tuple2('aacute', 225),
8991			_Utils_Tuple2('acirc', 226),
8992			_Utils_Tuple2('atilde', 227),
8993			_Utils_Tuple2('auml', 228),
8994			_Utils_Tuple2('aring', 229),
8995			_Utils_Tuple2('aelig', 230),
8996			_Utils_Tuple2('ccedil', 231),
8997			_Utils_Tuple2('egrave', 232),
8998			_Utils_Tuple2('eacute', 233),
8999			_Utils_Tuple2('ecirc', 234),
9000			_Utils_Tuple2('euml', 235),
9001			_Utils_Tuple2('igrave', 236),
9002			_Utils_Tuple2('iacute', 237),
9003			_Utils_Tuple2('icirc', 238),
9004			_Utils_Tuple2('iuml', 239),
9005			_Utils_Tuple2('eth', 240),
9006			_Utils_Tuple2('ntilde', 241),
9007			_Utils_Tuple2('ograve', 242),
9008			_Utils_Tuple2('oacute', 243),
9009			_Utils_Tuple2('ocirc', 244),
9010			_Utils_Tuple2('otilde', 245),
9011			_Utils_Tuple2('ouml', 246),
9012			_Utils_Tuple2('divide', 247),
9013			_Utils_Tuple2('oslash', 248),
9014			_Utils_Tuple2('ugrave', 249),
9015			_Utils_Tuple2('uacute', 250),
9016			_Utils_Tuple2('ucirc', 251),
9017			_Utils_Tuple2('uuml', 252),
9018			_Utils_Tuple2('yacute', 253),
9019			_Utils_Tuple2('thorn', 254),
9020			_Utils_Tuple2('yuml', 255),
9021			_Utils_Tuple2('OElig', 338),

9022			_Utils_Tuple2('oelig', 339),
9023			_Utils_Tuple2('Scaron', 352),
9024			_Utils_Tuple2('scaron', 353),
9025			_Utils_Tuple2('Yuml', 376),
9026			_Utils_Tuple2('fnof', 402),
9027			_Utils_Tuple2('circ', 710),
9028			_Utils_Tuple2('tilde', 732),
9029			_Utils_Tuple2('Alpha', 913),
9030			_Utils_Tuple2('Beta', 914),
9031			_Utils_Tuple2('Gamma', 915),
9032			_Utils_Tuple2('Delta', 916),
9033			_Utils_Tuple2('Epsilon', 917),
9034			_Utils_Tuple2('Zeta', 918),
9035			_Utils_Tuple2('Eta', 919),
9036			_Utils_Tuple2('Theta', 920),
9037			_Utils_Tuple2('Iota', 921),
9038			_Utils_Tuple2('Kappa', 922),
9039			_Utils_Tuple2('Lambda', 923),
9040			_Utils_Tuple2('Mu', 924),
9041			_Utils_Tuple2('Nu', 925),
9042			_Utils_Tuple2('Xi', 926),
9043			_Utils_Tuple2('Omicron', 927),
9044			_Utils_Tuple2('Pi', 928),
9045			_Utils_Tuple2('Rho', 929),
9046			_Utils_Tuple2('Sigma', 931),
9047			_Utils_Tuple2('Tau', 932),
9048			_Utils_Tuple2('Upsilon', 933),
9049			_Utils_Tuple2('Phi', 934),
9050			_Utils_Tuple2('Chi', 935),
9051			_Utils_Tuple2('Psi', 936),
9052			_Utils_Tuple2('Omega', 937),
9053			_Utils_Tuple2('alpha', 945),
9054			_Utils_Tuple2('beta', 946),
9055			_Utils_Tuple2('gamma', 947),
9056			_Utils_Tuple2('delta', 948),
9057			_Utils_Tuple2('epsilon', 949),
9058			_Utils_Tuple2('zeta', 950),
9059			_Utils_Tuple2('eta', 951),
9060			_Utils_Tuple2('theta', 952),
9061			_Utils_Tuple2('iota', 953),
9062			_Utils_Tuple2('kappa', 954),
9063			_Utils_Tuple2('lambda', 955),
9064			_Utils_Tuple2('mu', 956),
9065			_Utils_Tuple2('nu', 957),
9066			_Utils_Tuple2('xi', 958),
9067			_Utils_Tuple2('omicron', 959),
9068			_Utils_Tuple2('pi', 960),
9069			_Utils_Tuple2('rho', 961),
9070			_Utils_Tuple2('sigmaf', 962),
9071			_Utils_Tuple2('sigma', 963),
9072			_Utils_Tuple2('tau', 964),
9073			_Utils_Tuple2('upsilon', 965),
9074			_Utils_Tuple2('phi', 966),
9075			_Utils_Tuple2('chi', 967),
9076			_Utils_Tuple2('psi', 968),
9077			_Utils_Tuple2('omega', 969),
9078			_Utils_Tuple2('thetasym', 977),
9079			_Utils_Tuple2('upsih', 978),
9080			_Utils_Tuple2('piv', 982),
9081			_Utils_Tuple2('ensp', 8194),
9082			_Utils_Tuple2('emsp', 8195),
9083			_Utils_Tuple2('thinsp', 8201),
9084			_Utils_Tuple2('zwnj', 8204),
9085			_Utils_Tuple2('zwj', 8205),
9086			_Utils_Tuple2('lrm', 8206),
9087			_Utils_Tuple2('rlm', 8207),
9088			_Utils_Tuple2('ndash', 8211),
9089			_Utils_Tuple2('mdash', 8212),
9090			_Utils_Tuple2('lsquo', 8216),
9091			_Utils_Tuple2('rsquo', 8217),
9092			_Utils_Tuple2('sbquo', 8218),
9093			_Utils_Tuple2('ldquo', 8220),
9094			_Utils_Tuple2('rdquo', 8221),
9095			_Utils_Tuple2('bdquo', 8222),
9096			_Utils_Tuple2('dagger', 8224),
9097			_Utils_Tuple2('Dagger', 8225),
9098			_Utils_Tuple2('bull', 8226),
9099			_Utils_Tuple2('hellip', 8230),
9100			_Utils_Tuple2('permil', 8240),
9101			_Utils_Tuple2('prime', 8242),
9102			_Utils_Tuple2('Prime', 8243),
9103			_Utils_Tuple2('lsaquo', 8249),
9104			_Utils_Tuple2('rsaquo', 8250),
9105			_Utils_Tuple2('oline', 8254),
9106			_Utils_Tuple2('frasl', 8260),
9107			_Utils_Tuple2('euro', 8364),
9108			_Utils_Tuple2('image', 8465),
9109			_Utils_Tuple2('weierp', 8472),
9110			_Utils_Tuple2('real', 8476),
9111			_Utils_Tuple2('trade', 8482),
9112			_Utils_Tuple2('alefsym', 8501),
9113			_Utils_Tuple2('larr', 8592),
9114			_Utils_Tuple2('uarr', 8593),
9115			_Utils_Tuple2('rarr', 8594),
9116			_Utils_Tuple2('darr', 8595),
9117			_Utils_Tuple2('harr', 8596),
9118			_Utils_Tuple2('crarr', 8629),
9119			_Utils_Tuple2('lArr', 8656),
9120			_Utils_Tuple2('uArr', 8657),
9121			_Utils_Tuple2('rArr', 8658),
9122			_Utils_Tuple2('dArr', 8659),
9123			_Utils_Tuple2('hArr', 8660),
9124			_Utils_Tuple2('forall', 8704),
9125			_Utils_Tuple2('part', 8706),
9126			_Utils_Tuple2('exist', 8707),
9127			_Utils_Tuple2('empty', 8709),
9128			_Utils_Tuple2('nabla', 8711),
9129			_Utils_Tuple2('isin', 8712),
9130			_Utils_Tuple2('notin', 8713),
9131			_Utils_Tuple2('ni', 8715),
9132			_Utils_Tuple2('prod', 8719),
9133			_Utils_Tuple2('sum', 8721),
9134			_Utils_Tuple2('minus', 8722),
9135			_Utils_Tuple2('lowast', 8727),
9136			_Utils_Tuple2('radic', 8730),
9137			_Utils_Tuple2('prop', 8733),
9138			_Utils_Tuple2('infin', 8734),
9139			_Utils_Tuple2('ang', 8736),
9140			_Utils_Tuple2('and', 8743),
9141			_Utils_Tuple2('or', 8744),
9142			_Utils_Tuple2('cap', 8745),
9143			_Utils_Tuple2('cup', 8746),
9144			_Utils_Tuple2('int', 8747),
9145			_Utils_Tuple2('there4', 8756),
9146			_Utils_Tuple2('sim', 8764),
9147			_Utils_Tuple2('cong', 8773),
9148			_Utils_Tuple2('asymp', 8776),
9149			_Utils_Tuple2('ne', 8800),
9150			_Utils_Tuple2('equiv', 8801),
9151			_Utils_Tuple2('le', 8804),
9152			_Utils_Tuple2('ge', 8805),
9153			_Utils_Tuple2('sub', 8834),
9154			_Utils_Tuple2('sup', 8835),
9155			_Utils_Tuple2('nsub', 8836),
9156			_Utils_Tuple2('sube', 8838),

9157			_Utils_Tuple2('supe', 8839),
9158			_Utils_Tuple2('oplus', 8853),
9159			_Utils_Tuple2('otimes', 8855),
9160			_Utils_Tuple2('perp', 8869),
9161			_Utils_Tuple2('sdot', 8901),
9162			_Utils_Tuple2('lceil', 8968),
9163			_Utils_Tuple2('rceil', 8969),
9164			_Utils_Tuple2('lfloor', 8970),
9165			_Utils_Tuple2('rfloor', 8971),
9166			_Utils_Tuple2('lang', 9001),
9167			_Utils_Tuple2('rang', 9002),
9168			_Utils_Tuple2('loz', 9674),
9169			_Utils_Tuple2('spades', 9824),
9170			_Utils_Tuple2('clubs', 9827),
9171			_Utils_Tuple2('hearts', 9829),
9172			_Utils_Tuple2('diams', 9830)
9173		]));
9174var dillonkearns$elm_markdown$Markdown$Entity$replaceEntity = function (match) {
9175	var _n0 = match.submatches;
9176	if (_n0.b && (_n0.a.$ === 'Just')) {
9177		var first = _n0.a.a;
9178		var _n1 = A2(elm$core$Dict$get, first, dillonkearns$elm_markdown$Markdown$Entity$entities);
9179		if (_n1.$ === 'Just') {
9180			var code = _n1.a;
9181			return elm$core$String$fromChar(
9182				elm$core$Char$fromCode(code));
9183		} else {
9184			return match.match;
9185		}
9186	} else {
9187		return match.match;
9188	}
9189};
9190var dillonkearns$elm_markdown$Markdown$Entity$replaceEntities = A2(elm$regex$Regex$replace, dillonkearns$elm_markdown$Markdown$Entity$entitiesRegex, dillonkearns$elm_markdown$Markdown$Entity$replaceEntity);
9191var dillonkearns$elm_markdown$Markdown$Entity$hexadecimalRegex = A2(
9192	elm$core$Maybe$withDefault,
9193	elm$regex$Regex$never,
9194	elm$regex$Regex$fromString('&#[Xx]([0-9a-fA-F]{1,8});'));
9195var elm$core$String$foldl = _String_foldl;
9196var dillonkearns$elm_markdown$Markdown$Entity$hexToInt = function (string) {
9197	var folder = F2(
9198		function (hexDigit, _int) {
9199			return ((_int * 16) + A2(
9200				elm$core$Basics$modBy,
9201				39,
9202				elm$core$Char$toCode(hexDigit))) - 9;
9203		});
9204	return A3(
9205		elm$core$String$foldl,
9206		folder,
9207		0,
9208		elm$core$String$toLower(string));
9209};
9210var dillonkearns$elm_markdown$Markdown$Entity$replaceHexadecimal = function (match) {
9211	var _n0 = match.submatches;
9212	if (_n0.b && (_n0.a.$ === 'Just')) {
9213		var first = _n0.a.a;
9214		return dillonkearns$elm_markdown$Markdown$Entity$validUnicode(
9215			dillonkearns$elm_markdown$Markdown$Entity$hexToInt(first));
9216	} else {
9217		return match.match;
9218	}
9219};
9220var dillonkearns$elm_markdown$Markdown$Entity$replaceHexadecimals = A2(elm$regex$Regex$replace, dillonkearns$elm_markdown$Markdown$Entity$hexadecimalRegex, dillonkearns$elm_markdown$Markdown$Entity$replaceHexadecimal);
9221var dillonkearns$elm_markdown$Markdown$Helpers$containsAmpersand = function (string) {
9222	return A2(elm$core$String$contains, '&', string);
9223};
9224var dillonkearns$elm_markdown$Markdown$Helpers$escapableRegex = A2(
9225	elm$core$Maybe$withDefault,
9226	elm$regex$Regex$never,
9227	elm$regex$Regex$fromString('(\\\\+)([!\"#$%&\\\'()*+,./:;<=>?@[\\\\\\]^_`{|}~-])'));
9228var elm$core$Bitwise$shiftRightBy = _Bitwise_shiftRightBy;
9229var elm$core$String$repeatHelp = F3(
9230	function (n, chunk, result) {
9231		return (n <= 0) ? result : A3(
9232			elm$core$String$repeatHelp,
9233			n >> 1,
9234			_Utils_ap(chunk, chunk),
9235			(!(n & 1)) ? result : _Utils_ap(result, chunk));
9236	});
9237var elm$core$String$repeat = F2(
9238	function (n, chunk) {
9239		return A3(elm$core$String$repeatHelp, n, chunk, '');
9240	});
9241var dillonkearns$elm_markdown$Markdown$Helpers$replaceEscapable = A2(
9242	elm$regex$Regex$replace,
9243	dillonkearns$elm_markdown$Markdown$Helpers$escapableRegex,
9244	function (regexMatch) {
9245		var _n0 = regexMatch.submatches;
9246		if (((_n0.b && (_n0.a.$ === 'Just')) && _n0.b.b) && (_n0.b.a.$ === 'Just')) {
9247			var backslashes = _n0.a.a;
9248			var _n1 = _n0.b;
9249			var escapedStr = _n1.a.a;
9250			return _Utils_ap(
9251				A2(
9252					elm$core$String$repeat,
9253					(elm$core$String$length(backslashes) / 2) | 0,
9254					'\\'),
9255				escapedStr);
9256		} else {
9257			return regexMatch.match;
9258		}
9259	});
9260var dillonkearns$elm_markdown$Markdown$Helpers$formatStr = function (str) {
9261	var withEscapes = dillonkearns$elm_markdown$Markdown$Helpers$replaceEscapable(str);
9262	return dillonkearns$elm_markdown$Markdown$Helpers$containsAmpersand(withEscapes) ? dillonkearns$elm_markdown$Markdown$Entity$replaceHexadecimals(
9263		dillonkearns$elm_markdown$Markdown$Entity$replaceDecimals(
9264			dillonkearns$elm_markdown$Markdown$Entity$replaceEntities(withEscapes))) : withEscapes;
9265};
9266var dillonkearns$elm_markdown$Markdown$InlineParser$NormalType = {$: 'NormalType'};
9267var dillonkearns$elm_markdown$Markdown$InlineParser$normalMatch = function (text) {
9268	return dillonkearns$elm_markdown$Markdown$InlineParser$Match(
9269		{
9270			end: 0,
9271			matches: _List_Nil,
9272			start: 0,
9273			text: dillonkearns$elm_markdown$Markdown$Helpers$formatStr(text),
9274			textEnd: 0,
9275			textStart: 0,
9276			type_: dillonkearns$elm_markdown$Markdown$InlineParser$NormalType
9277		});
9278};
9279var dillonkearns$elm_markdown$Markdown$InlineParser$parseTextMatch = F3(
9280	function (rawText, _n2, parsedMatches) {
9281		var matchModel = _n2.a;
9282		var updtMatch = dillonkearns$elm_markdown$Markdown$InlineParser$Match(
9283			{
9284				end: matchModel.end,
9285				matches: A3(dillonkearns$elm_markdown$Markdown$InlineParser$parseTextMatches, matchModel.text, _List_Nil, matchModel.matches),
9286				start: matchModel.start,
9287				text: matchModel.text,
9288				textEnd: matchModel.textEnd,
9289				textStart: matchModel.textStart,
9290				type_: matchModel.type_
9291			});
9292		if (!parsedMatches.b) {
9293			var finalStr = A2(elm$core$String$dropLeft, matchModel.end, rawText);
9294			return elm$core$String$isEmpty(finalStr) ? _List_fromArray(
9295				[updtMatch]) : _List_fromArray(
9296				[
9297					updtMatch,
9298					dillonkearns$elm_markdown$Markdown$InlineParser$normalMatch(finalStr)
9299				]);
9300		} else {
9301			var matchHead = parsedMatches.a.a;
9302			var matchesTail = parsedMatches.b;
9303			var _n4 = matchHead.type_;
9304			if (_n4.$ === 'NormalType') {
9305				return A2(elm$core$List$cons, updtMatch, parsedMatches);
9306			} else {
9307				return _Utils_eq(matchModel.end, matchHead.start) ? A2(elm$core$List$cons, updtMatch, parsedMatches) : ((_Utils_cmp(matchModel.end, matchHead.start) < 0) ? A2(
9308					elm$core$List$cons,
9309					updtMatch,
9310					A2(
9311						elm$core$List$cons,
9312						dillonkearns$elm_markdown$Markdown$InlineParser$normalMatch(
9313							A3(elm$core$String$slice, matchModel.end, matchHead.start, rawText)),
9314						parsedMatches)) : parsedMatches);
9315			}
9316		}
9317	});
9318var dillonkearns$elm_markdown$Markdown$InlineParser$parseTextMatches = F3(
9319	function (rawText, parsedMatches, matches) {
9320		parseTextMatches:
9321		while (true) {
9322			if (!matches.b) {
9323				if (!parsedMatches.b) {
9324					return elm$core$String$isEmpty(rawText) ? _List_Nil : _List_fromArray(
9325						[
9326							dillonkearns$elm_markdown$Markdown$InlineParser$normalMatch(rawText)
9327						]);
9328				} else {
9329					var matchModel = parsedMatches.a.a;
9330					return (matchModel.start > 0) ? A2(
9331						elm$core$List$cons,
9332						dillonkearns$elm_markdown$Markdown$InlineParser$normalMatch(
9333							A2(elm$core$String$left, matchModel.start, rawText)),
9334						parsedMatches) : parsedMatches;
9335				}
9336			} else {
9337				var match = matches.a;
9338				var matchesTail = matches.b;
9339				var $temp$rawText = rawText,
9340					$temp$parsedMatches = A3(dillonkearns$elm_markdown$Markdown$InlineParser$parseTextMatch, rawText, match, parsedMatches),
9341					$temp$matches = matchesTail;
9342				rawText = $temp$rawText;
9343				parsedMatches = $temp$parsedMatches;
9344				matches = $temp$matches;
9345				continue parseTextMatches;
9346			}
9347		}
9348	});
9349var dillonkearns$elm_markdown$Markdown$InlineParser$angleBracketLToken

9349Regex = A2(
9350	elm$core$Maybe$withDefault,
9351	elm$regex$Regex$never,
9352	elm$regex$Regex$fromString('(\\\\*)(\\<)'));
9353var dillonkearns$elm_markdown$Markdown$InlineParser$AngleBracketOpen = {$: 'AngleBracketOpen'};
9354var dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToAngleBracketLToken = function (regMatch) {
9355	var _n0 = regMatch.submatches;
9356	if ((_n0.b && _n0.b.b) && (_n0.b.a.$ === 'Just')) {
9357		var maybeBackslashes = _n0.a;
9358		var _n1 = _n0.b;
9359		var delimiter = _n1.a.a;
9360		var backslashesLength = A2(
9361			elm$core$Maybe$withDefault,
9362			0,
9363			A2(elm$core$Maybe$map, elm$core$String$length, maybeBackslashes));
9364		return dillonkearns$elm_markdown$Markdown$Helpers$isEven(backslashesLength) ? elm$core$Maybe$Just(
9365			{index: regMatch.index + backslashesLength, length: 1, meaning: dillonkearns$elm_markdown$Markdown$InlineParser$AngleBracketOpen}) : elm$core$Maybe$Nothing;
9366	} else {
9367		return elm$core$Maybe$Nothing;
9368	}
9369};
9370var elm$core$List$maybeCons = F3(
9371	function (f, mx, xs) {
9372		var _n0 = f(mx);
9373		if (_n0.$ === 'Just') {
9374			var x = _n0.a;
9375			return A2(elm$core$List$cons, x, xs);
9376		} else {
9377			return xs;
9378		}
9379	});
9380var elm$core$List$filterMap = F2(
9381	function (f, xs) {
9382		return A3(
9383			elm$core$List$foldr,
9384			elm$core$List$maybeCons(f),
9385			_List_Nil,
9386			xs);
9387	});
9388var elm$regex$Regex$find = _Regex_findAtMost(_Regex_infinity);
9389var dillonkearns$elm_markdown$Markdown$InlineParser$findAngleBracketLTokens = function (str) {
9390	return A2(
9391		elm$core$List$filterMap,
9392		dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToAngleBracketLToken,
9393		A2(elm$regex$Regex$find, dillonkearns$elm_markdown$Markdown$InlineParser$angleBracketLTokenRegex, str));
9394};
9395var dillonkearns$elm_markdown$Markdown$InlineParser$angleBracketRTokenRegex = A2(
9396	elm$core$Maybe$withDefault,
9397	elm$regex$Regex$never,
9398	elm$regex$Regex$fromString('(\\\\*)(\\>)'));
9399var dillonkearns$elm_markdown$Markdown$InlineParser$AngleBracketClose = function (a) {
9400	return {$: 'AngleBracketClose', a: a};
9401};
9402var dillonkearns$elm_markdown$Markdown$InlineParser$Escaped = {$: 'Escaped'};
9403var dillonkearns$elm_markdown$Markdown$InlineParser$NotEscaped = {$: 'NotEscaped'};
9404var dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToAngleBracketRToken = function (regMatch) {
9405	var _n0 = regMatch.submatches;
9406	if ((_n0.b && _n0.b.b) && (_n0.b.a.$ === 'Just')) {
9407		var maybeBackslashes = _n0.a;
9408		var _n1 = _n0.b;
9409		var backslashesLength = A2(
9410			elm$core$Maybe$withDefault,
9411			0,
9412			A2(elm$core$Maybe$map, elm$core$String$length, maybeBackslashes));
9413		return elm$core$Maybe$Just(
9414			{
9415				index: regMatch.index + backslashesLength,
9416				length: 1,
9417				meaning: dillonkearns$elm_markdown$Markdown$Helpers$isEven(backslashesLength) ? dillonkearns$elm_markdown$Markdown$InlineParser$AngleBracketClose(dillonkearns$elm_markdown$Markdown$InlineParser$NotEscaped) : dillonkearns$elm_markdown$Markdown$InlineParser$AngleBracketClose(dillonkearns$elm_markdown$Markdown$InlineParser$Escaped)
9418			});
9419	} else {
9420		return elm$core$Maybe$Nothing;
9421	}
9422};
9423var dillonkearns$elm_markdown$Markdown$InlineParser$findAngleBracketRTokens = function (str) {
9424	return A2(
9425		elm$core$List$filterMap,
9426		dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToAngleBracketRToken,
9427		A2(elm$regex$Regex$find, dillonkearns$elm_markdown$Markdown$InlineParser$angleBracketRTokenRegex, str));
9428};
9429var dillonkearns$elm_markdown$Markdown$InlineParser$asteriskEmphasisTokenRegex = A2(
9430	elm$core$Maybe$withDefault,
9431	elm$regex$Regex$never,
9432	elm$regex$Regex$fromString('(\\\\*)([^*])?(\\*+)([^*])?'));
9433var dillonkearns$elm_markdown$Markdown$InlineParser$EmphasisToken = F2(
9434	function (a, b) {
9435		return {$: 'EmphasisToken', a: a, b: b};
9436	});
9437var dillonkearns$elm_markdown$Markdown$InlineParser$isPunctuation = function (c) {
9438	switch (c.valueOf()) {
9439		case '!':
9440			return true;
9441		case '\"':
9442			return true;
9443		case '#':
9444			return true;
9445		case '%':
9446			return true;
9447		case '&':
9448			return true;
9449		case '\'':
9450			return true;
9451		case '(':
9452			return true;
9453		case ')':
9454			return true;
9455		case '*':
9456			return true;
9457		case ',':
9458			return true;
9459		case '-':
9460			return true;
9461		case '.':
9462			return true;
9463		case '/':
9464			return true;
9465		case ':':
9466			return true;
9467		case ';':
9468			return true;
9469		case '?':
9470			return true;
9471		case '@':
9472			return true;
9473		case '[':
9474			return true;
9475		case ']':
9476			return true;
9477		case '_':
9478			return true;
9479		case '{':
9480			return true;
9481		case '}':
9482			return true;
9483		case '~':
9484			return true;
9485		default:
9486			return false;

9487	}
9488};
9489var dillonkearns$elm_markdown$Markdown$InlineParser$containPunctuation = A2(
9490	elm$core$String$foldl,
9491	F2(
9492		function (c, accum) {
9493			return accum || dillonkearns$elm_markdown$Markdown$InlineParser$isPunctuation(c);
9494		}),
9495	false);
9496var dillonkearns$elm_markdown$Markdown$InlineParser$isWhitespace = function (c) {
9497	switch (c.valueOf()) {
9498		case ' ':
9499			return true;
9500		case '\u000c':
9501			return true;
9502		case '\n':
9503			return true;
9504		case '\r':
9505			return true;
9506		case '\t':
9507			return true;
9508		case '\u000b':
9509			return true;
9510		case '\u00a0':
9511			return true;
9512		case '\u2028':
9513			return true;
9514		case '\u2029':
9515			return true;
9516		default:
9517			return false;
9518	}
9519};
9520var dillonkearns$elm_markdown$Markdown$InlineParser$containSpace = A2(
9521	elm$core$String$foldl,
9522	F2(
9523		function (c, accum) {
9524			return accum || dillonkearns$elm_markdown$Markdown$InlineParser$isWhitespace(c);
9525		}),
9526	false);
9527var dillonkearns$elm_markdown$Markdown$InlineParser$getFringeRank = function (mstring) {
9528	if (mstring.$ === 'Just') {
9529		var string = mstring.a;
9530		return (elm$core$String$isEmpty(string) || dillonkearns$elm_markdown$Markdown$InlineParser$containSpace(string)) ? 0 : (dillonkearns$elm_markdown$Markdown$InlineParser$containPunctuation(string) ? 1 : 2);
9531	} else {
9532		return 0;
9533	}
9534};
9535var dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToEmphasisToken = F3(
9536	function (_char, rawText, regMatch) {
9537		var _n0 = regMatch.submatches;
9538		if ((((_n0.b && _n0.b.b) && _n0.b.b.b) && (_n0.b.b.a.$ === 'Just')) && _n0.b.b.b.b) {
9539			var maybeBackslashes = _n0.a;
9540			var _n1 = _n0.b;
9541			var maybeLeftFringe = _n1.a;
9542			var _n2 = _n1.b;
9543			var delimiter = _n2.a.a;
9544			var _n3 = _n2.b;
9545			var maybeRightFringe = _n3.a;
9546			var rFringeRank = dillonkearns$elm_markdown$Markdown$InlineParser$getFringeRank(maybeRightFringe);
9547			var leftFringeLength = function () {
9548				if (maybeLeftFringe.$ === 'Just') {
9549					var left = maybeLeftFringe.a;
9550					return elm$core$String$length(left);
9551				} else {
9552					return 0;
9553				}
9554			}();
9555			var mLeftFringe = (regMatch.index && (!leftFringeLength)) ? elm$core$Maybe$Just(
9556				A3(elm$core$String$slice, regMatch.index - 1, regMatch.index, rawText)) : maybeLeftFringe;
9557			var backslashesLength = function () {
9558				if (maybeBackslashes.$ === 'Just') {
9559					var backslashes = maybeBackslashes.a;
9560					return elm$core$String$length(backslashes);
9561				} else {
9562					return 0;
9563				}
9564			}();
9565			var isEscaped = ((!dillonkearns$elm_markdown$Markdown$Helpers$isEven(backslashesLength)) && (!leftFringeLength)) || function () {
9566				if ((mLeftFringe.$ === 'Just') && (mLeftFringe.a === '\\')) {
9567					return true;
9568				} else {
9569					return false;
9570				}
9571			}();
9572			var delimiterLength = isEscaped ? (elm$core$String$length(delimiter) - 1) : elm$core$String$length(delimiter);
9573			var lFringeRank = isEscaped ? 1 : dillonkearns$elm_markdown$Markdown$InlineParser$getFringeRank(mLeftFringe);
9574			if ((delimiterLength <= 0) || (_Utils_eq(
9575				_char,
9576				_Utils_chr('_')) && ((lFringeRank === 2) && (rFringeRank === 2)))) {
9577				return elm$core$Maybe$Nothing;
9578			} else {
9579				var index = ((regMatch.index + backslashesLength) + leftFringeLength) + (isEscaped ? 1 : 0);
9580				return elm$core$Maybe$Just(
9581					{
9582						index: index,
9583						length: delimiterLength,
9584						meaning: A2(
9585							dillonkearns$elm_markdown$Markdown$InlineParser$EmphasisToken,
9586							_char,
9587							{leftFringeRank: lFringeRank, rightFringeRank: rFringeRank})
9588					});
9589			}
9590		} else {
9591			return elm$core$Maybe$Nothing;
9592		}
9593	});
9594var dillonkearns$elm_markdown$Markdown$InlineParser$findAsteriskEmphasisTokens = function (str) {
9595	return A2(
9596		elm$core$List$filterMap,
9597		A2(
9598			dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToEmphasisToken,
9599			_Utils_chr('*'),
9600			str),
9601		A2(elm$regex$Regex$find, dillonkearns$elm_markdown$Markdown$InlineParser$asteriskEmphasisTokenRegex, str));
9602};
9603var dillonkearns$elm_markdown$Markdown$InlineParser$codeTokenRegex = A2(
9604	elm$core$Maybe$withDefault,
9605	elm$regex$Regex$never,
9606	elm$regex$Regex$fromString('(\\\\*)(\\`+)'));
9607var dillonkearns$elm_markdown$Markdown$InlineParser$CodeToken = function (a) {
9608	return {$: 'CodeToken', a: a};
9609};
9610var dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToCodeToken = function (regMatch) {
9611	var _n0 = regMatch.submatches;
9612	if ((_n0.b && _n0.b.b) && (_n0.b.a.$ === 'Just')) {
9613		var maybeBackslashes = _n0.a;
9614		var _n1 = _n0.b;
9615		var backtick = _n1.a.a;
9616		var backslashesLength = A2(
9617			elm$core$Maybe$withDefault,
9618			0,
9619			A2(elm$core$Maybe$map, elm$core$String$length, maybeBackslashes));
9620		return elm$core$Maybe$Just(
9621			{
9622				index: regMatch.index + backslashesLength,

9623				length: elm$core$String$length(backtick),
9624				meaning: dillonkearns$elm_markdown$Markdown$Helpers$isEven(backslashesLength) ? dillonkearns$elm_markdown$Markdown$InlineParser$CodeToken(dillonkearns$elm_markdown$Markdown$InlineParser$NotEscaped) : dillonkearns$elm_markdown$Markdown$InlineParser$CodeToken(dillonkearns$elm_markdown$Markdown$InlineParser$Escaped)
9625			});
9626	} else {
9627		return elm$core$Maybe$Nothing;
9628	}
9629};
9630var dillonkearns$elm_markdown$Markdown$InlineParser$findCodeTokens = function (str) {
9631	return A2(
9632		elm$core$List$filterMap,
9633		dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToCodeToken,
9634		A2(elm$regex$Regex$find, dillonkearns$elm_markdown$Markdown$InlineParser$codeTokenRegex, str));
9635};
9636var dillonkearns$elm_markdown$Markdown$InlineParser$hardBreakTokenRegex = A2(
9637	elm$core$Maybe$withDefault,
9638	elm$regex$Regex$never,
9639	elm$regex$Regex$fromString('(?:(\\\\+)|( {2,}))\\n'));
9640var dillonkearns$elm_markdown$Markdown$InlineParser$HardLineBreakToken = {$: 'HardLineBreakToken'};
9641var dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToHardBreakToken = function (regMatch) {
9642	var _n0 = regMatch.submatches;
9643	_n0$2:
9644	while (true) {
9645		if (_n0.b) {
9646			if (_n0.a.$ === 'Just') {
9647				var backslashes = _n0.a.a;
9648				var backslashesLength = elm$core$String$length(backslashes);
9649				return (!dillonkearns$elm_markdown$Markdown$Helpers$isEven(backslashesLength)) ? elm$core$Maybe$Just(
9650					{index: (regMatch.index + backslashesLength) - 1, length: 2, meaning: dillonkearns$elm_markdown$Markdown$InlineParser$HardLineBreakToken}) : elm$core$Maybe$Nothing;
9651			} else {
9652				if (_n0.b.b && (_n0.b.a.$ === 'Just')) {
9653					var _n1 = _n0.b;
9654					return elm$core$Maybe$Just(
9655						{
9656							index: regMatch.index,
9657							length: elm$core$String$length(regMatch.match),
9658							meaning: dillonkearns$elm_markdown$Markdown$InlineParser$HardLineBreakToken
9659						});
9660				} else {
9661					break _n0$2;
9662				}
9663			}
9664		} else {
9665			break _n0$2;
9666		}
9667	}
9668	return elm$core$Maybe$Nothing;
9669};
9670var dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToSoftHardBreakToken = function (regMatch) {
9671	var _n0 = regMatch.submatches;
9672	_n0$2:
9673	while (true) {
9674		if (_n0.b) {
9675			if (_n0.a.$ === 'Just') {
9676				var backslashes = _n0.a.a;
9677				var backslashesLength = elm$core$String$length(backslashes);
9678				return dillonkearns$elm_markdown$Markdown$Helpers$isEven(backslashesLength) ? elm$core$Maybe$Just(
9679					{index: regMatch.index + backslashesLength, length: 1, meaning: dillonkearns$elm_markdown$Markdown$InlineParser$HardLineBreakToken}) : elm$core$Maybe$Just(
9680					{index: (regMatch.index + backslashesLength) - 1, length: 2, meaning: dillonkearns$elm_markdown$Markdown$InlineParser$HardLineBreakToken});
9681			} else {
9682				if (_n0.b.b) {
9683					var _n1 = _n0.b;
9684					var maybeSpaces = _n1.a;
9685					return elm$core$Maybe$Just(
9686						{
9687							index: regMatch.index,
9688							length: elm$core$String$length(regMatch.match),
9689							meaning: dillonkearns$elm_markdown$Markdown$InlineParser$HardLineBreakToken
9690						});
9691				} else {
9692					break _n0$2;
9693				}
9694			}
9695		} else {
9696			break _n0$2;
9697		}
9698	}
9699	return elm$core$Maybe$Nothing;
9700};
9701var dillonkearns$elm_markdown$Markdown$InlineParser$softAsHardLineBreak = false;
9702var dillonkearns$elm_markdown$Markdown$InlineParser$softAsHardLineBreakTokenRegex = A2(
9703	elm$core$Maybe$withDefault,
9704	elm$regex$Regex$never,
9705	elm$regex$Regex$fromString('(?:(\\\\+)|( *))\\n'));
9706var dillonkearns$elm_markdown$Markdown$InlineParser$findHardBreakTokens = function (str) {
9707	return dillonkearns$elm_markdown$Markdown$InlineParser$softAsHardLineBreak ? A2(
9708		elm$core$List$filterMap,
9709		dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToSoftHardBreakToken,
9710		A2(elm$regex$Regex$find, dillonkearns$elm_markdown$Markdown$InlineParser$softAsHardLineBreakTokenRegex, str)) : A2(
9711		elm$core$List$filterMap,
9712		dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToHardBreakToken,
9713		A2(elm$regex$Regex$find, dillonkearns$elm_markdown$Markdown$InlineParser$hardBreakTokenRegex, str));
9714};
9715var dillonkearns$elm_markdown$Markdown$InlineParser$linkImageCloseTokenRegex = A2(
9716	elm$core$Maybe$withDefault,
9717	elm$regex$Regex$never,
9718	elm$regex$Regex$fromString('(\\\\*)(\\])'));
9719var dillonkearns$elm_markdown$Markdown$InlineParser$SquareBracketClose = {$: 'SquareBracketClose'};
9720var dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToLinkImageCloseToken = function (regMatch) {
9721	var _n0 = regMatch.submatches;
9722	if ((_n0.b && _n0.b.b) && (_n0.b.a.$ === 'Just')) {
9723		var maybeBackslashes = _n0.a;
9724		var _n1 = _n0.b;
9725		var backslashesLength = A2(
9726			elm$core$Maybe$withDefault,
9727			0,
9728			A2(elm$core$Maybe$map, elm$core$String$length, maybeBackslashes));
9729		return dillonkearns$elm_markdown$Markdown$Helpers$isEven(backslashesLength) ? elm$core$Maybe$Just(
9730			{index: regMatch.index + backslashesLength, length: 1, meaning: dillonkearns$elm_markdown$Markdown$InlineParser$SquareBracketClose}) : elm$core$Maybe$Nothing;
9731	} else {
9732		return elm$core$Maybe$Nothing;
9733	}
9734};
9735var dillonkearns$elm_markdown$Markdown$InlineParser$findLinkImageCloseTokens = function (str) {
9736	return A2(
9737		elm$core$List$filterMap,
9738		dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToLinkImageCloseToken,
9739		A2(elm$regex$Regex$find, dillonkearns$elm_markdown$Markdown$InlineParser$linkImageCloseTokenRegex, str));
9740};
9741var dillonkearns$elm_markdown$Markdown$InlineParser$linkImageOpenToken

9741Regex = A2(
9742	elm$core$Maybe$withDefault,
9743	elm$regex$Regex$never,
9744	elm$regex$Regex$fromString('(\\\\*)(\\!)?(\\[)'));
9745var dillonkearns$elm_markdown$Markdown$InlineParser$Active = {$: 'Active'};
9746var dillonkearns$elm_markdown$Markdown$InlineParser$ImageOpenToken = {$: 'ImageOpenToken'};
9747var dillonkearns$elm_markdown$Markdown$InlineParser$LinkOpenToken = function (a) {
9748	return {$: 'LinkOpenToken', a: a};
9749};
9750var dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToLinkImageOpenToken = function (regMatch) {
9751	var _n0 = regMatch.submatches;
9752	if (((_n0.b && _n0.b.b) && _n0.b.b.b) && (_n0.b.b.a.$ === 'Just')) {
9753		var maybeBackslashes = _n0.a;
9754		var _n1 = _n0.b;
9755		var maybeImageOpen = _n1.a;
9756		var _n2 = _n1.b;
9757		var backslashesLength = A2(
9758			elm$core$Maybe$withDefault,
9759			0,
9760			A2(elm$core$Maybe$map, elm$core$String$length, maybeBackslashes));
9761		var isEscaped = !dillonkearns$elm_markdown$Markdown$Helpers$isEven(backslashesLength);
9762		var index = isEscaped ? ((regMatch.index + backslashesLength) + 1) : (regMatch.index + backslashesLength);
9763		if (isEscaped) {
9764			if (maybeImageOpen.$ === 'Just') {
9765				return elm$core$Maybe$Just(
9766					{
9767						index: index,
9768						length: 1,
9769						meaning: dillonkearns$elm_markdown$Markdown$InlineParser$LinkOpenToken(dillonkearns$elm_markdown$Markdown$InlineParser$Active)
9770					});
9771			} else {
9772				return elm$core$Maybe$Nothing;
9773			}
9774		} else {
9775			if (maybeImageOpen.$ === 'Just') {
9776				return elm$core$Maybe$Just(
9777					{index: index, length: 2, meaning: dillonkearns$elm_markdown$Markdown$InlineParser$ImageOpenToken});
9778			} else {
9779				return elm$core$Maybe$Just(
9780					{
9781						index: index,
9782						length: 1,
9783						meaning: dillonkearns$elm_markdown$Markdown$InlineParser$LinkOpenToken(dillonkearns$elm_markdown$Markdown$InlineParser$Active)
9784					});
9785			}
9786		}
9787	} else {
9788		return elm$core$Maybe$Nothing;
9789	}
9790};
9791var dillonkearns$elm_markdown$Markdown$InlineParser$findLinkImageOpenTokens = function (str) {
9792	return A2(
9793		elm$core$List$filterMap,
9794		dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToLinkImageOpenToken,
9795		A2(elm$regex$Regex$find, dillonkearns$elm_markdown$Markdown$InlineParser$linkImageOpenTokenRegex, str));
9796};
9797var dillonkearns$elm_markdown$Markdown$InlineParser$StrikethroughToken = function (a) {
9798	return {$: 'StrikethroughToken', a: a};
9799};
9800var dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToStrikethroughToken = function (regMatch) {
9801	var _n0 = regMatch.submatches;
9802	if ((_n0.b && _n0.b.b) && (_n0.b.a.$ === 'Just')) {
9803		var maybeBackslashes = _n0.a;
9804		var _n1 = _n0.b;
9805		var tilde = _n1.a.a;
9806		var backslashesLength = A2(
9807			elm$core$Maybe$withDefault,
9808			0,
9809			A2(elm$core$Maybe$map, elm$core$String$length, maybeBackslashes));
9810		var _n2 = dillonkearns$elm_markdown$Markdown$Helpers$isEven(backslashesLength) ? _Utils_Tuple2(
9811			elm$core$String$length(tilde),
9812			dillonkearns$elm_markdown$Markdown$InlineParser$StrikethroughToken(dillonkearns$elm_markdown$Markdown$InlineParser$NotEscaped)) : _Utils_Tuple2(
9813			elm$core$String$length(tilde),
9814			dillonkearns$elm_markdown$Markdown$InlineParser$StrikethroughToken(dillonkearns$elm_markdown$Markdown$InlineParser$Escaped));
9815		var length = _n2.a;
9816		var meaning = _n2.b;
9817		return elm$core$Maybe$Just(
9818			{index: regMatch.index + backslashesLength, length: length, meaning: meaning});
9819	} else {
9820		return elm$core$Maybe$Nothing;
9821	}
9822};
9823var dillonkearns$elm_markdown$Markdown$InlineParser$strikethroughTokenRegex = A2(
9824	elm$core$Maybe$withDefault,
9825	elm$regex$Regex$never,
9826	elm$regex$Regex$fromString('(\\\\*)(~{2,})([^~])?'));
9827var dillonkearns$elm_markdown$Markdown$InlineParser$findStrikethroughTokens = function (str) {
9828	return A2(
9829		elm$core$List$filterMap,
9830		dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToStrikethroughToken,
9831		A2(elm$regex$Regex$find, dillonkearns$elm_markdown$Markdown$InlineParser$strikethroughTokenRegex, str));
9832};
9833var dillonkearns$elm_markdown$Markdown$InlineParser$underlineEmphasisTokenRegex = A2(
9834	elm$core$Maybe$withDefault,
9835	elm$regex$Regex$never,
9836	elm$regex$Regex$fromString('(\\\\*)([^_])?(\\_+)([^_])?'));
9837var dillonkearns$elm_markdown$Markdown$InlineParser$findUnderlineEmphasisTokens = function (str) {
9838	return A2(
9839		elm$core$List$filterMap,
9840		A2(
9841			dillonkearns$elm_markdown$Markdown$InlineParser$regMatchToEmphasisToken,
9842			_Utils_chr('_'),
9843			str),
9844		A2(elm$regex$Regex$find, dillonkearns$elm_markdown$Markdown$InlineParser$underlineEmphasisTokenRegex, str));
9845};
9846var dillonkearns$elm_markdown$Markdown$InlineParser$mergeByIndex = F2(
9847	function (left, right) {
9848		if (left.b) {
9849			var lfirst = left.a;
9850			var lrest = left.b;
9851			if (right.b) {
9852				var rfirst = right.a;
9853				var rrest = right.b;
9854				return (_Utils_cmp(lfirst.index, rfirst.index) < 0) ? A2(
9855					elm$core$List$cons,
9856					lfirst,
9857					A2(dillonkearns$elm_markdown$Markdown$InlineParser$mergeByIndex, lrest, right)) : A2(
9858					elm$core$List$cons,
9859					rfirst,
9860					A2(dillonkearns$elm_markdown$Markdown$InlineParser$mergeByIndex, left, rrest));
9861			} else {
9862				return left;
9863			}
9864		} else {
9865			return right;
9866		}
9867	});
9868var dillonkearns$elm_markdown$Markdown$InlineParser$tokenize = function (rawText) {
9869	return A2(
9870		dillonkearns$elm_markdown$Markdown$InlineParser$mergeByIndex,
9871		dillonkearns$elm_markdown$Markdown$InlineParser$findAngleBracketRTokens(rawText),
9872		A2(
9873			dillonkearns$elm_markdown$Markdown$InlineParser$mergeByIndex,
9874			dillonkearns$elm_markdown$Markdown$InlineParser$findAngleBracketLTokens(rawText),
9875			A2(
9876				dillonkearns$elm_markdown$Markdown$InlineParser$mergeByIndex,
9877				dillonkearns$elm_markdown$Markdown$InlineParser$findHardBreakTokens(rawText),
9878				A2(
9879					dillonkearns$elm_markdown$Markdown$InlineParser$mergeByIndex,
9880					dillonkearns$elm_markdown$Markdown$InlineParser$findLinkImageCloseTokens(rawText),
9881					A2(
9882						dillonkearns$elm_markdown$Markdown$InlineParser$mergeByIndex,
9883						dillonkearns$elm_markdown$Markdown$InlineParser$findLinkImageOpenTokens(rawText),
9884						A2(
9885							dillonkearns$elm_markdown$Markdown$InlineParser$mergeByIndex,
9886							dillonkearns$elm_markdown$Markdown$InlineParser$findStrikethroughTokens(rawText),
9887							A2(
9888								dillonkearns$elm_markdown$Markdown$InlineParser$mergeByIndex,
9889								dillonkearns$elm_markdown$Markdown$InlineParser$findUnderlineEmphasisTokens(rawText),
9890								A2(
9891									dillonkearns$elm_markdown$Markdown$InlineParser$mergeByIndex,
9892									dillonkearns$elm_markdown$Markdown$InlineParser$findAsteriskEmphasisTokens(rawText),
9893									dillonkearns$elm_markdown$Markdown$InlineParser$findCodeTokens(rawText)))))))));
9894};

9895var dillonkearns$elm_markdown$Markdown$Helpers$cleanWhitespaces = function (original) {
9896	return original;
9897};
9898var dillonkearns$elm_markdown$Markdown$Helpers$ifError = F2(
9899	function (_function, result) {
9900		if (result.$ === 'Ok') {
9901			return result;
9902		} else {
9903			var err = result.a;
9904			return _function(err);
9905		}
9906	});
9907var dillonkearns$elm_markdown$Markdown$InlineParser$CodeType = {$: 'CodeType'};
9908var dillonkearns$elm_markdown$Markdown$InlineParser$EmphasisType = function (a) {
9909	return {$: 'EmphasisType', a: a};
9910};
9911var dillonkearns$elm_markdown$Markdown$InlineParser$HtmlType = function (a) {
9912	return {$: 'HtmlType', a: a};
9913};
9914var dillonkearns$elm_markdown$Markdown$InlineParser$ImageType = function (a) {
9915	return {$: 'ImageType', a: a};
9916};
9917var dillonkearns$elm_markdown$Markdown$InlineParser$Inactive = {$: 'Inactive'};
9918var dillonkearns$elm_markdown$Markdown$InlineParser$LinkType = function (a) {
9919	return {$: 'LinkType', a: a};
9920};
9921var dillonkearns$elm_markdown$Markdown$InlineParser$StrikethroughType = {$: 'StrikethroughType'};
9922var dillonkearns$elm_markdown$Markdown$InlineParser$AutolinkType = function (a) {
9923	return {$: 'AutolinkType', a: a};
9924};
9925var dillonkearns$elm_markdown$Markdown$InlineParser$decodeUrlRegex = A2(
9926	elm$core$Maybe$withDefault,
9927	elm$regex$Regex$never,
9928	elm$regex$Regex$fromString('%(?:3B|2C|2F|3F|3A|40|26|3D|2B|24|23|25)'));
9929var elm$core$Basics$composeR = F3(
9930	function (f, g, x) {
9931		return g(
9932			f(x));
9933	});
9934var elm$url$Url$percentDecode = _Url_percentDecode;
9935var elm$url$Url$percentEncode = _Url_percentEncode;
9936var dillonkearns$elm_markdown$Markdown$InlineParser$encodeUrl = A2(
9937	elm$core$Basics$composeR,
9938	elm$url$Url$percentEncode,
9939	A2(
9940		elm$regex$Regex$replace,
9941		dillonkearns$elm_markdown$Markdown$InlineParser$decodeUrlRegex,
9942		function (match) {
9943			return A2(
9944				elm$core$Maybe$withDefault,
9945				match.match,
9946				elm$url$Url$percentDecode(match.match));
9947		}));
9948var dillonkearns$elm_markdown$Markdown$InlineParser$urlRegex = A2(
9949	elm$core$Maybe$withDefault,
9950	elm$regex$Regex$never,
9951	elm$regex$Regex$fromString('^([A-Za-z][A-Za-z0-9.+\\-]{1,31}:[^<>\\x00-\\x20]*)$'));
9952var elm$regex$Regex$contains = _Regex_contains;
9953var dillonkearns$elm_markdown$Markdown$InlineParser$autolinkToMatch = function (_n0) {
9954	var match = _n0.a;
9955	return A2(elm$regex$Regex$contains, dillonkearns$elm_markdown$Markdown$InlineParser$urlRegex, match.text) ? elm$core$Result$Ok(
9956		dillonkearns$elm_markdown$Markdown$InlineParser$Match(
9957			_Utils_update(
9958				match,
9959				{
9960					type_: dillonkearns$elm_markdown$Markdown$InlineParser$AutolinkType(
9961						_Utils_Tuple2(
9962							match.text,
9963							dillonkearns$elm_markdown$Markdown$InlineParser$encodeUrl(match.text)))
9964				}))) : elm$core$Result$Err(
9965		dillonkearns$elm_markdown$Markdown$InlineParser$Match(match));
9966};
9967var dillonkearns$elm_markdown$Markdown$Helpers$insideSquareBracketRegex = '[^\\[\\]\\\\]*(?:\\\\.[^\\[\\]\\\\]*)*';
9968var dillonkearns$elm_markdown$Markdown$InlineParser$refLabelRegex = A2(
9969	elm$core$Maybe$withDefault,
9970	elm$regex$Regex$never,
9971	elm$regex$Regex$fromString('^\\[\\s*(' + (dillonkearns$elm_markdown$Markdown$Helpers$insideSquareBracketRegex + ')\\s*\\]')));
9972var dillonkearns$elm_markdown$Markdown$Helpers$prepareRefLabel = A2(elm$core$Basics$composeR, dillonkearns$elm_markdown$Markdown$Helpers$cleanWhitespaces, elm$core$String$toLower);
9973var dillonkearns$elm_markdown$Markdown$InlineParser$prepareUrlAndTitle = F2(
9974	function (rawUrl, maybeTitle) {
9975		return _Utils_Tuple2(
9976			dillonkearns$elm_markdown$Markdown$InlineParser$encodeUrl(
9977				dillonkearns$elm_markdown$Markdown$Helpers$formatStr(rawUrl)),
9978			A2(elm$core$Maybe$map, dillonkearns$elm_markdown$Markdown$Helpers$formatStr, maybeTitle));
9979	});
9980var elm$core$List$head = function (list) {
9981	if (list.b) {
9982		var x = list.a;
9983		var xs = list.b;
9984		return elm$core$Maybe$Just(x);
9985	} else {
9986		return elm$core$Maybe$Nothing;
9987	}
9988};
9989var dillonkearns$elm_markdown$Markdown$InlineParser$refRegexToMatch = F3(
9990	function (matchModel, references, maybeRegexMatch) {
9991		var refLabel = function (str) {
9992			return elm$core$String$isEmpty(str) ? matchModel.text : str;
9993		}(
9994			A2(
9995				elm$core$Maybe$withDefault,
9996				matchModel.text,
9997				A2(
9998					elm$core$Maybe$withDefault,
9999					elm$core$Maybe$Nothing,
10000					A2(
10001						elm$core$Maybe$andThen,
10002						A2(
10003							elm$core$Basics$composeR,
10004							function ($) {
10005								return $.submatches;
10006							},
10007							elm$core$List$head),
10008						maybeRegexMatch))));
10009		var _n0 = A2(
10010			elm$core$Dict$get,
10011			dillonkearns$elm_markdown$Markdown$Helpers$prepareRefLabel(refLabel),
10012			references);
10013		if (_n0.$ === 'Nothing') {
10014			return elm$core$Maybe$Nothing;
10015		} else {
10016			var _n1 = _n0.a;
10017			var rawUrl = _n1.a;
10018			var maybeTitle = _n1.b;
10019			var type_ = function () {
10020				var _n3 = matchModel.type_;
10021				if (_n3.$ === 'ImageType') {
10022					return dillonkearns$elm_markdown$Markdown$InlineParser$ImageType(
10023						A2(dillonkearns$elm_markdown$Markdown$InlineParser$prepareUrlAndTitle, rawUrl, maybeTitle));
10024				} else {
10025					return dillonkearns$elm_markdown$Markdown$InlineParser$LinkType(
10026						A2(dillonkearns$elm_markdown$Markdown$InlineParser$prepareUrlAndTitle, rawUrl, maybeTitle));
10027				}
10028			}();
10029			var regexMatchLength = function () {
10030				if (maybeRegexMatch.$ === 'Just') {
10031					var match = maybeRegexMatch.a.match;
10032					return elm$core$String$length(match);
10033				} else {
10034					return 0;
10035				}
10036			}();
10037			return elm$core$Maybe$Just(
10038				dillonkearns$elm_markdown$Markdown$InlineParser$Match(
10039					_Utils_update(
10040						matchModel,
10041						{end: matchModel.end + regexMatchLength, type_: type_})));
10042		}
10043	});
10044var elm$regex$Regex$findAtMost = _Regex_findAtMost;
10045var dillonkearns$elm_markdown$Markdown$InlineParser$checkForInlineReferences = F3(
10046	function (remainText, _n0, references) {
10047		var tempMatch = _n0.a;
10048		var matches = A3(elm$regex$Regex$findAtMost, 1, dillonkearns$elm_markdown$Markdown$InlineParser$refLabelRegex, remainText);
10049		return A3(
10050			dillonkearns$elm_markdown$Markdown$InlineParser$refRegexToMatch,
10051			tempMatch,
10052			references,
10053			elm$core$List$head(matches));
10054	});
10055var dillonkearns$elm_markdown$Markdown$Helpers$whiteSpaceChars = ' \\t\\f\\v\\r\\n';
10056var dillonkearns$elm_markdown$Markdown$Helpers$titleRegex = '(?:[' + (dillonkearns$elm_markdown$Markdown$Helpers$whiteSpaceChars + (']+' + ('(?:\'([^\'\\\\]*(?:\\\\.[^\'\\\\]*)*)\'|' + ('\"([^\"\\\\]*(?:\\\\.[^\"\\\\]*)*)\"|' + '\\(([^\\)\\\\]*(?:\\\\.[^\\)\\\\]*)*)\\)))?'))));
10057var dillonkearns$elm_markdown$Markdown$Helpers$lineEndChars = '\\f\\v\\r\\n';
10058var dillonkearns$elm_markdown$Markdown$InlineParser$hrefRegex = '(?:<([^<>' + (dillonkearns$elm_markdown$Markdown$Helpers$lineEndChars + (']*)>|([^' + (dillonkearns$elm_markdown$Markdown$Helpers$whiteSpaceChars + ('\\(\\)\\\\]*(?:\\\\.[^' + (dillonkearns$elm_markdown$Markdown$Helpers$whiteSpaceChars + '\\(\\)\\\\]*)*))')))));
10059var dillonkearns$elm_markdown$Markdown$InlineParser$inlineLinkTypeOrImageTypeRegex = A2(
10060	elm$core$Maybe$withDefault,
10061	elm$regex$Regex$never,
10062	elm$regex$Regex$fromString('^\\(\\s*' + (dillonkearns$elm_markdown$Markdown$InlineParser$hrefRegex + (dillonkearns$elm_markdown$Markdown$Helpers$titleRegex + '\\s*\\)'))));
10063var dillonkearns$elm_markdown$Markdown$Helpers$returnFirstJust = function (maybes) {
10064	var process = F2(
10065		function (a, maybeFound) {
10066			if (maybeFound.$ === 'Just') {
10067				var found = maybeFound.a;
10068				return elm$core$Maybe$Just(found);
10069			} else {
10070				return a;
10071			}
10072		});
10073	return A3(elm$core$List$foldl, process, elm$core$Maybe$Nothing, maybes);
10074};
10075var dillonkearns$elm_markdown$Markdown$InlineParser$inlineLinkTypeOrImageTypeRegexToMatch = F2(
10076	function (matchModel, regexMatch) {
10077		var _n0 = regexMatch.submatches;
10078		if ((((_n0.b && _n0.b.b) && _n0.b.b.b) && _n0.b.b.b.b) && _n0.b.b.b.b.b) {
10079			var maybeRawUrlAngleBrackets = _n0.a;
10080			var _n1 = _n0.b;
10081			var maybeRawUrlWithoutBrackets = _n1.a;
10082			var _n2 = _n1.b;
10083			var maybeTitleSingleQuotes = _n2.a;
10084			var _n3 = _n2.b;
10085			var maybeTitleDoubleQuotes = _n3.a;
10086			var _n4 = _n3.b;
10087			var maybeTitleParenthesis = _n4.a;
10088			var maybeTitle = dillonkearns$elm_markdown$Markdown$Helpers$returnFirstJust(
10089				_List_fromArray(
10090					[maybeTitleSingleQuotes, maybeTitleDoubleQuotes, maybeTitleParenthesis]));
10091			var toMatch = function (rawUrl) {
10092				return dillonkearns$elm_markdown$Markdown$InlineParser$Match(
10093					_Utils_update(
10094						matchModel,
10095						{
10096							end: matchModel.end + elm$core$String$length(regexMatch.match),
10097							type_: function () {
10098								var _n5 = matchModel.type_;
10099								if (_n5.$ === 'ImageType') {
10100									return dillonkearns$elm_markdown$Markdown$InlineParser$ImageType;
10101								} else {
10102									return dillonkearns$elm_markdown$Markdown$InlineParser$LinkType;
10103								}
10104							}()(
10105								A2(dillonkearns$elm_markdown$Markdown$InlineParser$prepareUrlAndTitle, rawUrl, maybeTitle))
10106						}));
10107			};
10108			var maybeRawUrl = dillonkearns$elm_markdown$Markdown$Helpers$returnFirstJust(
10109				_List_fromArray(
10110					[maybeRawUrlAngleBrackets, maybeRawUrlWithoutBrackets]));
10111			return elm$core$Maybe$Just(
10112				toMatch(
10113					A2(elm$core$Maybe$withDefault, '', maybeRawUrl)));
10114		} else {
10115			return elm$core$Maybe$Nothing;
10116		}
10117	});
10118var dillonkearns$elm_markdown$Markdown$InlineParser$checkForInlineLinkTypeOrImageType = F3(
10119	function (remainText, _n0, refs) {
10120		var tempMatch = _n0.a;
10121		var _n1 = A3(elm$regex$Regex$findAtMost, 1, dillonkearns$elm_markdown$Markdown$InlineParser$inlineLinkTypeOrImageTypeRegex, remainText);
10122		if (_n1.b) {
10123			var first = _n1.a;
10124			var _n2 = A2(dillonkearns$elm_markdown$Markdown$InlineParser$inlineLinkTypeOrImageTypeRegexToMatch, tempMatch, first);
10125			if (_n2.$ === 'Just') {
10126				var match = _n2.a;
10127				return elm$core$Maybe$Just(match);
10128			} else {
10129				return A3(
10130					dillonkearns$elm_markdown$Markdown$InlineParser$checkForInlineReferences,
10131					remainText,
10132					dillonkearns$elm_markdown$Markdown$InlineParser$Match(tempMatch),
10133					refs);
10134			}
10135		} else {
10136			return A3(
10137				dillonkearns$elm_markdown$Markdown$InlineParser$checkForInlineReferences,
10138				remainText,
10139				dillonkearns$elm_markdown$Markdown$InlineParser$Match(tempMatch),
10140				refs);
10141		}
10142	});
10143var elm$core$List$filter = F2(
10144	function (isGood, list) {
10145		return A3(
10146			elm$core$List$foldr,
10147			F2(
10148				function (x, xs) {
10149					return isGood(x) ? A2(elm$core$List$cons, x, xs) : xs;
10150				}),
10151			_List_Nil,
10152			list);
10153	});
10154var elm$core$List$isEmpty = function (xs) {
10155	if (!xs.b) {
10156		return true;
10157	} else {
10158		return false;

10159	}
10160};
10161var dillonkearns$elm_markdown$Markdown$InlineParser$checkParsedAheadOverlapping = F2(
10162	function (_n0, remainMatches) {
10163		var match = _n0.a;
10164		var overlappingMatches = elm$core$List$filter(
10165			function (_n1) {
10166				var testMatch = _n1.a;
10167				return (_Utils_cmp(match.end, testMatch.start) > 0) && (_Utils_cmp(match.end, testMatch.end) < 0);
10168			});
10169		return (elm$core$List$isEmpty(remainMatches) || elm$core$List$isEmpty(
10170			overlappingMatches(remainMatches))) ? elm$core$Maybe$Just(
10171			A2(
10172				elm$core$List$cons,
10173				dillonkearns$elm_markdown$Markdown$InlineParser$Match(match),
10174				remainMatches)) : elm$core$Maybe$Nothing;
10175	});
10176var dillonkearns$elm_markdown$Markdown$InlineParser$emailRegex = A2(
10177	elm$core$Maybe$withDefault,
10178	elm$regex$Regex$never,
10179	elm$regex$Regex$fromString('^([a-zA-Z0-9.!#$%&\'*+\\/=?^_`{|}~\\-]+@[a-zA-Z0-9](?:[a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9])?)*)$'));
10180var dillonkearns$elm_markdown$Markdown$InlineParser$emailAutolinkTypeToMatch = function (_n0) {
10181	var match = _n0.a;
10182	return A2(elm$regex$Regex$contains, dillonkearns$elm_markdown$Markdown$InlineParser$emailRegex, match.text) ? elm$core$Result$Ok(
10183		dillonkearns$elm_markdown$Markdown$InlineParser$Match(
10184			_Utils_update(
10185				match,
10186				{
10187					type_: dillonkearns$elm_markdown$Markdown$InlineParser$AutolinkType(
10188						_Utils_Tuple2(
10189							match.text,
10190							'mailto:' + dillonkearns$elm_markdown$Markdown$InlineParser$encodeUrl(match.text)))
10191				}))) : elm$core$Result$Err(
10192		dillonkearns$elm_markdown$Markdown$InlineParser$Match(match));
10193};
10194var dillonkearns$elm_markdown$Markdown$InlineParser$findTokenHelp = F3(
10195	function (innerTokens, isToken, tokens) {
10196		findTokenHelp:
10197		while (true) {
10198			if (!tokens.b) {
10199				return elm$core$Maybe$Nothing;
10200			} else {
10201				var nextToken = tokens.a;
10202				var remainingTokens = tokens.b;
10203				if (isToken(nextToken)) {
10204					return elm$core$Maybe$Just(
10205						_Utils_Tuple3(
10206							nextToken,
10207							elm$core$List$reverse(innerTokens),
10208							remainingTokens));
10209				} else {
10210					var $temp$innerTokens = A2(elm$core$List$cons, nextToken, innerTokens),
10211						$temp$isToken = isToken,
10212						$temp$tokens = remainingTokens;
10213					innerTokens = $temp$innerTokens;
10214					isToken = $temp$isToken;
10215					tokens = $temp$tokens;
10216					continue findTokenHelp;
10217				}
10218			}
10219		}
10220	});
10221var dillonkearns$elm_markdown$Markdown$InlineParser$findToken = F2(
10222	function (isToken, tokens) {
10223		return A3(dillonkearns$elm_markdown$Markdown$InlineParser$findTokenHelp, _List_Nil, isToken, tokens);
10224	});
10225var dillonkearns$elm_markdown$Markdown$InlineParser$HtmlToken = F2(
10226	function (a, b) {
10227		return {$: 'HtmlToken', a: a, b: b};
10228	});
10229var dillonkearns$elm_markdown$Markdown$InlineParser$NotOpening = {$: 'NotOpening'};
10230var elm$parser$Parser$Advanced$bagToList = F2(
10231	function (bag, list) {
10232		bagToList:
10233		while (true) {
10234			switch (bag.$) {
10235				case 'Empty':
10236					return list;
10237				case 'AddRight':
10238					var bag1 = bag.a;
10239					var x = bag.b;
10240					var $temp$bag = bag1,
10241						$temp$list = A2(elm$core$List$cons, x, list);
10242					bag = $temp$bag;
10243					list = $temp$list;
10244					continue bagToList;
10245				default:
10246					var bag1 = bag.a;
10247					var bag2 = bag.b;
10248					var $temp$bag = bag1,
10249						$temp$list = A2(elm$parser$Parser$Advanced$bagToList, bag2, list);
10250					bag = $temp$bag;
10251					list = $temp$list;
10252					continue bagToList;
10253			}
10254		}
10255	});
10256var elm$parser$Parser$Advanced$run = F2(
10257	function (_n0, src) {
10258		var parse = _n0.a;
10259		var _n1 = parse(
10260			{col: 1, context: _List_Nil, indent: 1, offset: 0, row: 1, src: src});
10261		if (_n1.$ === 'Good') {
10262			var value = _n1.b;
10263			return elm$core$Result$Ok(value);
10264		} else {
10265			var bag = _n1.b;
10266			return elm$core$Result$Err(
10267				A2(elm$parser$Parser$Advanced$bagToList, bag, _List_Nil));
10268		}
10269	});
10270var dillonkearns$elm_markdown$Markdown$InlineParser$htmlToToken = F2(
10271	function (rawText, _n0) {
10272		var match = _n0.a;
10273		var consumedCharacters = A2(
10274			elm$parser$Parser$Advanced$keeper,
10275			A2(
10276				elm$parser$Parser$Advanced$keeper,
10277				A2(
10278					elm$parser$Parser$Advanced$keeper,
10279					elm$parser$Parser$Advanced$succeed(
10280						F3(
10281							function (startOffset, htmlTag, endOffset) {
10282								return {htmlTag: htmlTag, length: endOffset - startOffset};
10283							})),
10284					elm$parser$Parser$Advanced$getOffset),
10285				dillonkearns$elm_markdown$HtmlParser$html),
10286			elm$parser$Parser$Advanced$getOffset);
10287		var parsed = A2(
10288			elm$parser$Parser$Advanced$run,
10289			consumedCharacters,
10290			A2(elm$core$String$dropLeft, match.start, rawText));
10291		if (parsed.$ === 'Ok') {
10292			var htmlTag = parsed.a.htmlTag;
10293			var length = parsed.a.length;
10294			var htmlToken = A2(dillonkearns$elm_markdown$Markdown$InlineParser$HtmlToken, dillonkearns$elm_markdown$Markdown$InlineParser$NotOpening, htmlTag);
10295			return elm$core$Maybe$Just(
10296				{index: match.start, length: length, meaning: htmlToken});
10297		} else {
10298			return elm$core$Maybe$Nothing;
10299		}
10300	});
10301var dillonkearns$elm_markdown$Markdown$InlineParser$isCloseToken = F2(
10302	function (htmlModel, token) {
10303		return false;

10304	});
10305var dillonkearns$elm_markdown$Markdown$InlineParser$isCodeTokenPair = F2(
10306	function (closeToken, openToken) {
10307		var _n0 = openToken.meaning;
10308		if (_n0.$ === 'CodeToken') {
10309			if (_n0.a.$ === 'Escaped') {
10310				var _n1 = _n0.a;
10311				return _Utils_eq(openToken.length - 1, closeToken.length);
10312			} else {
10313				var _n2 = _n0.a;
10314				return _Utils_eq(openToken.length, closeToken.length);
10315			}
10316		} else {
10317			return false;
10318		}
10319	});
10320var dillonkearns$elm_markdown$Markdown$InlineParser$isLinkTypeOrImageOpenToken = function (token) {
10321	var _n0 = token.meaning;
10322	switch (_n0.$) {
10323		case 'LinkOpenToken':
10324			return true;
10325		case 'ImageOpenToken':
10326			return true;
10327		default:
10328			return false;
10329	}
10330};
10331var dillonkearns$elm_markdown$Markdown$InlineParser$isOpenEmphasisToken = F2(
10332	function (closeToken, openToken) {
10333		var _n0 = openToken.meaning;
10334		if (_n0.$ === 'EmphasisToken') {
10335			var openChar = _n0.a;
10336			var open = _n0.b;
10337			var _n1 = closeToken.meaning;
10338			if (_n1.$ === 'EmphasisToken') {
10339				var closeChar = _n1.a;
10340				var close = _n1.b;
10341				return _Utils_eq(openChar, closeChar) ? ((_Utils_eq(open.leftFringeRank, open.rightFringeRank) || _Utils_eq(close.leftFringeRank, close.rightFringeRank)) ? (A2(elm$core$Basics$modBy, 3, closeToken.length + openToken.length) || ((!A2(elm$core$Basics$modBy, 3, closeToken.length)) && (!A2(elm$core$Basics$modBy, 3, openToken.length)))) : true) : false;
10342			} else {
10343				return false;
10344			}
10345		} else {
10346			return false;
10347		}
10348	});
10349var dillonkearns$elm_markdown$Markdown$InlineParser$isStrikethroughTokenPair = F2(
10350	function (closeToken, openToken) {
10351		var _n0 = function () {
10352			var _n1 = openToken.meaning;
10353			if (_n1.$ === 'StrikethroughToken') {
10354				if (_n1.a.$ === 'Escaped') {
10355					var _n2 = _n1.a;
10356					return _Utils_Tuple2(true, openToken.length - 1);
10357				} else {
10358					var _n3 = _n1.a;
10359					return _Utils_Tuple2(true, openToken.length);
10360				}
10361			} else {
10362				return _Utils_Tuple2(false, 0);
10363			}
10364		}();
10365		var openTokenIsStrikethrough = _n0.a;
10366		var openTokenLength = _n0.b;
10367		var _n4 = function () {
10368			var _n5 = closeToken.meaning;
10369			if (_n5.$ === 'StrikethroughToken') {
10370				if (_n5.a.$ === 'Escaped') {
10371					var _n6 = _n5.a;
10372					return _Utils_Tuple2(true, closeToken.length - 1);
10373				} else {
10374					var _n7 = _n5.a;
10375					return _Utils_Tuple2(true, closeToken.length);
10376				}
10377			} else {
10378				return _Utils_Tuple2(false, 0);
10379			}
10380		}();
10381		var closeTokenIsStrikethrough = _n4.a;
10382		var closeTokenLength = _n4.b;
10383		return closeTokenIsStrikethrough && (openTokenIsStrikethrough && _Utils_eq(closeTokenLength, openTokenLength));
10384	});
10385var dillonkearns$elm_markdown$Markdown$InlineParser$HardLineBreakType = {$: 'HardLineBreakType'};
10386var dillonkearns$elm_markdown$Markdown$InlineParser$tokenToMatch = F2(
10387	function (token, type_) {
10388		return dillonkearns$elm_markdown$Markdown$InlineParser$Match(
10389			{end: token.index + token.length, matches: _List_Nil, start: token.index, text: '', textEnd: 0, textStart: 0, type_: type_});
10390	});
10391var dillonkearns$elm_markdown$Markdown$InlineParser$lineBreakTTM = F5(
10392	function (remaining, tokens, matches, refs, rawText) {
10393		lineBreakTTM:
10394		while (true) {
10395			if (!remaining.b) {
10396				return matches;
10397			} else {
10398				var token = remaining.a;
10399				var tokensTail = remaining.b;
10400				var _n1 = token.meaning;
10401				if (_n1.$ === 'HardLineBreakToken') {
10402					var $temp$remaining = tokensTail,
10403						$temp$tokens = tokens,
10404						$temp$matches = A2(
10405						elm$core$List$cons,
10406						A2(dillonkearns$elm_markdown$Markdown$InlineParser$tokenToMatch, token, dillonkearns$elm_markdown$Markdown$InlineParser$HardLineBreakType),
10407						matches),
10408						$temp$refs = refs,
10409						$temp$rawText = rawText;
10410					remaining = $temp$remaining;
10411					tokens = $temp$tokens;
10412					matches = $temp$matches;
10413					refs = $temp$refs;
10414					rawText = $temp$rawText;
10415					continue lineBreakTTM;
10416				} else {
10417					var $temp$remaining = tokensTail,
10418						$temp$tokens = A2(elm$core$List$cons, token, tokens),
10419						$temp$matches = matches,
10420						$temp$refs = refs,
10421						$temp$rawText = rawText;
10422					remaining = $temp$remaining;
10423					tokens = $temp$tokens;
10424					matches = $temp$matches;
10425					refs = $temp$refs;
10426					rawText = $temp$rawText;
10427					continue lineBreakTTM;
10428				}
10429			}
10430		}
10431	});
10432var dillonkearns$elm_markdown$Markdown$InlineParser$removeParsedAheadTokens = F2(
10433	function (_n0, tokensTail) {
10434		var match = _n0.a;
10435		return A2(
10436			elm$core$List$filter,
10437			function (token) {
10438				return _Utils_cmp(token.index, match.end) > -1;
10439			},
10440			tokensTail);
10441	});
10442var dillonkearns$elm_markdown$Markdown$InlineParser$angleBracketsToMatch = F6(
10443	function (closeToken, escaped, matches, references, rawText, _n46) {
10444		var openToken = _n46.a;
10445		var remainTokens = _n46.c;
10446		var result = A2(
10447			dillonkearns$elm_markdown$Markdown$Helpers$ifError,
10448			dillonkearns$elm_markdown$Markdown$InlineParser$emailAutolinkTypeToMatch,
10449			dillonkearns$elm_markdown$Markdown$InlineParser$autolinkToMatch(
10450				A7(
10451					dillonkearns$elm_markdown$Markdown$InlineParser$tokenPairToMatch,
10452					references,
10453					rawText,
10454					function (s) {
10455						return s;
10456					},
10457					dillonkearns$elm_markdown$Markdown$InlineParser$CodeType,
10458					openToken,
10459					closeToken,
10460					_List_Nil)));
10461		if (result.$ === 'Err') {
10462			var tempMatch = result.a;
10463			if (escaped.$ === 'NotEscaped') {
10464				var _n49 = A2(dillonkearns$elm_markdown$Markdown$InlineParser$htmlToToken, rawText, tempMatch);
10465				if (_n49.$ === 'Just') {
10466					var newToken = _n49.a;
10467					return elm$core$Maybe$Just(
10468						_Utils_Tuple2(
10469							A2(elm$core$List$cons, newToken, remainTokens),
10470							matches));
10471				} else {
10472					return elm$core$Maybe$Nothing;
10473				}
10474			} else {
10475				return elm$core$Maybe$Nothing;
10476			}
10477		} else {
10478			var newMatch = result.a;
10479			return elm$core$Maybe$Just(
10480				_Utils_Tuple2(
10481					remainTokens,
10482					A2(elm$core$List$cons, newMatch, matches)));
10483		}
10484	});
10485var dillonkearns$elm_markdown$Markdown$InlineParser$codeAutolinkTypeHtmlTagTTM = F5(
10486	function (remaining, tokens, matches, references, rawText) {
10487		codeAutolinkTypeHtmlTagTTM:
10488		while (true) {
10489			if (!remaining.b) {
10490				return A5(
10491					dillonkearns$elm_markdown$Markdown$InlineParser$htmlElementTTM,
10492					elm$core$List$reverse(tokens),
10493					_List_Nil,
10494					matches,
10495					references,
10496					rawText);
10497			} else {
10498				var token = remaining.a;
10499				var tokensTail = remaining.b;
10500				var _n38 = token.meaning;
10501				switch (_n38.$) {
10502					case 'CodeToken':
10503						var isEscaped = _n38.a;
10504						var _n39 = A2(
10505							dillonkearns$elm_markdown$Markdown$InlineParser$findToken,
10506							dillonkearns$elm_markdown$Markdown$InlineParser$isCodeTokenPair(token),
10507							tokens);
10508						if (_n39.$ === 'Just') {
10509							var code = _n39.a;
10510							var _n40 = A5(dillonkearns$elm_markdown$Markdown$InlineParser$codeToMatch, token, matches, references, rawText, code);
10511							var newTokens = _n40.a;
10512							var newMatches = _n40.b;
10513							var $temp$remaining = tokensTail,
10514								$temp$tokens = newTokens,
10515								$temp$matches = newMatches,
10516								$temp$references = references,
10517								$temp$rawText = rawText;
10518							remaining = $temp$remaining;
10519							tokens = $temp$tokens;
10520							matches = $temp$matches;
10521							references = $temp$references;
10522							rawText = $temp$rawText;
10523							continue codeAutolinkTypeHtmlTagTTM;
10524						} else {
10525							var $temp$remaining = tokensTail,
10526								$temp$tokens = A2(elm$core$List$cons, token, tokens),
10527								$temp$matches = matches,
10528								$temp$references = references,
10529								$temp$rawText = rawText;
10530							remaining = $temp$remaining;
10531							tokens = $temp$tokens;
10532							matches = $temp$matches;
10533							references = $temp$references;
10534							rawText = $temp$rawText;
10535							continue codeAutolinkTypeHtmlTagTTM;
10536						}
10537					case 'AngleBracketClose':
10538						var isEscaped = _n38.a;
10539						var isAngleBracketOpen = function (_n45) {
10540							var meaning = _n45.meaning;
10541							if (meaning.$ === 'AngleBracketOpen') {
10542								return true;
10543							} else {
10544								return false;

10545							}
10546						};
10547						var _n41 = A2(dillonkearns$elm_markdown$Markdown$InlineParser$findToken, isAngleBracketOpen, tokens);
10548						if (_n41.$ === 'Just') {
10549							var found = _n41.a;
10550							var _n42 = A6(dillonkearns$elm_markdown$Markdown$InlineParser$angleBracketsToMatch, token, isEscaped, matches, references, rawText, found);
10551							if (_n42.$ === 'Just') {
10552								var _n43 = _n42.a;
10553								var newTokens = _n43.a;
10554								var newMatches = _n43.b;
10555								var $temp$remaining = tokensTail,
10556									$temp$tokens = A2(
10557									elm$core$List$filter,
10558									A2(elm$core$Basics$composeL, elm$core$Basics$not, isAngleBracketOpen),
10559									newTokens),
10560									$temp$matches = newMatches,
10561									$temp$references = references,
10562									$temp$rawText = rawText;
10563								remaining = $temp$remaining;
10564								tokens = $temp$tokens;
10565								matches = $temp$matches;
10566								references = $temp$references;
10567								rawText = $temp$rawText;
10568								continue codeAutolinkTypeHtmlTagTTM;
10569							} else {
10570								var $temp$remaining = tokensTail,
10571									$temp$tokens = A2(
10572									elm$core$List$filter,
10573									A2(elm$core$Basics$composeL, elm$core$Basics$not, isAngleBracketOpen),
10574									tokens),
10575									$temp$matches = matches,
10576									$temp$references = references,
10577									$temp$rawText = rawText;
10578								remaining = $temp$remaining;
10579								tokens = $temp$tokens;
10580								matches = $temp$matches;
10581								references = $temp$references;
10582								rawText = $temp$rawText;
10583								continue codeAutolinkTypeHtmlTagTTM;
10584							}
10585						} else {
10586							var $temp$remaining = tokensTail,
10587								$temp$tokens = A2(
10588								elm$core$List$filter,
10589								A2(elm$core$Basics$composeL, elm$core$Basics$not, isAngleBracketOpen),
10590								tokens),
10591								$temp$matches = matches,
10592								$temp$references = references,
10593								$temp$rawText = rawText;
10594							remaining = $temp$remaining;
10595							tokens = $temp$tokens;
10596							matches = $temp$matches;
10597							references = $temp$references;
10598							rawText = $temp$rawText;
10599							continue codeAutolinkTypeHtmlTagTTM;
10600						}
10601					default:
10602						var $temp$remaining = tokensTail,
10603							$temp$tokens = A2(elm$core$List$cons, token, tokens),
10604							$temp$matches = matches,
10605							$temp$references = references,
10606							$temp$rawText = rawText;
10607						remaining = $temp$remaining;
10608						tokens = $temp$tokens;
10609						matches = $temp$matches;
10610						references = $temp$references;
10611						rawText = $temp$rawText;
10612						continue codeAutolinkTypeHtmlTagTTM;
10613				}
10614			}
10615		}
10616	});
10617var dillonkearns$elm_markdown$Markdown$InlineParser$codeToMatch = F5(
10618	function (closeToken, matches, references, rawText, _n34) {
10619		var openToken = _n34.a;
10620		var remainTokens = _n34.c;
10621		var updatedOpenToken = function () {
10622			var _n35 = openToken.meaning;
10623			if ((_n35.$ === 'CodeToken') && (_n35.a.$ === 'Escaped')) {
10624				var _n36 = _n35.a;
10625				return _Utils_update(
10626					openToken,
10627					{index: openToken.index + 1, length: openToken.length - 1});
10628			} else {
10629				return openToken;
10630			}
10631		}();
10632		var match = A7(dillonkearns$elm_markdown$Markdown$InlineParser$tokenPairToMatch, references, rawText, dillonkearns$elm_markdown$Markdown$Helpers$cleanWhitespaces, dillonkearns$elm_markdown$Markdown$InlineParser$CodeType, updatedOpenToken, closeToken, _List_Nil);
10633		return _Utils_Tuple2(
10634			remainTokens,
10635			A2(elm$core$List$cons, match, matches));
10636	});
10637var dillonkearns$elm_markdown$Markdown$InlineParser$emphasisTTM = F5(
10638	function (remaining, tokens, matches, references, rawText) {
10639		emphasisTTM:
10640		while (true) {
10641			if (!remaining.b) {
10642				return A5(
10643					dillonkearns$elm_markdown$Markdown$InlineParser$strikethroughTTM,
10644					elm$core$List$reverse(tokens),
10645					_List_Nil,
10646					matches,
10647					references,
10648					rawText);
10649			} else {
10650				var token = remaining.a;
10651				var tokensTail = remaining.b;
10652				var _n29 = token.meaning;
10653				if (_n29.$ === 'EmphasisToken') {
10654					var _char = _n29.a;
10655					var leftFringeRank = _n29.b.leftFringeRank;
10656					var rightFringeRank = _n29.b.rightFringeRank;
10657					if (_Utils_eq(leftFringeRank, rightFringeRank)) {
10658						if (rightFringeRank && ((!_Utils_eq(
10659							_char,
10660							_Utils_chr('_'))) || (rightFringeRank === 1))) {
10661							var _n30 = A2(
10662								dillonkearns$elm_markdown$Markdown$InlineParser$findToken,
10663								dillonkearns$elm_markdown$Markdown$InlineParser$isOpenEmphasisToken(token),
10664								tokens);
10665							if (_n30.$ === 'Just') {
10666								var found = _n30.a;
10667								var _n31 = A5(dillonkearns$elm_markdown$Markdown$InlineParser$emphasisToMatch, references, rawText, token, tokensTail, found);
10668								var newRemaining = _n31.a;
10669								var match = _n31.b;
10670								var newTokens = _n31.c;
10671								var $temp$remaining = newRemaining,
10672									$temp$tokens = newTokens,
10673									$temp$matches = A2(elm$core$List$cons, match, matches),
10674									$temp$references = references,
10675									$temp$rawText = rawText;
10676								remaining = $temp$remaining;
10677								tokens = $temp$tokens;
10678								matches = $temp$matches;
10679								references = $temp$references;
10680								rawText = $temp$rawText;
10681								continue emphasisTTM;
10682							} else {
10683								var $temp$remaining = tokensTail,
10684									$temp$tokens = A2(elm$core$List$cons, token, tokens),
10685									$temp$matches = matches,
10686									$temp$references = references,
10687									$temp$rawText = rawText;
10688								remaining = $temp$remaining;
10689								tokens = $temp$tokens;
10690								matches = $temp$matches;
10691								references = $temp$references;
10692								rawText = $temp$rawText;
10693								continue emphasisTTM;
10694							}
10695						} else {
10696							var $temp$remaining = tokensTail,
10697								$temp$tokens = tokens,
10698								$temp$matches = matches,
10699								$temp$references = references,
10700								$temp$rawText = rawText;
10701							remaining = $temp$remaining;
10702							tokens = $temp$tokens;
10703							matches = $temp$matches;
10704							references = $temp$references;
10705							rawText = $temp$rawText;
10706							continue emphasisTTM;
10707						}
10708					} else {
10709						if (_Utils_cmp(leftFringeRank, rightFringeRank) < 0) {
10710							var $temp$remaining = tokensTail,
10711								$temp$tokens = A2(elm$core$List$cons, token, tokens),
10712								$temp$matches = matches,
10713								$temp$references = references,
10714								$temp$rawText = rawText;
10715							remaining = $temp$remaining;
10716							tokens = $temp$tokens;
10717							matches = $temp$matches;
10718							references = $temp$references;
10719							rawText = $temp$rawText;
10720							continue emphasisTTM;
10721						} else {
10722							var _n32 = A2(
10723								dillonkearns$elm_markdown$Markdown$InlineParser$findToken,
10724								dillonkearns$elm_markdown$Markdown$InlineParser$isOpenEmphasisToken(token),
10725								tokens);
10726							if (_n32.$ === 'Just') {
10727								var found = _n32.a;
10728								var _n33 = A5(dillonkearns$elm_markdown$Markdown$InlineParser$emphasisToMatch, references, rawText, token, tokensTail, found);
10729								var newRemaining = _n33.a;
10730								var match = _n33.b;
10731								var newTokens = _n33.c;
10732								var $temp$remaining = newRemaining,
10733									$temp$tokens = newTokens,
10734									$temp$matches = A2(elm$core$List$cons, match, matches),
10735									$temp$references = references,
10736									$temp$rawText = rawText;
10737								remaining = $temp$remaining;
10738								tokens = $temp$tokens;
10739								matches = $temp$matches;
10740								references = $temp$references;
10741								rawText = $temp$rawText;
10742								continue emphasisTTM;
10743							} else {
10744								var $temp$remaining = tokensTail,
10745									$temp$tokens = tokens,
10746									$temp$matches = matches,
10747									$temp$references = references,
10748									$temp$rawText = rawText;
10749								remaining = $temp$remaining;
10750								tokens = $temp$tokens;
10751								matches = $temp$matches;
10752								references = $temp$references;
10753								rawText = $temp$rawText;
10754								continue emphasisTTM;
10755							}
10756						}
10757					}
10758				} else {
10759					var $temp$remaining = tokensTail,
10760						$temp$tokens = A2(elm$core$List$cons, token, tokens),
10761						$temp$matches = matches,
10762						$temp$references = references,
10763						$temp$rawText = rawText;
10764					remaining = $temp$remaining;
10765					tokens = $temp$tokens;
10766					matches = $temp$matches;
10767					references = $temp$references;
10768					rawText = $temp$rawText;
10769					continue emphasisTTM;
10770				}
10771			}
10772		}
10773	});
10774var dillonkearns$elm_markdown$Markdown$InlineParser$emphasisToMatch = F5(
10775	function (references, rawText, closeToken, tokensTail, _n27) {
10776		var openToken = _n27.a;
10777		var innerTokens = _n27.b;
10778		var remainTokens = _n27.c;
10779		var remainLength = openToken.length - closeToken.length;
10780		var updt = (!remainLength) ? {closeToken: closeToken, openToken: openToken, remainTokens: remainTokens, tokensTail: tokensTail} : ((remainLength > 0) ? {
10781			closeToken: closeToken,
10782			openToken: _Utils_update(
10783				openToken,
10784				{index: openToken.index + remainLength, length: closeToken.length}),
10785			remainTokens: A2(
10786				elm$core$List$cons,
10787				_Utils_update(
10788					openToken,
10789					{length: remainLength}),
10790				remainTokens),
10791			tokensTail: tokensTail
10792		} : {
10793			closeToken: _Utils_update(
10794				closeToken,
10795				{length: openToken.length}),
10796			openToken: openToken,
10797			remainTokens: remainTokens,
10798			tokensTail: A2(
10799				elm$core$List$cons,
10800				_Utils_update(
10801					closeToken,
10802					{index: closeToken.index + openToken.length, length: -remainLength}),
10803				tokensTail)
10804		});
10805		var match = A7(
10806			dillonkearns$elm_markdown$Markdown$InlineParser$tokenPairToMatch,
10807			references,
10808			rawText,
10809			function (s) {
10810				return s;
10811			},
10812			dillonkearns$elm_markdown$Markdown$InlineParser$EmphasisType(updt.openToken.length),
10813			updt.openToken,
10814			updt.closeToken,
10815			elm$core$List$reverse(innerTokens));
10816		return _Utils_Tuple3(updt.tokensTail, match, updt.remainTokens);
10817	});
10818var dillonkearns$elm_markdown$Markdown$InlineParser$htmlElementTTM = F5(
10819	function (remaining, tokens, matches, references, rawText) {
10820		htmlElementTTM:
10821		while (true) {
10822			if (!remaining.b) {
10823				return A5(
10824					dillonkearns$elm_markdown$Markdown$InlineParser$linkImageTypeTTM,
10825					elm$core$List$reverse(tokens),
10826					_List_Nil,
10827					matches,
10828					references,
10829					rawText);
10830			} else {
10831				var token = remaining.a;
10832				var tokensTail = remaining.b;
10833				var _n23 = token.meaning;
10834				if (_n23.$ === 'HtmlToken') {
10835					var isOpen = _n23.a;
10836					var htmlModel = _n23.b;
10837					if (isOpen.$ === 'NotOpening') {
10838						var $temp$remaining = tokensTail,
10839							$temp$tokens = tokens,
10840							$temp$matches = A2(
10841							elm$core$List$cons,
10842							A2(
10843								dillonkearns$elm_markdown$Markdown$InlineParser$tokenToMatch,
10844								token,
10845								dillonkearns$elm_markdown$Markdown$InlineParser$HtmlType(htmlModel)),
10846							matches),
10847							$temp$references = references,
10848							$temp$rawText = rawText;
10849						remaining = $temp$remaining;
10850						tokens = $temp$tokens;
10851						matches = $temp$matches;
10852						references = $temp$references;
10853						rawText = $temp$rawText;
10854						continue htmlElementTTM;
10855					} else {

10856						var _n25 = A2(
10857							dillonkearns$elm_markdown$Markdown$InlineParser$findToken,
10858							dillonkearns$elm_markdown$Markdown$InlineParser$isCloseToken(htmlModel),
10859							tokensTail);
10860						if (_n25.$ === 'Nothing') {
10861							var $temp$remaining = tokensTail,
10862								$temp$tokens = tokens,
10863								$temp$matches = A2(
10864								elm$core$List$cons,
10865								A2(
10866									dillonkearns$elm_markdown$Markdown$InlineParser$tokenToMatch,
10867									token,
10868									dillonkearns$elm_markdown$Markdown$InlineParser$HtmlType(htmlModel)),
10869								matches),
10870								$temp$references = references,
10871								$temp$rawText = rawText;
10872							remaining = $temp$remaining;
10873							tokens = $temp$tokens;
10874							matches = $temp$matches;
10875							references = $temp$references;
10876							rawText = $temp$rawText;
10877							continue htmlElementTTM;
10878						} else {
10879							var _n26 = _n25.a;
10880							var closeToken = _n26.a;
10881							var innerTokens = _n26.b;
10882							var newTail = _n26.c;
10883							var newMatch = A7(
10884								dillonkearns$elm_markdown$Markdown$InlineParser$tokenPairToMatch,
10885								references,
10886								rawText,
10887								function (s) {
10888									return s;
10889								},
10890								dillonkearns$elm_markdown$Markdown$InlineParser$HtmlType(htmlModel),
10891								token,
10892								closeToken,
10893								innerTokens);
10894							var $temp$remaining = newTail,
10895								$temp$tokens = tokens,
10896								$temp$matches = A2(elm$core$List$cons, newMatch, matches),
10897								$temp$references = references,
10898								$temp$rawText = rawText;
10899							remaining = $temp$remaining;
10900							tokens = $temp$tokens;
10901							matches = $temp$matches;
10902							references = $temp$references;
10903							rawText = $temp$rawText;
10904							continue htmlElementTTM;
10905						}
10906					}
10907				} else {
10908					var $temp$remaining = tokensTail,
10909						$temp$tokens = A2(elm$core$List$cons, token, tokens),
10910						$temp$matches = matches,
10911						$temp$references = references,
10912						$temp$rawText = rawText;
10913					remaining = $temp$remaining;
10914					tokens = $temp$tokens;
10915					matches = $temp$matches;
10916					references = $temp$references;
10917					rawText = $temp$rawText;
10918					continue htmlElementTTM;
10919				}
10920			}
10921		}
10922	});
10923var dillonkearns$elm_markdown$Markdown$InlineParser$linkImageTypeTTM = F5(
10924	function (remaining, tokens, matches, references, rawText) {
10925		linkImageTypeTTM:
10926		while (true) {
10927			if (!remaining.b) {
10928				return A5(
10929					dillonkearns$elm_markdown$Markdown$InlineParser$emphasisTTM,
10930					elm$core$List$reverse(tokens),
10931					_List_Nil,
10932					matches,
10933					references,
10934					rawText);
10935			} else {
10936				var token = remaining.a;
10937				var tokensTail = remaining.b;
10938				var _n18 = token.meaning;
10939				if (_n18.$ === 'SquareBracketClose') {
10940					var _n19 = A2(dillonkearns$elm_markdown$Markdown$InlineParser$findToken, dillonkearns$elm_markdown$Markdown$InlineParser$isLinkTypeOrImageOpenToken, tokens);
10941					if (_n19.$ === 'Just') {
10942						var found = _n19.a;
10943						var _n20 = A6(dillonkearns$elm_markdown$Markdown$InlineParser$linkOrImageTypeToMatch, token, tokensTail, matches, references, rawText, found);
10944						if (_n20.$ === 'Just') {
10945							var _n21 = _n20.a;
10946							var x = _n21.a;
10947							var newMatches = _n21.b;
10948							var newTokens = _n21.c;
10949							var $temp$remaining = x,
10950								$temp$tokens = newTokens,
10951								$temp$matches = newMatches,
10952								$temp$references = references,
10953								$temp$rawText = rawText;
10954							remaining = $temp$remaining;
10955							tokens = $temp$tokens;
10956							matches = $temp$matches;
10957							references = $temp$references;
10958							rawText = $temp$rawText;
10959							continue linkImageTypeTTM;
10960						} else {
10961							var $temp$remaining = tokensTail,
10962								$temp$tokens = tokens,
10963								$temp$matches = matches,
10964								$temp$references = references,
10965								$temp$rawText = rawText;
10966							remaining = $temp$remaining;
10967							tokens = $temp$tokens;
10968							matches = $temp$matches;
10969							references = $temp$references;
10970							rawText = $temp$rawText;
10971							continue linkImageTypeTTM;
10972						}
10973					} else {
10974						var $temp$remaining = tokensTail,
10975							$temp$tokens = tokens,
10976							$temp$matches = matches,
10977							$temp$references = references,
10978							$temp$rawText = rawText;
10979						remaining = $temp$remaining;
10980						tokens = $temp$tokens;
10981						matches = $temp$matches;
10982						references = $temp$references;
10983						rawText = $temp$rawText;
10984						continue linkImageTypeTTM;
10985					}
10986				} else {
10987					var $temp$remaining = tokensTail,
10988						$temp$tokens = A2(elm$core$List$cons, token, tokens),
10989						$temp$matches = matches,
10990						$temp$references = references,
10991						$temp$rawText = rawText;
10992					remaining = $temp$remaining;
10993					tokens = $temp$tokens;
10994					matches = $temp$matches;
10995					references = $temp$references;
10996					rawText = $temp$rawText;
10997					continue linkImageTypeTTM;
10998				}
10999			}
11000		}
11001	});
11002var dillonkearns$elm_markdown$Markdown$InlineParser$linkOrImageTypeToMatch = F6(
11003	function (closeToken, tokensTail, oldMatches, references, rawText, _n8) {
11004		var openToken = _n8.a;
11005		var innerTokens = _n8.b;
11006		var remainTokens = _n8.c;
11007		var removeOpenToken = _Utils_Tuple3(
11008			tokensTail,
11009			oldMatches,
11010			_Utils_ap(innerTokens, remainTokens));
11011		var remainText = A2(elm$core$String$dropLeft, closeToken.index + 1, rawText);
11012		var inactivateLinkOpenToken = function (token) {
11013			var _n16 = token.meaning;
11014			if (_n16.$ === 'LinkOpenToken') {
11015				return _Utils_update(
11016					token,
11017					{
11018						meaning: dillonkearns$elm_markdown$Markdown$InlineParser$LinkOpenToken(dillonkearns$elm_markdown$Markdown$InlineParser$Inactive)
11019					});
11020			} else {
11021				return token;
11022			}
11023		};
11024		var findTempMatch = function (isLinkType) {
11025			return A7(
11026				dillonkearns$elm_markdown$Markdown$InlineParser$tokenPairToMatch,
11027				references,
11028				rawText,
11029				function (s) {
11030					return s;
11031				},
11032				isLinkType ? dillonkearns$elm_markdown$Markdown$InlineParser$LinkType(
11033					_Utils_Tuple2('', elm$core$Maybe$Nothing)) : dillonkearns$elm_markdown$Markdown$InlineParser$ImageType(
11034					_Utils_Tuple2('', elm$core$Maybe$Nothing)),
11035				openToken,
11036				closeToken,
11037				elm$core$List$reverse(innerTokens));
11038		};
11039		var _n9 = openToken.meaning;
11040		switch (_n9.$) {
11041			case 'ImageOpenToken':
11042				var tempMatch = findTempMatch(false);
11043				var _n10 = A3(dillonkearns$elm_markdown$Markdown$InlineParser$checkForInlineLinkTypeOrImageType, remainText, tempMatch, references);
11044				if (_n10.$ === 'Nothing') {
11045					return elm$core$Maybe$Just(removeOpenToken);
11046				} else {
11047					var match = _n10.a;
11048					var _n11 = A2(dillonkearns$elm_markdown$Markdown$InlineParser$checkParsedAheadOverlapping, match, oldMatches);
11049					if (_n11.$ === 'Just') {
11050						var matches = _n11.a;
11051						return elm$core$Maybe$Just(
11052							_Utils_Tuple3(
11053								A2(dillonkearns$elm_markdown$Markdown$InlineParser$removeParsedAheadTokens, match, tokensTail),
11054								matches,
11055								remainTokens));
11056					} else {
11057						return elm$core$Maybe$Just(removeOpenToken);
11058					}
11059				}
11060			case 'LinkOpenToken':
11061				if (_n9.a.$ === 'Active') {
11062					var _n12 = _n9.a;
11063					var tempMatch = findTempMatch(true);
11064					var _n13 = A3(dillonkearns$elm_markdown$Markdown$InlineParser$checkForInlineLinkTypeOrImageType, remainText, tempMatch, references);
11065					if (_n13.$ === 'Nothing') {
11066						return elm$core$Maybe$Just(removeOpenToken);
11067					} else {
11068						var match = _n13.a;
11069						var _n14 = A2(dillonkearns$elm_markdown$Markdown$InlineParser$checkParsedAheadOverlapping, match, oldMatches);
11070						if (_n14.$ === 'Just') {
11071							var matches = _n14.a;
11072							return elm$core$Maybe$Just(
11073								_Utils_Tuple3(
11074									A2(dillonkearns$elm_markdown$Markdown$InlineParser$removeParsedAheadTokens, match, tokensTail),
11075									matches,
11076									A2(elm$core$List$map, inactivateLinkOpenToken, remainTokens)));
11077						} else {
11078							return elm$core$Maybe$Just(removeOpenToken);
11079						}
11080					}
11081				} else {
11082					var _n15 = _n9.a;
11083					return elm$core$Maybe$Just(removeOpenToken);
11084				}
11085			default:
11086				return elm$core$Maybe$Nothing;
11087		}
11088	});
11089var dillonkearns$elm_markdown$Markdown$InlineParser$strikethroughTTM = F5(
11090	function (remaining, tokens, matches, references, rawText) {
11091		strikethroughTTM:
11092		while (true) {
11093			if (!remaining.b) {
11094				return A5(
11095					dillonkearns$elm_markdown$Markdown$InlineParser$lineBreakTTM,
11096					elm$core$List$reverse(tokens),
11097					_List_Nil,
11098					matches,
11099					references,
11100					rawText);
11101			} else {
11102				var token = remaining.a;
11103				var tokensTail = remaining.b;
11104				var _n5 = token.meaning;
11105				if (_n5.$ === 'StrikethroughToken') {
11106					var isEscaped = _n5.a;
11107					var _n6 = A2(
11108						dillonkearns$elm_markdown$Markdown$InlineParser$findToken,
11109						dillonkearns$elm_markdown$Markdown$InlineParser$isStrikethroughTokenPair(token),
11110						tokens);
11111					if (_n6.$ === 'Just') {
11112						var content = _n6.a;
11113						var _n7 = A5(dillonkearns$elm_markdown$Markdown$InlineParser$strikethroughToMatch, token, matches, references, rawText, content);
11114						var newTokens = _n7.a;
11115						var newMatches = _n7.b;
11116						var $temp$remaining = tokensTail,
11117							$temp$tokens = newTokens,
11118							$temp$matches = newMatches,
11119							$temp$references = references,
11120							$temp$rawText = rawText;
11121						remaining = $temp$remaining;
11122						tokens = $temp$tokens;
11123						matches = $temp$matches;
11124						references = $temp$references;
11125						rawText = $temp$rawText;
11126						continue strikethroughTTM;
11127					} else {
11128						var $temp$remaining = tokensTail,
11129							$temp$tokens = A2(elm$core$List$cons, token, tokens),
11130							$temp$matches = matches,
11131							$temp$references = references,
11132							$temp$rawText = rawText;
11133						remaining = $temp$remaining;
11134						tokens = $temp$tokens;
11135						matches = $temp$matches;
11136						references = $temp$references;
11137						rawText = $temp$rawText;
11138						continue strikethroughTTM;
11139					}
11140				} else {
11141					var $temp$remaining = tokensTail,
11142						$temp$tokens = A2(elm$core$List$cons, token, tokens),
11143						$temp$matches = matches,
11144						$temp$references = references,
11145						$temp$rawText = rawText;
11146					remaining = $temp$remaining;
11147					tokens = $temp$tokens;
11148					matches = $temp$matches;
11149					references = $temp$references;
11150					rawText = $temp$rawText;
11151					continue strikethroughTTM;
11152				}
11153			}
11154		}
11155	});
11156var dillonkearns$elm_markdown$Markdown$InlineParser$strikethroughToMatch = F5(
11157	function (closeToken, matches, references, rawText, _n1) {
11158		var openToken = _n1.a;
11159		var remainTokens = _n1.c;
11160		var updatedOpenToken = function () {
11161			var _n2 = openToken.meaning;
11162			if ((_n2.$ === 'StrikethroughToken') && (_n2.a.$ === 'Escaped')) {
11163				var _n3 = _n2.a;
11164				return _Utils_update(
11165					openToken,
11166					{index: openToken.index + 1, length: openToken.length - 1});
11167			} else {
11168				return openToken;
11169			}
11170		}();
11171		var match = A7(dillonkearns$elm_markdown$Markdown$InlineParser$tokenPairToMatch, references, rawText, dillonkearns$elm_markdown$Markdown$Helpers$cleanWhitespace

11171s, dillonkearns$elm_markdown$Markdown$InlineParser$StrikethroughType, updatedOpenToken, closeToken, _List_Nil);
11172		return _Utils_Tuple2(
11173			remainTokens,
11174			A2(elm$core$List$cons, match, matches));
11175	});
11176var dillonkearns$elm_markdown$Markdown$InlineParser$tokenPairToMatch = F7(
11177	function (references, rawText, processText, type_, openToken, closeToken, innerTokens) {
11178		var textStart = openToken.index + openToken.length;
11179		var textEnd = closeToken.index;
11180		var text = processText(
11181			A3(elm$core$String$slice, textStart, textEnd, rawText));
11182		var start = openToken.index;
11183		var end = closeToken.index + closeToken.length;
11184		var match = {end: end, matches: _List_Nil, start: start, text: text, textEnd: textEnd, textStart: textStart, type_: type_};
11185		var matches = A2(
11186			elm$core$List$map,
11187			function (_n0) {
11188				var matchModel = _n0.a;
11189				return A2(dillonkearns$elm_markdown$Markdown$InlineParser$prepareChildMatch, match, matchModel);
11190			},
11191			A4(dillonkearns$elm_markdown$Markdown$InlineParser$tokensToMatches, innerTokens, _List_Nil, references, rawText));
11192		return dillonkearns$elm_markdown$Markdown$InlineParser$Match(
11193			{end: end, matches: matches, start: start, text: text, textEnd: textEnd, textStart: textStart, type_: type_});
11194	});
11195var dillonkearns$elm_markdown$Markdown$InlineParser$tokensToMatches = F4(
11196	function (tokens, matches, references, rawText) {
11197		return A5(dillonkearns$elm_markdown$Markdown$InlineParser$codeAutolinkTypeHtmlTagTTM, tokens, _List_Nil, matches, references, rawText);
11198	});
11199var dillonkearns$elm_markdown$Markdown$InlineParser$parse = F2(
11200	function (refs, rawText_) {
11201		var rawText = elm$core$String$trim(rawText_);
11202		var tokens = dillonkearns$elm_markdown$Markdown$InlineParser$tokenize(rawText);
11203		return dillonkearns$elm_markdown$Markdown$InlineParser$matchesToInlines(
11204			A3(
11205				dillonkearns$elm_markdown$Markdown$InlineParser$parseTextMatches,
11206				rawText,
11207				_List_Nil,
11208				dillonkearns$elm_markdown$Markdown$InlineParser$organizeMatches(
11209					A4(dillonkearns$elm_markdown$Markdown$InlineParser$tokensToMatches, tokens, _List_Nil, refs, rawText))));
11210	});
11211var dillonkearns$elm_markdown$Parser$Extra$chompOneOrMore = function (condition) {
11212	return A2(
11213		elm$parser$Parser$Advanced$ignorer,
11214		A2(
11215			elm$parser$Parser$Advanced$chompIf,
11216			condition,
11217			elm$parser$Parser$Problem('Expected one or more character')),
11218		elm$parser$Parser$Advanced$chompWhile(condition));
11219};
11220var dillonkearns$elm_markdown$Parser$Token$greaterThan = A2(
11221	elm$parser$Parser$Advanced$Token,
11222	'>',
11223	elm$parser$Parser$Expecting('a `>`'));
11224var dillonkearns$elm_markdown$Parser$Token$lessThan = A2(
11225	elm$parser$Parser$Advanced$Token,
11226	'<',
11227	elm$parser$Parser$Expecting('a `<`'));
11228var dillonkearns$elm_markdown$Whitespace$isWhitespace = function (_char) {
11229	switch (_char.valueOf()) {
11230		case ' ':
11231			return true;
11232		case '\n':
11233			return true;
11234		case '\t':
11235			return true;
11236		case '\u000b':
11237			return true;
11238		case '\u000c':
11239			return true;
11240		case '\r':
11241			return true;
11242		default:
11243			return false;
11244	}
11245};
11246var elm$parser$Parser$Advanced$findSubString = _Parser_findSubString;
11247var elm$parser$Parser$Advanced$fromInfo = F4(
11248	function (row, col, x, context) {
11249		return A2(
11250			elm$parser$Parser$Advanced$AddRight,
11251			elm$parser$Parser$Advanced$Empty,
11252			A4(elm$parser$Parser$Advanced$DeadEnd, row, col, x, context));
11253	});
11254var elm$parser$Parser$Advanced$chompUntil = function (_n0) {
11255	var str = _n0.a;
11256	var expecting = _n0.b;
11257	return elm$parser$Parser$Advanced$Parser(
11258		function (s) {
11259			var _n1 = A5(elm$parser$Parser$Advanced$findSubString, str, s.offset, s.row, s.col, s.src);
11260			var newOffset = _n1.a;
11261			var newRow = _n1.b;
11262			var newCol = _n1.c;
11263			return _Utils_eq(newOffset, -1) ? A2(
11264				elm$parser$Parser$Advanced$Bad,
11265				false,
11266				A4(elm$parser$Parser$Advanced$fromInfo, newRow, newCol, expecting, s.context)) : A3(
11267				elm$parser$Parser$Advanced$Good,
11268				_Utils_cmp(s.offset, newOffset) < 0,
11269				_Utils_Tuple0,
11270				{col: newCol, context: s.context, indent: s.indent, offset: newOffset, row: newRow, src: s.src});
11271		});
11272};
11273var elm$parser$Parser$Advanced$Located = F3(
11274	function (row, col, context) {
11275		return {col: col, context: context, row: row};
11276	});
11277var elm$parser$Parser$Advanced$changeContext = F2(
11278	function (newContext, s) {
11279		return {col: s.col, context: newContext, indent: s.indent, offset: s.offset, row: s.row, src: s.src};
11280	});
11281var elm$parser$Parser$Advanced$inContext = F2(
11282	function (context, _n0) {
11283		var parse = _n0.a;
11284		return elm$parser$Parser$Advanced$Parser(
11285			function (s0) {
11286				var _n1 = parse(
11287					A2(
11288						elm$parser$Parser$Advanced$changeContext,
11289						A2(
11290							elm$core$List$cons,
11291							A3(elm$parser$Parser$Advanced$Located, s0.row, s0.col, context),

11292							s0.context),
11293						s0));
11294				if (_n1.$ === 'Good') {
11295					var p = _n1.a;
11296					var a = _n1.b;
11297					var s1 = _n1.c;
11298					return A3(
11299						elm$parser$Parser$Advanced$Good,
11300						p,
11301						a,
11302						A2(elm$parser$Parser$Advanced$changeContext, s0.context, s1));
11303				} else {
11304					var step = _n1;
11305					return step;
11306				}
11307			});
11308	});
11309var dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$destinationParser = A2(
11310	elm$parser$Parser$Advanced$inContext,
11311	'link destination',
11312	elm$parser$Parser$Advanced$oneOf(
11313		_List_fromArray(
11314			[
11315				A2(
11316				elm$parser$Parser$Advanced$keeper,
11317				A2(
11318					elm$parser$Parser$Advanced$ignorer,
11319					elm$parser$Parser$Advanced$succeed(elm$url$Url$percentEncode),
11320					elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$lessThan)),
11321				A2(
11322					elm$parser$Parser$Advanced$ignorer,
11323					elm$parser$Parser$Advanced$getChompedString(
11324						elm$parser$Parser$Advanced$chompUntil(dillonkearns$elm_markdown$Parser$Token$greaterThan)),
11325					elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$greaterThan))),
11326				elm$parser$Parser$Advanced$getChompedString(
11327				dillonkearns$elm_markdown$Parser$Extra$chompOneOrMore(
11328					A2(elm$core$Basics$composeL, elm$core$Basics$not, dillonkearns$elm_markdown$Whitespace$isWhitespace)))
11329			])));
11330var dillonkearns$elm_markdown$Parser$Token$closingSquareBracket = A2(
11331	elm$parser$Parser$Advanced$Token,
11332	']',
11333	elm$parser$Parser$Expecting('a `]`'));
11334var dillonkearns$elm_markdown$Parser$Token$openingSquareBracket = A2(
11335	elm$parser$Parser$Advanced$Token,
11336	'[',
11337	elm$parser$Parser$Expecting('a `[`'));
11338var dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$labelParser = A2(
11339	elm$parser$Parser$Advanced$keeper,
11340	A2(
11341		elm$parser$Parser$Advanced$ignorer,
11342		elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$Helpers$prepareRefLabel),
11343		elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$openingSquareBracket)),
11344	A2(
11345		elm$parser$Parser$Advanced$ignorer,
11346		elm$parser$Parser$Advanced$getChompedString(
11347			elm$parser$Parser$Advanced$chompUntil(dillonkearns$elm_markdown$Parser$Token$closingSquareBracket)),
11348		elm$parser$Parser$Advanced$symbol(
11349			A2(
11350				elm$parser$Parser$Advanced$Token,
11351				']:',
11352				elm$parser$Parser$Expecting(']:')))));
11353var dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$hasNoBlankLine = function (str) {
11354	return A2(elm$core$String$contains, '\n\n', str) ? elm$parser$Parser$Advanced$problem(
11355		elm$parser$Parser$Expecting('no blank line')) : elm$parser$Parser$Advanced$succeed(str);
11356};
11357var dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$onlyWhitespaceTillNewline = A2(
11358	elm$parser$Parser$Advanced$ignorer,
11359	elm$parser$Parser$Advanced$chompWhile(
11360		function (c) {
11361			return (!dillonkearns$elm_markdown$Whitespace$isLineEnd(c)) && dillonkearns$elm_markdown$Whitespace$isWhitespace(c);
11362		}),
11363	dillonkearns$elm_markdown$Helpers$lineEndOrEnd);
11364var dillonkearns$elm_markdown$Parser$Token$doubleQuote = A2(
11365	elm$parser$Parser$Advanced$Token,
11366	'\"',
11367	elm$parser$Parser$Expecting('a double quote'));
11368var dillonkearns$elm_markdown$Parser$Token$singleQuote = A2(
11369	elm$parser$Parser$Advanced$Token,
11370	'\'',
11371	elm$parser$Parser$Expecting('a single quote'));
11372var dillonkearns$elm_markdown$Whitespace$requiredWhitespace = A2(
11373	elm$parser$Parser$Advanced$ignorer,
11374	A2(
11375		elm$parser$Parser$Advanced$chompIf,
11376		dillonkearns$elm_markdown$Whitespace$isWhitespace,
11377		elm$parser$Parser$Expecting('Required whitespace')),
11378	elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$Whitespace$isWhitespace));
11379var dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$titleParser = function () {
11380	var inSingleQuotes = A2(
11381		elm$parser$Parser$Advanced$keeper,
11382		A2(
11383			elm$parser$Parser$Advanced$ignorer,
11384			elm$parser$Parser$Advanced$succeed(elm$core$Maybe$Just),
11385			elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$singleQuote)),
11386		A2(
11387			elm$parser$Parser$Advanced$ignorer,
11388			A2(
11389				elm$parser$Parser$Advanced$ignorer,
11390				A2(
11391					elm$parser$Parser$Advanced$andThen,
11392					dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$hasNoBlankLine,
11393					elm$parser$Parser$Advanced$getChompedString(
11394						elm$parser$Parser$Advanced$chompUntil(dillonkearns$elm_markdown$Parser$Token$singleQuote))),
11395				elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$singleQuote)),
11396			dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$onlyWhitespaceTillNewline));
11397	var inDoubleQuotes = A2(
11398		elm$parser$Parser$Advanced$keeper,
11399		A2(
11400			elm$parser$Parser$Advanced$ignorer,
11401			elm$parser$Parser$Advanced$succeed(elm$core$Maybe$Just),
11402			elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$doubleQuote)),
11403		A2(
11404			elm$parser$Parser$Advanced$ignorer,
11405			A2(
11406				elm$parser$Parser$Advanced$ignorer,
11407				A2(
11408					elm$parser$Parser$Advanced$andThen,
11409					dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$hasNoBlankLine,
11410					elm$parser$Parser$Advanced$getChompedString(
11411						elm$parser$Parser$Advanced$chompUntil(dillonkearns$elm_markdown$Parser$Token$doubleQuote))),
11412				elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$doubleQuote)),
11413			dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$onlyWhitespaceTillNewline));
11414	return A2(
11415		elm$parser$Parser$Advanced$inContext,
11416		'title',
11417		elm$parser$Parser$Advanced$oneOf(
11418			_List_fromArray(
11419				[
11420					elm$parser$Parser$Advanced$backtrackable(
11421					A2(
11422						elm$parser$Parser$Advanced$keeper,
11423						A2(
11424							elm$parser$Parser$Advanced$ignorer,
11425							elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
11426							dillonkearns$elm_markdown$Whitespace$requiredWhitespace),
11427						elm$parser$Parser$Advanced$oneOf(
11428							_List_fromArray(
11429								[
11430									inDoubleQuotes,
11431									inSingleQuotes,
11432									elm$parser$Parser$Advanced$succeed(elm$core$Maybe$Nothing)
11433								])))),
11434					A2(
11435					elm$parser$Parser$Advanced$ignorer,
11436					elm$parser$Parser$Advanced$succeed(elm$core$Maybe$Nothing),
11437					dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$onlyWhitespaceTillNewline)
11438				])));
11439}();
11440var dillonkearns$elm_markdown$Whitespace$isSpaceOrTab = function (_char) {
11441	switch (_char.valueOf()) {
11442		case ' ':
11443			return true;
11444		case '\t':
11445			return true;
11446		default:
11447			return false;

11448	}
11449};
11450var dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$parser = A2(
11451	elm$parser$Parser$Advanced$inContext,
11452	'link reference definition',
11453	A2(
11454		elm$parser$Parser$Advanced$keeper,
11455		A2(
11456			elm$parser$Parser$Advanced$keeper,
11457			A2(
11458				elm$parser$Parser$Advanced$keeper,
11459				A2(
11460					elm$parser$Parser$Advanced$ignorer,
11461					elm$parser$Parser$Advanced$succeed(
11462						F3(
11463							function (label, destination, title) {
11464								return _Utils_Tuple2(
11465									label,
11466									{destination: destination, title: title});
11467							})),
11468					dillonkearns$elm_markdown$Whitespace$upToThreeSpaces),
11469				A2(
11470					elm$parser$Parser$Advanced$ignorer,
11471					A2(
11472						elm$parser$Parser$Advanced$ignorer,
11473						A2(
11474							elm$parser$Parser$Advanced$ignorer,
11475							dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$labelParser,
11476							elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$Whitespace$isSpaceOrTab)),
11477						elm$parser$Parser$Advanced$oneOf(
11478							_List_fromArray(
11479								[
11480									dillonkearns$elm_markdown$Whitespace$lineEnd,
11481									elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
11482								]))),
11483					elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$Whitespace$isSpaceOrTab))),
11484			dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$destinationParser),
11485		dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$titleParser));
11486var dillonkearns$elm_markdown$Markdown$Parser$EmptyBlock = {$: 'EmptyBlock'};
11487var dillonkearns$elm_markdown$Markdown$Parser$InlineProblem = function (a) {
11488	return {$: 'InlineProblem', a: a};
11489};
11490var dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock = function (a) {
11491	return {$: 'ParsedBlock', a: a};
11492};
11493var dillonkearns$elm_markdown$Markdown$Parser$addReference = F2(
11494	function (state, linkRef) {
11495		return {
11496			linkReferenceDefinitions: A2(elm$core$List$cons, linkRef, state.linkReferenceDefinitions),
11497			rawBlocks: state.rawBlocks
11498		};
11499	});
11500var dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine = {$: 'BlankLine'};
11501var dillonkearns$elm_markdown$Markdown$Parser$blankLine = A2(
11502	elm$parser$Parser$Advanced$map,
11503	function (_n0) {
11504		return dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine;
11505	},
11506	A2(
11507		elm$parser$Parser$Advanced$ignorer,
11508		elm$parser$Parser$Advanced$backtrackable(
11509			elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$Whitespace$isSpaceOrTab)),
11510		dillonkearns$elm_markdown$Whitespace$lineEnd));
11511var dillonkearns$elm_markdown$Markdown$Parser$blockQuoteStarts = _List_fromArray(
11512	[
11513		elm$parser$Parser$Advanced$symbol(
11514		A2(
11515			elm$parser$Parser$Advanced$Token,
11516			'>',
11517			elm$parser$Parser$Expecting('>'))),
11518		A2(
11519		elm$parser$Parser$Advanced$ignorer,
11520		elm$parser$Parser$Advanced$backtrackable(
11521			elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$space)),
11522		elm$parser$Parser$Advanced$oneOf(
11523			_List_fromArray(
11524				[
11525					elm$parser$Parser$Advanced$symbol(
11526					A2(
11527						elm$parser$Parser$Advanced$Token,
11528						'>',
11529						elm$parser$Parser$Expecting(' >'))),
11530					elm$parser$Parser$Advanced$symbol(
11531					A2(
11532						elm$parser$Parser$Advanced$Token,
11533						' >',
11534						elm$parser$Parser$Expecting('  >'))),
11535					elm$parser$Parser$Advanced$symbol(
11536					A2(
11537						elm$parser$Parser$Advanced$Token,
11538						'  >',
11539						elm$parser$Parser$Expecting('   >')))
11540				])))
11541	]);
11542var dillonkearns$elm_markdown$Markdown$RawBlock$BlockQuote = function (a) {
11543	return {$: 'BlockQuote', a: a};
11544};
11545var dillonkearns$elm_markdown$Markdown$Parser$blockQuote = A2(
11546	elm$parser$Parser$Advanced$keeper,
11547	A2(
11548		elm$parser$Parser$Advanced$ignorer,
11549		A2(
11550			elm$parser$Parser$Advanced$ignorer,
11551			elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$RawBlock$BlockQuote),
11552			elm$parser$Parser$Advanced$oneOf(dillonkearns$elm_markdown$Markdown$Parser$blockQuoteStarts)),
11553		elm$parser$Parser$Advanced$oneOf(
11554			_List_fromArray(
11555				[
11556					elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$space),
11557					elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
11558				]))),
11559	A2(
11560		elm$parser$Parser$Advanced$ignorer,
11561		elm$parser$Parser$Advanced$getChompedString(dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd),
11562		dillonkearns$elm_markdown$Helpers$lineEndOrEnd));
11563var dillonkearns$elm_markdown$Markdown$Parser$problemToString = function (problem) {
11564	switch (problem.$) {
11565		case 'Expecting':
11566			var string = problem.a;
11567			return 'Expecting ' + string;
11568		case 'ExpectingInt':
11569			return 'Expecting int';
11570		case 'ExpectingHex':
11571			return 'Expecting hex';
11572		case 'ExpectingOctal':
11573			return 'Expecting octal';
11574		case 'ExpectingBinary':
11575			return 'Expecting binary';
11576		case 'ExpectingFloat':
11577			return 'Expecting float';
11578		case 'ExpectingNumber':
11579			return 'Expecting number';
11580		case 'ExpectingVariable':
11581			return 'Expecting variable';
11582		case 'ExpectingSymbol':
11583			var string = problem.a;
11584			return 'Expecting symbol ' + string;
11585		case 'ExpectingKeyword':
11586			var string = problem.a;

11587			return 'Expecting keyword ' + string;
11588		case 'ExpectingEnd':
11589			return 'Expecting keyword end';
11590		case 'UnexpectedChar':
11591			return 'Unexpected char';
11592		case 'Problem':
11593			var problemDescription = problem.a;
11594			return problemDescription;
11595		default:
11596			return 'Bad repeat';
11597	}
11598};
11599var dillonkearns$elm_markdown$Markdown$Parser$deadEndToString = function (deadEnd) {
11600	return 'Problem at row ' + (elm$core$String$fromInt(deadEnd.row) + ('\n' + dillonkearns$elm_markdown$Markdown$Parser$problemToString(deadEnd.problem)));
11601};
11602var dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString = function (deadEnds) {
11603	return A2(
11604		elm$core$String$join,
11605		'\n',
11606		A2(elm$core$List$map, dillonkearns$elm_markdown$Markdown$Parser$deadEndToString, deadEnds));
11607};
11608var dillonkearns$elm_markdown$Markdown$Parser$exactlyFourSpaces = elm$parser$Parser$Advanced$oneOf(
11609	_List_fromArray(
11610		[
11611			elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$tab),
11612			A2(
11613			elm$parser$Parser$Advanced$ignorer,
11614			elm$parser$Parser$Advanced$backtrackable(
11615				elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$space)),
11616			elm$parser$Parser$Advanced$oneOf(
11617				_List_fromArray(
11618					[
11619						elm$parser$Parser$Advanced$symbol(
11620						A2(
11621							elm$parser$Parser$Advanced$Token,
11622							'   ',
11623							elm$parser$Parser$ExpectingSymbol('Indentation'))),
11624						elm$parser$Parser$Advanced$symbol(
11625						A2(
11626							elm$parser$Parser$Advanced$Token,
11627							' \t',
11628							elm$parser$Parser$ExpectingSymbol('Indentation'))),
11629						elm$parser$Parser$Advanced$symbol(
11630						A2(
11631							elm$parser$Parser$Advanced$Token,
11632							'  \t',
11633							elm$parser$Parser$ExpectingSymbol('Indentation')))
11634					])))
11635		]));
11636var dillonkearns$elm_markdown$Markdown$RawBlock$IndentedCodeBlock = function (a) {
11637	return {$: 'IndentedCodeBlock', a: a};
11638};
11639var dillonkearns$elm_markdown$Markdown$Parser$indentedCodeBlock = A2(
11640	elm$parser$Parser$Advanced$keeper,
11641	A2(
11642		elm$parser$Parser$Advanced$ignorer,
11643		elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$RawBlock$IndentedCodeBlock),
11644		dillonkearns$elm_markdown$Markdown$Parser$exactlyFourSpaces),
11645	A2(
11646		elm$parser$Parser$Advanced$ignorer,
11647		elm$parser$Parser$Advanced$getChompedString(dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd),
11648		dillonkearns$elm_markdown$Helpers$lineEndOrEnd));
11649var dillonkearns$elm_markdown$Markdown$Block$Loose = {$: 'Loose'};
11650var dillonkearns$elm_markdown$Markdown$Block$Tight = {$: 'Tight'};
11651var dillonkearns$elm_markdown$Markdown$Parser$isTightBoolToListDisplay = function (isTight) {
11652	return isTight ? dillonkearns$elm_markdown$Markdown$Block$Tight : dillonkearns$elm_markdown$Markdown$Block$Loose;
11653};
11654var dillonkearns$elm_markdown$Markdown$Parser$joinRawStringsWith = F3(
11655	function (joinWith, string1, string2) {
11656		var _n0 = _Utils_Tuple2(string1, string2);
11657		if (_n0.a === '') {
11658			return string2;
11659		} else {
11660			if (_n0.b === '') {
11661				return string1;
11662			} else {
11663				return _Utils_ap(
11664					string1,
11665					_Utils_ap(joinWith, string2));
11666			}
11667		}
11668	});
11669var dillonkearns$elm_markdown$Markdown$Parser$joinStringsPreserveAll = F2(
11670	function (string1, string2) {
11671		return string1 + ('\n' + string2);
11672	});
11673var dillonkearns$elm_markdown$Markdown$RawBlock$OpenBlockOrParagraph = function (a) {
11674	return {$: 'OpenBlockOrParagraph', a: a};
11675};
11676var dillonkearns$elm_markdown$Markdown$Parser$innerParagraphParser = A2(
11677	elm$parser$Parser$Advanced$mapChompedString,
11678	F2(
11679		function (rawLine, _n0) {
11680			return dillonkearns$elm_markdown$Markdown$RawBlock$OpenBlockOrParagraph(
11681				dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines(rawLine));
11682		}),
11683	dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd);
11684var dillonkearns$elm_markdown$Markdown$Parser$openBlockOrParagraphParser = A2(elm$parser$Parser$Advanced$ignorer, dillonkearns$elm_markdown$Markdown$Parser$innerParagraphParser, dillonkearns$elm_markdown$Helpers$lineEndOrEnd);
11685var dillonkearns$elm_markdown$Markdown$OrderedList$ListItem = F4(
11686	function (order, intended, marker, body) {
11687		return {body: body, intended: intended, marker: marker, order: order};
11688	});
11689var dillonkearns$elm_markdown$Markdown$OrderedList$orderedListEmptyItemParser = A2(
11690	elm$parser$Parser$Advanced$keeper,
11691	elm$parser$Parser$Advanced$succeed(
11692		function (bodyStartPos) {
11693			return _Utils_Tuple2(bodyStartPos, '');
11694		}),
11695	A2(elm$parser$Parser$Advanced$ignorer, elm$parser$Parser$Advanced$getCol, dillonkearns$elm_markdown$Helpers$lineEndOrEnd));
11696var dillonkearns$elm_markdown$Markdown$OrderedList$orderedListItemBodyParser = A2(
11697	elm$parser$Parser$Advanced$keeper,
11698	A2(
11699		elm$parser$Parser$Advanced$keeper,
11700		A2(
11701			elm$parser$Parser$Advanced$ignorer,
11702			elm$parser$Parser$Advanced$succeed(
11703				F2(
11704					function (bodyStartPos, item) {
11705						return _Utils_Tuple2(bodyStartPos, item);
11706					})),
11707			dillonkearns$elm_markdown$Parser$Extra$chompOneOrMore(dillonkearns$elm_markdown$Whitespace$isSpaceOrTab)),
11708		elm$parser$Parser$Advanced$getCol),
11709	A2(
11710		elm$parser$Parser$Advanced$ignorer,
11711		elm$parser$Parser$Advanced$getChompedString(dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd),
11712		dillonkearns$elm_markdown$Helpers$lineEndOrEnd));
11713var dillonkearns$elm_markdown$Markdown$OrderedList$Dot = {$: 'Dot'};
11714var dillonkearns$elm_markdown$Markdown$OrderedList$Paren = {$: 'Paren'};
11715var dillonkearns$elm_markdown$Parser$Token$closingParen = A2(
11716	elm$parser$Parser$Advanced$Token,
11717	')',
11718	elm$parser$Parser$Expecting('a `)`'));
11719var dillonkearns$elm_markdown$Parser$Token$dot = A2(
11720	elm$parser$Parser$Advanced$Token,
11721	'.',
11722	elm$parser$Parser$Expecting('a `.`'));
11723var dillonkearns$elm_markdown$Markdown$OrderedList$orderedListMarkerParser = elm$parser$Parser$Advanced$oneOf(
11724	_List_fromArray(
11725		[
11726			A2(
11727			elm$parser$Parser$Advanced$ignorer,
11728			elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$OrderedList$Dot),
11729			elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$dot)),
11730			A2(
11731			elm$parser$Parser$Advanced$ignorer,
11732			elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$OrderedList$Paren),
11733			elm$parser$Parser$Advanced$symbol(dillonkearns$elm_markdown$Parser$Token$closingParen))
11734		]));
11735var dillonkearns$elm_markdown$Parser$Extra$positiveInteger = A2(
11736	elm$parser$Parser$Advanced$mapChompedString,
11737	F2(
11738		function (str, _n0) {
11739			return A2(
11740				elm$core$Maybe$withDefault,
11741				0,
11742				elm$core$String$toInt(str));
11743		}),
11744	dillonkearns$elm_markdown$Parser$Extra$chompOneOrMore(elm$core$Char$isDigit));
11745var dillonkearns$elm_markdown$Markdown$OrderedList$positiveIntegerMaxOf9Digits = A2(
11746	elm$parser$Parser$Advanced$andThen,
11747	function (parsed) {
11748		return (parsed <= 999999999) ? elm$parser$Parser$Advanced$succeed(parsed) : elm$parser$Parser$Advanced$problem(
11749			elm$parser$Parser$Problem('Starting numbers must be nine digits or less.'));
11750	},
11751	dillonkearns$elm_markdown$Parser$Extra$positiveInteger);
11752var dillonkearns$elm_markdown$Markdown$OrderedList$validateStartsWith1 = function (parsed) {
11753	if (parsed === 1) {
11754		return elm$parser$Parser$Advanced$succeed(parsed);
11755	} else {
11756		return elm$parser$Parser$Advanced$problem(
11757			elm$parser$Parser$Problem('Lists inside a paragraph or after a paragraph without a blank line must start with 1'));
11758	}
11759};
11760var dillonkearns$elm_markdown$Markdown$OrderedList$orderedListOrderParser = function (previousWasBody) {
11761	return previousWasBody ? A2(
11762		elm$parser$Parser$Advanced$andThen,
11763		dillonkearns$elm_markdown$Markdown$OrderedList$validateStartsWith1,
11764		A2(
11765			elm$parser$Parser$Advanced$keeper,
11766			A2(
11767				elm$parser$Parser$Advanced$ignorer,
11768				elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
11769				A2(dillonkearns$elm_markdown$Parser$Extra$upTo, 3, dillonkearns$elm_markdown$Whitespace$space)),
11770			dillonkearns$elm_markdown$Markdown$OrderedList$positiveIntegerMaxOf9Digits)) : A2(
11771		elm$parser$Parser$Advanced$keeper,
11772		A2(
11773			elm$parser$Parser$Advanced$ignorer,
11774			elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
11775			A2(dillonkearns$elm_markdown$Parser$Extra$upTo, 3, dillonkearns$elm_markdown$Whitespace$space)),
11776		dillonkearns$elm_markdown$Markdown$OrderedList$positiveIntegerMaxOf9Digits);
11777};
11778var dillonkearns$elm_markdown$Markdown$OrderedList$parser = function (previousWasBody) {
11779	var parseSubsequentItem = F5(
11780		function (start, order, marker, mid, _n0) {
11781			var end = _n0.a;
11782			var body = _n0.b;
11783			return ((end - mid) <= 4) ? A4(dillonkearns$elm_markdown$Markdown$OrderedList$ListItem, order, end 

11783- start, marker, body) : A4(
11784				dillonkearns$elm_markdown$Markdown$OrderedList$ListItem,
11785				order,
11786				(mid - start) + 1,
11787				marker,
11788				_Utils_ap(
11789					A2(elm$core$String$repeat, (end - mid) - 1, ' '),
11790					body));
11791		});
11792	return A2(
11793		elm$parser$Parser$Advanced$keeper,
11794		A2(
11795			elm$parser$Parser$Advanced$keeper,
11796			A2(
11797				elm$parser$Parser$Advanced$keeper,
11798				A2(
11799					elm$parser$Parser$Advanced$keeper,
11800					A2(
11801						elm$parser$Parser$Advanced$keeper,
11802						elm$parser$Parser$Advanced$succeed(parseSubsequentItem),
11803						elm$parser$Parser$Advanced$getCol),
11804					elm$parser$Parser$Advanced$backtrackable(
11805						dillonkearns$elm_markdown$Markdown$OrderedList$orderedListOrderParser(previousWasBody))),
11806				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$Markdown$OrderedList$orderedListMarkerParser)),
11807			elm$parser$Parser$Advanced$getCol),
11808		previousWasBody ? dillonkearns$elm_markdown$Markdown$OrderedList$orderedListItemBodyParser : elm$parser$Parser$Advanced$oneOf(
11809			_List_fromArray(
11810				[dillonkearns$elm_markdown$Markdown$OrderedList$orderedListEmptyItemParser, dillonkearns$elm_markdown$Markdown$OrderedList$orderedListItemBodyParser])));
11811};
11812var dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock = F6(
11813	function (a, b, c, d, e, f) {
11814		return {$: 'OrderedListBlock', a: a, b: b, c: c, d: d, e: e, f: f};
11815	});
11816var dillonkearns$elm_markdown$Markdown$Parser$orderedListBlock = function (previousWasBody) {
11817	return A2(
11818		elm$parser$Parser$Advanced$map,
11819		function (item) {
11820			return A6(dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock, true, item.intended, item.marker, item.order, _List_Nil, item.body);
11821		},
11822		dillonkearns$elm_markdown$Markdown$OrderedList$parser(previousWasBody));
11823};
11824var dillonkearns$elm_markdown$Markdown$Parser$thisIsDefinitelyNotAnHtmlTag = elm$parser$Parser$Advanced$oneOf(
11825	_List_fromArray(
11826		[
11827			elm$parser$Parser$Advanced$token(
11828			A2(
11829				elm$parser$Parser$Advanced$Token,
11830				' ',
11831				elm$parser$Parser$Expecting(' '))),
11832			elm$parser$Parser$Advanced$token(
11833			A2(
11834				elm$parser$Parser$Advanced$Token,
11835				'>',
11836				elm$parser$Parser$Expecting('>'))),
11837			A2(
11838			elm$parser$Parser$Advanced$ignorer,
11839			A2(
11840				elm$parser$Parser$Advanced$ignorer,
11841				A2(
11842					elm$parser$Parser$Advanced$chompIf,
11843					elm$core$Char$isAlpha,
11844					elm$parser$Parser$Expecting('Alpha')),
11845				elm$parser$Parser$Advanced$chompWhile(
11846					function (c) {
11847						return elm$core$Char$isAlphaNum(c) || _Utils_eq(
11848							c,
11849							_Utils_chr('-'));
11850					})),
11851			elm$parser$Parser$Advanced$oneOf(
11852				_List_fromArray(
11853					[
11854						elm$parser$Parser$Advanced$token(
11855						A2(
11856							elm$parser$Parser$Advanced$Token,
11857							':',
11858							elm$parser$Parser$Expecting(':'))),
11859						elm$parser$Parser$Advanced$token(
11860						A2(
11861							elm$parser$Parser$Advanced$Token,
11862							'@',
11863							elm$parser$Parser$Expecting('@'))),
11864						elm$parser$Parser$Advanced$token(
11865						A2(
11866							elm$parser$Parser$Advanced$Token,
11867							'\\',
11868							elm$parser$Parser$Expecting('\\'))),
11869						elm$parser$Parser$Advanced$token(
11870						A2(
11871							elm$parser$Parser$Advanced$Token,
11872							'+',
11873							elm$parser$Parser$Expecting('+'))),
11874						elm$parser$Parser$Advanced$token(
11875						A2(
11876							elm$parser$Parser$Advanced$Token,
11877							'.',
11878							elm$parser$Parser$Expecting('.')))
11879					])))
11880		]));
11881var dillonkearns$elm_markdown$Markdown$Parser$parseAsParagraphInsteadOfHtmlBlock = elm$parser$Parser$Advanced$backtrackable(
11882	A2(
11883		elm$parser$Parser$Advanced$mapChompedString,
11884		F2(
11885			function (rawLine, _n0) {
11886				return dillonkearns$elm_markdown$Markdown$RawBlock$OpenBlockOrParagraph(
11887					dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines(rawLine));
11888			}),
11889		A2(
11890			elm$parser$Parser$Advanced$ignorer,
11891			A2(
11892				elm$parser$Parser$Advanced$ignorer,
11893				A2(
11894					elm$parser$Parser$Advanced$ignorer,
11895					elm$parser$Parser$Advanced$token(
11896						A2(
11897							elm$parser$Parser$Advanced$Token,
11898							'<',
11899							elm$parser$Parser$Expecting('<'))),
11900					dillonkearns$elm_markdown$Markdown$Parser$thisIsDefinitelyNotAnHtmlTag),
11901				dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd),
11902			dillonkearns$elm_markdown$Helpers$lineEndOrEnd)));

11903var dillonkearns$elm_markdown$Markdown$RawBlock$LevelOne = {$: 'LevelOne'};
11904var dillonkearns$elm_markdown$Markdown$RawBlock$LevelTwo = {$: 'LevelTwo'};
11905var dillonkearns$elm_markdown$Markdown$RawBlock$SetextLine = F2(
11906	function (a, b) {
11907		return {$: 'SetextLine', a: a, b: b};
11908	});
11909var dillonkearns$elm_markdown$Parser$Token$equals = A2(
11910	elm$parser$Parser$Advanced$Token,
11911	'=',
11912	elm$parser$Parser$Expecting('a `=`'));
11913var dillonkearns$elm_markdown$Parser$Token$minus = A2(
11914	elm$parser$Parser$Advanced$Token,
11915	'-',
11916	elm$parser$Parser$Expecting('a `-`'));
11917var dillonkearns$elm_markdown$Markdown$Parser$setextLineParser = function () {
11918	var setextLevel = F3(
11919		function (level, levelToken, levelChar) {
11920			return A2(
11921				elm$parser$Parser$Advanced$ignorer,
11922				A2(
11923					elm$parser$Parser$Advanced$ignorer,
11924					elm$parser$Parser$Advanced$succeed(level),
11925					elm$parser$Parser$Advanced$token(levelToken)),
11926				elm$parser$Parser$Advanced$chompWhile(
11927					elm$core$Basics$eq(levelChar)));
11928		});
11929	return A2(
11930		elm$parser$Parser$Advanced$mapChompedString,
11931		F2(
11932			function (raw, level) {
11933				return A2(dillonkearns$elm_markdown$Markdown$RawBlock$SetextLine, level, raw);
11934			}),
11935		A2(
11936			elm$parser$Parser$Advanced$keeper,
11937			A2(
11938				elm$parser$Parser$Advanced$ignorer,
11939				elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
11940				dillonkearns$elm_markdown$Whitespace$upToThreeSpaces),
11941			A2(
11942				elm$parser$Parser$Advanced$ignorer,
11943				A2(
11944					elm$parser$Parser$Advanced$ignorer,
11945					elm$parser$Parser$Advanced$oneOf(
11946						_List_fromArray(
11947							[
11948								A3(
11949								setextLevel,
11950								dillonkearns$elm_markdown$Markdown$RawBlock$LevelOne,
11951								dillonkearns$elm_markdown$Parser$Token$equals,
11952								_Utils_chr('=')),
11953								A3(
11954								setextLevel,
11955								dillonkearns$elm_markdown$Markdown$RawBlock$LevelTwo,
11956								dillonkearns$elm_markdown$Parser$Token$minus,
11957								_Utils_chr('-'))
11958							])),
11959					elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$Whitespace$isSpaceOrTab)),
11960				dillonkearns$elm_markdown$Helpers$lineEndOrEnd)));
11961}();
11962var dillonkearns$elm_markdown$Markdown$RawBlock$TableDelimiter = function (a) {
11963	return {$: 'TableDelimiter', a: a};
11964};
11965var dillonkearns$elm_markdown$Markdown$Table$TableDelimiterRow = F2(
11966	function (a, b) {
11967		return {$: 'TableDelimiterRow', a: a, b: b};
11968	});
11969var dillonkearns$elm_markdown$Markdown$TableParser$chompSinglelineWhitespace = elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$Whitespace$isSpaceOrTab);
11970var dillonkearns$elm_markdown$Parser$Token$parseString = function (str) {
11971	return elm$parser$Parser$Advanced$token(
11972		A2(
11973			elm$parser$Parser$Advanced$Token,
11974			str,
11975			elm$parser$Parser$Expecting(str)));
11976};
11977var dillonkearns$elm_markdown$Markdown$TableParser$requirePipeIfNotFirst = function (columns) {
11978	return elm$core$List$isEmpty(columns) ? elm$parser$Parser$Advanced$oneOf(
11979		_List_fromArray(
11980			[
11981				dillonkearns$elm_markdown$Parser$Token$parseString('|'),
11982				elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
11983			])) : dillonkearns$elm_markdown$Parser$Token$parseString('|');
11984};
11985var dillonkearns$elm_markdown$Parser$Extra$maybeChomp = function (condition) {
11986	return elm$parser$Parser$Advanced$oneOf(
11987		_List_fromArray(
11988			[
11989				A2(
11990				elm$parser$Parser$Advanced$chompIf,
11991				condition,
11992				elm$parser$Parser$Problem('Character not found')),
11993				elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
11994			]));
11995};
11996var dillonkearns$elm_markdown$Markdown$TableParser$delimiterRowHelp = function (revDelimiterColumns) {
11997	return elm$parser$Parser$Advanced$oneOf(
11998		_List_fromArray(
11999			[
12000				elm$parser$Parser$Advanced$backtrackable(
12001				A2(
12002					elm$parser$Parser$Advanced$map,
12003					function (_n0) {
12004						return elm$parser$Parser$Advanced$Done(revDelimiterColumns);
12005					},
12006					dillonkearns$elm_markdown$Parser$Token$parseString('|\n'))),
12007				A2(
12008				elm$parser$Parser$Advanced$map,
12009				function (_n1) {
12010					return elm$parser$Parser$Advanced$Done(revDelimiterColumns);
12011				},
12012				dillonkearns$elm_markdown$Parser$Token$parseString('\n')),
12013				A2(
12014				elm$parser$Parser$Advanced$map,
12015				function (_n2) {
12016					return elm$parser$Parser$Advanced$Done(revDelimiterColumns);
12017				},
12018				elm$parser$Parser$Advanced$end(
12019					elm$parser$Parser$Expecting('end'))),
12020				elm$parser$Parser$Advanced$backtrackable(
12021				A2(
12022					elm$parser$Parser$Advanced$ignorer,
12023					A2(
12024						elm$parser$Parser$Advanced$ignorer,
12025						elm$parser$Parser$Advanced$succeed(
12026							elm$parser$Parser$Advanced$Done(revDelimiterColumns)),
12027						dillonkearns$elm_markdown$Parser$Token$parseString('|')),
12028					elm$parser$Parser$Advanced$end(
12029						elm$parser$Parser$Expecting('end')))),
12030				A2(
12031				elm$parser$Parser$Advanced$keeper,
12032				A2(
12033					elm$parser$Parser$Advanced$ignorer,
12034					A2(
12035						elm$parser$Parser$Advanced$ignorer,
12036						elm$parser$Parser$Advanced$succeed(
12037							function (column) {
12038								return elm$parser$Parser$Advanced$Loop(
12039									A2(elm$core$List$cons, column, revDelimiterColumns));
12040							}),
12041						dillonkearns$elm_markdown$Markdown$TableParser$requirePipeIfNotFirst(revDelimiterColumns)),
12042					dillonkearns$elm_markdown$Markdown$TableParser$chompSinglelineWhitespace),
12043				A2(
12044					elm$parser$Parser$Advanced$ignorer,
12045					elm$parser$Parser$Advanced$getChompedString(
12046						A2(
12047							elm$parser$Parser$Advanced$ignorer,
12048							A2(
12049								elm$parser$Parser$Advanced$ignorer,
12050								A2(
12051									elm$parser$Parser$Advanced$ignorer,
12052									elm$parser$Parser$Advanced$succeed(_Utils_Tuple0),
12053									dillonkearns$elm_markdown$Parser$Extra$maybeChomp(
12054										function (c) {
12055											return _Utils_eq(
12056												c,
12057												_Utils_chr(':'));
12058										})),
12059								dillonkearns$elm_markdown$Parser$Extra$chompOneOrMore(
12060									function (c) {
12061										return _Utils_eq(
12062											c,
12063											_Utils_chr('-'));
12064									})),
12065							dillonkearns$elm_markdown$Parser$Extra$maybeChomp(
12066								function (c) {
12067									return _Utils_eq(
12068										c,
12069										_Utils_chr(':'));
12070								}))),
12071					dillonkearns$elm_markdown$Markdown$TableParser$chompSinglelineWhitespace))
12072			]));
12073};
12074var dillonkearns$elm_markdown$Markdown$Block$AlignCenter = {$: 'AlignCenter'};
12075var dillonkearns$elm_markdown$Markdown$Block$AlignLeft = {$: 'AlignLeft'};
12076var dillonkearns$elm_markdown$Markdown$Block$AlignRight = {$: 'AlignRight'};
12077var dillonkearns$elm_markdown$Markdown$TableParser$delimiterToAlignment = function (cell) {
12078	var _n0 = _Utils_Tuple2(
12079		A2(elm$core$String$startsWith, ':', cell),
12080		A2(elm$core$String$endsWith, ':', cell));
12081	if (_n0.a) {
12082		if (_n0.b) {
12083			return elm$core$Maybe$Just(dillonkearns$elm_markdown$Markdown$Block$AlignCenter);
12084		} else {
12085			return elm$core$Maybe$Just(dillonkearns$elm_markdown$Markdown$Block$AlignLeft);
12086		}
12087	} else {
12088		if (_n0.b) {
12089			return elm$core$Maybe$Just(dillonkearns$elm_markdown$Markdown$Block$AlignRight);
12090		} else {
12091			return elm$core$Maybe$Nothing;
12092		}
12093	}
12094};
12095var dillonkearns$elm_markdown$Markdown$TableParser$delimiterRowParser = A2(
12096	elm$parser$Parser$Advanced$andThen,
12097	function (delimiterRow) {
12098		var trimmed = delimiterRow.a.trimmed;
12099		var headers = delimiterRow.b;
12100		return elm$core$List$isEmpty(headers) ? elm$parser$Parser$Advanced$problem(
12101			elm$parser$Parser$Expecting('Must have at least one column in delimiter row.')) : (((elm$core$List$length(headers) === 1) && (!(A2(elm$core$String$startsWith, '|', trimmed) && A2(elm$core$String$endsWith, '|', trimmed)))) ? elm$parser$Parser$Advanced$problem(
12102			elm$parser$Parser$Problem('Tables with a single column must have pipes at the start and end of the delimiter row to avoid ambiguity.')) : elm$parser$Parser$Advanced$succeed(delimiterRow));
12103	},
12104	A2(
12105		elm$parser$Parser$Advanced$mapChompedString,
12106		F2(
12107			function (delimiterText, revDelimiterColumns) {
12108				return A2(
12109					dillonkearns$elm_markdown$Markdown$Table$TableDelimiterRow,
12110					{
12111						raw: delimiterText,
12112						trimmed: elm$core$String$trim(delimiterText)
12113					},
12114					A2(
12115						elm$core$List$map,
12116						dillonkearns$elm_markdown$Markdown$TableParser$delimiterToAlignment,
12117						elm$core$List$reverse(revDelimiterColumns)));
12118			}),
12119		A2(elm$parser$Parser$Advanced$loop, _List_Nil, dillonkearns$elm_markdown$Markdown$TableParser$delimiterRowHelp)));
12120var dillonkearns$elm_markdown$Markdown$Parser$tableDelimiterInOpenParagraph = A2(elm$parser$Parser$Advanced$map, dillonkearns$elm_markdown$Markdown$RawBlock$TableDelimiter, dillonkearns$elm_markdown$Markdown$TableParser$delimiterRowParser);
12121var dillonkearns$elm_markdown$Markdown$RawBlock$Table = function (a) {
12122	return {$: 'Table', a: a};
12123};
12124var dillonkearns$elm_markdown$Markdown$Table$Table = F2(
12125	function (a, b) {
12126		return {$: 'Table', a: a, b: b};
12127	});
12128var dillonkearns$elm_markdown$Markdown$TableParser$parseCellHelper = function (_n0) {
12129	var curr = _n0.a;
12130	var acc = _n0.b;
12131	var _return = A2(
12132		elm$core$Maybe$withDefault,
12133		elm$parser$Parser$Advanced$Done(acc),
12134		A2(
12135			elm$core$Maybe$map,
12136			function (cell) {
12137				return elm$parser$Parser$Advanced$Done(
12138					A2(elm$core$List$cons, cell, acc));
12139			},
12140			curr));
12141	var finishCell = A2(
12142		elm$core$Maybe$withDefault,
12143		elm$parser$Parser$Advanced$Loop(
12144			_Utils_Tuple2(elm$core$Maybe$Nothing, acc)),
12145		A2(
12146			elm$core$Maybe$map,
12147			function (cell) {
12148				return elm$parser$Parser$Advanced$Loop(
12149					_Utils_Tuple2(
12150						elm$core$Maybe$Nothing,
12151						A2(elm$core$List$cons, cell, acc)));
12152			},
12153			curr));
12154	var addToCurrent = function (c) {
12155		return _Utils_ap(
12156			A2(elm$core$Maybe$withDefault, '', curr),
12157			c);
12158	};
12159	var continueCell = function (c) {
12160		return elm$parser$Parser$Advanced$Loop(
12161			_Utils_Tuple2(
12162				elm$core$Maybe$Just(
12163					addToCurrent(c)),
12164				acc));
12165	};
12166	return elm$parser$Parser$Advanced$oneOf(
12167		_List_fromArray(
12168			[
12169				A2(
12170				elm$parser$Parser$Advanced$map,
12171				function (_n1) {
12172					return _return;
12173				},
12174				dillonkearns$elm_markdown$Parser$Token$parseString('|\n')),
12175				A2(
12176				elm$parser$Parser$Advanced$map,
12177				function (_n2) {
12178					return _return;
12179				},
12180				dillonkearns$elm_markdown$Parser$Token$parseString('\n')),
12181				A2(
12182				elm$parser$Parser$Advanced$map,
12183				function (_n3) {
12184					return _return;
12185				},
12186				elm$parser$Parser$Advanced$end(
12187					elm$parser$Parser$Expecting('end'))),
12188				A2(
12189				elm$parser$Parser$Advanced$ignorer,
12190				elm$parser$Parser$Advanced$backtrackable(
12191					elm$parser$Parser$Advanced$succeed(
12192						continueCell('|'))),
12193				dillonkearns$elm_markdown$Parser$Token$parseString('\\\\|')),
12194				A2(
12195				elm$parser$Parser$Advanced$ignorer,
12196				elm$parser$Parser$Advanced$backtrackable(
12197					elm$parser$Parser$Advanced$succeed(
12198						continueCell('\\'))),
12199				dillonkearns$elm_markdown$Parser$Token$parseString('\\\\')),
12200				A2(
12201				elm$parser$Parser$Advanced$ignorer,
12202				elm$parser$Parser$Advanced$backtrackable(
12203					elm$parser$Parser$Advanced$succeed(
12204						continueCell('|'))),
12205				dillonkearns$elm_markdown$Parser$Token$parseString('\\|')),
12206				A2(
12207				elm$parser$Parser$Advanced$ignorer,
12208				elm$parser$Parser$Advanced$backtrackable(
12209					elm$parser$Parser$Advanced$succeed(finishCell)),
12210				dillonkearns$elm_markdown$Parser$Token$parseString('|')),
12211				A2(
12212				elm$parser$Parser$Advanced$mapChompedString,
12213				F2(
12214					function (_char, _n4) {
12215						return continueCell(_char);
12216					}),
12217				A2(
12218					elm$parser$Parser$Advanced$chompIf,
12219					elm$core$Basics$always(true),
12220					elm$parser$Parser$Problem('No character found')))
12221			]));
12222};
12223var dillonkearns$elm_markdown$Markdown$TableParser$parseCells = A2(
12224	elm$parser$Parser$Advanced$map,
12225	A2(
12226		elm$core$List$foldl,
12227		F2(
12228			function (cell, acc) {
12229				return A2(
12230					elm$core$List$cons,
12231					elm$core$String$trim(cell),
12232					acc);
12233			}),
12234		_List_Nil),
12235	A2(
12236		elm$parser$Parser$Advanced$loop,
12237		_Utils_Tuple2(elm$core$Maybe$Nothing, _List_Nil),
12238		dillonkearns$elm_markdown$Markdown$TableParser$parseCellHelper));
12239var dillonkearns$elm_markdown$Markdown$TableParser$rowParser = A2(
12240	elm$parser$Parser$Advanced$keeper,
12241	A2(
12242		elm$parser$Parser$Advanced$ignorer,
12243		elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
12244		elm$parser$Parser$Advanced$oneOf(
12245			_List_fromArray(
12246				[
12247					dillonkearns$elm_markdown$Parser$Token$parseString('|'),
12248					elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
12249				]))),
12250	dillonkearns$elm_markdown$Markdown$TableParser$parseCells);
12251var elm$core$List$takeReverse = F3(
12252	function (n, list, kept) {
12253		takeReverse:
12254		while (true) {
12255			if (n <= 0) {
12256				return kept;
12257			} else {
12258				if (!list.b) {
12259					return kept;
12260				} else {
12261					var x = list.a;
12262					var xs = list.b;
12263					var $temp$n = n - 1,
12264						$temp$list = xs,
12265						$temp$kept = A2(elm$core$List$cons, x, kept);
12266					n = $temp$n;
12267					list = $temp$list;
12268					kept = $temp$kept;
12269					continue takeReverse;
12270				}
12271			}
12272		}
12273	});
12274var elm$core$List$takeTailRec = F2(
12275	function (n, list) {
12276		return elm$core$List$reverse(
12277			A3(elm$core$List$takeReverse, n, list, _List_Nil));
12278	});
12279var elm$core$List$takeFast = F3(
12280	function (ctr, n, list) {
12281		if (n <= 0) {
12282			return _List_Nil;
12283		} else {
12284			var _n0 = _Utils_Tuple2(n, list);
12285			_n0$1:
12286			while (true) {
12287				_n0$5:
12288				while (true) {
12289					if (!_n0.b.b) {
12290						return list;
12291					} else {
12292						if (_n0.b.b.b) {
12293							switch (_n0.a) {
12294								case 1:
12295									break _n0$1;
12296								case 2:
12297									var _n2 = _n0.b;
12298									var x = _n2.a;
12299									var _n3 = _n2.b;
12300									var y = _n3.a;
12301									return _List_fromArray(
12302										[x, y]);
12303								case 3:
12304									if (_n0.b.b.b.b) {
12305										var _n4 = _n0.b;
12306										var x = _n4.a;
12307										var _n5 = _n4.b;
12308										var y = _n5.a;
12309										var _n6 = _n5.b;
12310										var z = _n6.a;
12311										return _List_fromArray(
12312											[x, y, z]);
12313									} else {
12314										break _n0$5;
12315									}
12316								default:
12317									if (_n0.b.b.b.b && _n0.b.b.b.b.b) {
12318										var _n7 = _n0.b;
12319										var x = _n7.a;
12320										var _n8 = _n7.b;
12321										var y = _n8.a;
12322										var _n9 = _n8.b;
12323										var z = _n9.a;
12324										var _n10 = _n9.b;
12325										var w = _n10.a;
12326										var tl = _n10.b;
12327										return (ctr > 1000) ? A2(
12328											elm$core$List$cons,
12329											x,
12330											A2(
12331												elm$core$List$cons,
12332												y,
12333												A2(
12334													elm$core$List$cons,
12335													z,
12336													A2(
12337														elm$core$List$cons,
12338														w,
12339														A2(elm$core$List$takeTailRec, n - 4, tl))))) : A2(
12340											elm$core$List$cons,
12341											x,
12342											A2(
12343												elm$core$List$cons,
12344												y,
12345												A2(
12346													elm$core$List$cons,
12347													z,
12348													A2(
12349														elm$core$List$cons,
12350														w,
12351														A3(elm$core$List$takeFast, ctr + 1, n - 4, tl)))));
12352									} else {
12353										break _n0$5;
12354									}
12355							}
12356						} else {
12357							if (_n0.a === 1) {
12358								break _n0$1;
12359							} else {
12360								break _n0$5;
12361							}
12362						}
12363					}
12364				}
12365				return list;
12366			}
12367			var _n1 = _n0.b;
12368			var x = _n1.a;
12369			return _List_fromArray(
12370				[x]);
12371		}
12372	});
12373var elm$core$List$take = F2(
12374	function (n, list) {
12375		return A3(elm$core$List$takeFast, 0, n, list);
12376	});
12377var dillonkearns$elm_markdown$Markdown$TableParser$standardizeRowLength = F2(
12378	function (expectedLength, row) {
12379		var rowLength = elm$core$List$length(row);
12380		var _n0 = A2(elm$core$Basics$compare, expectedLength, rowLength);
12381		switch (_n0.$) {
12382			case 'LT':
12383				return A2(elm$core$List$take, expectedLength, row);
12384			case 'EQ':
12385				return row;
12386			default:
12387				return _Utils_ap(
12388					row,
12389					A2(elm$core$List$repeat, expectedLength - rowLength, ''));
12390		}
12391	});
12392var elm$core$List$any = F2(
12393	function (isOkay, list) {
12394		any:
12395		while (true) {
12396			if (!list.b) {
12397				return false;

12398			} else {
12399				var x = list.a;
12400				var xs = list.b;
12401				if (isOkay(x)) {
12402					return true;
12403				} else {
12404					var $temp$isOkay = isOkay,
12405						$temp$list = xs;
12406					isOkay = $temp$isOkay;
12407					list = $temp$list;
12408					continue any;
12409				}
12410			}
12411		}
12412	});
12413var elm$core$List$all = F2(
12414	function (isOkay, list) {
12415		return !A2(
12416			elm$core$List$any,
12417			A2(elm$core$Basics$composeL, elm$core$Basics$not, isOkay),
12418			list);
12419	});
12420var dillonkearns$elm_markdown$Markdown$TableParser$bodyRowParser = function (expectedRowLength) {
12421	return A2(
12422		elm$parser$Parser$Advanced$andThen,
12423		function (row) {
12424			return (elm$core$List$isEmpty(row) || A2(elm$core$List$all, elm$core$String$isEmpty, row)) ? elm$parser$Parser$Advanced$problem(
12425				elm$parser$Parser$Problem('A line must have at least one column')) : elm$parser$Parser$Advanced$succeed(
12426				A2(dillonkearns$elm_markdown$Markdown$TableParser$standardizeRowLength, expectedRowLength, row));
12427		},
12428		dillonkearns$elm_markdown$Markdown$TableParser$rowParser);
12429};
12430var dillonkearns$elm_markdown$Markdown$Parser$tableRowIfTableStarted = function (_n0) {
12431	var headers = _n0.a;
12432	var body = _n0.b;
12433	return A2(
12434		elm$parser$Parser$Advanced$map,
12435		function (row) {
12436			return dillonkearns$elm_markdown$Markdown$RawBlock$Table(
12437				A2(
12438					dillonkearns$elm_markdown$Markdown$Table$Table,
12439					headers,
12440					_Utils_ap(
12441						body,
12442						_List_fromArray(
12443							[row]))));
12444		},
12445		dillonkearns$elm_markdown$Markdown$TableParser$bodyRowParser(
12446			elm$core$List$length(headers)));
12447};
12448var dillonkearns$elm_markdown$Markdown$Block$H1 = {$: 'H1'};
12449var dillonkearns$elm_markdown$Markdown$Block$H2 = {$: 'H2'};
12450var dillonkearns$elm_markdown$Markdown$Block$H3 = {$: 'H3'};
12451var dillonkearns$elm_markdown$Markdown$Block$H4 = {$: 'H4'};
12452var dillonkearns$elm_markdown$Markdown$Block$H5 = {$: 'H5'};
12453var dillonkearns$elm_markdown$Markdown$Block$H6 = {$: 'H6'};
12454var dillonkearns$elm_markdown$Markdown$Parser$toHeading = function (level) {
12455	switch (level) {
12456		case 1:
12457			return elm$core$Result$Ok(dillonkearns$elm_markdown$Markdown$Block$H1);
12458		case 2:
12459			return elm$core$Result$Ok(dillonkearns$elm_markdown$Markdown$Block$H2);
12460		case 3:
12461			return elm$core$Result$Ok(dillonkearns$elm_markdown$Markdown$Block$H3);
12462		case 4:
12463			return elm$core$Result$Ok(dillonkearns$elm_markdown$Markdown$Block$H4);
12464		case 5:
12465			return elm$core$Result$Ok(dillonkearns$elm_markdown$Markdown$Block$H5);
12466		case 6:
12467			return elm$core$Result$Ok(dillonkearns$elm_markdown$Markdown$Block$H6);
12468		default:
12469			return elm$core$Result$Err(
12470				elm$parser$Parser$Expecting(
12471					'A heading with 1 to 6 #\'s, but found ' + elm$core$String$fromInt(level)));
12472	}
12473};
12474var dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock = F4(
12475	function (a, b, c, d) {
12476		return {$: 'UnorderedListBlock', a: a, b: b, c: c, d: d};
12477	});
12478var dillonkearns$elm_markdown$Markdown$ListItem$EmptyItem = {$: 'EmptyItem'};
12479var dillonkearns$elm_markdown$Markdown$ListItem$PlainItem = function (a) {
12480	return {$: 'PlainItem', a: a};
12481};
12482var dillonkearns$elm_markdown$Markdown$ListItem$TaskItem = F2(
12483	function (a, b) {
12484		return {$: 'TaskItem', a: a, b: b};
12485	});
12486var dillonkearns$elm_markdown$Markdown$UnorderedList$getIntendedCodeItem = F4(
12487	function (markerStartPos, listMarker, markerEndPos, _n0) {
12488		var bodyStartPos = _n0.a;
12489		var item = _n0.b;
12490		var spaceNum = bodyStartPos - markerEndPos;
12491		if (spaceNum <= 4) {
12492			return _Utils_Tuple3(listMarker, bodyStartPos - markerStartPos, item);
12493		} else {
12494			var intendedCodeItem = function () {
12495				switch (item.$) {
12496					case 'TaskItem':
12497						var completion = item.a;
12498						var string = item.b;
12499						return A2(
12500							dillonkearns$elm_markdown$Markdown$ListItem$TaskItem,
12501							completion,
12502							_Utils_ap(
12503								A2(elm$core$String$repeat, spaceNum - 1, ' '),
12504								string));
12505					case 'PlainItem':
12506						var string = item.a;
12507						return dillonkearns$elm_markdown$Markdown$ListItem$PlainItem(
12508							_Utils_ap(
12509								A2(elm$core$String$repeat, spaceNum - 1, ' '),
12510								string));
12511					default:
12512						return dillonkearns$elm_markdown$Markdown$ListItem$EmptyItem;
12513				}
12514			}();
12515			return _Utils_Tuple3(listMarker, (markerEndPos - markerStartPos) + 1, intendedCodeItem);
12516		}
12517	});
12518var dillonkearns$elm_markdown$Markdown$UnorderedList$unorderedListEmptyItemParser = A2(
12519	elm$parser$Parser$Advanced$keeper,
12520	elm$parser$Parser$Advanced$succeed(
12521		function (bodyStartPos) {
12522			return _Utils_Tuple2(bodyStartPos, dillonkearns$elm_markdown$Markdown$ListItem$EmptyItem);
12523		}),
12524	A2(elm$parser$Parser$Advanced$ignorer, elm$parser$Parser$Advanced$getCol, dillonkearns$elm_markdown$Helpers$lineEndOrEnd));
12525var dillonkearns$elm_markdown$Markdown$ListItem$Complete = {$: 'Complete'};
12526var dillonkearns$elm_markdown$Markdown$ListItem$Incomplete = {$: 'Incomplete'};
12527var dillonkearns$elm_markdown$Markdown$ListItem$taskItemParser = elm$parser$Parser$Advanced$oneOf(
12528	_List_fromArray(
12529		[
12530			A2(
12531			elm$parser$Parser$Advanced$ignorer,
12532			elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$ListItem$Complete),
12533			elm$parser$Parser$Advanced$symbol(
12534				A2(
12535					elm$parser$Parser$Advanced$Token,
12536					'[x] ',
12537					elm$parser$Parser$ExpectingSymbol('[x] ')))),
12538			A2(
12539			elm$parser$Parser$Advanced$ignorer,
12540			elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$ListItem$Complete),
12541			elm$parser$Parser$Advanced$symbol(
12542				A2(
12543					elm$parser$Parser$Advanced$Token,
12544					'[X] ',
12545					elm$parser$Parser$ExpectingSymbol('[X] ')))),
12546			A2(
12547			elm$parser$Parser$Advanced$ignorer,
12548			elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$ListItem$Incomplete),
12549			elm$parser$Parser$Advanced$symbol(
12550				A2(
12551					elm$parser$Parser$Advanced$Token,
12552					'[ ] ',
12553					elm$parser$Parser$ExpectingSymbol('[ ] '))))
12554		]));
12555var dillonkearns$elm_markdown$Markdown$ListItem$parser = A2(
12556	elm$parser$Parser$Advanced$keeper,
12557	elm$parser$Parser$Advanced$oneOf(
12558		_List_fromArray(
12559			[
12560				A2(
12561				elm$parser$Parser$Advanced$keeper,
12562				elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$ListItem$TaskItem),
12563				A2(
12564					elm$parser$Parser$Advanced$ignorer,
12565					dillonkearns$elm_markdown$Markdown$ListItem$taskItemParser,
12566					elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$Whitespace$isSpaceOrTab))),
12567				elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$ListItem$PlainItem)
12568			])),
12569	A2(
12570		elm$parser$Parser$Advanced$ignorer,
12571		elm$parser$Parser$Advanced$getChompedString(dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd),
12572		dillonkearns$elm_markdown$Helpers$lineEndOrEnd));
12573var dillonkearns$elm_markdown$Markdown$UnorderedList$unorderedListItemBodyParser = A2(
12574	elm$parser$Parser$Advanced$keeper,
12575	A2(
12576		elm$parser$Parser$Advanced$keeper,
12577		A2(
12578			elm$parser$Parser$Advanced$ignorer,
12579			elm$parser$Parser$Advanced$succeed(
12580				F2(
12581					function (bodyStartPos, item) {
12582						return _Utils_Tuple2(bodyStartPos, item);
12583					})),
12584			dillonkearns$elm_markdown$Parser$Extra$chompOneOrMore(dillonkearns$elm_markdown$Whitespace$isSpaceOrTab)),
12585		elm$parser$Parser$Advanced$getCol),
12586	dillonkearns$elm_markdown$Markdown$ListItem$parser);
12587var dillonkearns$elm_markdown$Markdown$UnorderedList$Asterisk = {$: 'Asterisk'};
12588var dillonkearns$elm_markdown$Markdown$UnorderedList$Minus = {$: 'Minus'};
12589var dillonkearns$elm_markdown$Markdown$UnorderedList$Plus = {$: 'Plus'};
12590var dillonkearns$elm_markdown$Markdown$UnorderedList$unorderedListMarkerParser = elm$parser$Parser$Advanced$oneOf(
12591	_List_fromArray(
12592		[
12593			A2(
12594			elm$parser$Parser$Advanced$ignorer,
12595			A2(
12596				elm$parser$Parser$Advanced$ignorer,
12597				elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$UnorderedList$Minus),
12598				A2(dillonkearns$elm_markdown$Parser$Extra$upTo, 3, dillonkearns$elm_markdown$Whitespace$space)),
12599			elm$parser$Parser$Advanced$symbol(
12600				A2(
12601					elm$parser$Parser$Advanced$Token,
12602					'-',
12603					elm$parser$Parser$ExpectingSymbol('-')))),
12604			A2(
12605			elm$parser$Parser$Advanced$ignorer,
12606			elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$UnorderedList$Plus),
12607			elm$parser$Parser$Advanced$symbol(
12608				A2(
12609					elm$parser$Parser$Advanced$Token,
12610					'+',
12611					elm$parser$Parser$ExpectingSymbol('+')))),
12612			A2(
12613			elm$parser$Parser$Advanced$ignorer,
12614			elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$UnorderedList$Asterisk),
12615			elm$parser$Parser$Advanced$symbol(
12616				A2(
12617					elm$parser$Parser$Advanced$Token,
12618					'*',
12619					elm$parser$Parser$ExpectingSymbol('*'))))
12620		]));
12621var dillonkearns$elm_markdown$Markdown$UnorderedList$parser = function (previousWasBody) {
12622	return A2(
12623		elm$parser$Parser$Advanced$keeper,
12624		A2(
12625			elm$parser$Parser$Advanced$keeper,
12626			A2(
12627				elm$parser$Parser$Advanced$keeper,
12628				A2(
12629					elm$parser$Parser$Advanced$keeper,
12630					elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$Markdown$UnorderedList$getIntendedCodeItem),
12631					elm$parser$Parser$Advanced$getCol),
12632				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$Markdown$UnorderedList$unorderedListMarkerParser)),
12633			elm$parser$Parser$Advanced$getCol),
12634		previousWasBody ? dillonkearns$elm_markdown$Markdown$UnorderedList$unorderedListItemBodyParser : elm$parser$Parser$Advanced$oneOf(
12635			_List_fromArray(
12636				[dillonkearns$elm_markdown$Markdown$UnorderedList$unorderedListEmptyItemParser, dillonkearns$elm_markdown$Markdown$UnorderedList$unorderedListItemBodyParser])));
12637};
12638var dillonkearns$elm_markdown$Markdown$Parser$unorderedListBlock = function (previousWasBody) {
12639	var parseListItem = F3(
12640		function (listmarker, intended, unparsedListItem) {
12641			switch (unparsedListItem.$) {
12642				case 'TaskItem':
12643					var completion = unparsedListItem.a;
12644					var body = unparsedListItem.b;
12645					return {
12646						body: body,
12647						marker: listmarker,
12648						task: elm$core$Maybe$Just(
12649							function () {
12650								if (completion.$ === 'Complete') {
12651									return true;
12652								} else {
12653									return false;

12654								}
12655							}())
12656					};
12657				case 'PlainItem':
12658					var body = unparsedListItem.a;
12659					return {body: body, marker: listmarker, task: elm$core$Maybe$Nothing};
12660				default:
12661					return {body: '', marker: listmarker, task: elm$core$Maybe$Nothing};
12662			}
12663		});
12664	return A2(
12665		elm$parser$Parser$Advanced$map,
12666		function (_n0) {
12667			var listmarker = _n0.a;
12668			var intended = _n0.b;
12669			var unparsedListItem = _n0.c;
12670			return A4(
12671				dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
12672				true,
12673				intended,
12674				_List_Nil,
12675				A3(parseListItem, listmarker, intended, unparsedListItem));
12676		},
12677		dillonkearns$elm_markdown$Markdown$UnorderedList$parser(previousWasBody));
12678};
12679var dillonkearns$elm_markdown$Markdown$RawBlock$CodeBlock = function (a) {
12680	return {$: 'CodeBlock', a: a};
12681};
12682var dillonkearns$elm_markdown$Markdown$RawBlock$Html = function (a) {
12683	return {$: 'Html', a: a};
12684};
12685var dillonkearns$elm_markdown$Markdown$RawBlock$ParsedBlockQuote = function (a) {
12686	return {$: 'ParsedBlockQuote', a: a};
12687};
12688var dillonkearns$elm_markdown$Markdown$RawBlock$ThematicBreak = {$: 'ThematicBreak'};
12689var dillonkearns$elm_markdown$Markdown$Table$TableHeader = function (a) {
12690	return {$: 'TableHeader', a: a};
12691};
12692var dillonkearns$elm_markdown$Markdown$TableParser$parseHeader = F2(
12693	function (_n0, headersRow) {
12694		var columnAlignments = _n0.b;
12695		var headersWithAlignment = function (headers) {
12696			return A3(
12697				elm$core$List$map2,
12698				F2(
12699					function (headerCell, alignment) {
12700						return {alignment: alignment, label: headerCell};
12701					}),
12702				headers,
12703				columnAlignments);
12704		};
12705		var combineHeaderAndDelimiter = function (headers) {
12706			return _Utils_eq(
12707				elm$core$List$length(headers),
12708				elm$core$List$length(columnAlignments)) ? elm$core$Result$Ok(
12709				dillonkearns$elm_markdown$Markdown$Table$TableHeader(
12710					headersWithAlignment(headers))) : elm$core$Result$Err(
12711				'Tables must have the same number of header columns (' + (elm$core$String$fromInt(
12712					elm$core$List$length(headers)) + (') as delimiter columns (' + (elm$core$String$fromInt(
12713					elm$core$List$length(columnAlignments)) + ')'))));
12714		};
12715		var _n1 = A2(elm$parser$Parser$Advanced$run, dillonkearns$elm_markdown$Markdown$TableParser$rowParser, headersRow);
12716		if (_n1.$ === 'Ok') {
12717			var headers = _n1.a;
12718			return combineHeaderAndDelimiter(headers);
12719		} else {
12720			return elm$core$Result$Err('Unable to parse previous line as a table header');
12721		}
12722	});
12723var dillonkearns$elm_markdown$ThematicBreak$ThematicBreak = {$: 'ThematicBreak'};
12724var dillonkearns$elm_markdown$ThematicBreak$whitespace = elm$parser$Parser$Advanced$chompWhile(dillonkearns$elm_markdown$Whitespace$isSpaceOrTab);
12725var dillonkearns$elm_markdown$ThematicBreak$withChar = function (tchar) {
12726	var token = dillonkearns$elm_markdown$Parser$Token$parseString(
12727		elm$core$String$fromChar(tchar));
12728	return A2(
12729		elm$parser$Parser$Advanced$ignorer,
12730		A2(
12731			elm$parser$Parser$Advanced$ignorer,
12732			A2(
12733				elm$parser$Parser$Advanced$ignorer,
12734				A2(
12735					elm$parser$Parser$Advanced$ignorer,
12736					A2(
12737						elm$parser$Parser$Advanced$ignorer,
12738						A2(
12739							elm$parser$Parser$Advanced$ignorer,
12740							A2(
12741								elm$parser$Parser$Advanced$ignorer,
12742								elm$parser$Parser$Advanced$succeed(dillonkearns$elm_markdown$ThematicBreak$ThematicBreak),
12743								token),
12744							dillonkearns$elm_markdown$ThematicBreak$whitespace),
12745						token),
12746					dillonkearns$elm_markdown$ThematicBreak$whitespace),
12747				token),
12748			elm$parser$Parser$Advanced$chompWhile(
12749				function (c) {
12750					return _Utils_eq(c, tchar) || dillonkearns$elm_markdown$Whitespace$isSpaceOrTab(c);
12751				})),
12752		dillonkearns$elm_markdown$Helpers$lineEndOrEnd);
12753};
12754var dillonkearns$elm_markdown$ThematicBreak$parseThematicBreak = elm$parser$Parser$Advanced$oneOf(
12755	_List_fromArray(
12756		[
12757			dillonkearns$elm_markdown$ThematicBreak$withChar(
12758			_Utils_chr('-')),
12759			dillonkearns$elm_markdown$ThematicBreak$withChar(
12760			_Utils_chr('*')),
12761			dillonkearns$elm_markdown$ThematicBreak$withChar(
12762			_Utils_chr('_'))
12763		]));
12764var dillonkearns$elm_markdown$ThematicBreak$parser = elm$parser$Parser$Advanced$oneOf(
12765	_List_fromArray(
12766		[
12767			A2(
12768			elm$parser$Parser$Advanced$keeper,
12769			A2(
12770				elm$parser$Parser$Advanced$ignorer,
12771				A2(
12772					elm$parser$Parser$Advanced$ignorer,
12773					A2(
12774						elm$parser$Parser$Advanced$ignorer,
12775						elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
12776						dillonkearns$elm_markdown$Whitespace$space),
12777					elm$parser$Parser$Advanced$oneOf(
12778						_List_fromArray(
12779							[
12780								dillonkearns$elm_markdown$Whitespace$space,
12781								elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
12782							]))),
12783				elm$parser$Parser$Advanced$oneOf(
12784					_List_fromArray(
12785						[
12786							dillonkearns$elm_markdown$Whitespace$space,
12787							elm$parser$Parser$Advanced$succeed(_Utils_Tuple0)
12788						]))),
12789			dillonkearns$elm_markdown$ThematicBreak$parseThematicBreak),
12790			dillonkearns$elm_markdown$ThematicBreak$parseThematicBreak
12791		]));
12792var elm$core$List$append = F2(
12793	function (xs, ys) {
12794		if (!ys.b) {
12795			return xs;
12796		} else {
12797			return A3(elm$core$List$foldr, elm$core$List$cons, ys, xs);
12798		}
12799	});
12800var elm$core$List$concat = function (lists) {
12801	return A3(elm$core$List$foldr, elm$core$List$append, _List_Nil, lists);
12802};
12803var elm$core$List$concatMap = F2(
12804	function (f, list) {
12805		return elm$core$List$concat(
12806			A2(elm$core$List$map, f, list));
12807	});
12808var elm$core$List$member = F2(
12809	function (x, xs) {
12810		return A2(
12811			elm$core$List$any,
12812			function (a) {
12813				return _Utils_eq(a, x);
12814			},
12815			xs);
12816	});
12817var elm$core$Result$withDefault = F2(
12818	function (def, result) {
12819		if (result.$ === 'Ok') {
12820			var a = result.a;
12821			return a;
12822		} else {
12823			return def;
12824		}
12825	});
12826var elm$core$Tuple$mapSecond = F2(
12827	function (func, _n0) {
12828		var x = _n0.a;
12829		var y = _n0.b;
12830		return _Utils_Tuple2(
12831			x,
12832			func(y));
12833	});
12834var dillonkearns$elm_markdown$Markdown$Parser$childToBlocks = F2(
12835	function (node, blocks) {
12836		switch (node.$) {
12837			case 'Element':
12838				var tag = node.a;
12839				var attributes = node.b;
12840				var children = node.c;
12841				var _n99 = dillonkearns$elm_markdown$Markdown$Parser$nodesToBlocks(children);
12842				if (_n99.$ === 'Ok') {
12843					var childrenAsBlocks = _n99.a;
12844					var block = dillonkearns$elm_markdown$Markdown$Block$HtmlBlock(
12845						A3(dillonkearns$elm_markdown$Markdown$Block$HtmlElement, tag, attributes, childrenAsBlocks));
12846					return elm$core$Result$Ok(
12847						A2(elm$core$List$cons, block, blocks));
12848				} else {
12849					var err = _n99.a;
12850					return elm$core$Result$Err(err);
12851				}
12852			case 'Text':
12853				var innerText = node.a;
12854				var _n100 = dillonkearns$elm_markdown$Markdown$Parser$parse(innerText);
12855				if (_n100.$ === 'Ok') {
12856					var value = _n100.a;
12857					return elm$core$Result$Ok(
12858						_Utils_ap(
12859							elm$core$List$reverse(value),
12860							blocks));
12861				} else {
12862					var error = _n100.a;
12863					return elm$core$Result$Err(
12864						elm$parser$Parser$Expecting(
12865							A2(
12866								elm$core$String$join,
12867								'\n',
12868								A2(elm$core$List$map, dillonkearns$elm_markdown$Markdown$Parser$deadEndToString, error))));
12869				}
12870			case 'Comment':
12871				var string = node.a;
12872				return elm$core$Result$Ok(
12873					A2(
12874						elm$core$List$cons,
12875						dillonkearns$elm_markdown$Markdown$Block$HtmlBlock(
12876							dillonkearns$elm_markdown$Markdown$Block$HtmlComment(string)),
12877						blocks));
12878			case 'Cdata':
12879				var string = node.a;
12880				return elm$core$Result$Ok(
12881					A2(
12882						elm$core$List$cons,
12883						dillonkearns$elm_markdown$Markdown$Block$HtmlBlock(

12884							dillonkearns$elm_markdown$Markdown$Block$Cdata(string)),
12885						blocks));
12886			case 'ProcessingInstruction':
12887				var string = node.a;
12888				return elm$core$Result$Ok(
12889					A2(
12890						elm$core$List$cons,
12891						dillonkearns$elm_markdown$Markdown$Block$HtmlBlock(
12892							dillonkearns$elm_markdown$Markdown$Block$ProcessingInstruction(string)),
12893						blocks));
12894			default:
12895				var declarationType = node.a;
12896				var content = node.b;
12897				return elm$core$Result$Ok(
12898					A2(
12899						elm$core$List$cons,
12900						dillonkearns$elm_markdown$Markdown$Block$HtmlBlock(
12901							A2(dillonkearns$elm_markdown$Markdown$Block$HtmlDeclaration, declarationType, content)),
12902						blocks));
12903		}
12904	});
12905var dillonkearns$elm_markdown$Markdown$Parser$completeBlocks = function (state) {
12906	var _n84 = state.rawBlocks;
12907	_n84$5:
12908	while (true) {
12909		if (_n84.b) {
12910			switch (_n84.a.$) {
12911				case 'BlockQuote':
12912					var body2 = _n84.a.a;
12913					var rest = _n84.b;
12914					var _n85 = A2(
12915						elm$parser$Parser$Advanced$run,
12916						dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
12917						body2);
12918					if (_n85.$ === 'Ok') {
12919						var value = _n85.a;
12920						return elm$parser$Parser$Advanced$succeed(
12921							{
12922								linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
12923								rawBlocks: A2(
12924									elm$core$List$cons,
12925									dillonkearns$elm_markdown$Markdown$RawBlock$ParsedBlockQuote(value.rawBlocks),
12926									rest)
12927							});
12928					} else {
12929						var error = _n85.a;
12930						return elm$parser$Parser$Advanced$problem(
12931							elm$parser$Parser$Problem(
12932								dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(error)));
12933					}
12934				case 'UnorderedListBlock':
12935					var _n86 = _n84.a;
12936					var tight = _n86.a;
12937					var intended = _n86.b;
12938					var closeListItems = _n86.c;
12939					var openListItem = _n86.d;
12940					var rest = _n84.b;
12941					var _n87 = A2(
12942						elm$parser$Parser$Advanced$run,
12943						dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
12944						openListItem.body);
12945					if (_n87.$ === 'Ok') {
12946						var value = _n87.a;
12947						var tight2 = A2(elm$core$List$member, dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine, value.rawBlocks) ? false : tight;
12948						return elm$parser$Parser$Advanced$succeed(
12949							{
12950								linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
12951								rawBlocks: A2(
12952									elm$core$List$cons,
12953									A4(
12954										dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
12955										tight2,
12956										intended,
12957										A2(
12958											elm$core$List$cons,
12959											{body: value.rawBlocks, task: openListItem.task},
12960											closeListItems),
12961										openListItem),
12962									rest)
12963							});
12964					} else {
12965						var e = _n87.a;
12966						return elm$parser$Parser$Advanced$problem(
12967							elm$parser$Parser$Problem(
12968								dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
12969					}
12970				case 'OrderedListBlock':
12971					var _n92 = _n84.a;
12972					var tight = _n92.a;
12973					var intended = _n92.b;
12974					var marker = _n92.c;
12975					var order = _n92.d;
12976					var closeListItems = _n92.e;
12977					var openListItem = _n92.f;
12978					var rest = _n84.b;
12979					var _n93 = A2(
12980						elm$parser$Parser$Advanced$run,
12981						dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
12982						openListItem);
12983					if (_n93.$ === 'Ok') {
12984						var value = _n93.a;
12985						var tight2 = A2(elm$core$List$member, dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine, value.rawBlocks) ? false : tight;
12986						return elm$parser$Parser$Advanced$succeed(
12987							{
12988								linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
12989								rawBlocks: A2(
12990									elm$core$List$cons,
12991									A6(
12992										dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock,
12993										tight2,
12994										intended,
12995										marker,
12996										order,
12997										A2(elm$core$List$cons, value.rawBlocks, closeListItems),
12998										openListItem),
12999									rest)
13000							});
13001					} else {
13002						var e = _n93.a;
13003						return elm$parser$Parser$Advanced$problem(
13004							elm$parser$Parser$Problem(
13005								dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13006					}
13007				case 'BlankLine':
13008					if (_n84.b.b) {
13009						switch (_n84.b.a.$) {
13010							case 'UnorderedListBlock':
13011								var _n88 = _n84.a;
13012								var _n89 = _n84.b;
13013								var _n90 = _n89.a;
13014								var tight = _n90.a;
13015								var intended = _n90.b;
13016								var closeListItems = _n90.c;
13017								var openListItem = _n90.d;
13018								var rest = _n89.b;
13019								var _n91 = A2(
13020									elm$parser$Parser$Advanced$run,
13021									dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13022									openListItem.body);
13023								if (_n91.$ === 'Ok') {
13024									var value = _n91.a;
13025									var tight2 = A2(elm$core$List$member, dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine, value.rawBlocks) ? false : tight;
13026									return elm$parser$Parser$Advanced$succeed(
13027										{
13028											linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13029											rawBlocks: A2(
13030												elm$core$List$cons,
13031												A4(
13032													dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
13033													tight2,
13034													intended,
13035													A2(
13036														elm$core$List$cons,
13037														{body: value.rawBlocks, task: openListItem.task},
13038														closeListItems),
13039													openListItem),

13040												rest)
13041										});
13042								} else {
13043									var e = _n91.a;
13044									return elm$parser$Parser$Advanced$problem(
13045										elm$parser$Parser$Problem(
13046											dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13047								}
13048							case 'OrderedListBlock':
13049								var _n94 = _n84.a;
13050								var _n95 = _n84.b;
13051								var _n96 = _n95.a;
13052								var tight = _n96.a;
13053								var intended = _n96.b;
13054								var marker = _n96.c;
13055								var order = _n96.d;
13056								var closeListItems = _n96.e;
13057								var openListItem = _n96.f;
13058								var rest = _n95.b;
13059								var _n97 = A2(
13060									elm$parser$Parser$Advanced$run,
13061									dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13062									openListItem);
13063								if (_n97.$ === 'Ok') {
13064									var value = _n97.a;
13065									var tight2 = A2(elm$core$List$member, dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine, value.rawBlocks) ? false : tight;
13066									return elm$parser$Parser$Advanced$succeed(
13067										{
13068											linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13069											rawBlocks: A2(
13070												elm$core$List$cons,
13071												A6(
13072													dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock,
13073													tight2,
13074													intended,
13075													marker,
13076													order,
13077													A2(elm$core$List$cons, value.rawBlocks, closeListItems),
13078													openListItem),
13079												rest)
13080										});
13081								} else {
13082									var e = _n97.a;
13083									return elm$parser$Parser$Advanced$problem(
13084										elm$parser$Parser$Problem(
13085											dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13086								}
13087							default:
13088								break _n84$5;
13089						}
13090					} else {
13091						break _n84$5;
13092					}
13093				default:
13094					break _n84$5;
13095			}
13096		} else {
13097			break _n84$5;
13098		}
13099	}
13100	return elm$parser$Parser$Advanced$succeed(state);
13101};
13102var dillonkearns$elm_markdown$Markdown$Parser$completeOrMergeBlocks = F2(
13103	function (state, newRawBlock) {
13104		var _n41 = _Utils_Tuple2(newRawBlock, state.rawBlocks);
13105		_n41$13:
13106		while (true) {
13107			if (_n41.b.b) {
13108				switch (_n41.b.a.$) {
13109					case 'CodeBlock':
13110						if (_n41.a.$ === 'CodeBlock') {
13111							var block1 = _n41.a.a;
13112							var _n42 = _n41.b;
13113							var block2 = _n42.a.a;
13114							var rest = _n42.b;
13115							return elm$parser$Parser$Advanced$succeed(
13116								{
13117									linkReferenceDefinitions: state.linkReferenceDefinitions,
13118									rawBlocks: A2(
13119										elm$core$List$cons,
13120										dillonkearns$elm_markdown$Markdown$RawBlock$CodeBlock(
13121											{
13122												body: A2(dillonkearns$elm_markdown$Markdown$Parser$joinStringsPreserveAll, block2.body, block1.body),
13123												language: elm$core$Maybe$Nothing
13124											}),
13125										rest)
13126								});
13127						} else {
13128							break _n41$13;
13129						}
13130					case 'IndentedCodeBlock':
13131						switch (_n41.a.$) {
13132							case 'IndentedCodeBlock':
13133								var block1 = _n41.a.a;
13134								var _n43 = _n41.b;
13135								var block2 = _n43.a.a;
13136								var rest = _n43.b;
13137								return elm$parser$Parser$Advanced$succeed(
13138									{
13139										linkReferenceDefinitions: state.linkReferenceDefinitions,
13140										rawBlocks: A2(
13141											elm$core$List$cons,
13142											dillonkearns$elm_markdown$Markdown$RawBlock$IndentedCodeBlock(
13143												A2(dillonkearns$elm_markdown$Markdown$Parser$joinStringsPreserveAll, block2, block1)),
13144											rest)
13145									});
13146							case 'BlankLine':
13147								var _n44 = _n41.a;
13148								var _n45 = _n41.b;
13149								var block = _n45.a.a;
13150								var rest = _n45.b;
13151								return elm$parser$Parser$Advanced$succeed(
13152									{
13153										linkReferenceDefinitions: state.linkReferenceDefinitions,
13154										rawBlocks: A2(
13155											elm$core$List$cons,
13156											dillonkearns$elm_markdown$Markdown$RawBlock$IndentedCodeBlock(
13157												A2(dillonkearns$elm_markdown$Markdown$Parser$joinStringsPreserveAll, block, '\n')),
13158											rest)
13159									});
13160							default:
13161								break _n41$13;
13162						}
13163					case 'BlockQuote':
13164						var _n46 = _n41.b;
13165						var body2 = _n46.a.a;
13166						var rest = _n46.b;
13167						switch (newRawBlock.$) {
13168							case 'BlockQuote':
13169								var body1 = newRawBlock.a;
13170								return elm$parser$Parser$Advanced$succeed(
13171									{
13172										linkReferenceDefinitions: state.linkReferenceDefinitions,
13173										rawBlocks: A2(
13174											elm$core$List$cons,
13175											dillonkearns$elm_markdown$Markdown$RawBlock$BlockQuote(
13176												A2(dillonkearns$elm_markdown$Markdown$Parser$joinStringsPreserveAll, body2, body1)),
13177											rest)
13178									});
13179							case 'OpenBlockOrParagraph':
13180								var body1 = newRawBlock.a.a;
13181								return elm$parser$Parser$Advanced$succeed(
13182									{
13183										linkReferenceDefinitions: state.linkReferenceDefinitions,
13184										rawBlocks: A2(
13185											elm$core$List$cons,
13186											dillonkearns$elm_markdown$Markdown$RawBlock$BlockQuote(
13187												A3(dillonkearns$elm_markdown$Markdown$Parser$joinRawStringsWith, '\n', body2, body1)),
13188											rest)
13189									});
13190							default:
13191								var _n48 = A2(
13192									elm$parser$Parser$Advanced$run,
13193									dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13194									body2);
13195								if (_n48.$ === 'Ok') {
13196									var value = _n48.a;
13197									return elm$parser$Parser$Advanced$succeed(
13198										{
13199											linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13200											rawBlocks: A2(
13201												elm$core$List$cons,
13202												newRawBlock,

13203												A2(
13204													elm$core$List$cons,
13205													dillonkearns$elm_markdown$Markdown$RawBlock$ParsedBlockQuote(value.rawBlocks),
13206													rest))
13207										});
13208								} else {
13209									var e = _n48.a;
13210									return elm$parser$Parser$Advanced$problem(
13211										elm$parser$Parser$Problem(
13212											dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13213								}
13214						}
13215					case 'UnorderedListBlock':
13216						var _n49 = _n41.b;
13217						var _n50 = _n49.a;
13218						var tight = _n50.a;
13219						var intended1 = _n50.b;
13220						var closeListItems2 = _n50.c;
13221						var openListItem2 = _n50.d;
13222						var rest = _n49.b;
13223						switch (newRawBlock.$) {
13224							case 'UnorderedListBlock':
13225								var intended2 = newRawBlock.b;
13226								var closeListItems1 = newRawBlock.c;
13227								var openListItem1 = newRawBlock.d;
13228								if (_Utils_eq(openListItem2.marker, openListItem1.marker)) {
13229									var _n52 = A2(
13230										elm$parser$Parser$Advanced$run,
13231										dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13232										openListItem2.body);
13233									if (_n52.$ === 'Ok') {
13234										var value = _n52.a;
13235										return A2(elm$core$List$member, dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine, value.rawBlocks) ? elm$parser$Parser$Advanced$succeed(
13236											{
13237												linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13238												rawBlocks: A2(
13239													elm$core$List$cons,
13240													A4(
13241														dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
13242														false,
13243														intended2,
13244														A2(
13245															elm$core$List$cons,
13246															{body: value.rawBlocks, task: openListItem2.task},
13247															closeListItems2),
13248														openListItem1),
13249													rest)
13250											}) : elm$parser$Parser$Advanced$succeed(
13251											{
13252												linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13253												rawBlocks: A2(
13254													elm$core$List$cons,
13255													A4(
13256														dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
13257														tight,
13258														intended2,
13259														A2(
13260															elm$core$List$cons,
13261															{body: value.rawBlocks, task: openListItem2.task},
13262															closeListItems2),
13263														openListItem1),
13264													rest)
13265											});
13266									} else {
13267										var e = _n52.a;
13268										return elm$parser$Parser$Advanced$problem(
13269											elm$parser$Parser$Problem(
13270												dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13271									}
13272								} else {
13273									var _n53 = A2(
13274										elm$parser$Parser$Advanced$run,
13275										dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13276										openListItem2.body);
13277									if (_n53.$ === 'Ok') {
13278										var value = _n53.a;
13279										var tight2 = A2(elm$core$List$member, dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine, value.rawBlocks) ? false : tight;
13280										return elm$parser$Parser$Advanced$succeed(
13281											{
13282												linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13283												rawBlocks: A2(
13284													elm$core$List$cons,
13285													newRawBlock,
13286													A2(
13287														elm$core$List$cons,
13288														A4(
13289															dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
13290															tight2,
13291															intended1,
13292															A2(
13293																elm$core$List$cons,
13294																{body: value.rawBlocks, task: openListItem2.task},
13295																closeListItems2),
13296															openListItem1),
13297														rest))
13298											});
13299									} else {
13300										var e = _n53.a;
13301										return elm$parser$Parser$Advanced$problem(
13302											elm$parser$Parser$Problem(
13303												dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13304									}
13305								}
13306							case 'OpenBlockOrParagraph':
13307								var body1 = newRawBlock.a.a;
13308								return elm$parser$Parser$Advanced$succeed(
13309									{
13310										linkReferenceDefinitions: state.linkReferenceDefinitions,
13311										rawBlocks: A2(
13312											elm$core$List$cons,
13313											A4(
13314												dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
13315												tight,
13316												intended1,
13317												closeListItems2,
13318												_Utils_update(
13319													openListItem2,
13320													{
13321														body: A3(dillonkearns$elm_markdown$Markdown$Parser$joinRawStringsWith, '\n', openListItem2.body, body1)
13322													})),
13323											rest)
13324									});
13325							default:
13326								var _n54 = A2(
13327									elm$parser$Parser$Advanced$run,
13328									dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13329									openListItem2.body);
13330								if (_n54.$ === 'Ok') {
13331									var value = _n54.a;
13332									var tight2 = A2(elm$core$List$member, dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine, value.rawBlocks) ? false : tight;
13333									return elm$parser$Parser$Advanced$succeed(
13334										{
13335											linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13336											rawBlocks: A2(
13337												elm$core$List$cons,
13338												newRawBlock,

13339												A2(
13340													elm$core$List$cons,
13341													A4(
13342														dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
13343														tight2,
13344														intended1,
13345														A2(
13346															elm$core$List$cons,
13347															{body: value.rawBlocks, task: openListItem2.task},
13348															closeListItems2),
13349														openListItem2),
13350													rest))
13351										});
13352								} else {
13353									var e = _n54.a;
13354									return elm$parser$Parser$Advanced$problem(
13355										elm$parser$Parser$Problem(
13356											dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13357								}
13358						}
13359					case 'OrderedListBlock':
13360						var _n55 = _n41.b;
13361						var _n56 = _n55.a;
13362						var tight = _n56.a;
13363						var intended1 = _n56.b;
13364						var marker = _n56.c;
13365						var order = _n56.d;
13366						var closeListItems2 = _n56.e;
13367						var openListItem2 = _n56.f;
13368						var rest = _n55.b;
13369						switch (newRawBlock.$) {
13370							case 'OrderedListBlock':
13371								var intended2 = newRawBlock.b;
13372								var marker2 = newRawBlock.c;
13373								var closeListItems1 = newRawBlock.e;
13374								var openListItem1 = newRawBlock.f;
13375								if (_Utils_eq(marker, marker2)) {
13376									var _n58 = A2(
13377										elm$parser$Parser$Advanced$run,
13378										dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13379										openListItem2);
13380									if (_n58.$ === 'Ok') {
13381										var value = _n58.a;
13382										var tight2 = A2(elm$core$List$member, dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine, value.rawBlocks) ? false : tight;
13383										return elm$parser$Parser$Advanced$succeed(
13384											{
13385												linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13386												rawBlocks: A2(
13387													elm$core$List$cons,
13388													A6(
13389														dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock,
13390														tight2,
13391														intended2,
13392														marker,
13393														order,
13394														A2(elm$core$List$cons, value.rawBlocks, closeListItems2),
13395														openListItem1),
13396													rest)
13397											});
13398									} else {
13399										var e = _n58.a;
13400										return elm$parser$Parser$Advanced$problem(
13401											elm$parser$Parser$Problem(
13402												dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13403									}
13404								} else {
13405									var _n59 = A2(
13406										elm$parser$Parser$Advanced$run,
13407										dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13408										openListItem2);
13409									if (_n59.$ === 'Ok') {
13410										var value = _n59.a;
13411										var tight2 = A2(elm$core$List$member, dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine, value.rawBlocks) ? false : tight;
13412										return elm$parser$Parser$Advanced$succeed(
13413											{
13414												linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13415												rawBlocks: A2(
13416													elm$core$List$cons,
13417													newRawBlock,
13418													A2(
13419														elm$core$List$cons,
13420														A6(
13421															dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock,
13422															tight2,
13423															intended1,
13424															marker,
13425															order,
13426															A2(elm$core$List$cons, value.rawBlocks, closeListItems2),
13427															openListItem2),
13428														rest))
13429											});
13430									} else {
13431										var e = _n59.a;
13432										return elm$parser$Parser$Advanced$problem(
13433											elm$parser$Parser$Problem(
13434												dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13435									}
13436								}
13437							case 'OpenBlockOrParagraph':
13438								var body1 = newRawBlock.a.a;
13439								return elm$parser$Parser$Advanced$succeed(
13440									{
13441										linkReferenceDefinitions: state.linkReferenceDefinitions,
13442										rawBlocks: A2(
13443											elm$core$List$cons,
13444											A6(dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock, tight, intended1, marker, order, closeListItems2, openListItem2 + ('\n' + body1)),
13445											rest)
13446									});
13447							default:
13448								var _n60 = A2(
13449									elm$parser$Parser$Advanced$run,
13450									dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13451									openListItem2);
13452								if (_n60.$ === 'Ok') {
13453									var value = _n60.a;
13454									var tight2 = A2(elm$core$List$member, dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine, value.rawBlocks) ? false : tight;
13455									return elm$parser$Parser$Advanced$succeed(
13456										{
13457											linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13458											rawBlocks: A2(
13459												elm$core$List$cons,
13460												newRawBlock,

13461												A2(
13462													elm$core$List$cons,
13463													A6(
13464														dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock,
13465														tight2,
13466														intended1,
13467														marker,
13468														order,
13469														A2(elm$core$List$cons, value.rawBlocks, closeListItems2),
13470														openListItem2),
13471													rest))
13472										});
13473								} else {
13474									var e = _n60.a;
13475									return elm$parser$Parser$Advanced$problem(
13476										elm$parser$Parser$Problem(
13477											dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13478								}
13479						}
13480					case 'OpenBlockOrParagraph':
13481						switch (_n41.a.$) {
13482							case 'OpenBlockOrParagraph':
13483								var body1 = _n41.a.a.a;
13484								var _n61 = _n41.b;
13485								var body2 = _n61.a.a.a;
13486								var rest = _n61.b;
13487								return elm$parser$Parser$Advanced$succeed(
13488									{
13489										linkReferenceDefinitions: state.linkReferenceDefinitions,
13490										rawBlocks: A2(
13491											elm$core$List$cons,
13492											dillonkearns$elm_markdown$Markdown$RawBlock$OpenBlockOrParagraph(
13493												dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines(
13494													A3(dillonkearns$elm_markdown$Markdown$Parser$joinRawStringsWith, '\n', body2, body1))),
13495											rest)
13496									});
13497							case 'SetextLine':
13498								if (_n41.a.a.$ === 'LevelOne') {
13499									var _n62 = _n41.a;
13500									var _n63 = _n62.a;
13501									var _n64 = _n41.b;
13502									var unparsedInlines = _n64.a.a;
13503									var rest = _n64.b;
13504									return elm$parser$Parser$Advanced$succeed(
13505										{
13506											linkReferenceDefinitions: state.linkReferenceDefinitions,
13507											rawBlocks: A2(
13508												elm$core$List$cons,
13509												A2(dillonkearns$elm_markdown$Markdown$RawBlock$Heading, 1, unparsedInlines),
13510												rest)
13511										});
13512								} else {
13513									var _n65 = _n41.a;
13514									var _n66 = _n65.a;
13515									var _n67 = _n41.b;
13516									var unparsedInlines = _n67.a.a;
13517									var rest = _n67.b;
13518									return elm$parser$Parser$Advanced$succeed(
13519										{
13520											linkReferenceDefinitions: state.linkReferenceDefinitions,
13521											rawBlocks: A2(
13522												elm$core$List$cons,
13523												A2(dillonkearns$elm_markdown$Markdown$RawBlock$Heading, 2, unparsedInlines),
13524												rest)
13525										});
13526								}
13527							case 'TableDelimiter':
13528								var _n68 = _n41.a.a;
13529								var text = _n68.a;
13530								var alignments = _n68.b;
13531								var _n69 = _n41.b;
13532								var rawHeaders = _n69.a.a.a;
13533								var rest = _n69.b;
13534								var _n70 = A2(
13535									dillonkearns$elm_markdown$Markdown$TableParser$parseHeader,
13536									A2(dillonkearns$elm_markdown$Markdown$Table$TableDelimiterRow, text, alignments),
13537									rawHeaders);
13538								if (_n70.$ === 'Ok') {
13539									var headers = _n70.a.a;
13540									return elm$parser$Parser$Advanced$succeed(
13541										{
13542											linkReferenceDefinitions: state.linkReferenceDefinitions,
13543											rawBlocks: A2(
13544												elm$core$List$cons,
13545												dillonkearns$elm_markdown$Markdown$RawBlock$Table(
13546													A2(dillonkearns$elm_markdown$Markdown$Table$Table, headers, _List_Nil)),
13547												rest)
13548										});
13549								} else {
13550									return elm$parser$Parser$Advanced$succeed(
13551										{
13552											linkReferenceDefinitions: state.linkReferenceDefinitions,
13553											rawBlocks: A2(
13554												elm$core$List$cons,
13555												dillonkearns$elm_markdown$Markdown$RawBlock$OpenBlockOrParagraph(
13556													dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines(
13557														A3(dillonkearns$elm_markdown$Markdown$Parser$joinRawStringsWith, '\n', rawHeaders, text.raw))),
13558												rest)
13559										});
13560								}
13561							default:
13562								break _n41$13;
13563						}
13564					case 'Table':
13565						if (_n41.a.$ === 'Table') {
13566							var updatedTable = _n41.a.a;
13567							var _n71 = _n41.b;
13568							var rest = _n71.b;
13569							return elm$parser$Parser$Advanced$succeed(
13570								{
13571									linkReferenceDefinitions: state.linkReferenceDefinitions,
13572									rawBlocks: A2(
13573										elm$core$List$cons,
13574										dillonkearns$elm_markdown$Markdown$RawBlock$Table(updatedTable),
13575										rest)
13576								});
13577						} else {
13578							break _n41$13;
13579						}
13580					case 'BlankLine':
13581						if (_n41.b.b.b) {
13582							switch (_n41.b.b.a.$) {
13583								case 'OrderedListBlock':
13584									var _n72 = _n41.b;
13585									var _n73 = _n72.a;
13586									var _n74 = _n72.b;
13587									var _n75 = _n74.a;
13588									var tight = _n75.a;
13589									var intended1 = _n75.b;
13590									var marker = _n75.c;
13591									var order = _n75.d;
13592									var closeListItems2 = _n75.e;
13593									var openListItem2 = _n75.f;
13594									var rest = _n74.b;
13595									var _n76 = A2(
13596										elm$parser$Parser$Advanced$run,
13597										dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13598										openListItem2);
13599									if (_n76.$ === 'Ok') {
13600										var value = _n76.a;
13601										if (newRawBlock.$ === 'OrderedListBlock') {
13602											var intended2 = newRawBlock.b;
13603											var openListItem = newRawBlock.f;

13604											return elm$parser$Parser$Advanced$succeed(
13605												{
13606													linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13607													rawBlocks: A2(
13608														elm$core$List$cons,
13609														A6(
13610															dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock,
13611															false,
13612															intended2,
13613															marker,
13614															order,
13615															A2(elm$core$List$cons, value.rawBlocks, closeListItems2),
13616															openListItem),
13617														rest)
13618												});
13619										} else {
13620											return elm$parser$Parser$Advanced$succeed(
13621												{
13622													linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13623													rawBlocks: A2(
13624														elm$core$List$cons,
13625														newRawBlock,
13626														A2(
13627															elm$core$List$cons,
13628															dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine,
13629															A2(
13630																elm$core$List$cons,
13631																A6(
13632																	dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock,
13633																	tight,
13634																	intended1,
13635																	marker,
13636																	order,
13637																	A2(elm$core$List$cons, value.rawBlocks, closeListItems2),
13638																	openListItem2),
13639																rest)))
13640												});
13641										}
13642									} else {
13643										var e = _n76.a;
13644										return elm$parser$Parser$Advanced$problem(
13645											elm$parser$Parser$Problem(
13646												dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13647									}
13648								case 'UnorderedListBlock':
13649									var _n78 = _n41.b;
13650									var _n79 = _n78.a;
13651									var _n80 = _n78.b;
13652									var _n81 = _n80.a;
13653									var tight = _n81.a;
13654									var intended1 = _n81.b;
13655									var closeListItems2 = _n81.c;
13656									var openListItem2 = _n81.d;
13657									var rest = _n80.b;
13658									var _n82 = A2(
13659										elm$parser$Parser$Advanced$run,
13660										dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13661										openListItem2.body);
13662									if (_n82.$ === 'Ok') {
13663										var value = _n82.a;
13664										if (newRawBlock.$ === 'UnorderedListBlock') {
13665											var openListItem = newRawBlock.d;
13666											return elm$parser$Parser$Advanced$succeed(
13667												{
13668													linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13669													rawBlocks: A2(
13670														elm$core$List$cons,
13671														A4(
13672															dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
13673															false,
13674															intended1,
13675															A2(
13676																elm$core$List$cons,
13677																{body: value.rawBlocks, task: openListItem2.task},
13678																closeListItems2),
13679															openListItem),
13680														rest)
13681												});
13682										} else {
13683											return elm$parser$Parser$Advanced$succeed(
13684												{
13685													linkReferenceDefinitions: _Utils_ap(state.linkReferenceDefinitions, value.linkReferenceDefinitions),
13686													rawBlocks: A2(
13687														elm$core$List$cons,
13688														newRawBlock,
13689														A2(
13690															elm$core$List$cons,
13691															dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine,
13692															A2(
13693																elm$core$List$cons,
13694																A4(
13695																	dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
13696																	tight,
13697																	intended1,
13698																	A2(
13699																		elm$core$List$cons,
13700																		{body: value.rawBlocks, task: openListItem2.task},
13701																		closeListItems2),
13702																	openListItem2),
13703																rest)))
13704												});
13705										}
13706									} else {
13707										var e = _n82.a;
13708										return elm$parser$Parser$Advanced$problem(
13709											elm$parser$Parser$Problem(
13710												dillonkearns$elm_markdown$Markdown$Parser$deadEndsToString(e)));
13711									}
13712								default:
13713									break _n41$13;
13714							}
13715						} else {
13716							break _n41$13;
13717						}
13718					default:
13719						break _n41$13;
13720				}
13721			} else {
13722				break _n41$13;
13723			}
13724		}
13725		return elm$parser$Parser$Advanced$succeed(
13726			{
13727				linkReferenceDefinitions: state.linkReferenceDefinitions,
13728				rawBlocks: A2(elm$core$List$cons, newRawBlock, state.rawBlocks)
13729			});
13730	});
13731var dillonkearns$elm_markdown$Markdown$Parser$inlineParseHelper = F2(
13732	function (referencesDict, _n36) {
13733		var unparsedInlines = _n36.a;
13734		var mappedReferencesDict = elm$core$Dict$fromList(
13735			A2(
13736				elm$core$List$map,
13737				elm$core$Tuple$mapSecond(
13738					function (_n37) {
13739						var destination = _n37.destination;
13740						var title = _n37.title;
13741						return _Utils_Tuple2(destination, title);
13742					}),
13743				referencesDict));
13744		return A2(
13745			elm$core$List$map,
13746			dillonkearns$elm_markdown$Markdown$Parser$mapInline,
13747			A2(dillonkearns$elm_markdown$Markdown$InlineParser$parse, mappedReferencesDict, unparsedInlines));
13748	});
13749var dillonkearns$elm_markdown$Markdown$Parser$mapInline = function (inline) {
13750	switch (inline.$) {
13751		case 'Text':
13752			var string = inline.a;
13753			return dillonkearns$elm_markdown$Markdown$Block$Text(string);
13754		case 'HardLineBreak':
13755			return dillonkearns$elm_markdown$Markdown$Block$HardLineBreak;
13756		case 'CodeInline':
13757			var string = inline.a;
13758			return dillonkearns$elm_markdown$Markdown$Block$CodeSpan(string);
13759		case 'Link':
13760			var string = inline.a;
13761			var maybeString = inline.b;
13762			var inlines = inline.c;
13763			return A3(
13764				dillonkearns$elm_markdown$Markdown$Block$Link,

13765				string,
13766				maybeString,
13767				A2(elm$core$List$map, dillonkearns$elm_markdown$Markdown$Parser$mapInline, inlines));
13768		case 'Image':
13769			var string = inline.a;
13770			var maybeString = inline.b;
13771			var inlines = inline.c;
13772			return A3(
13773				dillonkearns$elm_markdown$Markdown$Block$Image,
13774				string,
13775				maybeString,
13776				A2(elm$core$List$map, dillonkearns$elm_markdown$Markdown$Parser$mapInline, inlines));
13777		case 'HtmlInline':
13778			var node = inline.a;
13779			return dillonkearns$elm_markdown$Markdown$Block$HtmlInline(
13780				dillonkearns$elm_markdown$Markdown$Parser$nodeToRawBlock(node));
13781		case 'Emphasis':
13782			var level = inline.a;
13783			var inlines = inline.b;
13784			switch (level) {
13785				case 1:
13786					return dillonkearns$elm_markdown$Markdown$Block$Emphasis(
13787						A2(elm$core$List$map, dillonkearns$elm_markdown$Markdown$Parser$mapInline, inlines));
13788				case 2:
13789					return dillonkearns$elm_markdown$Markdown$Block$Strong(
13790						A2(elm$core$List$map, dillonkearns$elm_markdown$Markdown$Parser$mapInline, inlines));
13791				default:
13792					return dillonkearns$elm_markdown$Markdown$Helpers$isEven(level) ? dillonkearns$elm_markdown$Markdown$Block$Strong(
13793						_List_fromArray(
13794							[
13795								dillonkearns$elm_markdown$Markdown$Parser$mapInline(
13796								A2(dillonkearns$elm_markdown$Markdown$Inline$Emphasis, level - 2, inlines))
13797							])) : dillonkearns$elm_markdown$Markdown$Block$Emphasis(
13798						_List_fromArray(
13799							[
13800								dillonkearns$elm_markdown$Markdown$Parser$mapInline(
13801								A2(dillonkearns$elm_markdown$Markdown$Inline$Emphasis, level - 1, inlines))
13802							]));
13803			}
13804		default:
13805			var inlines = inline.a;
13806			return dillonkearns$elm_markdown$Markdown$Block$Strikethrough(
13807				A2(elm$core$List$map, dillonkearns$elm_markdown$Markdown$Parser$mapInline, inlines));
13808	}
13809};
13810var dillonkearns$elm_markdown$Markdown$Parser$nodeToRawBlock = function (node) {
13811	switch (node.$) {
13812		case 'Text':
13813			var innerText = node.a;
13814			return dillonkearns$elm_markdown$Markdown$Block$HtmlComment('TODO this never happens, but use types to drop this case.');
13815		case 'Element':
13816			var tag = node.a;
13817			var attributes = node.b;
13818			var children = node.c;
13819			var parseChild = function (child) {
13820				if (child.$ === 'Text') {
13821					var text = child.a;
13822					return dillonkearns$elm_markdown$Markdown$Parser$textNodeToBlocks(text);
13823				} else {
13824					return _List_fromArray(
13825						[
13826							dillonkearns$elm_markdown$Markdown$Block$HtmlBlock(
13827							dillonkearns$elm_markdown$Markdown$Parser$nodeToRawBlock(child))
13828						]);
13829				}
13830			};
13831			return A3(
13832				dillonkearns$elm_markdown$Markdown$Block$HtmlElement,
13833				tag,
13834				attributes,
13835				A2(elm$core$List$concatMap, parseChild, children));
13836		case 'Comment':
13837			var string = node.a;
13838			return dillonkearns$elm_markdown$Markdown$Block$HtmlComment(string);
13839		case 'Cdata':
13840			var string = node.a;
13841			return dillonkearns$elm_markdown$Markdown$Block$Cdata(string);
13842		case 'ProcessingInstruction':
13843			var string = node.a;
13844			return dillonkearns$elm_markdown$Markdown$Block$ProcessingInstruction(string);
13845		default:
13846			var declarationType = node.a;
13847			var content = node.b;
13848			return A2(dillonkearns$elm_markdown$Markdown$Block$HtmlDeclaration, declarationType, content);
13849	}
13850};
13851var dillonkearns$elm_markdown$Markdown$Parser$nodesToBlocks = function (children) {
13852	return A2(dillonkearns$elm_markdown$Markdown$Parser$nodesToBlocksHelp, children, _List_Nil);
13853};
13854var dillonkearns$elm_markdown$Markdown$Parser$nodesToBlocksHelp = F2(
13855	function (remaining, soFar) {
13856		nodesToBlocksHelp:
13857		while (true) {
13858			if (remaining.b) {
13859				var node = remaining.a;
13860				var rest = remaining.b;
13861				var _n31 = A2(dillonkearns$elm_markdown$Markdown$Parser$childToBlocks, node, soFar);
13862				if (_n31.$ === 'Ok') {
13863					var newSoFar = _n31.a;
13864					var $temp$remaining = rest,
13865						$temp$soFar = newSoFar;
13866					remaining = $temp$remaining;
13867					soFar = $temp$soFar;
13868					continue nodesToBlocksHelp;
13869				} else {
13870					var e = _n31.a;
13871					return elm$core$Result$Err(e);
13872				}
13873			} else {
13874				return elm$core$Result$Ok(
13875					elm$core$List$reverse(soFar));
13876			}
13877		}
13878	});
13879var dillonkearns$elm_markdown$Markdown$Parser$parse = function (input) {
13880	var _n27 = A2(
13881		elm$parser$Parser$Advanced$run,
13882		A2(
13883			elm$parser$Parser$Advanced$ignorer,
13884			dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser(),
13885			dillonkearns$elm_markdown$Helpers$endOfFile),
13886		input);
13887	if (_n27.$ === 'Err') {
13888		var e = _n27.a;
13889		return elm$core$Result$Err(e);
13890	} else {
13891		var v = _n27.a;
13892		var _n28 = dillonkearns$elm_markdown$Markdown$Parser$parseAllInlines(v);
13893		if (_n28.$ === 'Err') {
13894			var e = _n28.a;
13895			return A2(
13896				elm$parser$Parser$Advanced$run,
13897				elm$parser$Parser$Advanced$problem(e),
13898				'');
13899		} else {
13900			var blocks = _n28.a;
13901			var isNotEmptyParagraph = function (block) {
13902				if ((block.$ === 'Paragraph') && (!block.a.b)) {
13903					return false;

13904				} else {
13905					return true;
13906				}
13907			};
13908			return elm$core$Result$Ok(
13909				A2(elm$core$List$filter, isNotEmptyParagraph, blocks));
13910		}
13911	}
13912};
13913var dillonkearns$elm_markdown$Markdown$Parser$parseAllInlines = function (state) {
13914	return A3(dillonkearns$elm_markdown$Markdown$Parser$parseAllInlinesHelp, state, state.rawBlocks, _List_Nil);
13915};
13916var dillonkearns$elm_markdown$Markdown$Parser$parseAllInlinesHelp = F3(
13917	function (state, rawBlocks, parsedBlocks) {
13918		parseAllInlinesHelp:
13919		while (true) {
13920			if (rawBlocks.b) {
13921				var rawBlock = rawBlocks.a;
13922				var rest = rawBlocks.b;
13923				var _n26 = A2(dillonkearns$elm_markdown$Markdown$Parser$parseInlines, state.linkReferenceDefinitions, rawBlock);
13924				switch (_n26.$) {
13925					case 'ParsedBlock':
13926						var newParsedBlock = _n26.a;
13927						var $temp$state = state,
13928							$temp$rawBlocks = rest,
13929							$temp$parsedBlocks = A2(elm$core$List$cons, newParsedBlock, parsedBlocks);
13930						state = $temp$state;
13931						rawBlocks = $temp$rawBlocks;
13932						parsedBlocks = $temp$parsedBlocks;
13933						continue parseAllInlinesHelp;
13934					case 'EmptyBlock':
13935						var $temp$state = state,
13936							$temp$rawBlocks = rest,
13937							$temp$parsedBlocks = parsedBlocks;
13938						state = $temp$state;
13939						rawBlocks = $temp$rawBlocks;
13940						parsedBlocks = $temp$parsedBlocks;
13941						continue parseAllInlinesHelp;
13942					default:
13943						var e = _n26.a;
13944						return elm$core$Result$Err(e);
13945				}
13946			} else {
13947				return elm$core$Result$Ok(parsedBlocks);
13948			}
13949		}
13950	});
13951var dillonkearns$elm_markdown$Markdown$Parser$parseHeaderInlines = F2(
13952	function (linkReferences, header) {
13953		return A2(
13954			elm$core$List$map,
13955			function (_n24) {
13956				var label = _n24.label;
13957				var alignment = _n24.alignment;
13958				return A3(
13959					dillonkearns$elm_markdown$Markdown$Parser$parseRawInline,
13960					linkReferences,
13961					function (parsedHeaderLabel) {
13962						return {alignment: alignment, label: parsedHeaderLabel};
13963					},
13964					dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines(label));
13965			},
13966			header);
13967	});
13968var dillonkearns$elm_markdown$Markdown$Parser$parseInlines = F2(
13969	function (linkReferences, rawBlock) {
13970		switch (rawBlock.$) {
13971			case 'Heading':
13972				var level = rawBlock.a;
13973				var unparsedInlines = rawBlock.b;
13974				var _n17 = dillonkearns$elm_markdown$Markdown$Parser$toHeading(level);
13975				if (_n17.$ === 'Ok') {
13976					var parsedLevel = _n17.a;
13977					return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(
13978						A2(
13979							dillonkearns$elm_markdown$Markdown$Block$Heading,
13980							parsedLevel,
13981							A2(dillonkearns$elm_markdown$Markdown$Parser$inlineParseHelper, linkReferences, unparsedInlines)));
13982				} else {
13983					var e = _n17.a;
13984					return dillonkearns$elm_markdown$Markdown$Parser$InlineProblem(e);
13985				}
13986			case 'OpenBlockOrParagraph':
13987				var unparsedInlines = rawBlock.a;
13988				return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(
13989					dillonkearns$elm_markdown$Markdown$Block$Paragraph(
13990						A2(dillonkearns$elm_markdown$Markdown$Parser$inlineParseHelper, linkReferences, unparsedInlines)));
13991			case 'Html':
13992				var html = rawBlock.a;
13993				return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(
13994					dillonkearns$elm_markdown$Markdown$Block$HtmlBlock(html));
13995			case 'UnorderedListBlock':
13996				var tight = rawBlock.a;
13997				var intended = rawBlock.b;
13998				var unparsedItems = rawBlock.c;
13999				var parseItem = F2(
14000					function (rawBlockTask, rawBlocks) {
14001						var blocksTask = function () {
14002							if (rawBlockTask.$ === 'Just') {
14003								if (!rawBlockTask.a) {
14004									return dillonkearns$elm_markdown$Markdown$Block$IncompleteTask;
14005								} else {
14006									return dillonkearns$elm_markdown$Markdown$Block$CompletedTask;
14007								}
14008							} else {
14009								return dillonkearns$elm_markdown$Markdown$Block$NoTask;
14010							}
14011						}();
14012						var blocks = function () {
14013							var _n18 = dillonkearns$elm_markdown$Markdown$Parser$parseAllInlines(
14014								{linkReferenceDefinitions: linkReferences, rawBlocks: rawBlocks});
14015							if (_n18.$ === 'Ok') {
14016								var parsedBlocks = _n18.a;
14017								return parsedBlocks;
14018							} else {
14019								var e = _n18.a;
14020								return _List_Nil;
14021							}
14022						}();
14023						return A2(dillonkearns$elm_markdown$Markdown$Block$ListItem, blocksTask, blocks);
14024					});
14025				return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(
14026					A2(
14027						dillonkearns$elm_markdown$Markdown$Block$UnorderedList,
14028						dillonkearns$elm_markdown$Markdown$Parser$isTightBoolToListDisplay(tight),
14029						elm$core$List$reverse(
14030							A2(
14031								elm$core$List$map,
14032								function (item) {
14033									return A2(parseItem, item.task, item.body);
14034								},
14035								unparsedItems))));
14036			case 'OrderedListBlock':
14037				var tight = rawBlock.a;
14038				var startingIndex = rawBlock.d;
14039				var unparsedItems = rawBlock.e;
14040				var parseItem = function (rawBlocks) {
14041					var _n20 = dillonkearns$elm_markdown$Markdown$Parser$parseAllInlines(
14042						{linkReferenceDefinitions: linkReferences, rawBlocks: rawBlocks});
14043					if (_n20.$ === 'Ok') {
14044						var parsedBlocks = _n20.a;
14045						return parsedBlocks;
14046					} else {
14047						var e = _n20.a;
14048						return _List_Nil;
14049					}
14050				};
14051				return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(
14052					A3(
14053						dillonkearns$elm_markdown$Markdown$Block$OrderedList,
14054						dillonkearns$elm_markdown$Markdown$Parser$isTightBoolToListDisplay(tight),
14055						startingIndex,
14056						elm$core$List$reverse(
14057							A2(elm$core$List$map, parseItem, unparsedItems))));
14058			case 'CodeBlock':
14059				var codeBlock = rawBlock.a;
14060				return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(
14061					dillonkearns$elm_markdown$Markdown$Block$CodeBlock(codeBlock));
14062			case 'ThematicBreak':
14063				return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(dillonkearns$elm_markdown$Markdown$Block$ThematicBreak);
14064			case 'BlankLine':
14065				return dillonkearns$elm_markdown$Markdown$Parser$EmptyBlock;
14066			case 'BlockQuote':
14067				var rawBlocks = rawBlock.a;
14068				return dillonkearns$elm_markdown$Markdown$Parser$EmptyBlock;
14069			case 'ParsedBlockQuote':
14070				var rawBlocks = rawBlock.a;
14071				var _n21 = dillonkearns$elm_markdown$Markdown$Parser$parseAllInlines(
14072					{linkReferenceDefinitions: linkReferences, rawBlocks: rawBlocks});
14073				if (_n21.$ === 'Ok') {
14074					var parsedBlocks = _n21.a;
14075					return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(
14076						dillonkearns$elm_markdown$Markdown$Block$BlockQuote(parsedBlocks));
14077				} else {
14078					var e = _n21.a;
14079					return dillonkearns$elm_markdown$Markdown$Parser$InlineProblem(e);
14080				}
14081			case 'IndentedCodeBlock':
14082				var codeBlockBody = rawBlock.a;
14083				return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(
14084					dillonkearns$elm_markdown$Markdown$Block$CodeBlock(
14085						{body: codeBlockBody, language: elm$core$Maybe$Nothing}));
14086			case 'Table':
14087				var _n22 = rawBlock.a;
14088				var header = _n22.a;
14089				var rows = _n22.b;
14090				return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(
14091					A2(
14092						dillonkearns$elm_markdown$Markdown$Block$Table,
14093						A2(dillonkearns$elm_markdown$Markdown$Parser$parseHeaderInlines, linkReferences, header),
14094						A2(dillonkearns$elm_markdown$Markdown$Parser$parseRowInlines, linkReferences, rows)));
14095			case 'TableDelimiter':
14096				var _n23 = rawBlock.a;
14097				var text = _n23.a;
14098				return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(
14099					dillonkearns$elm_markdown$Markdown$Block$Paragraph(
14100						A2(
14101							dillonkearns$elm_markdown$Markdown$Parser$inlineParseHelper,
14102							linkReferences,
14103							dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines(text.raw))));
14104			default:
14105				var raw = rawBlock.b;
14106				return dillonkearns$elm_markdown$Markdown$Parser$ParsedBlock(
14107					dillonkearns$elm_markdown$Markdown$Block$Paragraph(
14108						A2(
14109							dillonkearns$elm_markdown$Markdown$Parser$inlineParseHelper,
14110							linkReferences,
14111							dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines(raw))));
14112		}
14113	});
14114var dillonkearns$elm_markdown$Markdown$Parser$parseRawInline = F3(
14115	function (linkReferences, wrap, unparsedInlines) {
14116		return wrap(
14117			A2(dillonkearns$elm_markdown$Markdown$Parser$inlineParseHelper, linkReferences, unparsedInlines));
14118	});
14119var dillonkearns$elm_markdown$Markdown$Parser$parseRowInlines = F2(
14120	function (linkReferences, rows) {
14121		return A2(
14122			elm$core$List$map,
14123			function (row) {
14124				return A2(
14125					elm$core$List$map,
14126					function (column) {
14127						return A3(
14128							dillonkearns$elm_markdown$Markdown$Parser$parseRawInline,
14129							linkReferences,
14130							elm$core$Basics$identity,
14131							dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines(column));
14132					},
14133					row);
14134			},
14135			rows);
14136	});
14137var dillonkearns$elm_markdown$Markdown$Parser$stepRawBlock = function (revStmts) {
14138	return elm$parser$Parser$Advanced$oneOf(
14139		_List_fromArray(
14140			[
14141				A2(
14142				elm$parser$Parser$Advanced$map,
14143				function (_n2) {
14144					return elm$parser$Parser$Advanced$Done(revStmts);
14145				},
14146				dillonkearns$elm_markdown$Helpers$endOfFile),
14147				A2(
14148				elm$parser$Parser$Advanced$map,
14149				function (reference) {
14150					return elm$parser$Parser$Advanced$Loop(
14151						A2(dillonkearns$elm_markdown$Markdown$Parser$addReference, revStmts, reference));
14152				},
14153				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$Markdown$LinkReferenceDefinition$parser)),
14154				function () {
14155				var _n3 = revStmts.rawBlocks;
14156				_n3$6:
14157				while (true) {
14158					if (_n3.b) {
14159						switch (_n3.a.$) {
14160							case 'OpenBlockOrParagraph':
14161								return A2(
14162									elm$parser$Parser$Advanced$map,
14163									function (block) {
14164										return elm$parser$Parser$Advanced$Loop(block);
14165									},
14166									A2(
14167										elm$parser$Parser$Advanced$andThen,
14168										dillonkearns$elm_markdown$Markdown$Parser$completeOrMergeBlocks(revStmts),
14169										dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockAfterOpenBlockOrParagraphParser()));
14170							case 'Table':
14171								var table = _n3.a.a;
14172								return A2(
14173									elm$parser$Parser$Advanced$map,
14174									function (block) {
14175										return elm$parser$Parser$Advanced$Loop(block);
14176									},
14177									A2(
14178										elm$parser$Parser$Advanced$andThen,
14179										dillonkearns$elm_markdown$Markdown$Parser$completeOrMergeBlocks(revStmts),
14180										elm$parser$Parser$Advanced$oneOf(
14181											_List_fromArray(
14182												[
14183													dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockNotAfterOpenBlockOrParagraphParser(),
14184													dillonkearns$elm_markdown$Markdown$Parser$tableRowIfTableStarted(table)
14185												]))));
14186							case 'UnorderedListBlock':
14187								var _n4 = _n3.a;
14188								var tight = _n4.a;
14189								var intended = _n4.b;
14190								var closeListItems = _n4.c;
14191								var openListItem = _n4.d;
14192								var rest = _n3.b;
14193								var completeOrMergeUnorderedListBlockBlankLine = F2(
14194									function (state, newString) {
14195										return _Utils_update(
14196											state,
14197											{
14198												rawBlocks: A2(
14199													elm$core$List$cons,
14200													dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine,
14201													A2(
14202														elm$core$List$cons,
14203														A4(
14204															dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
14205															tight,
14206															intended,
14207															closeListItems,
14208															_Utils_update(
14209																openListItem,
14210																{
14211																	body: A3(dillonkearns$elm_markdown$Markdown$Parser$joinRawStringsWith, '', openListItem.body, newString)
14212																})),
14213														rest))
14214											});
14215									});
14216								var completeOrMergeUnorderedListBlock = F2(
14217									function (state, newString) {
14218										return _Utils_update(
14219											state,
14220											{
14221												rawBlocks: A2(
14222													elm$core$List$cons,
14223													A4(
14224														dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
14225														tight,
14226														intended,
14227														closeListItems,
14228														_Utils_update(
14229															openListItem,
14230															{
14231																body: A3(dillonkearns$elm_markdown$Markdown$Parser$joinRawStringsWith, '\n', openListItem.body, newString)
14232															})),
14233													rest)
14234											});
14235									});
14236								return elm$parser$Parser$Advanced$oneOf(
14237									_List_fromArray(
14238										[
14239											A2(
14240											elm$parser$Parser$Advanced$map,
14241											function (block) {
14242												return elm$parser$Parser$Advanced$Loop(block);
14243											},
14244											A2(
14245												elm$parser$Parser$Advanced$map,
14246												function (_n5) {
14247													return A2(completeOrMergeUnorderedListBlockBlankLine, revStmts, '\n');
14248												},
14249												dillonkearns$elm_markdown$Markdown$Parser$blankLine)),
14250											A2(
14251											elm$parser$Parser$Advanced$map,
14252											function (block) {
14253												return elm$parser$Parser$Advanced$Loop(block);
14254											},
14255											A2(
14256												elm$parser$Parser$Advanced$map,
14257												completeOrMergeUnorderedListBlock(revStmts),
14258												A2(
14259													elm$parser$Parser$Advanced$keeper,
14260													A2(
14261														elm$parser$Parser$Advanced$ignorer,
14262														elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
14263														elm$parser$Parser$Advanced$symbol(
14264															A2(
14265																elm$parser$Parser$Advanced$Token,
14266																A2(elm$core$String$repeat, intended, ' '),
14267																elm$parser$Parser$ExpectingSymbol('Indentation')))),
14268													A2(
14269														elm$parser$Parser$Advanced$ignorer,
14270														elm$parser$Parser$Advanced$getChompedString(dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd),
14271														dillonkearns$elm_markdown$Helpers$lineEndOrEnd)))),
14272											A2(
14273											elm$parser$Parser$Advanced$map,
14274											function (block) {
14275												return elm$parser$Parser$Advanced$Loop(block);
14276											},
14277											A2(
14278												elm$parser$Parser$Advanced$andThen,
14279												dillonkearns$elm_markdown$Markdown$Parser$completeOrMergeBlocks(revStmts),
14280												dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockAfterList()))
14281										]));
14282							case 'OrderedListBlock':
14283								var _n10 = _n3.a;
14284								var tight = _n10.a;
14285								var intended = _n10.b;
14286								var marker = _n10.c;
14287								var order = _n10.d;
14288								var closeListItems = _n10.e;
14289								var openListItem = _n10.f;
14290								var rest = _n3.b;
14291								var completeOrMergeUnorderedListBlockBlankLine = F2(
14292									function (state, newString) {
14293										return _Utils_update(
14294											state,
14295											{
14296												rawBlocks: A2(
14297													elm$core$List$cons,
14298													dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine,
14299													A2(
14300														elm$core$List$cons,
14301														A6(dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock, tight, intended, marker, order, closeListItems, openListItem + ('\n' + newString)),
14302														rest))
14303											});
14304									});
14305								var completeOrMergeUnorderedListBlock = F2(
14306									function (state, newString) {
14307										return _Utils_update(
14308											state,
14309											{
14310												rawBlocks: A2(
14311													elm$core$List$cons,
14312													A6(dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock, tight, intended, marker, order, closeListItems, openListItem + ('\n' + newString)),
14313													rest)
14314											});
14315									});
14316								return elm$parser$Parser$Advanced$oneOf(
14317									_List_fromArray(
14318										[
14319											A2(
14320											elm$parser$Parser$Advanced$map,
14321											function (block) {
14322												return elm$parser$Parser$Advanced$Loop(block);
14323											},
14324											A2(
14325												elm$parser$Parser$Advanced$map,
14326												function (_n11) {
14327													return A2(completeOrMergeUnorderedListBlockBlankLine, revStmts, '\n');
14328												},
14329												dillonkearns$elm_markdown$Markdown$Parser$blankLine)),
14330											A2(
14331											elm$parser$Parser$Advanced$map,
14332											function (block) {
14333												return elm$parser$Parser$Advanced$Loop(block);
14334											},
14335											A2(
14336												elm$parser$Parser$Advanced$map,
14337												completeOrMergeUnorderedListBlock(revStmts),
14338												A2(
14339													elm$parser$Parser$Advanced$keeper,
14340													A2(
14341														elm$parser$Parser$Advanced$ignorer,
14342														elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
14343														elm$parser$Parser$Advanced$symbol(
14344															A2(
14345																elm$parser$Parser$Advanced$Token,

14346																A2(elm$core$String$repeat, intended, ' '),
14347																elm$parser$Parser$ExpectingSymbol('Indentation')))),
14348													A2(
14349														elm$parser$Parser$Advanced$ignorer,
14350														elm$parser$Parser$Advanced$getChompedString(dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd),
14351														dillonkearns$elm_markdown$Helpers$lineEndOrEnd)))),
14352											A2(
14353											elm$parser$Parser$Advanced$map,
14354											function (block) {
14355												return elm$parser$Parser$Advanced$Loop(block);
14356											},
14357											A2(
14358												elm$parser$Parser$Advanced$andThen,
14359												dillonkearns$elm_markdown$Markdown$Parser$completeOrMergeBlocks(revStmts),
14360												dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockAfterList()))
14361										]));
14362							case 'BlankLine':
14363								if (_n3.b.b) {
14364									switch (_n3.b.a.$) {
14365										case 'UnorderedListBlock':
14366											var _n6 = _n3.a;
14367											var _n7 = _n3.b;
14368											var _n8 = _n7.a;
14369											var tight = _n8.a;
14370											var intended = _n8.b;
14371											var closeListItems = _n8.c;
14372											var openListItem = _n8.d;
14373											var rest = _n7.b;
14374											var completeOrMergeUnorderedListBlockBlankLine = F2(
14375												function (state, newString) {
14376													return _Utils_update(
14377														state,
14378														{
14379															rawBlocks: A2(
14380																elm$core$List$cons,
14381																dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine,
14382																A2(
14383																	elm$core$List$cons,
14384																	A4(
14385																		dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
14386																		tight,
14387																		intended,
14388																		closeListItems,
14389																		_Utils_update(
14390																			openListItem,
14391																			{
14392																				body: A3(dillonkearns$elm_markdown$Markdown$Parser$joinRawStringsWith, '', openListItem.body, newString)
14393																			})),
14394																	rest))
14395														});
14396												});
14397											var completeOrMergeUnorderedListBlock = F2(
14398												function (state, newString) {
14399													return _Utils_update(
14400														state,
14401														{
14402															rawBlocks: A2(
14403																elm$core$List$cons,
14404																A4(
14405																	dillonkearns$elm_markdown$Markdown$RawBlock$UnorderedListBlock,
14406																	tight,
14407																	intended,
14408																	closeListItems,
14409																	_Utils_update(
14410																		openListItem,
14411																		{
14412																			body: A3(dillonkearns$elm_markdown$Markdown$Parser$joinRawStringsWith, '\n', openListItem.body, newString)
14413																		})),
14414																rest)
14415														});
14416												});
14417											return (elm$core$String$trim(openListItem.body) === '') ? A2(
14418												elm$parser$Parser$Advanced$map,
14419												function (block) {
14420													return elm$parser$Parser$Advanced$Loop(block);
14421												},
14422												A2(
14423													elm$parser$Parser$Advanced$andThen,
14424													dillonkearns$elm_markdown$Markdown$Parser$completeOrMergeBlocks(revStmts),
14425													dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockNotAfterOpenBlockOrParagraphParser())) : elm$parser$Parser$Advanced$oneOf(
14426												_List_fromArray(
14427													[
14428														A2(
14429														elm$parser$Parser$Advanced$map,
14430														function (block) {
14431															return elm$parser$Parser$Advanced$Loop(block);
14432														},
14433														A2(
14434															elm$parser$Parser$Advanced$map,
14435															function (_n9) {
14436																return A2(completeOrMergeUnorderedListBlockBlankLine, revStmts, '\n');
14437															},
14438															dillonkearns$elm_markdown$Markdown$Parser$blankLine)),
14439														A2(
14440														elm$parser$Parser$Advanced$map,
14441														function (block) {
14442															return elm$parser$Parser$Advanced$Loop(block);
14443														},
14444														A2(
14445															elm$parser$Parser$Advanced$map,
14446															completeOrMergeUnorderedListBlock(revStmts),
14447															A2(
14448																elm$parser$Parser$Advanced$keeper,
14449																A2(
14450																	elm$parser$Parser$Advanced$ignorer,
14451																	elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
14452																	elm$parser$Parser$Advanced$symbol(
14453																		A2(
14454																			elm$parser$Parser$Advanced$Token,
14455																			A2(elm$core$String$repeat, intended, ' '),
14456																			elm$parser$Parser$ExpectingSymbol('Indentation')))),
14457																A2(
14458																	elm$parser$Parser$Advanced$ignorer,
14459																	elm$parser$Parser$Advanced$getChompedString(dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd),
14460																	dillonkearns$elm_markdown$Helpers$lineEndOrEnd)))),
14461														A2(
14462														elm$parser$Parser$Advanced$map,
14463														function (block) {
14464															return elm$parser$Parser$Advanced$Loop(block);
14465														},
14466														A2(
14467															elm$parser$Parser$Advanced$andThen,
14468															dillonkearns$elm_markdown$Markdown$Parser$completeOrMergeBlocks(revStmts),
14469															dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockNotAfterOpenBlockOrParagraphParser()))
14470													]));
14471										case 'OrderedListBlock':
14472											var _n12 = _n3.a;
14473											var _n13 = _n3.b;
14474											var _n14 = _n13.a;
14475											var tight = _n14.a;
14476											var intended = _n14.b;
14477											var marker = _n14.c;
14478											var order = _n14.d;
14479											var closeListItems = _n14.e;
14480											var openListItem = _n14.f;
14481											var rest = _n13.b;
14482											var completeOrMergeUnorderedListBlockBlankLine = F2(
14483												function (state, newString) {
14484													return _Utils_update(
14485														state,
14486														{
14487															rawBlocks: A2(
14488																elm$core$List$cons,
14489																dillonkearns$elm_markdown$Markdown$RawBlock$BlankLine,
14490																A2(
14491																	elm$core$List$cons,
14492																	A6(dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock, tight, intended, marker, order, closeListItems, openListItem + ('\n' + newString)),
14493																	rest))
14494														});
14495												});
14496											var completeOrMergeUnorderedListBlock = F2(
14497												function (state, newString) {
14498													return _Utils_update(
14499														state,
14500														{
14501															rawBlocks: A2(
14502																elm$core$List$cons,
14503																A6(dillonkearns$elm_markdown$Markdown$RawBlock$OrderedListBlock, tight, intended, marker, order, closeListItems, openListItem + ('\n' + newString)),
14504																rest)
14505														});
14506												});
14507											return (elm$core$String$trim(openListItem) === '') ? A2(
14508												elm$parser$Parser$Advanced$map,
14509												function (block) {
14510													return elm$parser$Parser$Advanced$Loop(block);
14511												},
14512												A2(
14513													elm$parser$Parser$Advanced$andThen,
14514													dillonkearns$elm_markdown$Markdown$Parser$completeOrMergeBlocks(revStmts),
14515													dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockNotAfterOpenBlockOrParagraphParser())) : elm$parser$Parser$Advanced$oneOf(
14516												_List_fromArray(
14517													[
14518														A2(
14519														elm$parser$Parser$Advanced$map,
14520														function (block) {
14521															return elm$parser$Parser$Advanced$Loop(block);
14522														},
14523														A2(
14524															elm$parser$Parser$Advanced$map,
14525															function (_n15) {
14526																return A2(completeOrMergeUnorderedListBlockBlankLine, revStmts, '\n');
14527															},
14528															dillonkearns$elm_markdown$Markdown$Parser$blankLine)),
14529														A2(
14530														elm$parser$Parser$Advanced$map,
14531														function (block) {
14532															return elm$parser$Parser$Advanced$Loop(block);
14533														},
14534														A2(
14535															elm$parser$Parser$Advanced$map,
14536															completeOrMergeUnorderedListBlock(revStmts),
14537															A2(
14538																elm$parser$Parser$Advanced$keeper,
14539																A2(
14540																	elm$parser$Parser$Advanced$ignorer,
14541																	elm$parser$Parser$Advanced$succeed(elm$core$Basics$identity),
14542																	elm$parser$Parser$Advanced$symbol(
14543																		A2(
14544																			elm$parser$Parser$Advanced$Token,
14545																			A2(elm$core$String$repeat, intended, ' '),
14546																			elm$parser$Parser$ExpectingSymbol('Indentation')))),
14547																A2(
14548																	elm$parser$Parser$Advanced$ignorer,
14549																	elm$parser$Parser$Advanced$getChompedString(dillonkearns$elm_markdown$Helpers$chompUntilLineEndOrEnd),
14550																	dillonkearns$elm_markdown$Helpers$lineEndOrEnd)))),
14551														A2(
14552														elm$parser$Parser$Advanced$map,
14553														function (block) {
14554															return elm$parser$Parser$Advanced$Loop(block);
14555														},
14556														A2(
14557															elm$parser$Parser$Advanced$andThen,
14558															dillonkearns$elm_markdown$Markdown$Parser$completeOrMergeBlocks(revStmts),
14559															dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockNotAfterOpenBlockOrParagraphParser()))
14560													]));
14561										default:
14562											break _n3$6;
14563									}
14564								} else {
14565									break _n3$6;
14566								}
14567							default:
14568								break _n3$6;
14569						}
14570					} else {
14571						break _n3$6;
14572					}
14573				}
14574				return A2(
14575					elm$parser$Parser$Advanced$map,
14576					function (block) {
14577						return elm$parser$Parser$Advanced$Loop(block);
14578					},
14579					A2(
14580						elm$parser$Parser$Advanced$andThen,
14581						dillonkearns$elm_markdown$Markdown$Parser$completeOrMergeBlocks(revStmts),
14582						dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockNotAfterOpenBlockOrParagraphParser()));
14583			}(),
14584				A2(
14585				elm$parser$Parser$Advanced$map,
14586				function (block) {
14587					return elm$parser$Parser$Advanced$Loop(block);
14588				},
14589				A2(
14590					elm$parser$Parser$Advanced$andThen,
14591					dillonkearns$elm_markdown$Markdown$Parser$completeOrMergeBlocks(revStmts),
14592					dillonkearns$elm_markdown$Markdown$Parser$openBlockOrParagraphParser))
14593			]));
14594};
14595var dillonkearns$elm_markdown$Markdown$Parser$textNodeToBlocks = function (textNodeValue) {
14596	return A2(
14597		elm$core$Result$withDefault,
14598		_List_Nil,
14599		dillonkearns$elm_markdown$Markdown$Parser$parse(textNodeValue));
14600};
14601var dillonkearns$elm_markdown$Markdown$Parser$xmlNodeToHtmlNode = function (xmlNode) {
14602	switch (xmlNode.$) {
14603		case 'Text':
14604			var innerText = xmlNode.a;
14605			return elm$parser$Parser$Advanced$succeed(
14606				dillonkearns$elm_markdown$Markdown$RawBlock$OpenBlockOrParagraph(
14607					dillonkearns$elm_markdown$Markdown$RawBlock$UnparsedInlines(innerText)));
14608		case 'Element':
14609			var tag = xmlNode.a;
14610			var attributes = xmlNode.b;
14611			var children = xmlNode.c;
14612			var _n1 = dillonkearns$elm_markdown$Markdown$Parser$nodesToBlocks(children);
14613			if (_n1.$ === 'Ok') {
14614				var parsedChildren = _n1.a;
14615				return elm$parser$Parser$Advanced$succeed(
14616					dillonkearns$elm_markdown$Markdown$RawBlock$Html(
14617						A3(dillonkearns$elm_markdown$Markdown$Block$HtmlElement, tag, attributes, parsedChildren)));
14618			} else {
14619				var err = _n1.a;
14620				return elm$parser$Parser$Advanced$problem(err);
14621			}
14622		case 'Comment':
14623			var string = xmlNode.a;
14624			return elm$parser$Parser$Advanced$succeed(
14625				dillonkearns$elm_markdown$Markdown$RawBlock$Html(
14626					dillonkearns$elm_markdown$Markdown$Block$HtmlComment(string)));
14627		case 'Cdata':
14628			var string = xmlNode.a;
14629			return elm$parser$Parser$Advanced$succeed(
14630				dillonkearns$elm_markdown$Markdown$RawBlock$Html(

14631					dillonkearns$elm_markdown$Markdown$Block$Cdata(string)));
14632		case 'ProcessingInstruction':
14633			var string = xmlNode.a;
14634			return elm$parser$Parser$Advanced$succeed(
14635				dillonkearns$elm_markdown$Markdown$RawBlock$Html(
14636					dillonkearns$elm_markdown$Markdown$Block$ProcessingInstruction(string)));
14637		default:
14638			var declarationType = xmlNode.a;
14639			var content = xmlNode.b;
14640			return elm$parser$Parser$Advanced$succeed(
14641				dillonkearns$elm_markdown$Markdown$RawBlock$Html(
14642					A2(dillonkearns$elm_markdown$Markdown$Block$HtmlDeclaration, declarationType, content)));
14643	}
14644};
14645function dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser() {
14646	return A2(
14647		elm$parser$Parser$Advanced$andThen,
14648		dillonkearns$elm_markdown$Markdown$Parser$completeBlocks,
14649		A2(
14650			elm$parser$Parser$Advanced$loop,
14651			{linkReferenceDefinitions: _List_Nil, rawBlocks: _List_Nil},
14652			dillonkearns$elm_markdown$Markdown$Parser$stepRawBlock));
14653}
14654function dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockNotAfterOpenBlockOrParagraphParser() {
14655	return elm$parser$Parser$Advanced$oneOf(
14656		_List_fromArray(
14657			[
14658				dillonkearns$elm_markdown$Markdown$Parser$parseAsParagraphInsteadOfHtmlBlock,
14659				dillonkearns$elm_markdown$Markdown$Parser$blankLine,
14660				dillonkearns$elm_markdown$Markdown$Parser$blockQuote,
14661				A2(
14662				elm$parser$Parser$Advanced$map,
14663				dillonkearns$elm_markdown$Markdown$RawBlock$CodeBlock,
14664				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$Markdown$CodeBlock$parser)),
14665				dillonkearns$elm_markdown$Markdown$Parser$indentedCodeBlock,
14666				A2(
14667				elm$parser$Parser$Advanced$map,
14668				function (_n40) {
14669					return dillonkearns$elm_markdown$Markdown$RawBlock$ThematicBreak;
14670				},
14671				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$ThematicBreak$parser)),
14672				dillonkearns$elm_markdown$Markdown$Parser$unorderedListBlock(false),
14673				dillonkearns$elm_markdown$Markdown$Parser$orderedListBlock(false),
14674				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$Markdown$Heading$parser),
14675				dillonkearns$elm_markdown$Markdown$Parser$cyclic$htmlParser()
14676			]));
14677}
14678function dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockAfterOpenBlockOrParagraphParser() {
14679	return elm$parser$Parser$Advanced$oneOf(
14680		_List_fromArray(
14681			[
14682				dillonkearns$elm_markdown$Markdown$Parser$parseAsParagraphInsteadOfHtmlBlock,
14683				dillonkearns$elm_markdown$Markdown$Parser$blankLine,
14684				dillonkearns$elm_markdown$Markdown$Parser$blockQuote,
14685				A2(
14686				elm$parser$Parser$Advanced$map,
14687				dillonkearns$elm_markdown$Markdown$RawBlock$CodeBlock,
14688				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$Markdown$CodeBlock$parser)),
14689				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$Markdown$Parser$setextLineParser),
14690				A2(
14691				elm$parser$Parser$Advanced$map,
14692				function (_n39) {
14693					return dillonkearns$elm_markdown$Markdown$RawBlock$ThematicBreak;
14694				},
14695				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$ThematicBreak$parser)),
14696				dillonkearns$elm_markdown$Markdown$Parser$unorderedListBlock(true),
14697				dillonkearns$elm_markdown$Markdown$Parser$orderedListBlock(true),
14698				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$Markdown$Heading$parser),
14699				dillonkearns$elm_markdown$Markdown$Parser$cyclic$htmlParser(),
14700				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$Markdown$Parser$tableDelimiterInOpenParagraph)
14701			]));
14702}
14703function dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockAfterList() {
14704	return elm$parser$Parser$Advanced$oneOf(
14705		_List_fromArray(
14706			[
14707				dillonkearns$elm_markdown$Markdown$Parser$parseAsParagraphInsteadOfHtmlBlock,
14708				dillonkearns$elm_markdown$Markdown$Parser$blankLine,
14709				dillonkearns$elm_markdown$Markdown$Parser$blockQuote,
14710				A2(
14711				elm$parser$Parser$Advanced$map,
14712				dillonkearns$elm_markdown$Markdown$RawBlock$CodeBlock,
14713				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$Markdown$CodeBlock$parser)),
14714				A2(
14715				elm$parser$Parser$Advanced$map,
14716				function (_n38) {
14717					return dillonkearns$elm_markdown$Markdown$RawBlock$ThematicBreak;
14718				},
14719				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$ThematicBreak$parser)),
14720				dillonkearns$elm_markdown$Markdown$Parser$unorderedListBlock(false),
14721				dillonkearns$elm_markdown$Markdown$Parser$orderedListBlock(false),
14722				elm$parser$Parser$Advanced$backtrackable(dillonkearns$elm_markdown$Markdown$Heading$parser),
14723				dillonkearns$elm_markdown$Markdown$Parser$cyclic$htmlParser()
14724			]));
14725}
14726function dillonkearns$elm_markdown$Markdown$Parser$cyclic$htmlParser() {
14727	return A2(elm$parser$Parser$Advanced$andThen, dillonkearns$elm_markdown$Markdown$Parser$xmlNodeToHtmlNode, dillonkearns$elm_markdown$HtmlParser$html);
14728}
14729try {
14730	var dillonkearns$elm_markdown$Markdown$Parser$rawBlockParser = dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser();
14731	dillonkearns$elm_markdown$Markdown$Parser$cyclic$rawBlockParser = function () {
14732		return dillonkearns$elm_markdown$Markdown$Parser$rawBlockParser;
14733	};
14734	var dillonkearns$elm_markdown$Markdown$Parser$mergeableBlockNotAfterOpenBlockOrParagraphParser = dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockNotAfterOpenBlockOrParagraphParser();
14735	dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockNotAfterOpenBlockOrParagraphParser = function () {
14736		return dillonkearns$elm_markdown$Markdown$Parser$mergeableBlockNotAfterOpenBlockOrParagraphParser;
14737	};
14738	var dillonkearns$elm_markdown$Markdown$Parser$mergeableBlockAfterOpenBlockOrParagraphParser = dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockAfterOpenBlockOrParagraphParser();
14739	dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockAfterOpenBlockOrParagraphParser = function () {
14740		return dillonkearns$elm_markdown$Markdown$Parser$mergeableBlockAfterOpenBlockOrParagraphParser;
14741	};
14742	var dillonkearns$elm_markdown$Markdown$Parser$mergeableBlockAfterList = dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockAfterList();
14743	dillonkearns$elm_markdown$Markdown$Parser$cyclic$mergeableBlockAfterList = function () {
14744		return dillonkearns$elm_markdown$Markdown$Parser$mergeableBlockAfterList;
14745	};
14746	var dillonkearns$elm_markdown$Markdown$Parser$htmlParser = dillonkearns$elm_markdown$Markdown$Parser$cyclic$htmlParser();
14747	dillonkearns$elm_markdown$Markdown$Parser$cyclic$htmlParser = function () {
14748		return dillonkearns$elm_markdown$Markdown$Parser$htmlParser;
14749	};
14750} catch ($) {

14751throw 'Some top-level definitions from `Markdown.Parser` are causing infinite recursion:\n\n  ┌─────┐\n  │    childToBlocks\n  │     ↓\n  │    rawBlockParser\n  │     ↓\n  │    completeBlocks\n  │     ↓\n  │    completeOrMergeBlocks\n  │     ↓\n  │    mergeableBlockNotAfterOpenBlockOrParagraphParser\n  │     ↓\n  │    mergeableBlockAfterOpenBlockOrParagraphParser\n  │     ↓\n  │    mergeableBlockAfterList\n  │     ↓\n  │    htmlParser\n  │     ↓\n  │    inlineParseHelper\n  │     ↓\n  │    mapInline\n  │     ↓\n  │    nodeToRawBlock\n  │     ↓\n  │    nodesToBlocks\n  │     ↓\n  │    nodesToBlocksHelp\n  │     ↓\n  │    parse\n  │     ↓\n  │    parseAllInlines\n  │     ↓\n  │    parseAllInlinesHelp\n  │     ↓\n  │    parseHeaderInlines\n  │     ↓\n  │    parseInlines\n  │     ↓\n  │    parseRawInline\n  │     ↓\n  │    parseRowInlines\n  │     ↓\n  │    stepRawBlock\n  │     ↓\n  │    textNodeToBlocks\n  │     ↓\n  │    xmlNodeToHtmlNode\n  └─────┘\n\nThese errors are very tricky, so read https://elm-lang.org/0.19.0/halting-problem to learn how to fix it!';}
14752var elm$core$Result$map2 = F3(
14753	function (func, ra, rb) {
14754		if (ra.$ === 'Err') {
14755			var x = ra.a;
14756			return elm$core$Result$Err(x);
14757		} else {
14758			var a = ra.a;
14759			if (rb.$ === 'Err') {
14760				var x = rb.a;
14761				return elm$core$Result$Err(x);
14762			} else {
14763				var b = rb.a;
14764				return elm$core$Result$Ok(
14765					A2(func, a, b));
14766			}
14767		}
14768	});
14769var dillonkearns$elm_markdown$Markdown$Renderer$combineResults = A2(
14770	elm$core$List$foldr,
14771	elm$core$Result$map2(elm$core$List$cons),
14772	elm$core$Result$Ok(_List_Nil));
14773var dillonkearns$elm_markdown$Markdown$Block$foldl = F3(
14774	function (_function, acc, list) {
14775		foldl:
14776		while (true) {
14777			if (!list.b) {
14778				return acc;
14779			} else {
14780				var block = list.a;
14781				var remainingBlocks = list.b;
14782				switch (block.$) {
14783					case 'HtmlBlock':
14784						var html = block.a;
14785						if (html.$ === 'HtmlElement') {
14786							var children = html.c;
14787							var $temp$function = _function,
14788								$temp$acc = A2(_function, block, acc),
14789								$temp$list = _Utils_ap(children, remainingBlocks);
14790							_function = $temp$function;
14791							acc = $temp$acc;
14792							list = $temp$list;
14793							continue foldl;
14794						} else {
14795							var $temp$function = _function,
14796								$temp$acc = A2(_function, block, acc),
14797								$temp$list = remainingBlocks;
14798							_function = $temp$function;
14799							acc = $temp$acc;
14800							list = $temp$list;
14801							continue foldl;
14802						}
14803					case 'UnorderedList':
14804						var tight = block.a;
14805						var blocks = block.b;
14806						var childBlocks = A2(
14807							elm$core$List$concatMap,
14808							function (_n3) {
14809								var children = _n3.b;
14810								return children;
14811							},
14812							blocks);
14813						var $temp$function = _function,
14814							$temp$acc = A2(_function, block, acc),
14815							$temp$list = _Utils_ap(childBlocks, remainingBlocks);
14816						_function = $temp$function;
14817						acc = $temp$acc;
14818						list = $temp$list;
14819						continue foldl;
14820					case 'OrderedList':
14821						var _int = block.b;
14822						var blocks = block.c;
14823						var $temp$function = _function,
14824							$temp$acc = A2(_function, block, acc),
14825							$temp$list = _Utils_ap(
14826							elm$core$List$concat(blocks),
14827							remainingBlocks);
14828						_function = $temp$function;
14829						acc = $temp$acc;
14830						list = $temp$list;
14831						continue foldl;
14832					case 'BlockQuote':
14833						var blocks = block.a;
14834						var $temp$function = _function,
14835							$temp$acc = A2(_function, block, acc),
14836							$temp$list = _Utils_ap(blocks, remainingBlocks);
14837						_function = $temp$function;
14838						acc = $temp$acc;
14839						list = $temp$list;
14840						continue foldl;
14841					case 'Heading':
14842						var $temp$function = _function,
14843							$temp$acc = A2(_function, block, acc),
14844							$temp$list = remainingBlocks;
14845						_function = $temp$function;
14846						acc = $temp$acc;
14847						list = $temp$list;
14848						continue foldl;
14849					case 'Paragraph':
14850						var $temp$function = _function,
14851							$temp$acc = A2(_function, block, acc),
14852							$temp$list = remainingBlocks;
14853						_function = $temp$function;
14854						acc = $temp$acc;
14855						list = $temp$list;
14856						continue foldl;
14857					case 'Table':
14858						var $temp$function = _function,
14859							$temp$acc = A2(_function, block, acc),
14860							$temp$list = remainingBlocks;
14861						_function = $temp$function;
14862						acc = $temp$acc;
14863						list = $temp$list;
14864						continue foldl;
14865					case 'CodeBlock':
14866						var $temp$function = _function,
14867							$temp$acc = A2(_function, block, acc),
14868							$temp$list = remainingBlocks;
14869						_function = $temp$function;
14870						acc = $temp$acc;
14871						list = $temp$list;
14872						continue foldl;
14873					default:
14874						var $temp$function = _function,
14875							$temp$acc = A2(_function, block, acc),
14876							$temp$list = remainingBlocks;
14877						_function = $temp$function;
14878						acc = $temp$acc;
14879						list = $temp$list;
14880						continue foldl;
14881				}
14882			}
14883		}
14884	});
14885var dillonkearns$elm_markdown$Markdown$Block$extractInlineBlockText = function (block) {
14886	switch (block.$) {
14887		case 'Paragraph':
14888			var inlines = block.a;
14889			return dillonkearns$elm_markdown$Markdown$Block$extractInlineText(inlines);
14890		case 'HtmlBlock':
14891			var html = block.a;
14892			if (html.$ === 'HtmlElement') {
14893				var blocks = html.c;
14894				return A3(
14895					dillonkearns$elm_markdown$Markdown$Block$foldl,
14896					F2(
14897						function (nestedBlock, soFar) {
14898							return _Utils_ap(
14899								soFar,
14900								dillonkearns$elm_markdown$Markdown$Block$extractInlineBlockText(nestedBlock));
14901						}),
14902					'',
14903					blocks);
14904			} else {
14905				return '';
14906			}
14907		case 'UnorderedList':
14908			var tight = block.a;
14909			var items = block.b;

14910			return A2(
14911				elm$core$String$join,
14912				'\n',
14913				A2(
14914					elm$core$List$map,
14915					function (_n4) {
14916						var task = _n4.a;
14917						var blocks = _n4.b;
14918						return A2(
14919							elm$core$String$join,
14920							'\n',
14921							A2(elm$core$List$map, dillonkearns$elm_markdown$Markdown$Block$extractInlineBlockText, blocks));
14922					},
14923					items));
14924		case 'OrderedList':
14925			var tight = block.a;
14926			var _int = block.b;
14927			var items = block.c;
14928			return A2(
14929				elm$core$String$join,
14930				'\n',
14931				A2(
14932					elm$core$List$map,
14933					function (blocks) {
14934						return A2(
14935							elm$core$String$join,
14936							'\n',
14937							A2(elm$core$List$map, dillonkearns$elm_markdown$Markdown$Block$extractInlineBlockText, blocks));
14938					},
14939					items));
14940		case 'BlockQuote':
14941			var blocks = block.a;
14942			return A2(
14943				elm$core$String$join,
14944				'\n',
14945				A2(elm$core$List$map, dillonkearns$elm_markdown$Markdown$Block$extractInlineBlockText, blocks));
14946		case 'Heading':
14947			var headingLevel = block.a;
14948			var inlines = block.b;
14949			return dillonkearns$elm_markdown$Markdown$Block$extractInlineText(inlines);
14950		case 'Table':
14951			var header = block.a;
14952			var rows = block.b;
14953			return A2(
14954				elm$core$String$join,
14955				'\n',
14956				elm$core$List$concat(
14957					_List_fromArray(
14958						[
14959							A2(
14960							elm$core$List$map,
14961							dillonkearns$elm_markdown$Markdown$Block$extractInlineText,
14962							A2(
14963								elm$core$List$map,
14964								function ($) {
14965									return $.label;
14966								},
14967								header)),
14968							elm$core$List$concat(
14969							A2(
14970								elm$core$List$map,
14971								elm$core$List$map(dillonkearns$elm_markdown$Markdown$Block$extractInlineText),
14972								rows))
14973						])));
14974		case 'CodeBlock':
14975			var body = block.a.body;
14976			return body;
14977		default:
14978			return '';
14979	}
14980};
14981var dillonkearns$elm_markdown$Markdown$Block$extractInlineText = function (inlines) {
14982	return A3(elm$core$List$foldl, dillonkearns$elm_markdown$Markdown$Block$extractTextHelp, '', inlines);
14983};
14984var dillonkearns$elm_markdown$Markdown$Block$extractTextHelp = F2(
14985	function (inline, text) {
14986		switch (inline.$) {
14987			case 'Text':
14988				var str = inline.a;
14989				return _Utils_ap(text, str);
14990			case 'HardLineBreak':
14991				return text + ' ';
14992			case 'CodeSpan':
14993				var str = inline.a;
14994				return _Utils_ap(text, str);
14995			case 'Link':
14996				var inlines = inline.c;
14997				return _Utils_ap(
14998					text,
14999					dillonkearns$elm_markdown$Markdown$Block$extractInlineText(inlines));
15000			case 'Image':
15001				var inlines = inline.c;
15002				return _Utils_ap(
15003					text,
15004					dillonkearns$elm_markdown$Markdown$Block$extractInlineText(inlines));
15005			case 'HtmlInline':
15006				var html = inline.a;
15007				if (html.$ === 'HtmlElement') {
15008					var blocks = html.c;
15009					return A3(
15010						dillonkearns$elm_markdown$Markdown$Block$foldl,
15011						F2(
15012							function (block, soFar) {
15013								return _Utils_ap(
15014									soFar,
15015									dillonkearns$elm_markdown$Markdown$Block$extractInlineBlockText(block));
15016							}),
15017						text,
15018						blocks);
15019				} else {
15020					return text;
15021				}
15022			case 'Strong':
15023				var inlines = inline.a;
15024				return _Utils_ap(
15025					text,
15026					dillonkearns$elm_markdown$Markdown$Block$extractInlineText(inlines));
15027			case 'Emphasis':
15028				var inlines = inline.a;
15029				return _Utils_ap(
15030					text,
15031					dillonkearns$elm_markdown$Markdown$Block$extractInlineText(inlines));
15032			default:
15033				var inlines = inline.a;
15034				return _Utils_ap(
15035					text,
15036					dillonkearns$elm_markdown$Markdown$Block$extractInlineText(inlines));
15037		}
15038	});
15039var elm$core$Result$andThen = F2(
15040	function (callback, result) {
15041		if (result.$ === 'Ok') {
15042			var value = result.a;
15043			return callback(value);
15044		} else {
15045			var msg = result.a;
15046			return elm$core$Result$Err(msg);
15047		}
15048	});
15049var dillonkearns$elm_markdown$Markdown$Renderer$renderHtml = F5(
15050	function (tagName, attributes, children, _n0, renderedChildren) {
15051		var htmlRenderer = _n0.a;
15052		return A2(
15053			elm$core$Result$andThen,
15054			function (okChildren) {
15055				return A2(
15056					elm$core$Result$map,
15057					function (myRenderer) {
15058						return myRenderer(okChildren);
15059					},
15060					A3(htmlRenderer, tagName, attributes, children));
15061			},
15062			dillonkearns$elm_markdown$Markdown$Renderer$combineResults(renderedChildren));
15063	});
15064var elm$core$List$drop = F2(
15065	function (n, list) {
15066		drop:
15067		while (true) {
15068			if (n <= 0) {
15069				return list;
15070			} else {
15071				if (!list.b) {
15072					return list;
15073				} else {
15074					var x = list.a;
15075					var xs = list.b;
15076					var $temp$n = n - 1,
15077						$temp$list = xs;
15078					n = $temp$n;
15079					list = $temp$list;
15080					continue drop;
15081				}
15082			}
15083		}
15084	});
15085var elm$core$List$singleton = function (value) {
15086	return _List_fromArray(
15087		[value]);
15088};
15089var elm$core$Tuple$pair = F2(
15090	function (a, b) {
15091		return _Utils_Tuple2(a, b);
15092	});
15093var dillonkearns$elm_markdown$Markdown$Renderer$foldThing = F3(
15094	function (renderer, topLevelInline, soFar) {
15095		var _n12 = A2(dillonkearns$elm_markdown$Markdown$Renderer$render

15095SingleInline, renderer, topLevelInline);
15096		if (_n12.$ === 'Just') {
15097			var inline = _n12.a;
15098			return A2(elm$core$List$cons, inline, soFar);
15099		} else {
15100			return soFar;
15101		}
15102	});
15103var dillonkearns$elm_markdown$Markdown$Renderer$renderHelper = F2(
15104	function (renderer, blocks) {
15105		return A2(
15106			elm$core$List$filterMap,
15107			dillonkearns$elm_markdown$Markdown$Renderer$renderHelperSingle(renderer),
15108			blocks);
15109	});
15110var dillonkearns$elm_markdown$Markdown$Renderer$renderHelperSingle = function (renderer) {
15111	return function (block) {
15112		switch (block.$) {
15113			case 'Heading':
15114				var level = block.a;
15115				var content = block.b;
15116				return elm$core$Maybe$Just(
15117					A2(
15118						elm$core$Result$map,
15119						function (children) {
15120							return renderer.heading(
15121								{
15122									children: children,
15123									level: level,
15124									rawText: dillonkearns$elm_markdown$Markdown$Block$extractInlineText(content)
15125								});
15126						},
15127						A2(dillonkearns$elm_markdown$Markdown$Renderer$renderStyled, renderer, content)));
15128			case 'Paragraph':
15129				var content = block.a;
15130				return elm$core$Maybe$Just(
15131					A2(
15132						elm$core$Result$map,
15133						renderer.paragraph,
15134						A2(dillonkearns$elm_markdown$Markdown$Renderer$renderStyled, renderer, content)));
15135			case 'HtmlBlock':
15136				var html = block.a;
15137				if (html.$ === 'HtmlElement') {
15138					var tag = html.a;
15139					var attributes = html.b;
15140					var children = html.c;
15141					return elm$core$Maybe$Just(
15142						A4(dillonkearns$elm_markdown$Markdown$Renderer$renderHtmlNode, renderer, tag, attributes, children));
15143				} else {
15144					return elm$core$Maybe$Nothing;
15145				}
15146			case 'UnorderedList':
15147				var tight = block.a;
15148				var items = block.b;
15149				return elm$core$Maybe$Just(
15150					A2(
15151						elm$core$Result$map,
15152						function (listItems) {
15153							return renderer.unorderedList(
15154								A2(
15155									elm$core$List$map,
15156									function (_n7) {
15157										var task = _n7.a;
15158										var children = _n7.b;
15159										return A2(
15160											dillonkearns$elm_markdown$Markdown$Block$ListItem,
15161											task,
15162											elm$core$List$concat(children));
15163									},
15164									listItems));
15165						},
15166						dillonkearns$elm_markdown$Markdown$Renderer$combineResults(
15167							A2(
15168								elm$core$List$map,
15169								function (_n4) {
15170									var task = _n4.a;
15171									var children = _n4.b;
15172									return A2(
15173										elm$core$Result$map,
15174										dillonkearns$elm_markdown$Markdown$Block$ListItem(task),
15175										dillonkearns$elm_markdown$Markdown$Renderer$combineResults(
15176											function (blocks) {
15177												return A2(
15178													elm$core$List$filterMap,
15179													function (listItemBlock) {
15180														var _n5 = _Utils_Tuple2(tight, listItemBlock);
15181														if ((_n5.a.$ === 'Tight') && (_n5.b.$ === 'Paragraph')) {
15182															var _n6 = _n5.a;
15183															var content = _n5.b.a;
15184															return elm$core$Maybe$Just(
15185																A2(dillonkearns$elm_markdown$Markdown$Renderer$renderStyled, renderer, content));
15186														} else {
15187															return A2(
15188																elm$core$Maybe$map,
15189																elm$core$Result$map(elm$core$List$singleton),
15190																A2(dillonkearns$elm_markdown$Markdown$Renderer$renderHelperSingle, renderer, listItemBlock));
15191														}
15192													},
15193													blocks);
15194											}(children)));
15195								},
15196								items))));
15197			case 'OrderedList':
15198				var tight = block.a;
15199				var startingIndex = block.b;
15200				var items = block.c;
15201				return elm$core$Maybe$Just(
15202					A2(
15203						elm$core$Result$map,
15204						function (listItems) {
15205							return A2(
15206								renderer.orderedList,
15207								startingIndex,
15208								A2(
15209									elm$core$List$map,
15210									function (children) {
15211										return elm$core$List$concat(children);
15212									},
15213									listItems));
15214						},
15215						dillonkearns$elm_markdown$Markdown$Renderer$combineResults(
15216							A2(
15217								elm$core$List$map,
15218								function (itemsblocks) {
15219									return dillonkearns$elm_markdown$Markdown$Renderer$combineResults(
15220										function (blocks) {
15221											return A2(
15222												elm$core$List$filterMap,
15223												function (listItemBlock) {
15224													var _n8 = _Utils_Tuple2(tight, listItemBlock);
15225													if ((_n8.a.$ === 'Tight') && (_n8.b.$ === 'Paragraph')) {
15226														var _n9 = _n8.a;
15227														var content = _n8.b.a;
15228														return elm$core$Maybe$Just(
15229															A2(dillonkearns$elm_markdown$Markdown$Renderer$render

15229Styled, renderer, content));
15230													} else {
15231														return A2(
15232															elm$core$Maybe$map,
15233															elm$core$Result$map(elm$core$List$singleton),
15234															A2(dillonkearns$elm_markdown$Markdown$Renderer$renderHelperSingle, renderer, listItemBlock));
15235													}
15236												},
15237												blocks);
15238										}(itemsblocks));
15239								},
15240								items))));
15241			case 'CodeBlock':
15242				var codeBlock = block.a;
15243				return elm$core$Maybe$Just(
15244					elm$core$Result$Ok(
15245						renderer.codeBlock(codeBlock)));
15246			case 'ThematicBreak':
15247				return elm$core$Maybe$Just(
15248					elm$core$Result$Ok(renderer.thematicBreak));
15249			case 'BlockQuote':
15250				var nestedBlocks = block.a;
15251				return elm$core$Maybe$Just(
15252					A2(
15253						elm$core$Result$map,
15254						renderer.blockQuote,
15255						dillonkearns$elm_markdown$Markdown$Renderer$combineResults(
15256							A2(dillonkearns$elm_markdown$Markdown$Renderer$renderHelper, renderer, nestedBlocks))));
15257			default:
15258				var header = block.a;
15259				var rows = block.b;
15260				var renderedHeaderCells = dillonkearns$elm_markdown$Markdown$Renderer$combineResults(
15261					A2(
15262						elm$core$List$map,
15263						function (_n11) {
15264							var label = _n11.label;
15265							var alignment = _n11.alignment;
15266							return A2(
15267								elm$core$Result$map,
15268								elm$core$Tuple$pair(alignment),
15269								A2(dillonkearns$elm_markdown$Markdown$Renderer$renderStyled, renderer, label));
15270						},
15271						header));
15272				var renderedHeader = A2(
15273					elm$core$Result$map,
15274					function (listListView) {
15275						return renderer.tableHeader(
15276							elm$core$List$singleton(
15277								renderer.tableRow(
15278									A2(
15279										elm$core$List$map,
15280										function (_n10) {
15281											var maybeAlignment = _n10.a;
15282											var item = _n10.b;
15283											return A2(renderer.tableHeaderCell, maybeAlignment, item);
15284										},
15285										listListView))));
15286					},
15287					renderedHeaderCells);
15288				var renderedBody = function (r) {
15289					return elm$core$List$isEmpty(r) ? _List_Nil : _List_fromArray(
15290						[
15291							renderer.tableBody(r)
15292						]);
15293				};
15294				var alignmentForColumn = function (columnIndex) {
15295					return A2(
15296						elm$core$Maybe$andThen,
15297						function ($) {
15298							return $.alignment;
15299						},
15300						elm$core$List$head(
15301							A2(elm$core$List$drop, columnIndex, header)));
15302				};
15303				var renderRow = function (cells) {
15304					return A2(
15305						elm$core$Result$map,
15306						renderer.tableRow,
15307						A2(
15308							elm$core$Result$map,
15309							elm$core$List$indexedMap(
15310								F2(
15311									function (index, cell) {
15312										return A2(
15313											renderer.tableCell,
15314											alignmentForColumn(index),
15315											cell);
15316									})),
15317							dillonkearns$elm_markdown$Markdown$Renderer$combineResults(
15318								A2(
15319									elm$core$List$map,
15320									dillonkearns$elm_markdown$Markdown$Renderer$renderStyled(renderer),
15321									cells))));
15322				};
15323				var renderedRows = dillonkearns$elm_markdown$Markdown$Renderer$combineResults(
15324					A2(elm$core$List$map, renderRow, rows));
15325				return elm$core$Maybe$Just(
15326					A3(
15327						elm$core$Result$map2,
15328						F2(
15329							function (h, r) {
15330								return renderer.table(
15331									A2(
15332										elm$core$List$cons,
15333										h,
15334										renderedBody(r)));
15335							}),
15336						renderedHeader,
15337						renderedRows));
15338		}
15339	};
15340};
15341var dillonkearns$elm_markdown$Markdown$Renderer$renderHtmlNode = F4(
15342	function (renderer, tag, attributes, children) {
15343		return A5(
15344			dillonkearns$elm_markdown$Markdown$Renderer$renderHtml,
15345			tag,
15346			attributes,
15347			children,
15348			renderer.html,
15349			A2(dillonkearns$elm_markdown$Markdown$Renderer$renderHelper, renderer, children));
15350	});
15351var dillonkearns$elm_markdown$Markdown$Renderer$renderSingleInline = F2(
15352	function (renderer, inline) {
15353		switch (inline.$) {
15354			case 'Strong':
15355				var innerInlines = inline.a;
15356				return elm$core$Maybe$Just(
15357					A2(
15358						elm$core$Result$map,
15359						renderer.strong,
15360						A2(dillonkearns$elm_markdown$Markdown$Renderer$renderStyled, renderer, innerInlines)));
15361			case 'Emphasis':
15362				var innerInlines = inline.a;
15363				return elm$core$Maybe$Just(
15364					A2(
15365						elm$core$Result$map,
15366						renderer.emphasis,

15367						A2(dillonkearns$elm_markdown$Markdown$Renderer$renderStyled, renderer, innerInlines)));
15368			case 'Strikethrough':
15369				var innerInlines = inline.a;
15370				return elm$core$Maybe$Just(
15371					A2(
15372						elm$core$Result$map,
15373						renderer.strikethrough,
15374						A2(dillonkearns$elm_markdown$Markdown$Renderer$renderStyled, renderer, innerInlines)));
15375			case 'Image':
15376				var src = inline.a;
15377				var title = inline.b;
15378				var children = inline.c;
15379				return elm$core$Maybe$Just(
15380					elm$core$Result$Ok(
15381						renderer.image(
15382							{
15383								alt: dillonkearns$elm_markdown$Markdown$Block$extractInlineText(children),
15384								src: src,
15385								title: title
15386							})));
15387			case 'Text':
15388				var string = inline.a;
15389				return elm$core$Maybe$Just(
15390					elm$core$Result$Ok(
15391						renderer.text(string)));
15392			case 'CodeSpan':
15393				var string = inline.a;
15394				return elm$core$Maybe$Just(
15395					elm$core$Result$Ok(
15396						renderer.codeSpan(string)));
15397			case 'Link':
15398				var destination = inline.a;
15399				var title = inline.b;
15400				var inlines = inline.c;
15401				return elm$core$Maybe$Just(
15402					A2(
15403						elm$core$Result$andThen,
15404						function (children) {
15405							return elm$core$Result$Ok(
15406								A2(
15407									renderer.link,
15408									{destination: destination, title: title},
15409									children));
15410						},
15411						A2(dillonkearns$elm_markdown$Markdown$Renderer$renderStyled, renderer, inlines)));
15412			case 'HardLineBreak':
15413				return elm$core$Maybe$Just(
15414					elm$core$Result$Ok(renderer.hardLineBreak));
15415			default:
15416				var html = inline.a;
15417				if (html.$ === 'HtmlElement') {
15418					var tag = html.a;
15419					var attributes = html.b;
15420					var children = html.c;
15421					return elm$core$Maybe$Just(
15422						A4(dillonkearns$elm_markdown$Markdown$Renderer$renderHtmlNode, renderer, tag, attributes, children));
15423				} else {
15424					return elm$core$Maybe$Nothing;
15425				}
15426		}
15427	});
15428var dillonkearns$elm_markdown$Markdown$Renderer$renderStyled = F2(
15429	function (renderer, styledStrings) {
15430		return dillonkearns$elm_markdown$Markdown$Renderer$combineResults(
15431			A3(
15432				elm$core$List$foldr,
15433				dillonkearns$elm_markdown$Markdown$Renderer$foldThing(renderer),
15434				_List_Nil,
15435				styledStrings));
15436	});
15437var dillonkearns$elm_markdown$Markdown$Renderer$render = F2(
15438	function (renderer, ast) {
15439		return dillonkearns$elm_markdown$Markdown$Renderer$combineResults(
15440			A2(dillonkearns$elm_markdown$Markdown$Renderer$renderHelper, renderer, ast));
15441	});
15442var dillonkearns$elm_markdown$Markdown$Html$resultOr = F2(
15443	function (ra, rb) {
15444		if (ra.$ === 'Err') {
15445			var singleError = ra.a;
15446			if (rb.$ === 'Ok') {
15447				var okValue = rb.a;
15448				return elm$core$Result$Ok(okValue);
15449			} else {
15450				var errorsSoFar = rb.a;
15451				return elm$core$Result$Err(
15452					A2(elm$core$List$cons, singleError, errorsSoFar));
15453			}
15454		} else {
15455			var okValue = ra.a;
15456			return elm$core$Result$Ok(okValue);
15457		}
15458	});
15459var dillonkearns$elm_markdown$Markdown$Html$attributesToString = function (attributes) {
15460	return A2(
15461		elm$core$String$join,
15462		' ',
15463		A2(
15464			elm$core$List$map,
15465			function (_n0) {
15466				var name = _n0.name;
15467				var value = _n0.value;
15468				return name + ('=\"' + (value + '\"'));
15469			},
15470			attributes));
15471};
15472var dillonkearns$elm_markdown$Markdown$Html$tagToString = F2(
15473	function (tagName, attributes) {
15474		return elm$core$List$isEmpty(attributes) ? ('<' + (tagName + '>')) : ('<' + (tagName + (' ' + (dillonkearns$elm_markdown$Markdown$Html$attributesToString(attributes) + '>'))));
15475	});
15476var dillonkearns$elm_markdown$Markdown$HtmlRenderer$HtmlRenderer = function (a) {
15477	return {$: 'HtmlRenderer', a: a};
15478};
15479var dillonkearns$elm_markdown$Markdown$Html$oneOf = function (decoders) {
15480	var unwrappedDecoders = A2(
15481		elm$core$List$map,
15482		function (_n1) {
15483			var rawDecoder = _n1.a;
15484			return rawDecoder;
15485		},
15486		decoders);
15487	return function (rawDecoder) {
15488		return dillonkearns$elm_markdown$Markdown$HtmlRenderer$HtmlRenderer(
15489			F3(
15490				function (tagName, attributes, innerBlocks) {
15491					return A2(
15492						elm$core$Result$mapError,
15493						function (errors) {
15494							if (!errors.b) {
15495								return 'Ran into a oneOf with no possibilities!';
15496							} else {
15497								if (!errors.b.b) {
15498									var singleError = errors.a;
15499									return 'Problem with the given value:\n\n' + (A2(dillonkearns$elm_markdown$Markdown$Html$tagToString, tagName, attributes) + ('\n\n' + (singleError + '\n')));
15500								} else {
15501									return 'oneOf failed parsing this value:\n    ' + (A2(dillonkearns$elm_markdown$Markdown$Html$tagToString, tagName, attributes) + ('\n\nParsing failed in the following 2 ways:\n\n\n' + (A2(
15502										elm$core$String$join,
15503										'\n\n',
15504										A2(
15505											elm$core$List$indexedMap,
15506											F2(
15507												function (index, error) {
15508													return '(' + (elm$core$String$fromInt(index + 1) + (') ' + error));
15509												}),
15510											errors)) + '\n')));
15511								}
15512							}
15513						},
15514						A3(rawDecoder, tagName, attributes, innerBlocks));
15515				}));
15516	}(
15517		A3(
15518			elm$core$List$foldl,
15519			F2(
15520				function (decoder, soFar) {
15521					return F3(
15522						function (tagName, attributes, children) {
15523							return A2(
15524								dillonkearns$elm_markdown$Markdown$Html$resultOr,
15525								A3(decoder, tagName, attributes, children),
15526								A3(soFar, tagName, attributes, children));
15527						});
15528				}),
15529			F3(
15530				function (tagName, attributes, children) {
15531					return elm$core$Result$Err(_List_Nil);
15532				}),
15533			unwrappedDecoders));
15534};
15535var dillonkearns$elm_markdown$Markdown$Html$tag = F2(
15536	function (expectedTag, a) {
15537		return dillonkearns$elm_markdown$Markdown$HtmlRenderer$HtmlRenderer(
15538			F3(
15539				function (tagName, attributes, children) {
15540					return _Utils_eq(tagName, expectedTag) ? elm$core$Result$Ok(a) : elm$core$Result$Err('Expected ' + (expectedTag + (' but was ' + tagName)));
15541				}));
15542	});
15543var dillonkearns$elm_markdown$List$Helpers$find = F2(
15544	function (predicate, list) {
15545		find:
15546		while (true) {
15547			if (!list.b) {
15548				return elm$core$Maybe$Nothing;
15549			} else {
15550				var first = list.a;
15551				var rest = list.b;
15552				if (predicate(first)) {
15553					return elm$core$Maybe$Just(first);
15554				} else {
15555					var $temp$predicate = predicate,
15556						$temp$list = rest;
15557					predicate = $temp$predicate;
15558					list = $temp$list;
15559					continue find;
15560				}
15561			}
15562		}
15563	});
15564var dillonkearns$elm_markdown$Markdown$Html$withOptionalAttribute = F2(
15565	function (attributeName, _n0) {
15566		var renderer = _n0.a;
15567		return dillonkearns$elm_markdown$Markdown$HtmlRenderer$HtmlRenderer(
15568			F3(
15569				function (tagName, attributes, innerBlocks) {
15570					return function () {
15571						var _n1 = A2(
15572							dillonkearns$elm_markdown$List$Helpers$find,
15573							function (_n2) {
15574								var name = _n2.name;
15575								var value = _n2.value;
15576								return _Utils_eq(name, attributeName);
15577							},
15578							attributes);
15579						if (_n1.$ === 'Just') {
15580							var value = _n1.a.value;
15581							return elm$core$Result$map(
15582								elm$core$Basics$apR(
15583									elm$core$Maybe$Just(value)));
15584						} else {
15585							return elm$core$Result$map(
15586								elm$core$Basics$apR(elm$core$Maybe$Nothing));
15587						}
15588					}()(
15589						A3(renderer, tagName, attributes, innerBlocks));
15590				}));
15591	});
15592var dtwrks$elm_book$ElmBook$Internal$ComponentOptions$Inline = {$: 'Inline'};
15593var dtwrks$elm_book$ElmBook$Internal$ComponentOptions$ComponentOptions = function (a) {
15594	return {$: 'ComponentOptions', a: a};
15595};
15596var dtwrks$elm_book$ElmBook$Internal$ComponentOptions$parseBool = function (v) {
15597	if ((v.$ === 'Just') && (v.a === 'true')) {
15598		return elm$core$Maybe$Just(true);
15599	} else {
15600		return elm$core$Maybe$Nothing;
15601	}
15602};
15603var dtwrks$elm_book$ElmBook$Internal$ComponentOptions$Block = {$: 'Block'};
15604var dtwrks$elm_book$ElmBook$Internal$ComponentOptions$parseDisplay = function (displayString) {
15605	_n0$3:
15606	while (true) {
15607		if (displayString.$ === 'Just') {
15608			switch (displayString.a) {
15609				case 'block':
15610					return elm$core$Maybe$Just(dtwrks$elm_book$ElmBook$Internal$ComponentOptions$Block);
15611				case 'inline':
15612					return elm$core$Maybe$Just(dtwrks$elm_book$ElmBook$Internal$ComponentOptions$Inline);
15613				case 'card':
15614					return elm$core$Maybe$Just(dtwrks$elm_book$ElmBook$Internal$ComponentOptions$Card);
15615				default:
15616					break _n0$3;
15617			}
15618		} else {
15619			break _n0$3;
15620		}
15621	}
15622	return elm$core$Maybe$Nothing;
15623};
15624var dtwrks$elm_book$ElmBook$Internal$ComponentOptions$markdownOptions = F2(
15625	function (validOptions, options) {
15626		return A2(

15627			dtwrks$elm_book$ElmBook$Internal$ComponentOptions$toValidOptions,
15628			validOptions,
15629			dtwrks$elm_book$ElmBook$Internal$ComponentOptions$ComponentOptions(
15630				{
15631					background: options.background,
15632					display: dtwrks$elm_book$ElmBook$Internal$ComponentOptions$parseDisplay(options.display),
15633					fullWidth: dtwrks$elm_book$ElmBook$Internal$ComponentOptions$parseBool(options.fullWidth),
15634					hiddenLabel: dtwrks$elm_book$ElmBook$Internal$ComponentOptions$parseBool(options.hiddenLabel)
15635				}));
15636	});
15637var dtwrks$elm_book$ElmBook$Internal$Msg$LogAction = F2(
15638	function (a, b) {
15639		return {$: 'LogAction', a: a, b: b};
15640	});
15641var dtwrks$elm_book$ElmBook$UI$ChapterComponent$viewLabel = F2(
15642	function (options_, label) {
15643		var _n0 = _Utils_Tuple3(label, options_.hiddenLabel, options_.display);
15644		if (_n0.a === '') {
15645			return elm$html$Html$text('');
15646		} else {
15647			if (_n0.b) {
15648				return elm$html$Html$text('');
15649			} else {
15650				if (_n0.c.$ === 'Inline') {
15651					var _n1 = _n0.c;
15652					return elm$html$Html$text('');
15653				} else {
15654					return A2(
15655						elm$html$Html$p,
15656						_List_fromArray(
15657							[
15658								elm$html$Html$Attributes$class('elm-book elm-book__chapter-component__title elm-book-sans')
15659							]),
15660						_List_fromArray(
15661							[
15662								elm$html$Html$text(label)
15663							]));
15664				}
15665			}
15666		}
15667	});
15668var elm$html$Html$article = _VirtualDom_node('article');
15669var dtwrks$elm_book$ElmBook$UI$ChapterComponent$viewBlock = F2(
15670	function (options_, _n0) {
15671		var label = _n0.a;
15672		var html = _n0.b;
15673		return A2(
15674			elm$html$Html$article,
15675			_List_fromArray(
15676				[
15677					elm$html$Html$Attributes$class('elm-book__chapter-component')
15678				]),
15679			_List_fromArray(
15680				[
15681					A2(dtwrks$elm_book$ElmBook$UI$ChapterComponent$viewLabel, options_, label),
15682					A2(
15683					elm$html$Html$div,
15684					_List_Nil,
15685					_List_fromArray(
15686						[html]))
15687				]));
15688	});
15689var dtwrks$elm_book$ElmBook$UI$ChapterComponent$viewCard = F2(
15690	function (options_, _n0) {
15691		var label = _n0.a;
15692		var html = _n0.b;
15693		return A2(
15694			elm$html$Html$article,
15695			_List_fromArray(
15696				[
15697					elm$html$Html$Attributes$class('elm-book__chapter-component')
15698				]),
15699			_List_fromArray(
15700				[
15701					A2(dtwrks$elm_book$ElmBook$UI$ChapterComponent$viewLabel, options_, label),
15702					A2(
15703					elm$html$Html$div,
15704					_List_fromArray(
15705						[
15706							elm$html$Html$Attributes$class('elm-book__chapter-component__background elm-book-shadows-light'),
15707							A2(elm$html$Html$Attributes$style, 'background', options_.background)
15708						]),
15709					_List_fromArray(
15710						[
15711							A2(
15712							elm$html$Html$div,
15713							_List_fromArray(
15714								[
15715									elm$html$Html$Attributes$class('elm-book__chapter-component__content')
15716								]),
15717							_List_fromArray(
15718								[html]))
15719						]))
15720				]));
15721	});
15722var dtwrks$elm_book$ElmBook$UI$ChapterComponent$viewDisplay = F2(
15723	function (options_, _n0) {
15724		var label = _n0.a;
15725		var html = _n0.b;
15726		var _n1 = options_.display;
15727		switch (_n1.$) {
15728			case 'Inline':
15729				return html;
15730			case 'Block':
15731				return A2(
15732					dtwrks$elm_book$ElmBook$UI$ChapterComponent$viewBlock,
15733					options_,
15734					_Utils_Tuple2(label, html));
15735			default:
15736				return A2(
15737					dtwrks$elm_book$ElmBook$UI$ChapterComponent$viewCard,
15738					options_,
15739					_Utils_Tuple2(label, html));
15740		}
15741	});
15742var elm$virtual_dom$VirtualDom$map = _VirtualDom_map;
15743var elm$html$Html$map = elm$virtual_dom$VirtualDom$map;
15744var dtwrks$elm_book$ElmBook$UI$ChapterComponent$view = F3(
15745	function (chapterTitle, options_, _n0) {
15746		var label = _n0.a;
15747		var html = _n0.b;
15748		return A2(
15749			elm$html$Html$map,
15750			function (msg) {
15751				var actionContext = (label !== '') ? (chapterTitle + (' / ' + (label + ' / '))) : (chapterTitle + ' / ');
15752				if (msg.$ === 'LogAction') {
15753					var label_ = msg.b;
15754					return A2(dtwrks$elm_book$ElmBook$Internal$Msg$LogAction, actionContext, label_);
15755				} else {
15756					return msg;
15757				}
15758			},
15759			A2(
15760				dtwrks$elm_book$ElmBook$UI$ChapterComponent$viewDisplay,
15761				options_,
15762				_Utils_Tuple2(label, html)));
15763	});
15764var elm$html$Html$a = _VirtualDom_node('a');
15765var elm$html$Html$blockquote = _VirtualDom_node('blockquote');
15766var elm$html$Html$br = _VirtualDom_node('br');
15767var elm$html$Html$code = _VirtualDom_node('code');
15768var elm$html$Html$em = _VirtualDom_node('em');
15769var elm$html$Html$h1 = _VirtualDom_node('h1');
15770var elm$html$Html$h2 = _VirtualDom_node('h2');
15771var elm$html$Html$h3 = _VirtualDom_node('h3');
15772var elm$html$Html$h4 = _VirtualDom_node('h4');
15773var elm$html$Html$h5 = _VirtualDom_node('h5');
15774var elm$html$Html$h6 = _VirtualDom_node('h6');
15775var elm$html$Html$hr = _VirtualDom_node('hr');
15776var elm$html$Html$img = _VirtualDom_node('img');
15777var elm$html$Html$input = _VirtualDom_node('input');
15778var elm$html$Html$ol = _VirtualDom_node('ol');
15779var elm$html$Html$pre = _VirtualDom_node('pre');
15780var elm$html$Html$span = _VirtualDom_node('span');
15781var elm$html$Html$strong = _VirtualDom_node('strong');
15782var elm$html$Html$table = _VirtualDom_node('table');
15783var elm$html$Html$tbody = _VirtualDom_node('tbody');
15784var elm$html$Html$td = _VirtualDom_node('td');
15785var elm$html$Html$th = _VirtualDom_node('th');
15786var elm$html$Html$thead = _VirtualDom_node('thead');
15787var elm$html$Html$tr = _VirtualDom_node('tr');
15788var elm$html$Html$Attributes$align = elm$html$Html$Attributes$stringProperty('align');
15789var elm$html$Html$Attributes$alt = elm$html$Html$Attributes$stringProperty('alt');
15790var elm$json$Json$Encode$bool = _Json_wrap;
15791var elm$html$Html$Attributes$boolProperty = F2(
15792	function (key, bool) {
15793		return A2(
15794			_VirtualDom_property,
15795			key,
15796			elm$json$Json$Encode$bool(bool));
15797	});
15798var elm$html$Html$Attributes$checked = elm$html$Html$Attributes$boolProperty('checked');
15799var elm$html$Html$Attributes$disabled = elm$html$Html$Attributes$boolProperty('disabled');
15800var elm$html$Html$Attributes$href = function (url) {
15801	return A2(
15802		elm$html$Html$Attributes$stringProperty,
15803		'href',
15804		_VirtualDom_noJavaScriptUri(url));
15805};
15806var elm$html$Html$Attributes$src = function (url) {
15807	return A2(
15808		elm$html$Html$Attributes$stringProperty,
15809		'src',
15810		_VirtualDom_noJavaScriptOrHtmlUri(url));
15811};
15812var elm$html$Html$Attributes$start = function (n) {
15813	return A2(
15814		elm$html$Html$Attributes$stringProperty,
15815		'start',
15816		elm$core$String$fromInt(n));
15817};
15818var elm$html$Html$Attributes$title = elm$html$Html$Attributes$stringProperty('title');
15819var elm$html$Html$Attributes$type_ = elm$html$Html$Attributes$stringProperty('type');
15820var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$HCode = function (a) {
15821	return {$: 'HCode', a: a};
15822};
15823var elm$parser$Parser$DeadEnd = F3(
15824	function (row, col, problem) {
15825		return {col: col, problem: problem, row: row};
15826	});
15827var elm$parser$Parser$problemToDeadEnd = function (p) {
15828	return A3(elm$parser$Parser$DeadEnd, p.row, p.col, p.problem);
15829};
15830var elm$parser$Parser$run = F2(
15831	function (parser, source) {
15832		var _n0 = A2(elm$parser$Parser$Advanced$run, parser, source);
15833		if (_n0.$ === 'Ok') {
15834			var a = _n0.a;
15835			return elm$core$Result$Ok(a);
15836		} else {
15837			var problems = _n0.a;
15838			return elm$core$Result$Err(
15839				A2(elm$core$List$map, elm$parser$Parser$problemToDeadEnd, problems));
15840		}
15841	});
15842var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3 = {$: 'Style3'};
15843var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style4 = {$: 'Style4'};
15844var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style5 = {$: 'Style5'};
15845var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRuleToFragment = function (a) {
15846	switch (a.$) {
15847		case 'Identifier':
15848			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3, 'css-ar-i');
15849		case 'Prefix':
15850			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style5, 'css-ar-p');
15851		case 'Keyword':
15852			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3, 'css-ar-k');
15853		default:
15854			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style4, 'css-ar-v');
15855	}
15856};
15857var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style2 = {$: 'Style2'};
15858var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeSelectorToFragment = function (att) {
15859	switch (att.$) {
15860		case 'AttributeName':
15861			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style5, 'css-s-a-an');
15862		case 'AttributeValue':
15863			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style2, 'css-s-a-av');
15864		default:
15865			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3, 'css-s-a-o');
15866	}
15867};
15868var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Default = {$: 'Default'};
15869var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style7 = {$: 'Style7'};
15870var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$selectorToFragment = function (s) {
15871	switch (s.$) {
15872		case 'Element':
15873			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3, 'css-s-e');
15874		case 'Id':
15875			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style5, 'css-s-i');
15876		case 'Class':
15877			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style5, 'css-s-cl');
15878		case 'Combinator':
15879			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style7, 'css-s-c');
15880		case 'Universal':
15881			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3, 'css-s-u');
15882		case 'AttributeSelector':
15883			var att = s.a;
15884			return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeSelectorToFragment(att);

15885		case 'PseudoElement':
15886			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Default, 'css-s-pe');
15887		default:
15888			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Default, 'css-s-pc');
15889	}
15890};
15891var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style1 = {$: 'Style1'};
15892var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$syntaxToStyle = function (syntax) {
15893	switch (syntax.$) {
15894		case 'String':
15895			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style2, 'css-s');
15896		case 'AtRule':
15897			var a = syntax.a;
15898			return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRuleToFragment(a);
15899		case 'Selector':
15900			var s = syntax.a;
15901			return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$selectorToFragment(s);
15902		case 'Property':
15903			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style4, 'css-p');
15904		case 'PropertyValue':
15905			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style4, 'css-pv');
15906		case 'Number':
15907			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style1, 'css-n');
15908		default:
15909			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3, 'css-u');
15910	}
15911};
15912var elm$parser$Parser$map = elm$parser$Parser$Advanced$map;
15913var elm$parser$Parser$toAdvancedStep = function (step) {
15914	if (step.$ === 'Loop') {
15915		var s = step.a;
15916		return elm$parser$Parser$Advanced$Loop(s);
15917	} else {
15918		var a = step.a;
15919		return elm$parser$Parser$Advanced$Done(a);
15920	}
15921};
15922var elm$parser$Parser$loop = F2(
15923	function (state, callback) {
15924		return A2(
15925			elm$parser$Parser$Advanced$loop,
15926			state,
15927			function (s) {
15928				return A2(
15929					elm$parser$Parser$map,
15930					elm$parser$Parser$toAdvancedStep,
15931					callback(s));
15932			});
15933	});
15934var elm$parser$Parser$Done = function (a) {
15935	return {$: 'Done', a: a};
15936};
15937var elm$parser$Parser$Loop = function (a) {
15938	return {$: 'Loop', a: a};
15939};
15940var elm$parser$Parser$UnexpectedChar = {$: 'UnexpectedChar'};
15941var elm$parser$Parser$chompIf = function (isGood) {
15942	return A2(elm$parser$Parser$Advanced$chompIf, isGood, elm$parser$Parser$UnexpectedChar);
15943};
15944var elm$parser$Parser$getChompedString = elm$parser$Parser$Advanced$getChompedString;
15945var elm$parser$Parser$oneOf = elm$parser$Parser$Advanced$oneOf;
15946var elm$parser$Parser$succeed = elm$parser$Parser$Advanced$succeed;
15947var elm$parser$Parser$andThen = elm$parser$Parser$Advanced$andThen;
15948var elm$parser$Parser$symbol = function (str) {
15949	return elm$parser$Parser$Advanced$symbol(
15950		A2(
15951			elm$parser$Parser$Advanced$Token,
15952			str,
15953			elm$parser$Parser$ExpectingSymbol(str)));
15954};
15955var elm$core$Dict$member = F2(
15956	function (key, dict) {
15957		var _n0 = A2(elm$core$Dict$get, key, dict);
15958		if (_n0.$ === 'Just') {
15959			return true;
15960		} else {
15961			return false;
15962		}
15963	});
15964var elm$core$Set$member = F2(
15965	function (key, _n0) {
15966		var dict = _n0.a;
15967		return A2(elm$core$Dict$member, key, dict);
15968	});
15969var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule = function (a) {
15970	return {$: 'AtRule', a: a};
15971};
15972var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Identifier = {$: 'Identifier'};
15973var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Prefix = {$: 'Prefix'};
15974var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$String = {$: 'String'};
15975var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRuleValue = {$: 'AtRuleValue'};
15976var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Keyword = {$: 'Keyword'};
15977var elm$core$Set$Set_elm_builtin = function (a) {
15978	return {$: 'Set_elm_builtin', a: a};
15979};
15980var elm$core$Set$empty = elm$core$Set$Set_elm_builtin(elm$core$Dict$empty);
15981var elm$core$Set$insert = F2(
15982	function (key, _n0) {
15983		var dict = _n0.a;
15984		return elm$core$Set$Set_elm_builtin(
15985			A3(elm$core$Dict$insert, key, _Utils_Tuple0, dict));
15986	});
15987var elm$core$Set$fromList = function (list) {
15988	return A3(elm$core$List$foldl, elm$core$Set$insert, elm$core$Set$empty, list);
15989};
15990var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRuleKeywordSet = elm$core$Set$fromList(
15991	_List_fromArray(
15992		['and', 'or', 'not', 'only']));
15993var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isAtRuleKeyword = function (n) {
15994	return A2(elm$core$Set$member, n, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRuleKeywordSet);
15995};
15996var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isCommentChar = function (c) {
15997	return _Utils_eq(
15998		c,
15999		_Utils_chr('/'));
16000};
16001var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$selectorNameInvalidCharSet = elm$core$Set$fromList(
16002	_List_fromArray(
16003		[
16004			_Utils_chr(':'),
16005			_Utils_chr('{'),
16006			_Utils_chr('}'),
16007			_Utils_chr(','),
16008			_Utils_chr('.'),
16009			_Utils_chr('#'),
16010			_Utils_chr('>'),
16011			_Utils_chr('+'),
16012			_Utils_chr('~'),
16013			_Utils_chr('*'),
16014			_Utils_chr('['),
16015			_Utils_chr(']'),
16016			_Utils_chr('|'),
16017			_Utils_chr(';'),
16018			_Utils_chr('('),
16019			_Utils_chr(')')
16020		]));
16021var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak = function (c) {
16022	return _Utils_eq(
16023		c,
16024		_Utils_chr('\n'));
16025};
16026var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isSpace = function (c) {
16027	return _Utils_eq(
16028		c,
16029		_Utils_chr(' ')) || _Utils_eq(
16030		c,
16031		_Utils_chr('\t'));
16032};
16033var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isWhitespace = function (c) {
16034	return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isSpace(c) || pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak(c);
16035};
16036var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar = function (c) {
16037	return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isWhitespace(c) || (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isCommentChar(c) || A2(elm$core$Set$member, c, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$selectorNameInvalidCharSet)));
16038};
16039var elm$parser$Parser$chompWhile = elm$parser$Parser$Advanced$chompWhile;
16040var elm$parser$Parser$ignorer = elm$parser$Parser$Advanced$ignorer;
16041var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile = function (isNotRelevant) {
16042	return A2(
16043		elm$parser$Parser$ignorer,
16044		A2(
16045			elm$parser$Parser$ignorer,
16046			elm$parser$Parser$succeed(_Utils_Tuple0),
16047			elm$parser$Parser$chompIf(isNotRelevant)),
16048		elm$parser$Parser$chompWhile(isNotRelevant));
16049};
16050var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C = function (a) {
16051	return {$: 'C', a: a};
16052};
16053var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRuleKeywordOrValue = function (revTokens) {
16054	return A2(
16055		elm$parser$Parser$map,
16056		function (n) {
16057			return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isAtRuleKeyword(n) ? A2(
16058				elm$core$List$cons,
16059				_Utils_Tuple2(
16060					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16061						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Keyword)),
16062					n),
16063				revTokens) : A2(
16064				elm$core$List$cons,
16065				_Utils_Tuple2(
16066					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16067						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRuleValue)),
16068					n),
16069				revTokens);
16070		},
16071		elm$parser$Parser$getChompedString(
16072			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar)));
16073};
16074var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRuleSet = elm$core$Set$fromList(
16075	_List_fromArray(
16076		['@page', '@font-face', '@swash', '@annotation', '@ornaments', '@stylistic', '@styleset', '@character-variant']));
16077var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$LineBreak = {$: 'LineBreak'};
16078var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$lineBreak = A2(
16079	elm$parser$Parser$map,
16080	function (_n0) {
16081		return _List_fromArray(
16082			[
16083				_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$LineBreak, '\n')
16084			]);
16085	},
16086	elm$parser$Parser$symbol('\n'));
16087var elm$parser$Parser$problem = function (msg) {
16088	return elm$parser$Parser$Advanced$problem(
16089		elm$parser$Parser$Problem(msg));
16090};
16091var elm$parser$Parser$end = elm$parser$Parser$Advanced$end(elm$parser$Parser$ExpectingEnd);
16092var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$addThen = F3(
16093	function (f, list, plist) {
16094		return A2(
16095			elm$parser$Parser$andThen,
16096			function (n) {
16097				return f(
16098					_Utils_ap(n, list));
16099			},
16100			plist);
16101	});
16102var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$consThen = F3(
16103	function (f, list, pn) {
16104		return A2(
16105			elm$parser$Parser$andThen,
16106			function (n) {
16107				return f(
16108					A2(elm$core$List$cons, n, list));
16109			},
16110			pn);
16111	});
16112var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile = F2(
16113	function (isNotRelevant, previousParser) {
16114		return A2(
16115			elm$parser$Parser$ignorer,
16116			previousParser,
16117			elm$parser$Parser$chompWhile(isNotRelevant));
16118	});
16119var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedUnne

16119stable = F2(
16120	function (options, revAList) {
16121		var defaultMap = options.defaultMap;
16122		var isNotRelevant = options.isNotRelevant;
16123		var end = options.end;
16124		var innerParsers = options.innerParsers;
16125		return elm$parser$Parser$oneOf(
16126			_List_fromArray(
16127				[
16128					A2(
16129					elm$parser$Parser$map,
16130					elm$core$Basics$always(
16131						A2(
16132							elm$core$List$cons,
16133							defaultMap(end),
16134							revAList)),
16135					elm$parser$Parser$symbol(end)),
16136					A2(
16137					elm$parser$Parser$map,
16138					elm$core$Basics$always(revAList),
16139					elm$parser$Parser$end),
16140					A3(
16141					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$addThen,
16142					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedUnnestable(options),
16143					revAList,
16144					elm$parser$Parser$oneOf(innerParsers)),
16145					A3(
16146					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$consThen,
16147					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedUnnestable(options),
16148					revAList,
16149					A2(
16150						elm$parser$Parser$map,
16151						defaultMap,
16152						elm$parser$Parser$getChompedString(
16153							A2(
16154								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
16155								isNotRelevant,
16156								elm$parser$Parser$chompIf(
16157									elm$core$Basics$always(true))))))
16158				]));
16159	});
16160var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedNestable = F3(
16161	function (nestLevel, options, revAList) {
16162		var defaultMap = options.defaultMap;
16163		var isNotRelevant = options.isNotRelevant;
16164		var start = options.start;
16165		var end = options.end;
16166		var innerParsers = options.innerParsers;
16167		return elm$parser$Parser$oneOf(
16168			_List_fromArray(
16169				[
16170					A2(
16171					elm$parser$Parser$andThen,
16172					function (n) {
16173						return (nestLevel === 1) ? elm$parser$Parser$succeed(n) : A3(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedNestable, nestLevel - 1, options, n);
16174					},
16175					A2(
16176						elm$parser$Parser$map,
16177						elm$core$Basics$always(
16178							A2(
16179								elm$core$List$cons,
16180								defaultMap(end),
16181								revAList)),
16182						elm$parser$Parser$symbol(end))),
16183					A3(
16184					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$consThen,
16185					A2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedNestable, nestLevel + 1, options),
16186					revAList,
16187					A2(
16188						elm$parser$Parser$map,
16189						defaultMap,
16190						elm$parser$Parser$getChompedString(
16191							A2(
16192								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
16193								isNotRelevant,
16194								elm$parser$Parser$symbol(start))))),
16195					A3(
16196					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$addThen,
16197					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedUnne

16197stable(options),
16198					revAList,
16199					elm$parser$Parser$oneOf(innerParsers)),
16200					A2(
16201					elm$parser$Parser$map,
16202					elm$core$Basics$always(revAList),
16203					elm$parser$Parser$end),
16204					A3(
16205					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$consThen,
16206					A2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedNestable, nestLevel, options),
16207					revAList,
16208					A2(
16209						elm$parser$Parser$map,
16210						defaultMap,
16211						elm$parser$Parser$getChompedString(
16212							A2(
16213								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
16214								isNotRelevant,
16215								elm$parser$Parser$chompIf(
16216									elm$core$Basics$always(true))))))
16217				]));
16218	});
16219var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedHelp = F2(
16220	function (options, revAList) {
16221		var start = options.start;
16222		var end = options.end;
16223		var isNotRelevant = options.isNotRelevant;
16224		var _n0 = _Utils_Tuple2(
16225			elm$core$String$uncons(options.start),
16226			elm$core$String$uncons(options.end));
16227		if (_n0.a.$ === 'Nothing') {
16228			var _n1 = _n0.a;
16229			return elm$parser$Parser$problem('Trying to parse a delimited helper, but the start token cannot be an empty string!');
16230		} else {
16231			if (_n0.b.$ === 'Nothing') {
16232				var _n2 = _n0.b;
16233				return elm$parser$Parser$problem('Trying to parse a delimited helper, but the end token cannot be an empty string!');
16234			} else {
16235				var _n3 = _n0.a.a;
16236				var startChar = _n3.a;
16237				var _n4 = _n0.b.a;
16238				var endChar = _n4.a;
16239				return options.isNestable ? A3(
16240					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedNestable,
16241					1,
16242					_Utils_update(
16243						options,
16244						{
16245							isNotRelevant: function (c) {
16246								return isNotRelevant(c) && ((!_Utils_eq(c, startChar)) && (!_Utils_eq(c, endChar)));
16247							}
16248						}),
16249					revAList) : A2(
16250					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedUnne

16250stable,
16251					_Utils_update(
16252						options,
16253						{
16254							isNotRelevant: function (c) {
16255								return isNotRelevant(c) && (!_Utils_eq(c, endChar));
16256							}
16257						}),
16258					revAList);
16259			}
16260		}
16261	});
16262var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited = function (options) {
16263	var start = options.start;
16264	var isNotRelevant = options.isNotRelevant;
16265	var defaultMap = options.defaultMap;
16266	return A2(
16267		elm$parser$Parser$andThen,
16268		function (n) {
16269			return A2(
16270				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimitedHelp,
16271				options,
16272				_List_fromArray(
16273					[n]));
16274		},
16275		A2(
16276			elm$parser$Parser$map,
16277			elm$core$Basics$always(
16278				defaultMap(start)),
16279			elm$parser$Parser$symbol(start)));
16280};
16281var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Comment = {$: 'Comment'};
16282var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$comment = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(
16283	{
16284		defaultMap: function (b) {
16285			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Comment, b);
16286		},
16287		end: '*/',
16288		innerParsers: _List_fromArray(
16289			[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$lineBreak]),
16290		isNestable: false,
16291		isNotRelevant: function (c) {
16292			return !pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak(c);
16293		},
16294		start: '/*'
16295	});
16296var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal = {$: 'Normal'};
16297var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep = function (revTokens) {
16298	return elm$parser$Parser$oneOf(
16299		_List_fromArray(
16300			[
16301				A2(
16302				elm$parser$Parser$map,
16303				function (b) {
16304					return elm$parser$Parser$Loop(
16305						A2(
16306							elm$core$List$cons,
16307							_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
16308							revTokens));
16309				},
16310				elm$parser$Parser$getChompedString(
16311					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isSpace))),
16312				A2(
16313				elm$parser$Parser$map,
16314				function (ns) {
16315					return elm$parser$Parser$Loop(
16316						_Utils_ap(ns, revTokens));
16317				},
16318				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$lineBreak),
16319				A2(
16320				elm$parser$Parser$map,
16321				function (ns) {
16322					return elm$parser$Parser$Loop(
16323						_Utils_ap(ns, revTokens));
16324				},
16325				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$comment)
16326			]));
16327};
16328var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$keyframesOrCounterStyle = function (a) {
16329	return A2(
16330		elm$parser$Parser$loop,
16331		_List_fromArray(
16332			[
16333				_Utils_Tuple2(
16334				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16335					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Identifier)),
16336				a)
16337			]),
16338		function (ns) {
16339			return elm$parser$Parser$oneOf(
16340				_List_fromArray(
16341					[
16342						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep(ns),
16343						A2(
16344						elm$parser$Parser$map,
16345						function (b) {
16346							return elm$parser$Parser$Loop(
16347								A2(
16348									elm$core$List$cons,
16349									_Utils_Tuple2(
16350										pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16351											pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Prefix)),
16352										b),
16353									ns));
16354						},
16355						elm$parser$Parser$getChompedString(
16356							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar))),
16357						A2(
16358						elm$parser$Parser$map,
16359						function (b) {
16360							return elm$parser$Parser$Loop(
16361								A2(
16362									elm$core$List$cons,
16363									_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
16364									ns));
16365						},
16366						elm$parser$Parser$getChompedString(
16367							elm$parser$Parser$chompIf(
16368								function (c) {
16369									return !_Utils_eq(
16370										c,
16371										_Utils_chr('{'));
16372								}))),
16373						elm$parser$Parser$succeed(
16374						elm$parser$Parser$Done(ns))
16375					]));
16376		});
16377};
16378var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$nestableAtRuleOpener = function (ns) {
16379	return elm$parser$Parser$oneOf(
16380		_List_fromArray(
16381			[
16382				A2(
16383				elm$parser$Parser$map,
16384				elm$core$Basics$always(
16385					A2(
16386						elm$core$List$cons,
16387						_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, '{'),
16388						ns)),
16389				elm$parser$Parser$symbol('{')),
16390				elm$parser$Parser$succeed(ns)
16391			]));
16392};
16393var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Number = {$: 'Number'};
16394var elm$parser$Parser$backtrackable = elm$parser$Parser$Advanced$backtrackable;
16395var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$escapableSet = elm$core$Set$fromList(
16396	_List_fromArray(
16397		[
16398			_Utils_chr('\''),
16399			_Utils_chr('\"'),
16400			_Utils_chr('\\'),
16401			_Utils_chr('n'),
16402			_Utils_chr('r'),
16403			_Utils_chr('t'),
16404			_Utils_chr('b'),
16405			_Utils_chr('f'),
16406			_Utils_chr('v')
16407		]));
16408var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isEscapableChar = function (c) {
16409	return A2(elm$core$Set$member, c, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$escapableSet);
16410};
16411var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$escapable = A2(
16412	elm$parser$Parser$ignorer,
16413	A2(
16414		elm$parser$Parser$ignorer,
16415		elm$parser$Parser$succeed(_Utils_Tuple0),
16416		elm$parser$Parser$backtrackable(
16417			elm$parser$Parser$symbol('\\'))),
16418	elm$parser$Parser$chompIf(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isEscapableChar));
16419var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$cssEscapable = A2(
16420	elm$parser$Parser$map,
16421	function (b) {
16422		return _List_fromArray(
16423			[
16424				_Utils_Tuple2(
16425				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Number),
16426				b)
16427			]);
16428	},
16429	elm$parser$Parser$getChompedString(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$escapable));
16430var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isEscapable = function (c) {
16431	return _Utils_eq(
16432		c,
16433		_Utils_chr('\\'));
16434};
16435var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$quoteDelimiter = {
16436	defaultMap: function (b) {
16437		return _Utils_Tuple2(
16438			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$String),
16439			b);
16440	},
16441	end: '\'',
16442	innerParsers: _List_fromArray(
16443		[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$lineBreak, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$cssEscapable]),
16444	isNestable: false,
16445	isNotRelevant: function (c) {
16446		return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak(c) || pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isEscapable(c));
16447	},
16448	start: '\''
16449};
16450var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$doubleQuote = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(
16451	_Utils_update(
16452		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$quoteDelimiter,
16453		{end: '\"', start: '\"'}));
16454var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$quote = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$quoteDelimiter);
16455var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringLiteral = function (revTokens) {
16456	return A2(
16457		elm$parser$Parser$map,
16458		function (n) {
16459			return _Utils_ap(n, revTokens);
16460		},
16461		elm$parser$Parser$oneOf(
16462			_List_fromArray(
16463				[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$quote, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$doubleQuote])));
16464};
16465var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$mediaOrSupports = function (a) {
16466	return A2(
16467		elm$parser$Parser$andThen,
16468		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$nestableAtRuleOpener,
16469		A2(
16470			elm$parser$Parser$loop,
16471			_List_fromArray(
16472				[
16473					_Utils_Tuple2(
16474					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16475						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Identifier)),
16476					a)
16477				]),
16478			function (ns) {
16479				return elm$parser$Parser$oneOf(
16480					_List_fromArray(
16481						[
16482							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep(ns),
16483							A2(
16484							elm$parser$Parser$map,
16485							elm$parser$Parser$Loop,
16486							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringLiteral(ns)),
16487							A2(
16488							elm$parser$Parser$map,
16489							elm$parser$Parser$Loop,
16490							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRuleKeywordOrValue(ns)),
16491							A2(
16492							elm$parser$Parser$map,
16493							function (b) {
16494								return elm$parser$Parser$Loop(
16495									A2(
16496										elm$core$List$cons,
16497										_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
16498										ns));
16499							},
16500							elm$parser$Parser$getChompedString(
16501								elm$parser$Parser$chompIf(
16502									function (c) {
16503										return !_Utils_eq(
16504											c,
16505											_Utils_chr('{'));
16506									}))),
16507							elm$parser$Parser$succeed(
16508							elm$parser$Parser$Done(ns))
16509						]));
16510			}));
16511};
16512var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$PropertyValue = {$: 'PropertyValue'};
16513var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringArg = F2(
16514	function (fnStr, revTokens) {
16515		return A2(
16516			elm$parser$Parser$andThen,
16517			function (revT_) {
16518				return elm$parser$Parser$oneOf(
16519					_List_fromArray(
16520						[
16521							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringLiteral(revT_),
16522							A2(
16523							elm$parser$Parser$map,
16524							function (n) {
16525								return A2(
16526									elm$core$List$cons,
16527									_Utils_Tuple2(
16528										pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$String),
16529										n),
16530									revT_);
16531							},
16532							elm$parser$Parser$getChompedString(
16533								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(
16534									function (c) {
16535										return !_Utils_eq(
16536											c,
16537											_Utils_chr(')'));
16538									}))),
16539							elm$parser$Parser$succeed(revT_)
16540						]));
16541			},
16542			A2(
16543				elm$parser$Parser$map,
16544				elm$core$Basics$always(
16545					A2(
16546						elm$core$List$cons,
16547						_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, '('),
16548						A2(
16549							elm$core$List$cons,
16550							_Utils_Tuple2(
16551								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$PropertyValue),
16552								fnStr),
16553							revTokens))),
16554				elm$parser$Parser$symbol(fnStr + '(')));
16555	});
16556var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRuleHelper = function (a) {
16557	switch (a) {
16558		case '@import':
16559			return A2(
16560				elm$parser$Parser$loop,
16561				_List_fromArray(
16562					[
16563						_Utils_Tuple2(
16564						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16565							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Identifier)),
16566						a)
16567					]),
16568				function (ns) {
16569					return elm$parser$Parser$oneOf(
16570						_List_fromArray(
16571							[
16572								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep(ns),
16573								A2(
16574								elm$parser$Parser$map,
16575								elm$parser$Parser$Loop,
16576								A2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringArg, 'url', ns)),
16577								A2(
16578								elm$parser$Parser$map,
16579								elm$parser$Parser$Loop,
16580								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringLiteral(ns)),
16581								A2(
16582								elm$parser$Parser$map,
16583								elm$parser$Parser$Loop,
16584								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRuleKeywordOrValue(ns)),
16585								A2(
16586								elm$parser$Parser$map,
16587								function (b) {
16588									return elm$parser$Parser$Loop(
16589										A2(
16590											elm$core$List$cons,
16591											_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
16592											ns));
16593								},
16594								elm$parser$Parser$getChompedString(
16595									elm$parser$Parser$chompIf(
16596										function (c) {
16597											return !_Utils_eq(
16598												c,
16599												_Utils_chr(';'));
16600										}))),
16601								elm$parser$Parser$succeed(
16602								elm$parser$Parser$Done(ns))
16603							]));
16604				});
16605		case '@namespace':
16606			return A2(
16607				elm$parser$Parser$loop,
16608				_List_fromArray(
16609					[
16610						_Utils_Tuple2(
16611						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16612							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Identifier)),
16613						a)
16614					]),
16615				function (ns) {
16616					return elm$parser$Parser$oneOf(
16617						_List_fromArray(
16618							[
16619								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep(ns),
16620								A2(
16621								elm$parser$Parser$map,
16622								elm$parser$Parser$Loop,
16623								A2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringArg, 'url', ns)),
16624								A2(
16625								elm$parser$Parser$map,
16626								elm$parser$Parser$Loop,
16627								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringLiteral(ns)),
16628								A2(
16629								elm$parser$Parser$map,
16630								function (b) {
16631									return elm$parser$Parser$Loop(
16632										A2(
16633											elm$core$List$cons,
16634											_Utils_Tuple2(
16635												pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16636													pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Prefix)),
16637												b),
16638											ns));
16639								},
16640								elm$parser$Parser$getChompedString(
16641									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar))),
16642								A2(
16643								elm$parser$Parser$map,
16644								function (b) {
16645									return elm$parser$Parser$Loop(
16646										A2(
16647											elm$core$List$cons,
16648											_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
16649											ns));
16650								},
16651								elm$parser$Parser$getChompedString(
16652									elm$parser$Parser$chompIf(
16653										function (c) {
16654											return !_Utils_eq(
16655												c,
16656												_Utils_chr(';'));
16657										}))),
16658								elm$parser$Parser$succeed(
16659								elm$parser$Parser$Done(ns))
16660							]));
16661				});
16662		case '@charset':
16663			return A2(
16664				elm$parser$Parser$loop,
16665				_List_fromArray(
16666					[
16667						_Utils_Tuple2(
16668						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16669							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Identifier)),
16670						a)
16671					]),
16672				function (ns) {
16673					return elm$parser$Parser$oneOf(
16674						_List_fromArray(
16675							[
16676								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep(ns),
16677								A2(
16678								elm$parser$Parser$map,
16679								elm$parser$Parser$Loop,
16680								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringLiteral(ns)),
16681								A2(
16682								elm$parser$Parser$map,
16683								function (b) {
16684									return elm$parser$Parser$Loop(
16685										A2(
16686											elm$core$List$cons,
16687											_Utils_Tuple2(
16688												pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$String),
16689												b),
16690											n

16690s));
16691								},
16692								elm$parser$Parser$getChompedString(
16693									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar))),
16694								A2(
16695								elm$parser$Parser$map,
16696								function (b) {
16697									return elm$parser$Parser$Loop(
16698										A2(
16699											elm$core$List$cons,
16700											_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
16701											ns));
16702								},
16703								elm$parser$Parser$getChompedString(
16704									elm$parser$Parser$chompIf(
16705										function (c) {
16706											return !_Utils_eq(
16707												c,
16708												_Utils_chr(';'));
16709										}))),
16710								elm$parser$Parser$succeed(
16711								elm$parser$Parser$Done(ns))
16712							]));
16713				});
16714		case '@media':
16715			return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$mediaOrSupports(a);
16716		case '@supports':
16717			return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$mediaOrSupports(a);
16718		case '@keyframes':
16719			return A2(
16720				elm$parser$Parser$andThen,
16721				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$nestableAtRuleOpener,
16722				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$keyframesOrCounterStyle(a));
16723		case '@counter-style':
16724			return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$keyframesOrCounterStyle(a);
16725		case '@font-feature-values':
16726			return A2(
16727				elm$parser$Parser$andThen,
16728				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$nestableAtRuleOpener,
16729				A2(
16730					elm$parser$Parser$loop,
16731					_List_fromArray(
16732						[
16733							_Utils_Tuple2(
16734							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16735								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Identifier)),
16736							a)
16737						]),
16738					function (ns) {
16739						return elm$parser$Parser$oneOf(
16740							_List_fromArray(
16741								[
16742									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep(ns),
16743									A2(
16744									elm$parser$Parser$map,
16745									function (b) {
16746										return elm$parser$Parser$Loop(
16747											A2(
16748												elm$core$List$cons,
16749												_Utils_Tuple2(
16750													pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16751														pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Prefix)),
16752													b),
16753												ns));
16754									},
16755									elm$parser$Parser$getChompedString(
16756										pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar))),
16757									A2(
16758									elm$parser$Parser$map,
16759									function (b) {
16760										return elm$parser$Parser$Loop(
16761											A2(
16762												elm$core$List$cons,
16763												_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
16764												ns));
16765									},
16766									elm$parser$Parser$getChompedString(
16767										elm$parser$Parser$chompIf(
16768											function (c) {
16769												return !_Utils_eq(
16770													c,
16771													_Utils_chr('{'));
16772											}))),
16773									elm$parser$Parser$succeed(
16774									elm$parser$Parser$Done(ns))
16775								]));
16776					}));
16777		default:
16778			return A2(elm$core$Set$member, a, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRuleSet) ? elm$parser$Parser$succeed(
16779				_List_fromArray(
16780					[
16781						_Utils_Tuple2(
16782						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
16783							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AtRule(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Identifier)),
16784						a)
16785					])) : elm$parser$Parser$succeed(
16786				_List_fromArray(
16787					[
16788						_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, a)
16789					]));
16790	}
16791};
16792var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRule = A2(
16793	elm$parser$Parser$andThen,
16794	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRuleHelper,
16795	elm$parser$Parser$getChompedString(
16796		A2(
16797			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
16798			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar,
16799			elm$parser$Parser$symbol('@'))));
16800var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Property = {$: 'Property'};
16801var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isPropertyChar = function (c) {
16802	return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isWhitespace(c) || (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isCommentChar(c) || (_Utils_eq(
16803		c,
16804		_Utils_chr(':')) || (_Utils_eq(
16805		c,
16806		_Utils_chr(';')) || _Utils_eq(
16807		c,
16808		_Utils_chr('}'))))));
16809};
16810var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Unit = {$: 'Unit'};
16811var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$operatorCharSet = elm$core$Set$fromList(
16812	_List_fromArray(
16813		[
16814			_Utils_chr('+'),
16815			_Utils_chr('-'),
16816			_Utils_chr('%'),
16817			_Utils_chr('*'),
16818			_Utils_chr('/')
16819		]));
16820var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isOperatorChar = function (c) {
16821	return A2(elm$core$Set$member, c, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$operatorCharSet);
16822};
16823var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isPropertyValueChar = function (c) {
16824	return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isPropertyChar(c) && (!(_Utils_eq(
16825		c,
16826		_Utils_chr('(')) || (_Utils_eq(
16827		c,
16828		_Utils_chr(')')) || (_Utils_eq(
16829		c,
16830		_Utils_chr(',')) || pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isOperatorChar(c)))));
16831};
16832var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$hexColor = function (revTokens) {
16833	return A2(
16834		elm$parser$Parser$map,
16835		function (n) {
16836			return A2(
16837				elm$core$List$cons,
16838				_Utils_Tuple2(
16839					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Number),
16840					n),
16841				revTokens);
16842		},
16843		elm$parser$Parser$getChompedString(
16844			A2(
16845				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
16846				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isPropertyValueChar,
16847				elm$parser$Parser$symbol('#'))));
16848};
16849var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isNotPropertyValueChar = function (c) {
16850	return _Utils_eq(
16851		c,
16852		_Utils_chr('(')) || (_Utils_eq(
16853		c,
16854		_Utils_chr(')')) || (_Utils_eq(
16855		c,
16856		_Utils_chr(':')) || (_Utils_eq(
16857		c,
16858		_Utils_chr(',')) || _Utils_eq(
16859		c,
16860		_Utils_chr('/')))));
16861};
16862var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$unitSet = elm$core$Set$fromList(
16863	_List_fromArray(
16864		['em', 'ex', 'ch', 'rem', 'vw', 'vh', 'vmin', 'vmax', 'cm', 'mm', 'q', 'in', 'pt', 'pc', 'px', 'deg', 'grad', 'rad', 'turn', 's', 'ms', 'Hz', 'kHz', 'dpi', 'dpcm', 'dppx']));
16865var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isUnit = function (n) {
16866	return A2(elm$core$Set$member, n, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$unitSet);
16867};
16868var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isNumber = function (c) {
16869	return elm$core$Char$isDigit(c) || _Utils_eq(
16870		c,
16871		_Utils_chr('.'));
16872};
16873var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$positiveNumber = A2(
16874	elm$parser$Parser$ignorer,
16875	A2(
16876		elm$parser$Parser$ignorer,
16877		elm$parser$Parser$succeed(_Utils_Tuple0),
16878		elm$parser$Parser$chompIf(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isNumber)),
16879	elm$parser$Parser$chompWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isNumber));
16880var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$negativeNumber = A2(
16881	elm$parser$Parser$ignorer,
16882	A2(
16883		elm$parser$Parser$ignorer,
16884		elm$parser$Parser$succeed(_Utils_Tuple0),
16885		elm$parser$Parser$backtrackable(
16886			elm$parser$Parser$symbol('-'))),
16887	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$positiveNumber);
16888var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$number = elm$parser$Parser$oneOf(
16889	_List_fromArray(
16890		[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$positiveNumber, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$negativeNumber]));
16891var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$number = A2(
16892	elm$parser$Parser$map,
16893	function (b) {
16894		return _Utils_Tuple2(
16895			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Number),
16896			b);
16897	},
16898	elm$parser$Parser$getChompedString(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$number));
16899var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$valueLoop = function (revTokens) {
16900	return elm$parser$Parser$oneOf(
16901		_List_fromArray(
16902			[
16903				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep(revTokens),
16904				A2(
16905				elm$parser$Parser$map,
16906				elm$parser$Parser$Loop,
16907				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringLiteral(revTokens)),
16908				A2(
16909				elm$parser$Parser$map,
16910				function (n) {
16911					return elm$parser$Parser$Loop(
16912						A2(elm$core$List$cons, n, revTokens));
16913				},
16914				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$number),
16915				A2(
16916				elm$parser$Parser$map,
16917				elm$parser$Parser$Loop,
16918				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$hexColor(revTokens)),
16919				A2(
16920				elm$parser$Parser$map,
16921				elm$parser$Parser$Loop,
16922				A2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringArg, 'url', revTokens)),
16923				A2(
16924				elm$parser$Parser$map,
16925				elm$parser$Parser$Loop,
16926				A2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringArg, 'format', revTokens)),
16927				A2(
16928				elm$parser$Parser$map,
16929				elm$parser$Parser$Loop,
16930				A2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringArg, 'local', revTokens)),
16931				A2(
16932				elm$parser$Parser$map,
16933				function (n) {
16934					return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isUnit(n) ? elm$parser$Parser$Loop(
16935						A2(
16936							elm$core$List$cons,
16937							_Utils_Tuple2(
16938								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Unit),

16939								n),
16940							revTokens)) : elm$parser$Parser$Loop(
16941						A2(
16942							elm$core$List$cons,
16943							_Utils_Tuple2(
16944								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$PropertyValue),
16945								n),
16946							revTokens));
16947				},
16948				elm$parser$Parser$getChompedString(
16949					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isPropertyValueChar))),
16950				A2(
16951				elm$parser$Parser$map,
16952				function (b) {
16953					return elm$parser$Parser$Loop(
16954						A2(
16955							elm$core$List$cons,
16956							_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
16957							revTokens));
16958				},
16959				elm$parser$Parser$getChompedString(
16960					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isNotPropertyValueChar))),
16961				A2(
16962				elm$parser$Parser$map,
16963				function (b) {
16964					return elm$parser$Parser$Loop(
16965						A2(
16966							elm$core$List$cons,
16967							_Utils_Tuple2(
16968								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Unit),
16969								b),
16970							revTokens));
16971				},
16972				elm$parser$Parser$getChompedString(
16973					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isOperatorChar))),
16974				elm$parser$Parser$succeed(
16975				elm$parser$Parser$Done(revTokens))
16976			]));
16977};
16978var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$valueHelper = function (opener) {
16979	return A2(
16980		elm$parser$Parser$loop,
16981		_List_fromArray(
16982			[opener]),
16983		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$valueLoop);
16984};
16985var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$value = A2(
16986	elm$parser$Parser$andThen,
16987	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$valueHelper,
16988	A2(
16989		elm$parser$Parser$map,
16990		function (b) {
16991			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
16992		},
16993		elm$parser$Parser$getChompedString(
16994			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(
16995				elm$core$Basics$eq(
16996					_Utils_chr(':'))))));
16997var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$declarationLoop = function (revTokens) {
16998	return elm$parser$Parser$oneOf(
16999		_List_fromArray(
17000			[
17001				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep(revTokens),
17002				A2(
17003				elm$parser$Parser$map,
17004				function (b) {
17005					return elm$parser$Parser$Loop(
17006						A2(
17007							elm$core$List$cons,
17008							_Utils_Tuple2(
17009								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Property),
17010								b),
17011							revTokens));
17012				},
17013				elm$parser$Parser$getChompedString(
17014					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isPropertyChar))),
17015				A2(
17016				elm$parser$Parser$map,
17017				function (b) {
17018					return elm$parser$Parser$Loop(
17019						A2(
17020							elm$core$List$cons,
17021							_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
17022							revTokens));
17023				},
17024				elm$parser$Parser$getChompedString(
17025					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(
17026						function (c) {
17027							return _Utils_eq(
17028								c,
17029								_Utils_chr(';')) || _Utils_eq(
17030								c,
17031								_Utils_chr('/'));
17032						}))),
17033				A2(
17034				elm$parser$Parser$map,
17035				function (n) {
17036					return elm$parser$Parser$Loop(
17037						_Utils_ap(n, revTokens));
17038				},
17039				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$value),
17040				elm$parser$Parser$succeed(
17041				elm$parser$Parser$Done(revTokens))
17042			]));
17043};
17044var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$declarationBlockHelper = function (opener) {
17045	return A2(
17046		elm$parser$Parser$loop,
17047		_List_fromArray(
17048			[opener]),
17049		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$declarationLoop);
17050};
17051var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$declarationBlock = A2(
17052	elm$parser$Parser$andThen,
17053	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$declarationBlockHelper,
17054	A2(
17055		elm$parser$Parser$map,
17056		function (b) {
17057			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
17058		},
17059		elm$parser$Parser$getChompedString(
17060			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(
17061				function (c) {
17062					return _Utils_eq(
17063						c,
17064						_Utils_chr('{'));
17065				}))));
17066var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Selector = function (a) {
17067	return {$: 'Selector', a: a};
17068};
17069var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AttributeName = {$: 'AttributeName'};
17070var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AttributeSelector = function (a) {
17071	return {$: 'AttributeSelector', a: a};
17072};
17073var elm$core$Dict$union = F2(
17074	function (t1, t2) {
17075		return A3(elm$core$Dict$foldl, elm$core$Dict$insert, t2, t1);
17076	});
17077var elm$core$Set$union = F2(
17078	function (_n0, _n1) {
17079		var dict1 = _n0.a;
17080		var dict2 = _n1.a;
17081		return elm$core$Set$Set_elm_builtin(
17082			A2(elm$core$Dict$union, dict1, dict2));
17083	});
17084var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attSelOperatorCharSet = elm$core$Set$fromList(
17085	_List_fromArray(
17086		[
17087			_Utils_chr('='),
17088			_Utils_chr('~'),
17089			_Utils_chr('|'),
17090			_Utils_chr('^'),
17091			_Utils_chr('$'),
17092			_Utils_chr('*')
17093		]));
17094var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$whitespaceCharSet = elm$core$Set$fromList(
17095	_List_fromArray(
17096		[
17097			_Utils_chr(' '),
17098			_Utils_chr('\t'),
17099			_Utils_chr('\n')
17100		]));
17101var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attSelNameInvalidCharSet = A2(
17102	elm$core$Set$insert,
17103	_Utils_chr(']'),
17104	A2(elm$core$Set$union, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attSelOperatorCharSet, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$whitespaceCharSet));
17105var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeName = A2(
17106	elm$parser$Parser$map,
17107	function (b) {
17108		return _Utils_Tuple2(
17109			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
17110				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Selector(
17111					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AttributeSelector(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AttributeName))),
17112			b);
17113	},
17114	elm$parser$Parser$getChompedString(
17115		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(
17116			function (c) {
17117				return !A2(elm$core$Set$member, c, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attSelNameInvalidCharSet);
17118			})));
17119var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AttributeOperator = {$: 'AttributeOperator'};
17120var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeOperator = A2(
17121	elm$parser$Parser$map,
17122	function (b) {
17123		return _Utils_Tuple2(
17124			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
17125				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Selector(
17126					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AttributeSelector(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AttributeOperator))),
17127			b);
17128	},
17129	elm$parser$Parser$getChompedString(
17130		elm$parser$Parser$oneOf(
17131			_List_fromArray(
17132				[
17133					elm$parser$Parser$symbol('~='),
17134					elm$parser$Parser$symbol('|='),
17135					elm$parser$Parser$symbol('^='),
17136					elm$parser$Parser$symbol('$='),
17137					elm$parser$Parser$symbol('*='),
17138					elm$parser$Parser$symbol('=')
17139				]))));
17140var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AttributeValue = {$: 'AttributeValue'};
17141var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeValue = function (revTokens) {
17142	return elm$parser$Parser$oneOf(
17143		_List_fromArray(
17144			[
17145				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep(revTokens),
17146				A2(
17147				elm$parser$Parser$map,
17148				elm$parser$Parser$Done,
17149				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$stringLiteral(revTokens)),
17150				A2(
17151				elm$parser$Parser$map,
17152				elm$parser$Parser$Done,
17153				A2(
17154					elm$parser$Parser$map,
17155					function (b) {
17156						return A2(
17157							elm$core$List$cons,
17158							_Utils_Tuple2(
17159								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
17160									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Selector(
17161										pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AttributeSelector(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$AttributeValue))),
17162								b),
17163							revTokens);
17164					},
17165					elm$parser$Parser$getChompedString(
17166						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(
17167							function (c) {
17168								return (!_Utils_eq(
17169									c,
17170									_Utils_chr(']'))) && (!pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isWhitespace(c));
17171							})))),
17172				elm$parser$Parser$succeed(
17173				elm$parser$Parser$Done(revTokens))
17174			]));
17175};
17176var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeSelectorLoop = function (revTokens) {
17177	return elm$parser$Parser$oneOf(
17178		_List_fromArray(
17179			[
17180				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep(revTokens),
17181				A2(
17182				elm$parser$Parser$map,
17183				function (n) {
17184					return elm$parser$Parser$Loop(
17185						A2(elm$core$List$cons, n, revTokens));
17186				},
17187				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeName),
17188				A2(
17189				elm$parser$Parser$andThen,
17190				function (operator) {
17191					return A2(
17192						elm$parser$Parser$map,
17193						function (n) {
17194							return elm$parser$Parser$Loop(
17195								_Utils_ap(n, revTokens));
17196						},
17197						A2(
17198							elm$parser$Parser$loop,
17199							_List_fromArray(
17200								[operator]),
17201							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeValue));
17202				},
17203				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeOperator),
17204				elm$parser$Parser$succeed(
17205				elm$parser$Parser$Done(revTokens))
17206			]));
17207};
17208var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeSelector = A2(
17209	elm$parser$Parser$andThen,
17210	function (opener) {
17211		return A2(
17212			elm$parser$Parser$loop,
17213			_List_fromArray(
17214				[opener]),
17215			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeSelectorLoop);
17216	},
17217	A2(
17218		elm$parser$Parser$map,
17219		elm$core$Basics$always(
17220			_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, '[')),
17221		elm$parser$Parser$symbol('[')));
17222var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Class = {$: 'Class'};
17223var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$class = A2(
17224	elm$parser$Parser$map,
17225	function (b) {
17226		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Class, b);
17227	},
17228	elm$parser$Parser$getChompedString(
17229		A2(
17230			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
17231			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar,
17232			elm$parser$Parser$symbol('.'))));
17233var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Combinator = {$: 'Combinator'};
17234var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$combinator = A2(
17235	elm$parser$Parser$map,
17236	function (b) {
17237		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Combinator, b);
17238	},
17239	elm$parser$Parser$getChompedString(
17240		elm$parser$Parser$oneOf(
17241			_List_fromArray(
17242				[
17243					elm$parser$Parser$symbol('+'),
17244					elm$parser$Parser$symbol('~'),
17245					elm$parser$Parser$symbol('>')
17246				]))));
17247var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Element = {$: 'Element'};
17248var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$element = A2(
17249	elm$parser$Parser$map,
17250	function (b) {
17251		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Element, b);
17252	},
17253	elm$parser$Parser$getChompedString(
17254		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar)));
17255var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Id = {$: 'Id'};
17256var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$id = A2(
17257	elm$parser$Parser$map,
17258	function (b) {
17259		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Id, b);
17260	},
17261	elm$parser$Parser$getChompedString(
17262		A2(
17263			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
17264			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar,
17265			elm$parser$Parser$symbol('#'))));
17266var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$PseudoClass = {$: 'PseudoClass'};
17267var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$pseudoClass = A2(
17268	elm$parser$Parser$map,
17269	function (b) {
17270		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$PseudoClass, b);
17271	},
17272	elm$parser$Parser$getChompedString(
17273		A2(
17274			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
17275			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar,
17276			elm$parser$Parser$symbol(':'))));
17277var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$PseudoElement = {$: 'PseudoElement'};
17278var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$pseudoElement = A2(
17279	elm$parser$Parser$map,
17280	function (b) {
17281		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$PseudoElement, b);
17282	},
17283	elm$parser$Parser$getChompedString(
17284		A2(
17285			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
17286			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$isSelectorNameChar,
17287			elm$parser$Parser$symbol('::'))));
17288var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Universal = {$: 'Universal'};
17289var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$universal = A2(
17290	elm$parser$Parser$map,
17291	elm$core$Basics$always(
17292		_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Universal, '*')),
17293	elm$parser$Parser$symbol('*'));
17294var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$selector = elm$parser$Parser$oneOf(
17295	_List_fromArray(
17296		[
17297			A2(
17298			elm$parser$Parser$map,
17299			function (_n0) {
17300				var n = _n0.a;
17301				var s = _n0.b;
17302				return _List_fromArray(
17303					[
17304						_Utils_Tuple2(
17305						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(
17306							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$Selector(n)),
17307						s)
17308					]);
17309			},
17310			elm$parser$Parser$oneOf(
17311				_List_fromArray(
17312					[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$id, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$class, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$element, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$universal, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$combinator, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$pseudoElement, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$pseudoClass]))),
17313			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$attributeSelector
17314		]));
17315var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$mainLoop = function (revTokens) {
17316	return elm$parser$Parser$oneOf(
17317		_List_fromArray(
17318			[
17319				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$whitespaceOrCommentStep(revTokens),
17320				A2(
17321				elm$parser$Parser$map,
17322				function (n) {
17323					return elm$parser$Parser$Loop(
17324						_Utils_ap(n, revTokens));
17325				},
17326				

17326pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$atRule),
17327				A2(
17328				elm$parser$Parser$map,
17329				function (n) {
17330					return elm$parser$Parser$Loop(
17331						_Utils_ap(n, revTokens));
17332				},
17333				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$selector),
17334				A2(
17335				elm$parser$Parser$map,
17336				function (n) {
17337					return elm$parser$Parser$Loop(
17338						_Utils_ap(n, revTokens));
17339				},
17340				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$declarationBlock),
17341				A2(
17342				elm$parser$Parser$map,
17343				function (b) {
17344					return elm$parser$Parser$Loop(
17345						A2(
17346							elm$core$List$cons,
17347							_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
17348							revTokens));
17349				},
17350				elm$parser$Parser$getChompedString(
17351					elm$parser$Parser$chompIf(
17352						elm$core$Basics$always(true)))),
17353				elm$parser$Parser$succeed(
17354				elm$parser$Parser$Done(revTokens))
17355			]));
17356};
17357var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$toRevTokens = A2(elm$parser$Parser$loop, _List_Nil, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$mainLoop);
17358var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$newLine = function (fragments) {
17359	return {fragments: fragments, highlight: elm$core$Maybe$Nothing};
17360};
17361var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Comment = {$: 'Comment'};
17362var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toFragment = F2(
17363	function (toStyle, _n0) {
17364		var syntax = _n0.a;
17365		var text = _n0.b;
17366		switch (syntax.$) {
17367			case 'Normal':
17368				return {additionalClass: '', requiredStyle: pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Default, text: text};
17369			case 'Comment':
17370				return {additionalClass: '', requiredStyle: pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Comment, text: text};
17371			case 'LineBreak':
17372				return {additionalClass: '', requiredStyle: pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Default, text: text};
17373			default:
17374				var c = syntax.a;
17375				var _n2 = toStyle(c);
17376				var requiredStyle = _n2.a;
17377				var additionalClass = _n2.b;
17378				return {additionalClass: additionalClass, requiredStyle: requiredStyle, text: text};
17379		}
17380	});
17381var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toLinesHelp = F3(
17382	function (toStyle, _n0, _n1) {
17383		var syntax = _n0.a;
17384		var text = _n0.b;
17385		var lines = _n1.a;
17386		var fragments = _n1.b;
17387		var maybeLastSyntax = _n1.c;
17388		if (_Utils_eq(syntax, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$LineBreak)) {
17389			return _Utils_Tuple3(
17390				A2(
17391					elm$core$List$cons,
17392					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$newLine(fragments),
17393					lines),
17394				_List_fromArray(
17395					[
17396						A2(
17397						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toFragment,
17398						toStyle,
17399						_Utils_Tuple2(syntax, text))
17400					]),
17401				elm$core$Maybe$Nothing);
17402		} else {
17403			if (_Utils_eq(
17404				elm$core$Maybe$Just(syntax),
17405				maybeLastSyntax)) {
17406				if (fragments.b) {
17407					var headFrag = fragments.a;
17408					var tailFrags = fragments.b;
17409					return _Utils_Tuple3(
17410						lines,
17411						A2(
17412							elm$core$List$cons,
17413							_Utils_update(
17414								headFrag,
17415								{
17416									text: _Utils_ap(text, headFrag.text)
17417								}),
17418							tailFrags),
17419						maybeLastSyntax);
17420				} else {
17421					return _Utils_Tuple3(
17422						lines,
17423						A2(
17424							elm$core$List$cons,
17425							A2(
17426								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toFragment,
17427								toStyle,
17428								_Utils_Tuple2(syntax, text)),
17429							fragments),
17430						maybeLastSyntax);
17431				}
17432			} else {
17433				return _Utils_Tuple3(
17434					lines,
17435					A2(
17436						elm$core$List$cons,
17437						A2(
17438							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toFragment,
17439							toStyle,
17440							_Utils_Tuple2(syntax, text)),
17441						fragments),
17442					elm$core$Maybe$Just(syntax));
17443			}
17444		}
17445	});
17446var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toLines = F2(
17447	function (toStyle, revTokens) {
17448		return function (_n0) {
17449			var lines = _n0.a;
17450			var frags = _n0.b;
17451			return A2(
17452				elm$core$List$cons,
17453				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$newLine(frags),
17454				lines);
17455		}(
17456			A3(
17457				elm$core$List$foldl,
17458				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toLinesHelp(toStyle),
17459				_Utils_Tuple3(_List_Nil, _List_Nil, elm$core$Maybe$Nothing),
17460				revTokens));
17461	});
17462var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$toLines = A2(
17463	elm$core$Basics$composeR,
17464	elm$parser$Parser$run(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$toRevTokens),
17465	elm$core$Result$map(
17466		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toLines(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$syntaxToStyle)));
17467var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$css = A2(
17468	elm$core$Basics$composeR,
17469	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Css$toLines,
17470	elm$core$Result$map(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$HCode));
17471var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style6 = {$: 'Style6'};
17472var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$syntaxToStyle = function (syntax) {
17473	switch (syntax.$) {
17474		case 'String':
17475			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style2, 'elm-s');
17476		case 'BasicSymbol':
17477			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3, 'elm-bs');
17478		case 'GroupSymbol':
17479			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style4, 'elm-gs');
17480		case 'Capitalized':
17481			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style6, 'elm-c');
17482		case 'Keyword':
17483			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3, 'elm-k');
17484		case 'Function':
17485			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style5, 'elm-f');

17486		case 'TypeSignature':
17487			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style4, 'elm-ts');
17488		default:
17489			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style1, 'elm-n');
17490	}
17491};
17492var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$inlineComment = A2(
17493	elm$parser$Parser$map,
17494	function (b) {
17495		return _List_fromArray(
17496			[
17497				_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Comment, b)
17498			]);
17499	},
17500	elm$parser$Parser$getChompedString(
17501		A2(
17502			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
17503			A2(elm$core$Basics$composeL, elm$core$Basics$not, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak),
17504			elm$parser$Parser$symbol('--'))));
17505var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$lineBreakList = A2(
17506	elm$parser$Parser$map,
17507	function (_n0) {
17508		return _List_fromArray(
17509			[
17510				_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$LineBreak, '\n')
17511			]);
17512	},
17513	elm$parser$Parser$symbol('\n'));
17514var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$multilineComment = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(
17515	{
17516		defaultMap: function (b) {
17517			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Comment, b);
17518		},
17519		end: '-}',
17520		innerParsers: _List_fromArray(
17521			[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$lineBreakList]),
17522		isNestable: true,
17523		isNotRelevant: function (c) {
17524			return !pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak(c);
17525		},
17526		start: '{-'
17527	});
17528var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$comment = elm$parser$Parser$oneOf(
17529	_List_fromArray(
17530		[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$inlineComment, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$multilineComment]));
17531var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$BasicSymbol = {$: 'BasicSymbol'};
17532var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Capitalized = {$: 'Capitalized'};
17533var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$GroupSymbol = {$: 'GroupSymbol'};
17534var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Keyword = {$: 'Keyword'};
17535var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Number = {$: 'Number'};
17536var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$basicSymbols = elm$core$Set$fromList(
17537	_List_fromArray(
17538		[
17539			_Utils_chr('|'),
17540			_Utils_chr('.'),
17541			_Utils_chr('='),
17542			_Utils_chr('\\'),
17543			_Utils_chr('/'),
17544			_Utils_chr('('),
17545			_Utils_chr(')'),
17546			_Utils_chr('-'),
17547			_Utils_chr('>'),
17548			_Utils_chr('<'),
17549			_Utils_chr(':'),
17550			_Utils_chr('+'),
17551			_Utils_chr('!'),
17552			_Utils_chr('$'),
17553			_Utils_chr('%'),
17554			_Utils_chr('&'),
17555			_Utils_chr('*')
17556		]));
17557var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isBasicSymbol = function (c) {
17558	return A2(elm$core$Set$member, c, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$basicSymbols);
17559};
17560var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$basicSymbol = elm$parser$Parser$getChompedString(
17561	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isBasicSymbol));
17562var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$groupSymbols = elm$core$Set$fromList(
17563	_List_fromArray(
17564		[
17565			_Utils_chr(','),
17566			_Utils_chr('['),
17567			_Utils_chr(']'),
17568			_Utils_chr('{'),
17569			_Utils_chr('}')
17570		]));
17571var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isGroupSymbol = function (c) {
17572	return A2(elm$core$Set$member, c, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$groupSymbols);
17573};
17574var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isStringLiteralChar = function (c) {
17575	return _Utils_eq(
17576		c,
17577		_Utils_chr('\"')) || _Utils_eq(
17578		c,
17579		_Utils_chr('\''));
17580};
17581var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isVariableChar = function (c) {
17582	return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isWhitespace(c) || (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isBasicSymbol(c) || (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isGroupSymbol(c) || pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isStringLiteralChar(c))));
17583};
17584var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$capitalized = elm$parser$Parser$getChompedString(
17585	A2(
17586		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
17587		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isVariableChar,
17588		elm$parser$Parser$chompIf(elm$core$Char$isUpper)));
17589var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$groupSymbol = elm$parser$Parser$getChompedString(
17590	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isGroupSymbol));
17591var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Function = {$: 'Function'};
17592var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$infixSet = elm$core$Set$fromList(
17593	_List_fromArray(
17594		[
17595			_Utils_chr('+'),
17596			_Utils_chr('-'),
17597			_Utils_chr('/'),
17598			_Utils_chr('*'),
17599			_Utils_chr('='),
17600			_Utils_chr('.'),
17601			_Utils_chr('$'),
17602			_Utils_chr('<'),
17603			_Utils_chr('>'),
17604			_Utils_chr(':'),
17605			_Utils_chr('&'),
17606			_Utils_chr('|'),
17607			_Utils_chr('^'),
17608			_Utils_chr('?'),
17609			_Utils_chr('%'),
17610			_Utils_chr('#'),
17611			_Utils_chr('@'),
17612			_Utils_chr('~'),
17613			_Utils_chr('!'),
17614			_Utils_chr(',')
17615		]));
17616var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isInfixChar = function (c) {
17617	return A2(elm$core$Set$member, c, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$infixSet);
17618};
17619var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$infixParser = A2(
17620	elm$parser$Parser$map,
17621	function (b) {
17622		return _Utils_Tuple2(
17623			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Function),
17624			b);
17625	},
17626	elm$parser$Parser$getChompedString(
17627		A2(
17628			elm$parser$Parser$ignorer,
17629			A2(
17630				elm$parser$Parser$ignorer,
17631				A2(
17632					elm$parser$Parser$ignorer,
17633					elm$parser$Parser$succeed(_Utils_Tuple0),
17634					elm$parser$Parser$backtrackable(
17635						elm$parser$Parser$symbol('('))),
17636				elm$parser$Parser$backtrackable(
17637					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isInfixChar))),
17638			elm$parser$Parser$backtrackable(
17639				elm$parser$Parser$symbol(')')))));
17640var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$keywordSet = elm$core$Set$fromList(
17641	_List_fromArray(
17642		['as', 'where', 'let', 'in', 'if', 'else', 'then', 'case', 'of', 'type', 'alias']));
17643var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isKeyword = function (str) {
17644	return A2(elm$core$Set$member, str, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$keywordSet);
17645};
17646var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$variable = elm$parser$Parser$getChompedString(
17647	A2(
17648		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
17649		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isVariableChar,
17650		elm$parser$Parser$chompIf(elm$core$Char$isLower)));
17651var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$weirdText = elm$parser$Parser$getChompedString(
17652	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isVariableChar));
17653var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionBodyContent = elm$parser$Parser$oneOf(
17654	_List_fromArray(
17655		[
17656			A2(
17657			elm$parser$Parser$map,
17658			function (b) {
17659				return _Utils_Tuple2(
17660					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Number),
17661					b);
17662			},
17663			elm$parser$Parser$getChompedString(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$number)),
17664			A2(
17665			elm$parser$Parser$map,
17666			elm$core$Basics$always(
17667				_Utils_Tuple2(
17668					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Capitalized),
17669					'()')),
17670			elm$parser$Parser$symbol('()')),
17671			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$infixParser,
17672			A2(
17673			elm$parser$Parser$map,
17674			function (b) {
17675				return _Utils_Tuple2(
17676					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$BasicSymbol),
17677					b);
17678			},
17679			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$basicSymbol),
17680			A2(
17681			elm$parser$Parser$map,
17682			function (b) {
17683				return _Utils_Tuple2(
17684					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$GroupSymbol),
17685					b);
17686			},
17687			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$groupSymbol),
17688			A2(
17689			elm$parser$Parser$map,
17690			function (b) {
17691				return _Utils_Tuple2(
17692					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Capitalized),
17693					b);
17694			},
17695			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$capitalized),
17696			A2(
17697			elm$parser$Parser$map,
17698			function (n) {
17699				return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isKeyword(n) ? _Utils_Tuple2(
17700					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Keyword),
17701					n) : _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, n);
17702			},
17703			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$variable),
17704			A2(
17705			elm$parser$Parser$map,
17706			function (b) {
17707				return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
17708			},
17709			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$weirdText)
17710		]));
17711var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$String = {$: 'String'};
17712var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$elmEscapable = A2(
17713	elm$parser$Parser$map,
17714	function (b) {
17715		return _List_fromArray(
17716			[
17717				_Utils_Tuple2(
17718				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Capitalized),
17719				b)
17720			]);
17721	},
17722	elm$parser$Parser$getChompedString(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$escapable));
17723var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$stringDelimiter = {
17724	defaultMap: function (b) {
17725		return _Utils_Tuple2(
17726			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$String),
17727			b);
17728	},
17729	end: '\"',
17730	innerParsers: _List_fromArray(
17731		[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$lineBreakList, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$elmEscapable]),
17732	isNestable: false,
17733	isNotRelevant: function (c) {
17734		return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak(c) || pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isEscapable(c));
17735	},
17736	start: '\"'
17737};
17738var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$doubleQuote = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$stringDelimiter);
17739var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$quote = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(
17740	_Utils_update(
17741		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$stringDelimiter,
17742		{end: '\'', start: '\''}));
17743var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$tripleDoubleQuote = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(
17744	_Utils_update(
17745		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$stringDelimiter,
17746		{end: '\"\"\"', start: '\"\"\"'}));
17747var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$stringLiteral = elm$parser$Parser$oneOf(
17748	_List_fromArray(
17749		[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$tripleDoubleQuote, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$doubleQuote, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$quote]));
17750var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$lineBreak = A2(
17751	elm$parser$Parser$map,
17752	function (_n0) {
17753		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$LineBreak, '\n');
17754	},
17755	elm$parser$Parser$symbol('\n'));
17756var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$space = A2(
17757	elm$parser$Parser$map,
17758	function (b) {
17759		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
17760	},
17761	elm$parser$Parser$getChompedString(
17762		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isSpace)));
17763var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$checkContext = function (revTokens) {
17764	return elm$parser$Parser$oneOf(
17765		_List_fromArray(
17766			[
17767				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$whitespaceOrCommentStep(revTokens),
17768				elm$parser$Parser$succeed(
17769				elm$parser$Parser$Done(revTokens))
17770			]));
17771};
17772var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$whitespaceOrCommentStep = function (revTokens) {
17773	return elm$parser$Parser$oneOf(
17774		_List_fromArray(
17775			[
17776				A2(
17777				elm$parser$Parser$map,
17778				function (n) {
17779					return elm$parser$Parser$Loop(
17780						A2(elm$core$List$cons, n, revTokens));
17781				},
17782				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$space),
17783				A2(
17784				elm$parser$Parser$andThen,
17785				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$checkContext,
17786				A2(
17787					elm$parser$Parser$map,
17788					function (n) {
17789						return A2(elm$core$List$cons, n, revTokens);
17790					},
17791					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$lineBreak)),
17792				A2(
17793				elm$parser$Parser$map,
17794				function (n) {
17795					return elm$parser$Parser$Loop(
17796						_Utils_ap(n, revTokens));
17797				},
17798				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$comment)
17799			]));
17800};
17801var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionBody = function (revTokens) {
17802	return elm$parser$Parser$oneOf(
17803		_List_fromArray(
17804			[
17805				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$whitespaceOrCommentStep(revTokens),
17806				A2(
17807				elm$parser$Parser$map,
17808				function (ns) {
17809					return elm$parser$Parser$Loop(
17810						_Utils_ap(ns, revTokens));
17811				},
17812				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$stringLiteral),
17813				A2(
17814				elm$parser$Parser$map,
17815				function (n) {
17816					return elm$parser$Parser$Loop(
17817						A2(elm$core$List$cons, n, revTokens));
17818				},
17819				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionBodyContent),
17820				elm$parser$Parser$succeed(
17821				elm$parser$Parser$Done(revTokens))
17822			]));
17823};
17824var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$TypeSignature = {$: 'TypeSignature'};
17825var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$fnSigIsNotRelevant = function (c) {
17826	return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isWhitespace(c) || (_Utils_eq(
17827		c,
17828		_Utils_chr('(')) || (_Utils_eq(
17829		c,
17830		_Utils_chr(')')) || (_Utils_eq(
17831		c,
17832		_Utils_chr('-')) || _Utils_eq(
17833		c,
17834		_Utils_chr(','))))));
17835};
17836var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$fnSigContentHelp = elm$parser$Parser$oneOf(
17837	_List_fromArray(
17838		[
17839			A2(
17840		

17840	elm$parser$Parser$map,
17841			elm$core$Basics$always(
17842				_Utils_Tuple2(
17843					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$TypeSignature),
17844					'()')),
17845			elm$parser$Parser$symbol('()')),
17846			A2(
17847			elm$parser$Parser$map,
17848			elm$core$Basics$always(
17849				_Utils_Tuple2(
17850					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$BasicSymbol),
17851					'->')),
17852			elm$parser$Parser$symbol('->')),
17853			A2(
17854			elm$parser$Parser$map,
17855			function (b) {
17856				return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
17857			},
17858			elm$parser$Parser$getChompedString(
17859				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(
17860					function (c) {
17861						return _Utils_eq(
17862							c,
17863							_Utils_chr('(')) || (_Utils_eq(
17864							c,
17865							_Utils_chr(')')) || (_Utils_eq(
17866							c,
17867							_Utils_chr('-')) || _Utils_eq(
17868							c,
17869							_Utils_chr(','))));
17870					}))),
17871			A2(
17872			elm$parser$Parser$map,
17873			function (b) {
17874				return _Utils_Tuple2(
17875					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$TypeSignature),
17876					b);
17877			},
17878			elm$parser$Parser$getChompedString(
17879				A2(
17880					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
17881					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$fnSigIsNotRelevant,
17882					elm$parser$Parser$chompIf(elm$core$Char$isUpper)))),
17883			A2(
17884			elm$parser$Parser$map,
17885			function (b) {
17886				return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
17887			},
17888			elm$parser$Parser$getChompedString(
17889				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$fnSigIsNotRelevant)))
17890		]));
17891var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$fnSigContent = function (revTokens) {
17892	return elm$parser$Parser$oneOf(
17893		_List_fromArray(
17894			[
17895				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$whitespaceOrCommentStep(revTokens),
17896				A2(
17897				elm$parser$Parser$map,
17898				function (n) {
17899					return elm$parser$Parser$Loop(
17900						A2(elm$core$List$cons, n, revTokens));
17901				},
17902				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$fnSigContentHelp),
17903				elm$parser$Parser$succeed(
17904				elm$parser$Parser$Done(revTokens))
17905			]));
17906};
17907var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionSignature = function (revTokens) {
17908	return elm$parser$Parser$oneOf(
17909		_List_fromArray(
17910			[
17911				A2(
17912				elm$parser$Parser$map,
17913				elm$parser$Parser$Done,
17914				A2(
17915					elm$parser$Parser$andThen,
17916					function (ns) {
17917						return A2(elm$parser$Parser$loop, ns, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$fnSigContent);
17918					},
17919					A2(
17920						elm$parser$Parser$map,
17921						elm$core$Basics$always(
17922							A2(
17923								elm$core$List$cons,
17924								_Utils_Tuple2(
17925									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$BasicSymbol),
17926									':'),
17927								revTokens)),
17928						elm$parser$Parser$symbol(':')))),
17929				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$whitespaceOrCommentStep(revTokens),
17930				A2(
17931				elm$parser$Parser$map,
17932				elm$parser$Parser$Done,
17933				A2(elm$parser$Parser$loop, revTokens, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionBody)),
17934				elm$parser$Parser$succeed(
17935				elm$parser$Parser$Done(revTokens))
17936			]));
17937};
17938var elm$parser$Parser$ExpectingKeyword = function (a) {
17939	return {$: 'ExpectingKeyword', a: a};
17940};
17941var elm$parser$Parser$Advanced$keyword = function (_n0) {
17942	var kwd = _n0.a;
17943	var expecting = _n0.b;
17944	var progress = !elm$core$String$isEmpty(kwd);
17945	return elm$parser$Parser$Advanced$Parser(
17946		function (s) {
17947			var _n1 = A5(elm$parser$Parser$Advanced$isSubString, kwd, s.offset, s.row, s.col, s.src);
17948			var newOffset = _n1.a;
17949			var newRow = _n1.b;
17950			var newCol = _n1.c;
17951			return (_Utils_eq(newOffset, -1) || (0 <= A3(
17952				elm$parser$Parser$Advanced$isSubChar,
17953				function (c) {
17954					return elm$core$Char$isAlphaNum(c) || _Utils_eq(
17955						c,
17956						_Utils_chr('_'));
17957				},
17958				newOffset,
17959				s.src))) ? A2(
17960				elm$parser$Parser$Advanced$Bad,
17961				false,
17962				A2(elm$parser$Parser$Advanced$fromState, s, expecting)) : A3(
17963				elm$parser$Parser$Advanced$Good,
17964				progress,
17965				_Utils_Tuple0,
17966				{col: newCol, context: s.context, indent: s.indent, offset: newOffset, row: newRow, src: s.src});
17967		});
17968};
17969var elm$parser$Parser$keyword = function (kwd) {
17970	return elm$parser$Parser$Advanced$keyword(
17971		A2(
17972			elm$parser$Parser$Advanced$Token,
17973			kwd,
17974			elm$parser$Parser$ExpectingKeyword(kwd)));
17975};
17976var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isCommentChar = function (c) {
17977	return _Utils_eq(
17978		c,
17979		_Utils_chr('-')) || _Utils_eq(
17980		c,
17981		_Utils_chr('{'));
17982};
17983var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$commentChar = elm$parser$Parser$getChompedString(
17984	elm$parser$Parser$chompIf(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isCommentChar));
17985var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$modDecIsNotRelevant = function (c) {
17986	return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isWhitespace(c) || (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isCommentChar(c) || _Utils_eq(
17987		c,
17988		_Utils_chr('('))));
17989};
17990var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$mdpIsNotRelevant = function (c) {
17991	return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isWhitespace(c) || (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isCommentChar(c) || (_Utils_eq(
17992		c,
17993		_Utils_chr('(')) || (_Utils_eq(
17994		c,
17995		_Utils_chr(')')) || (_Utils_eq(
17996		c,
17997		_Utils_chr(',')) || _Utils_eq(
17998		c,
17999		_Utils_chr('.')))))));
18000};
18001var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$mdpnIsSpecialChar = function (c) {
18002	return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak(c) || (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isCommentChar(c) || (_Utils_eq(
18003		c,
18004		_Utils_chr('(')) || _Utils_eq(
18005		c,
18006		_Utils_chr(')'))));
18007};
18008var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$checkContextNested = function (_n1) {
18009	var nestLevel = _n1.a;
18010	var revTokens = _n1.b;
18011	return elm$parser$Parser$oneOf(
18012		_List_fromArray(
18013			[
18014				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$whitespaceOrCommentStepNested(
18015				_Utils_Tuple2(nestLevel, revTokens)),
18016				elm$parser$Parser$succeed(
18017				elm$parser$Parser$Done(revTokens))
18018			]));
18019};
18020var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$whitespaceOrCommentStepNested = function (_n0) {
18021	var nestLevel = _n0.a;
18022	var revTokens = _n0.b;
18023	return elm$parser$Parser$oneOf(
18024		_List_fromArray(
18025			[
18026				A2(
18027				elm$parser$Parser$map,
18028				function (n) {
18029					return elm$parser$Parser$Loop(
18030						_Utils_Tuple2(
18031							nestLevel,
18032							A2(elm$core$List$cons, n, revTokens)));
18033				},
18034				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$space),
18035				A2(
18036				elm$parser$Parser$andThen,
18037				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$checkContextNested,
18038				A2(
18039					elm$parser$Parser$map,
18040					function (n) {
18041						return _Utils_Tuple2(
18042							nestLevel,
18043							A2(elm$core$List$cons, n, revTokens));
18044					},
18045					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$lineBreak)),
18046				A2(
18047				elm$parser$Parser$map,
18048				function (n) {
18049					return elm$parser$Parser$Loop(
18050						_Utils_Tuple2(
18051							nestLevel,
18052							_Utils_ap(n, revTokens)));
18053				},
18054				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$comment)
18055			]));
18056};
18057var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$modDecParNest = function (_n0) {
18058	var nestLevel = _n0.a;
18059	var revTokens = _n0.b;
18060	return elm$parser$Parser$oneOf(
18061		_List_fromArray(
18062			[
18063				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$whitespaceOrCommentStepNested(
18064				_Utils_Tuple2(nestLevel, revTokens)),
18065				A2(
18066				elm$parser$Parser$map,
18067				function (ns) {
18068					return elm$parser$Parser$Loop(
18069						_Utils_Tuple2(nestLevel + 1, ns));
18070				},
18071				A2(
18072					elm$parser$Parser$map,
18073					elm$core$Basics$always(
18074						A2(
18075							elm$core$List$cons,
18076							_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, '('),
18077							revTokens)),
18078					elm$parser$Parser$symbol('('))),
18079				A2(
18080				elm$parser$Parser$map,
18081				function (ns) {
18082					return (!nestLevel) ? elm$parser$Parser$Done(ns) : elm$parser$Parser$Loop(
18083						_Utils_Tuple2(nestLevel - 1, ns));
18084				},
18085				A2(
18086					elm$parser$Parser$map,
18087					elm$core$Basics$always(
18088						A2(
18089							elm$core$List$cons,
18090							_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, ')'),
18091							revTokens)),
18092					elm$parser$Parser$symbol(')'))),
18093				A2(
18094				elm$parser$Parser$map,
18095				function (n) {
18096					return elm$parser$Parser$Loop(
18097						_Utils_Tuple2(
18098							nestLevel,
18099							A2(elm$core$List$cons, n, revTokens)));
18100				},
18101				elm$parser$Parser$oneOf(
18102					_List_fromArray(
18103						[
18104							A2(
18105							elm$parser$Parser$map,
18106							function (b) {
18107								return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
18108							},
18109							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$commentChar),
18110							A2(
18111							elm$parser$Parser$map,
18112							function (s) {
18113								return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, s);
18114							},
18115							elm$parser$Parser$getChompedString(
18116								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(
18117									A2(elm$core$Basics$composeL, elm$core$Basics$not, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$mdpnIsSpecialChar))))
18118						]))),
18119				elm$parser$Parser$succeed(
18120				elm$parser$Parser$Done(revTokens))
18121			]));
18122};
18123var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$modDecParentheses = function (revTokens) {
18124	return elm$parser$Parser$oneOf(
18125		_List_fromArray(
18126			[
18127				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$whitespaceOrCommentStep(revTokens),
18128				A2(
18129				elm$parser$Parser$map,
18130				elm$parser$Parser$Done,
18131				A2(
18132					elm$parser$Parser$map,
18133					elm$core$Basics$always(
18134						A2(
18135							elm$core$List$cons,
18136							_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, ')'),
18137							revTokens)),
18138					elm$parser$Parser$symbol(')'))),
18139				A2(
18140				elm$parser$Parser$map,
18141				function (n) {
18142					return elm$parser$Parser$Loop(
18143						A2(elm$core$List$cons, n, revTokens));
18144				},
18145				elm$parser$Parser$oneOf(
18146					_List_fromArray(
18147						[
18148							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$infixParser,
18149							A2(
18150							elm$parser$Parser$map,
18151							function (b) {
18152								return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
18153							},
18154							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$commentChar),
18155							A2(
18156							elm$parser$Parser$map,
18157							function (b) {
18158								return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
18159							},
18160							elm$parser$Parser$getChompedString(
18161								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(
18162									function (c) {
18163										return _Utils_eq(
18164											c,
18165											_Utils_chr(',')) || _Utils_eq(
18166											c,
18167											_Utils_chr('.'));
18168									}))),
18169							A2(
18170							elm$parser$Parser$map,
18171							function (b) {
18172								return _Utils_Tuple2(
18173									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$TypeSignature),
18174									b);
18175							},
18176							elm$parser$Parser$getChompedString(
18177								A2(
18178									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
18179									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$mdpIsNotRelevant,
18180									elm$parser$Parser$chompIf(elm$core$Char$isUpper)))),
18181							A2(
18182							elm$parser$Parser$map,
18183							function (b) {
18184								return _Utils_Tuple2(
18185									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Function),
18186									b);
18187							},
18188							elm$parser$Parser$getChompedString(
18189								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$mdpIsNotRelevant)))
18190						]))),
18191				A2(
18192				elm$parser$Parser$map,
18193				elm$parser$Parser$Loop,
18194				A2(
18195					elm$parser$Parser$andThen,
18196					function (n) {
18197						return A2(
18198							elm$parser$Parser$loop,
18199							_Utils_Tuple2(0, n),
18200							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$modDecParNest);
18201					},
18202					A2(
18203						elm$parser$Parser$map,
18204						elm$core$Basics$always(
18205							A2(
18206								elm$core$List$cons,
18207								_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, '('),
18208								revTokens)),
18209						elm$parser$Parser$symbol('(')))),
18210				elm$parser$Parser$succeed(
18211				elm$parser$Parser$Done(revTokens))
18212			]));
18213};
18214var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$moduleDeclaration = function (revTokens) {
18215	return elm$parser$Parser$oneOf(
18216		_List_fromArray(
18217			[
18218				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$whitespaceOrCommentStep(revTokens),
18219				A2(
18220				elm$parser$Parser$map,
18221				elm$parser$Parser$Loop,
18222				A2(
18223					elm$parser$Parser$andThen,
18224					function (n) {
18225						return A2(elm$parser$Parser$loop, n, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$modDecParentheses);
18226					},
18227					A2(
18228						elm$parser$Parser$map,
18229						elm$core$Basics$always(
18230							A2(
18231								elm$core$List$cons,
18232								_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, '('),
18233								revTokens)),
18234						elm$parser$Parser$symbol('(')))),
18235				A2(
18236				elm$parser$Parser$map,
18237				function (n) {
18238					return elm$parser$Parser$Loop(
18239						A2(elm$core$List$cons, n, revTokens));
18240				},
18241				elm$parser$Parser$oneOf(
18242					_List_fromArray(
18243						[
18244							A2(
18245							elm$parser$Parser$map,
18246							function (b) {
18247								return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
18248							},
18249							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$commentChar),
18250							A2(
18251							elm$parser$Parser$map,
18252							elm$core$Basics$always(
18253								_Utils_Tuple2(
18254									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Keyword),
18255									'exposing')),
18256							elm$parser$Parser$keyword('exposing')),
18257							A2(
18258							elm$parser$Parser$map,
18259							elm$core$Basics$always(
18260								_Utils_Tuple2(
18261									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Keyword),
18262									'as')),
18263							elm$parser$Parser$keyword('as')),
18264							A2(
18265							elm$parser$Parser$map,
18266							function (b) {
18267								return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
18268							},
18269							elm$parser$Parser$getChompedString(
18270								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$modDecIsNotRelevant)))
18271						]))),
18272				elm$parser$Parser$succeed(
18273				elm$parser$Parser$Done(revTokens))
18274			]));
18275};
18276var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$portDeclarationHelp = F2(
18277	function (revTokens, str) {
18278		return (str === 'module') ? A2(
18279			elm$parser$Parser$loop,
18280			A2(
18281				elm$core$List$cons,
18282				_Utils_Tuple2(
18283					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Keyword),
18284					str),
18285				revTokens),
18286			pablohirafuji$elm

18286_syntax_highlight$SyntaxHighlight$Language$Elm$moduleDeclaration) : A2(
18287			elm$parser$Parser$loop,
18288			A2(
18289				elm$core$List$cons,
18290				_Utils_Tuple2(
18291					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Function),
18292					str),
18293				revTokens),
18294			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionSignature);
18295	});
18296var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$portDeclaration = function (revTokens) {
18297	return elm$parser$Parser$oneOf(
18298		_List_fromArray(
18299			[
18300				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$whitespaceOrCommentStep(revTokens),
18301				A2(
18302				elm$parser$Parser$map,
18303				elm$parser$Parser$Done,
18304				A2(
18305					elm$parser$Parser$andThen,
18306					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$portDeclarationHelp(revTokens),
18307					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$variable)),
18308				A2(
18309				elm$parser$Parser$map,
18310				elm$parser$Parser$Done,
18311				A2(elm$parser$Parser$loop, revTokens, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionBody)),
18312				elm$parser$Parser$succeed(
18313				elm$parser$Parser$Done(revTokens))
18314			]));
18315};
18316var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$lineStartVariable = F2(
18317	function (revTokens, n) {
18318		return ((n === 'module') || (n === 'import')) ? A2(
18319			elm$parser$Parser$loop,
18320			A2(
18321				elm$core$List$cons,
18322				_Utils_Tuple2(
18323					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Keyword),
18324					n),
18325				revTokens),
18326			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$moduleDeclaration) : ((n === 'port') ? A2(
18327			elm$parser$Parser$loop,
18328			A2(
18329				elm$core$List$cons,
18330				_Utils_Tuple2(
18331					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Keyword),
18332					n),
18333				revTokens),
18334			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$portDeclaration) : (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$isKeyword(n) ? A2(
18335			elm$parser$Parser$loop,
18336			A2(
18337				elm$core$List$cons,
18338				_Utils_Tuple2(
18339					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Keyword),
18340					n),
18341				revTokens),
18342			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionBody) : A2(
18343			elm$parser$Parser$loop,
18344			A2(
18345				elm$core$List$cons,
18346				_Utils_Tuple2(
18347					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$Function),
18348					n),
18349				revTokens),
18350			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionSignature)));
18351	});
18352var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$mainLoop = function (revTokens) {
18353	return elm$parser$Parser$oneOf(
18354		_List_fromArray(
18355			[
18356				A2(
18357				elm$parser$Parser$map,
18358				function (n) {
18359					return elm$parser$Parser$Loop(
18360						A2(elm$core$List$cons, n, revTokens));
18361				},
18362				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$space),
18363				A2(
18364				elm$parser$Parser$map,
18365				function (n) {
18366					return elm$parser$Parser$Loop(
18367						A2(elm$core$List$cons, n, revTokens));
18368				},
18369				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$lineBreak),
18370				A2(
18371				elm$parser$Parser$map,
18372				function (n) {
18373					return elm$parser$Parser$Loop(
18374						_Utils_ap(n, revTokens));
18375				},
18376				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$comment),
18377				A2(
18378				elm$parser$Parser$map,
18379				elm$parser$Parser$Loop,
18380				A2(
18381					elm$parser$Parser$andThen,
18382					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$lineStartVariable(revTokens),
18383					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$variable)),
18384				A2(
18385				elm$parser$Parser$map,
18386				elm$parser$Parser$Loop,
18387				A2(
18388					elm$parser$Parser$andThen,
18389					function (s) {
18390						return A2(
18391							elm$parser$Parser$loop,
18392							_Utils_ap(s, revTokens),
18393							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionBody);
18394					},
18395					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$stringLiteral)),
18396				A2(
18397				elm$parser$Parser$map,
18398				elm$parser$Parser$Loop,
18399				A2(
18400					elm$parser$Parser$andThen,
18401					function (s) {
18402						return A2(
18403							elm$parser$Parser$loop,
18404							A2(elm$core$List$cons, s, revTokens),
18405							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionBody);
18406					},
18407					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$functionBodyContent)),
18408				elm$parser$Parser$succeed(
18409				elm$parser$Parser$Done(revTokens))
18410			]));
18411};
18412var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$toRevTokens = A2(elm$parser$Parser$loop, _List_Nil, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$mainLoop);
18413var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$toLines = A2(
18414	elm$core$Basics$composeR,
18415	elm$parser$Parser$run(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$toRevTokens),
18416	elm$core$Result$map(
18417		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toLines(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$syntaxToStyle)));
18418var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$elm = A2(
18419	elm$core$Basics$composeR,
18420	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Elm$toLines,
18421	elm$core$Result$map(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$HCode));
18422var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$syntaxToStyle = function (syntax) {
18423	switch (syntax.$) {
18424		case 'Number':
18425			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style1, 'js-n');
18426		case 'String':
18427			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style2, 'js-s');
18428		case 'Keyword':
18429			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3, 'js-k');
18430		case 'DeclarationKeyword':
18431			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style4, 'js-dk');
18432		case 'FunctionEval':
18433			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style4, 'js-fe');
18434		case 'Function':
18435			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style5, 'js-f');
18436		case 'LiteralKeyword':
18437			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style6, 'js-lk');
18438		case 'Param':
18439			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style7, 'js-p');
18440		default:
18441			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style5, 'js-ce');
18442	}
18443};
18444var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$groupSet = elm$core$Set$fromList(
18445	_List_fromArray(
18446		[
18447			_Utils_chr('{'),
18448			_Utils_chr('}'),
18449			_Utils_chr('('),
18450			_Utils_chr(')'),
18451			_Utils_chr('['),
18452			_Utils_chr(']'),
18453			_Utils_chr(','),
18454			_Utils_chr(';')
18455		]));
18456var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isGroupChar = function (c) {
18457	return A2(elm$core$Set$member, c, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$groupSet);
18458};
18459var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$groupChar = A2(
18460	elm$parser$Parser$map,
18461	function (b) {
18462		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
18463	},
18464	elm$parser$Parser$getChompedString(
18465		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isGroupChar)));
18466var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isCommentChar = function (c) {
18467	return _Utils_eq(
18468		c,
18469		_Utils_chr('/'));
18470};
18471var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$operatorSet = elm$core$Set$fromList(
18472	_List_fromArray(
18473		[
18474			_Utils_chr('+'),
18475			_Utils_chr('-'),
18476			_Utils_chr('*'),
18477			_Utils_chr('/'),
18478			_Utils_chr('='),
18479			_Utils_chr('!'),
18480			_Utils_chr('<'),
18481			_Utils_chr('>'),
18482			_Utils_chr('&'),
18483			_Utils_chr('|'),
18484			_Utils_chr('?'),
18485			_Utils_chr('^'),
18486			_Utils_chr(':'),
18487			_Utils_chr('~'),
18488			_Utils_chr('%'),
18489			_Utils_chr('.')
18490		]));
18491var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$punctuactorSet = A2(elm$core$Set$union, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$operatorSet, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$groupSet);
18492var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isPunctuaction = function (c) {
18493	return A2(elm$core$Set$member, c, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$punctuactorSet);
18494};
18495var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isStringLiteralChar = function (c) {
18496	return _Utils_eq(
18497		c,
18498		_Utils_chr('\"')) || (_Utils_eq(
18499		c,
18500		_Utils_chr('\'')) || _Utils_eq(
18501		c,
18502		_Utils_chr('`')));
18503};
18504var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isIdentifierNameChar = function (c) {
18505	return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isPunctuaction(c) || (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isStringLiteralChar(c) || (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isCommentChar(c) || pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isWhitespace(c))));
18506};
18507var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$DeclarationKeyword = {$: 'DeclarationKeyword'};
18508var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Function = {$: 'Function'};
18509var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Keyword = {$: 'Keyword'};
18510var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$LiteralKeyword = {$: 'LiteralKeyword'};
18511var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Param = {$: 'Param'};
18512var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$ClassExtends = {$: 'ClassExtends'};
18513var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$inlineComment = A2(
18514	elm$parser$Parser$map,
18515	function (b) {
18516		return _List_fromArray(
18517			[
18518				_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Comment, b)
18519			]);
18520	},
18521	elm$parser$Parser$getChompedString(
18522		A2(
18523			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$thenChompWhile,
18524			A2(elm$core$Basics$composeL, elm$core$Basics$not, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak),
18525			elm$parser$Parser$symbol('//'))));
18526var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$lineBreakList = A2(
18527	elm$parser$Parser$map,
18528	function (_n0) {
18529		return _List_fromArray(
18530			[
18531				_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$LineBreak, '\n')
18532			]);
18533	},
18534	elm$parser$Parser$symbol('\n'));
18535var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$multilineComment = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(
18536	{
18537		defaultMap: function (b) {
18538			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Comment, b);
18539		},
18540		end: '*/',
18541		innerParsers: _List_fromArray(
18542			[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$lineBreakList]),
18543		isNestable: false,
18544		isNotRelevant: function (c) {
18545			return !pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak(c);
18546		},
18547		start: '/*'
18548	});
18549var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$comment = elm$parser$Parser$oneOf(
18550	_List_fromArray(
18551		[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$inlineComment, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$multilineComment]));
18552var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$whitespaceOrCommentStep = function (revTokens) {
18553	return elm$parser$Parser$oneOf(
18554		_List_fromArray(
18555			[
18556				A2(
18557				elm$parser$Parser$map,
18558				function (b) {
18559					return elm$parser$Parser$Loop(
18560						A2(
18561							elm$core$List$cons,
18562							_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
18563							revTokens));
18564				},
18565				elm$parser$Parser$getChompedString(
18566					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isSpace))),
18567				A2(
18568				elm$parser$Parser$map,
18569				function (ns) {
18570					return elm$parser$Parser$Loop(
18571						_Utils_ap(ns, revTokens));
18572				},
18573				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$lineBreakList),
18574				A2(
18575				elm$parser$Parser$map,
18576				function (ns) {
18577					return elm$parser$Parser$Loop(
18578						_Utils_ap(ns, revTokens));
18579				},
18580				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$comment)
18581			]));
18582};
18583var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$classExtendsLoop = function (revTokens) {
18584	return elm$parser$Parser$oneOf(
18585		_List_fromArray(
18586			[
18587				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$whitespaceOrCommentStep(revTokens),
18588				A2(
18589				elm$parser$Parser$map,
18590				function (b) {
18591					return elm$parser$Parser$Loop(
18592						A2(
18593							elm$core$List$cons,
18594							_Utils_Tuple2(
18595								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$ClassExtends),
18596								b),
18597							revTokens));
18598				},
18599				elm$parser$Parser$getChompedString(
18600					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isIdentifierNameChar))),
18601				elm$parser$Parser$succeed(
18602				elm$parser$Parser$Done(revTokens))
18603			]));
18604};
18605var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$classDeclarationLoop = function (revTokens) {
18606	return elm$parser$Parser$oneOf(
18607		_List_fromArray(
18608			[
18609				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$whitespaceOrCommentStep(revTokens),
18610				A2(
18611				elm$parser$Parser$andThen,
18612				function (n) {
18613					return (n === 'extends') ? A2(
18614						elm$parser$Parser$map,
18615						elm$parser$Parser$Loop,
18616						A2(
18617							elm$parser$Parser$loop,
18618							A2(
18619								elm$core$List$cons,
18620								_Utils_Tuple2(
18621									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Keyword),
18622									n),
18623								revTokens),
18624							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$classExtendsLoop)) : elm$parser$Parser$succeed(
18625						elm$parser$Parser$Loop(
18626							A2(
18627								elm$core$List$cons,
18628								_Utils_Tuple2(
18629									pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Function),
18630									n),
18631								revTokens)));
18632				},
18633				elm$parser$Parser$getChompedString(
18634					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isIdentifierNameChar))),
18635				elm$parser$Parser$succeed(
18636				elm$parser$Parser$Done(revTokens))
18637			]));
18638};
18639var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$argLoop = function (revTokens) {
18640	return elm$parser$Parser$oneOf(
18641		_List_fromArray(
18642			[
18643				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$whitespaceOrCommentStep(revTokens),
18644				A2(
18645				elm$parser$Parser$map,
18646				function (b) {
18647					return elm$parser$Parser$Loop(
18648						A2(
18649							elm$core$List$cons,
18650							_Utils_Tuple2(
18651								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Param),
18652								b),
18653							revTokens));
18654				},
18655				elm$parser$Parser$getChompedString(
18656					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile

18656(
18657						function (c) {
18658							return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isCommentChar(c) || (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isWhitespace(c) || (_Utils_eq(
18659								c,
18660								_Utils_chr(',')) || _Utils_eq(
18661								c,
18662								_Utils_chr(')')))));
18663						}))),
18664				A2(
18665				elm$parser$Parser$map,
18666				function (b) {
18667					return elm$parser$Parser$Loop(
18668						A2(
18669							elm$core$List$cons,
18670							_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
18671							revTokens));
18672				},
18673				elm$parser$Parser$getChompedString(
18674					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(
18675						function (c) {
18676							return _Utils_eq(
18677								c,
18678								_Utils_chr('/')) || _Utils_eq(
18679								c,
18680								_Utils_chr(','));
18681						}))),
18682				elm$parser$Parser$succeed(
18683				elm$parser$Parser$Done(revTokens))
18684			]));
18685};
18686var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$functionDeclarationLoop = function (revTokens) {
18687	return elm$parser$Parser$oneOf(
18688		_List_fromArray(
18689			[
18690				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$whitespaceOrCommentStep(revTokens),
18691				A2(
18692				elm$parser$Parser$map,
18693				function (b) {
18694					return elm$parser$Parser$Loop(
18695						A2(
18696							elm$core$List$cons,
18697							_Utils_Tuple2(
18698								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Function),
18699								b),
18700							revTokens));
18701				},
18702				elm$parser$Parser$getChompedString(
18703					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isIdentifierNameChar))),
18704				A2(
18705				elm$parser$Parser$map,
18706				function (_n0) {
18707					return elm$parser$Parser$Loop(
18708						A2(
18709							elm$core$List$cons,
18710							_Utils_Tuple2(
18711								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Keyword),
18712								'*'),
18713							revTokens));
18714				},
18715				elm$parser$Parser$symbol('*')),
18716				A2(
18717				elm$parser$Parser$map,
18718				elm$parser$Parser$Loop,
18719				A2(
18720					elm$parser$Parser$andThen,
18721					function (_n1) {
18722						return A2(
18723							elm$parser$Parser$loop,
18724							A2(
18725								elm$core$List$cons,
18726								_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, '('),
18727								revTokens),
18728							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$argLoop);
18729					},
18730					elm$parser$Parser$symbol('('))),
18731				elm$parser$Parser$succeed(
18732				elm$parser$Parser$Done(revTokens))
18733			]));
18734};
18735var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$FunctionEval = {$: 'FunctionEval'};
18736var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$functionEvalLoop = F3(
18737	function (identifier, revTokens, thisRevToken) {
18738		return elm$parser$Parser$oneOf(
18739			_List_fromArray(
18740				[
18741					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$whitespaceOrCommentStep(thisRevToken),
18742					A2(
18743					elm$parser$Parser$map,
18744					function (_n0) {
18745						return elm$parser$Parser$Done(
18746							_Utils_ap(
18747								A2(
18748									elm$core$List$cons,
18749									_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, '('),
18750									thisRevToken),
18751								A2(
18752									elm$core$List$cons,
18753									_Utils_Tuple2(
18754										pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$FunctionEval),
18755										identifier),
18756									revTokens)));
18757					},
18758					elm$parser$Parser$symbol('(')),
18759					elm$parser$Parser$succeed(
18760					elm$parser$Parser$Done(
18761						_Utils_ap(
18762							thisRevToken,
18763							A2(
18764								elm$core$List$cons,
18765								_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, identifier),
18766								revTokens))))
18767				]));
18768	});
18769var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$declarationKeywordSet = elm$core$Set$fromList(
18770	_List_fromArray(
18771		['var', 'const', 'let']));
18772var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isDeclarationKeyword = function (str) {
18773	return A2(elm$core$Set$member, str, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$declarationKeywordSet);
18774};
18775var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$keywordSet = elm$core$Set$fromList(
18776	_List_fromArray(
18777		['break', 'do', 'instanceof', 'typeof', 'case', 'else', 'new', 'catch', 'finally', 'return', 'void', 'continue', 'for', 'switch', 'while', 'debugger', 'this', 'with', 'default', 'if', 'throw', 'delete', 'in', 'try', 'enum', 'extends', 'export', 'import', 'implements', 'private', 'public', 'yield', 'interface', 'package', 'protected']));
18778var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isKeyword = function (str) {
18779	return A2(elm$core$Set$member, str, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$keywordSet);
18780};
18781var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$literalKeywordSet = elm$core$Set$fromList(
18782	_List_fromArray(
18783		['true', 'false', 'null', 'undefined', 'NaN', 'Infinity']));
18784var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isLiteralKeyword = function (str) {
18785	return A2(elm$core$Set$member, str, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$literalKeywordSet);
18786};
18787var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$keywordParser = F2(
18788	function (revTokens, n) {
18789		return ((n === 'function') || (n === 'static')) ? A2(
18790			elm$parser$Parser$loop,
18791			A2(
18792				elm$core$List$cons,
18793				_Utils_Tuple2(
18794					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$DeclarationKeyword),
18795					n),
18796				revTokens),
18797			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$functionDeclarationLoop) : ((n === 'class') ? A2(
18798			elm$parser$Parser$loop,
18799			A2(
18800				elm$core$List$cons,
18801				_Utils_Tuple2(
18802					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$DeclarationKeyword),
18803					n),
18804				revTokens),
18805			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$classDeclarationLoop) : (((n === 'this') || (n === 'super')) ? elm$parser$Parser$succeed(
18806			A2(
18807				elm$core$List$cons,
18808				_Utils_Tuple2(
18809					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Param),
18810					n),
18811				revTokens)) : ((n === 'constructor') ? A2(
18812			elm$parser$Parser$loop,
18813			A2(
18814				elm$core$List$cons,
18815				_Utils_Tuple2(
18816					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Function),
18817					n),
18818				revTokens),
18819			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$functionDeclarationLoop) : (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isKeyword(n) ? elm$parser$Parser$succeed(
18820			A2(
18821				elm$core$List$cons,
18822				_Utils_Tuple2(
18823					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Keyword),
18824					n),
18825				revTokens)) : (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isDeclarationKeyword(n) ? elm$parser$Parser$succeed(
18826			A2(
18827				elm$core$List$cons,
18828				_Utils_Tuple2(
18829					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$DeclarationKeyword),
18830					n),
18831				revTokens)) : (pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isLiteralKeyword(n) ? elm$parser$Parser$succeed(
18832			A2(
18833				elm$core$List$cons,
18834				_Utils_Tuple2(
18835					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$LiteralKeyword),
18836					n),
18837				revTokens)) : A2(
18838			elm$parser$Parser$loop,
18839			_List_Nil,
18840			A2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$functionEvalLoop, n, revTokens))))))));
18841	});
18842var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Number = {$: 'Number'};
18843var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$number = A2(
18844	elm$parser$Parser$map,
18845	function (b) {
18846		return _Utils_Tuple2(
18847			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Number),
18848			b);
18849	},
18850	elm$parser$Parser$getChompedString(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$number));
18851var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isOperatorChar = function (c) {
18852	return A2(elm$core$Set$member, c, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$operatorSet);
18853};
18854var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$operatorChar = A2(
18855	elm$parser$Parser$map,
18856	function (b) {
18857		return _Utils_Tuple2(
18858			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$Keyword),
18859			b);
18860	},
18861	elm$parser$Parser$getChompedString(
18862		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isOperatorChar)));
18863var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$String = {$: 'String'};
18864var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$jsEscapable = A2(
18865	elm$parser$Parser$map,
18866	function (b) {
18867		return _List_fromArray(
18868			[
18869				_Utils_Tuple2(
18870				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$LiteralKeyword),
18871				b)
18872			]);
18873	},
18874	elm$parser$Parser$getChompedString(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$escapable));
18875var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$quoteDelimiter = {
18876	defaultMap: function (b) {
18877		return _Utils_Tuple2(
18878			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$String),
18879			b);
18880	},
18881	end: '\'',
18882	innerParsers: _List_fromArray(
18883		[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$lineBreakList, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$jsEscapable]),
18884	isNestable: false,
18885	isNotRelevant: function (c) {
18886		return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak(c) || pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isEscapable(c));
18887	},
18888	start: '\''
18889};
18890var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$doubleQuote = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(
18891	_Utils_update(
18892		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$quoteDelimiter,
18893		{end: '\"', start: '\"'}));
18894var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$quote = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$quoteDelimiter);
18895var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$templateString = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(
18896	_Utils_update(
18897		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$quoteDelimiter,
18898		{
18899			end: '`',
18900			innerParsers: _List_fromArray(
18901				[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$lineBreakList, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$jsEscapable]),
18902			isNotRelevant: function (c) {
18903				return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak(c) || pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isEscapable(c));
18904			},
18905			start: '`'
18906		}));
18907var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$stringLiteral = elm$parser$Parser$oneOf(
18908	_List_fromArray(
18909		[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$quote, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$doubleQuote, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$templateString]));
18910var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$mainLoop = function (revTokens) {
18911	return elm$parser$Parser$oneOf(
18912		_List_fromArray(
18913			[
18914				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$whitespaceOrCommentStep(revTokens),
18915				A2(
18916				elm$parser$Parser$map,
18917				function (s) {
18918					return elm$parser$Parser$Loop(
18919						_Utils_ap(s, revTokens));
18920				},
18921				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$stringLiteral),
18922				A2(
18923				elm$parser$Parser$map,
18924				function (s) {
18925					return elm$parser$Parser$Loop(
18926						A2(elm$core$List$cons, s, revTokens));
18927				},
18928				elm$parser$Parser$oneOf(
18929					_List_fromArray(
18930						[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$operatorChar, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$groupChar, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$number]))),
18931				A2(
18932				elm$parser$Parser$map,
18933				elm$parser$Parser$Loop,
18934				A2(
18935					elm$parser$Parser$andThen,
18936					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$keywordParser(revTokens),
18937					elm$parser$Parser$getChompedString(
18938						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$isIdentifierNameChar)))),
18939				elm$parser$Parser$succeed(
18940				elm$parser$Parser$Done(revTokens))
18941			]));
18942};
18943var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$toRevTokens = A2(elm$parser$Parser$loop, _List_Nil, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$mainLoop);
18944var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$toLines = A2(
18945	elm$core$Basics$composeR,
18946	elm$parser$Parser$run(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$toRevTokens),
18947	elm$core$Result$map(
18948		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toLines(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$syntaxToStyle)));
18949var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$javascript = A2(
18950	elm$core$Basics$composeR,
18951	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Javascript$toLines,
18952	elm$core$Result$map(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$HCode));
18953var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$syntaxToStyle = function (syntax) {
18954	switch (syntax.$) {
18955		case 'String':
18956			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style2, 'json-s');
18957		case 'Escapable':
18958			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style1, 'json-e');
18959		case 'Number':
18960			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style1, 'json-n');
18961		case 'Boolean':
18962			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3, 'json-b');
18963		case 'Null':
18964			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style3, 'json-null');
18965		case 'ObjectKey':
18966			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Style4, 'json-k');
18967		case 'Object':
18968			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Default, 'json-o');
18969		default:
18970			return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Default, 'json-a');
18971	}
18972};
18973var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Array = {$: 'Array'};
18974var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Boolean = {$: 'Boole

18974an'};
18975var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Null = {$: 'Null'};
18976var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Object = {$: 'Object'};
18977var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$ObjectKey = {$: 'ObjectKey'};
18978var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$String = {$: 'String'};
18979var elm$parser$Parser$ExpectingFloat = {$: 'ExpectingFloat'};
18980var elm$parser$Parser$Advanced$consumeBase = _Parser_consumeBase;
18981var elm$parser$Parser$Advanced$consumeBase16 = _Parser_consumeBase16;
18982var elm$core$String$toFloat = _String_toFloat;
18983var elm$parser$Parser$Advanced$bumpOffset = F2(
18984	function (newOffset, s) {
18985		return {col: s.col + (newOffset - s.offset), context: s.context, indent: s.indent, offset: newOffset, row: s.row, src: s.src};
18986	});
18987var elm$parser$Parser$Advanced$chompBase10 = _Parser_chompBase10;
18988var elm$parser$Parser$Advanced$isAsciiCode = _Parser_isAsciiCode;
18989var elm$parser$Parser$Advanced$consumeExp = F2(
18990	function (offset, src) {
18991		if (A3(elm$parser$Parser$Advanced$isAsciiCode, 101, offset, src) || A3(elm$parser$Parser$Advanced$isAsciiCode, 69, offset, src)) {
18992			var eOffset = offset + 1;
18993			var expOffset = (A3(elm$parser$Parser$Advanced$isAsciiCode, 43, eOffset, src) || A3(elm$parser$Parser$Advanced$isAsciiCode, 45, eOffset, src)) ? (eOffset + 1) : eOffset;
18994			var newOffset = A2(elm$parser$Parser$Advanced$chompBase10, expOffset, src);
18995			return _Utils_eq(expOffset, newOffset) ? (-newOffset) : newOffset;
18996		} else {
18997			return offset;
18998		}
18999	});
19000var elm$parser$Parser$Advanced$consumeDotAndExp = F2(
19001	function (offset, src) {
19002		return A3(elm$parser$Parser$Advanced$isAsciiCode, 46, offset, src) ? A2(
19003			elm$parser$Parser$Advanced$consumeExp,
19004			A2(elm$parser$Parser$Advanced$chompBase10, offset + 1, src),
19005			src) : A2(elm$parser$Parser$Advanced$consumeExp, offset, src);
19006	});
19007var elm$parser$Parser$Advanced$finalizeInt = F5(
19008	function (invalid, handler, startOffset, _n0, s) {
19009		var endOffset = _n0.a;
19010		var n = _n0.b;
19011		if (handler.$ === 'Err') {
19012			var x = handler.a;
19013			return A2(
19014				elm$parser$Parser$Advanced$Bad,
19015				true,
19016				A2(elm$parser$Parser$Advanced$fromState, s, x));
19017		} else {
19018			var toValue = handler.a;
19019			return _Utils_eq(startOffset, endOffset) ? A2(
19020				elm$parser$Parser$Advanced$Bad,
19021				_Utils_cmp(s.offset, startOffset) < 0,
19022				A2(elm$parser$Parser$Advanced$fromState, s, invalid)) : A3(
19023				elm$parser$Parser$Advanced$Good,
19024				true,
19025				toValue(n),
19026				A2(elm$parser$Parser$Advanced$bumpOffset, endOffset, s));
19027		}
19028	});
19029var elm$parser$Parser$Advanced$finalizeFloat = F6(
19030	function (invalid, expecting, intSettings, floatSettings, intPair, s) {
19031		var intOffset = intPair.a;
19032		var floatOffset = A2(elm$parser$Parser$Advanced$consumeDotAndExp, intOffset, s.src);
19033		if (floatOffset < 0) {
19034			return A2(
19035				elm$parser$Parser$Advanced$Bad,
19036				true,
19037				A4(elm$parser$Parser$Advanced$fromInfo, s.row, s.col - (floatOffset + s.offset), invalid, s.context));
19038		} else {
19039			if (_Utils_eq(s.offset, floatOffset)) {
19040				return A2(
19041					elm$parser$Parser$Advanced$Bad,
19042					false,
19043					A2(elm$parser$Parser$Advanced$fromState, s, expecting));
19044			} else {
19045				if (_Utils_eq(intOffset, floatOffset)) {
19046					return A5(elm$parser$Parser$Advanced$finalizeInt, invalid, intSettings, s.offset, intPair, s);
19047				} else {
19048					if (floatSettings.$ === 'Err') {
19049						var x = floatSettings.a;
19050						return A2(
19051							elm$parser$Parser$Advanced$Bad,
19052							true,
19053							A2(elm$parser$Parser$Advanced$fromState, s, invalid));
19054					} else {
19055						var toValue = floatSettings.a;
19056						var _n1 = elm$core$String$toFloat(
19057							A3(elm$core$String$slice, s.offset, floatOffset, s.src));
19058						if (_n1.$ === 'Nothing') {
19059							return A2(
19060								elm$parser$Parser$Advanced$Bad,
19061								true,
19062								A2(elm$parser$Parser$Advanced$fromState, s, invalid));
19063						} else {
19064							var n = _n1.a;
19065							return A3(
19066								elm$parser$Parser$Advanced$Good,
19067								true,
19068								toValue(n),
19069								A2(elm$parser$Parser$Advanced$bumpOffset, floatOffset, s));
19070						}
19071					}
19072				}
19073			}
19074		}
19075	});
19076var elm$parser$Parser$Advanced$number = function (c) {
19077	return elm$parser$Parser$Advanced$Parser(
19078		function (s) {
19079			if (A3(elm$parser$Parser$Advanced$isAsciiCode, 48, s.offset, s.src)) {
19080				var zeroOffset = s.offset + 1;
19081				var baseOffset = zeroOffset + 1;
19082				return A3(elm$parser$Parser$Advanced$isAsciiCode, 120, zeroOffset, s.src) ? A5(
19083					elm$parser$Parser$Advanced$finalizeInt,
19084					c.invalid,
19085					c.hex,
19086					baseOffset,
19087					A2(elm$parser$Parser$Advanced$consumeBase16, baseOffset, s.src),
19088					s) : (A3(elm$parser$Parser$Advanced$isAsciiCode, 111, zeroOffset, s.src) ? A5(
19089					elm$parser$Parser$Advanced$finalizeInt,
19090					c.invalid,
19091					c.octal,
19092					baseOffset,
19093					A3(elm$parser$Parser$Advanced$consumeBase, 8, baseOffset, s.src),
19094					s) : (A3(elm$parser$Parser$Advanced$isAsciiCode, 98, zeroOffset, s.src) ? A5(
19095					elm$parser$Parser$Advanced$finalizeInt,
19096					c.invalid,
19097					c.binary,
19098					baseOffset,
19099					A3(elm$parser$Parser$Advanced$consumeBase, 2, baseOffset, s.src),
19100					s) : A6(
19101					elm$parser$Parser$Advanced$finalizeFloat,
19102					c.invalid,
19103					c.expecting,
19104					c._int,
19105					c._float,
19106					_Utils_Tuple2(zeroOffset, 0),
19107					s)));
19108			} else {
19109				return A6(
19110					elm$parser$Parser$Advanced$finalizeFloat,
19111					c.invalid,
19112					c.expecting,
19113					c._int,
19114					c._float,
19115					A3(elm$parser$Parser$Advanced$consumeBase, 10, s.offset, s.src),
19116					s);
19117			}
19118		});
19119};
19120var elm$parser$Parser$Advanced$float = F2(
19121	function (expecting, invalid) {
19122		return elm$parser$Parser$Advanced$number(
19123			{
19124				binary: elm$core$Result$Err(invalid),
19125				expecting: expecting,
19126				_float: elm$core$Result$Ok(elm$core$Basics$identity),
19127				hex: elm$core$Result$Err(invalid),
19128				_int: elm$core$Result$Ok(elm$core$Basics$toFloat),

19129				invalid: invalid,
19130				octal: elm$core$Result$Err(invalid)
19131			});
19132	});
19133var elm$parser$Parser$float = A2(elm$parser$Parser$Advanced$float, elm$parser$Parser$ExpectingFloat, elm$parser$Parser$ExpectingFloat);
19134var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$positiveNumberExponentialNotation = A2(
19135	elm$parser$Parser$ignorer,
19136	elm$parser$Parser$succeed(_Utils_Tuple0),
19137	elm$parser$Parser$backtrackable(elm$parser$Parser$float));
19138var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$negativeNumberExponentialNotation = A2(
19139	elm$parser$Parser$ignorer,
19140	A2(
19141		elm$parser$Parser$ignorer,
19142		elm$parser$Parser$succeed(_Utils_Tuple0),
19143		elm$parser$Parser$backtrackable(
19144			elm$parser$Parser$symbol('-'))),
19145	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$positiveNumberExponentialNotation);
19146var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$numberExponentialNotation = elm$parser$Parser$oneOf(
19147	_List_fromArray(
19148		[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$positiveNumberExponentialNotation, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$negativeNumberExponentialNotation, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$number]));
19149var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Number = {$: 'Number'};
19150var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$number = A2(
19151	elm$parser$Parser$map,
19152	function (b) {
19153		return _Utils_Tuple2(
19154			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Number),
19155			b);
19156	},
19157	elm$parser$Parser$getChompedString(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$numberExponentialNotation));
19158var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$lineBreak = A2(
19159	elm$parser$Parser$map,
19160	function (_n0) {
19161		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$LineBreak, '\n');
19162	},
19163	elm$parser$Parser$symbol('\n'));
19164var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Escapable = {$: 'Escapable'};
19165var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$escapableSet = elm$core$Set$fromList(
19166	_List_fromArray(
19167		[
19168			_Utils_chr('\"'),
19169			_Utils_chr('\\'),
19170			_Utils_chr('/'),
19171			_Utils_chr('b'),
19172			_Utils_chr('f'),
19173			_Utils_chr('n'),
19174			_Utils_chr('r'),
19175			_Utils_chr('t'),
19176			_Utils_chr('u')
19177		]));
19178var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$isEscapableChar = function (c) {
19179	return A2(elm$core$Set$member, c, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$escapableSet);
19180};
19181var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$escapable = A2(
19182	elm$parser$Parser$ignorer,
19183	A2(
19184		elm$parser$Parser$ignorer,
19185		elm$parser$Parser$succeed(_Utils_Tuple0),
19186		elm$parser$Parser$backtrackable(
19187			elm$parser$Parser$symbol('\\'))),
19188	elm$parser$Parser$chompIf(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$isEscapableChar));
19189var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$stringEscapable = A2(
19190	elm$parser$Parser$map,
19191	function (b) {
19192		return _List_fromArray(
19193			[
19194				_Utils_Tuple2(
19195				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Escapable),
19196				b)
19197			]);
19198	},
19199	elm$parser$Parser$getChompedString(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$escapable));
19200var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$doubleQuoteDelimiter = function (syntax_) {
19201	return {
19202		defaultMap: function (b) {
19203			return _Utils_Tuple2(
19204				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(syntax_),
19205				b);
19206		},
19207		end: '\"',
19208		innerParsers: _List_fromArray(
19209			[
19210				A2(elm$parser$Parser$map, elm$core$List$singleton, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$lineBreak),
19211				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$stringEscapable
19212			]),
19213		isNestable: false,
19214		isNotRelevant: function (c) {
19215			return !(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isLineBreak(c) || pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isEscapable(c));
19216		},
19217		start: '\"'
19218	};
19219};
19220var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$stringLiteral = F2(
19221	function (syntax_, revTokens) {
19222		return A2(
19223			elm$parser$Parser$map,
19224			function (n) {
19225				return _Utils_ap(n, revTokens);
19226			},
19227			pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$delimited(
19228				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$doubleQuoteDelimiter(syntax_)));
19229	});
19230var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$space = A2(
19231	elm$parser$Parser$map,
19232	function (b) {
19233		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
19234	},
19235	elm$parser$Parser$getChompedString(
19236		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isSpace)));
19237var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$whitespace = elm$parser$Parser$oneOf(
19238	_List_fromArray(
19239		[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$space, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$lineBreak]));
19240var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$arrayLoop = function (revTokens) {
19241	return elm$parser$Parser$oneOf(
19242		_List_fromArray(
19243			[
19244				A2(
19245				elm$parser$Parser$map,
19246				function (n) {
19247					return elm$parser$Parser$Loop(
19248						A2(elm$core$List$cons, n, revTokens));
19249				},
19250				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$whitespace),
19251				A2(
19252				elm$parser$Parser$map,
19253				function (n) {
19254					return elm$parser$Parser$Loop(
19255						A2(elm$core$List$cons, n, revTokens));
19256				},
19257				A2(
19258					elm$parser$Parser$map,
19259					function (_n4) {
19260						return _Utils_Tuple2(
19261							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Array),
19262							',');
19263					},
19264					elm$parser$Parser$symbol(','))),
19265				A2(
19266				elm$parser$Parser$map,
19267				function (n) {
19268					return elm$parser$Parser$Done(
19269						A2(elm$core$List$cons, n, revTokens));
19270				},
19271				A2(
19272					elm$parser$Parser$map,
19273					function (_n5) {
19274						return _Utils_Tuple2(
19275							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Array),
19276							']');
19277					},
19278					elm$parser$Parser$symbol(']'))),
19279				A2(
19280				elm$parser$Parser$map,
19281				function (ns) {
19282					return elm$parser$Parser$Loop(
19283						_Utils_ap(ns, revTokens));
19284				},
19285				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$value(

19285)),
19286				elm$parser$Parser$succeed(
19287				elm$parser$Parser$Done(revTokens))
19288			]));
19289};
19290var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$objectLoop = function (revTokens) {
19291	return elm$parser$Parser$oneOf(
19292		_List_fromArray(
19293			[
19294				A2(
19295				elm$parser$Parser$map,
19296				function (n) {
19297					return elm$parser$Parser$Loop(
19298						A2(elm$core$List$cons, n, revTokens));
19299				},
19300				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$whitespace),
19301				A2(
19302				elm$parser$Parser$map,
19303				elm$parser$Parser$Loop,
19304				A2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$stringLiteral, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$ObjectKey, revTokens)),
19305				A2(
19306				elm$parser$Parser$map,
19307				elm$parser$Parser$Loop,
19308				A2(
19309					elm$parser$Parser$andThen,
19310					function (_n0) {
19311						var revTokens_ = A2(
19312							elm$core$List$cons,
19313							_Utils_Tuple2(
19314								pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Object),
19315								':'),
19316							revTokens);
19317						return A2(
19318							elm$parser$Parser$map,
19319							function (ns) {
19320								return _Utils_ap(ns, revTokens_);
19321							},
19322							elm$parser$Parser$oneOf(
19323								_List_fromArray(
19324									[
19325										A2(
19326										elm$parser$Parser$andThen,
19327										function (ws) {
19328											return elm$parser$Parser$oneOf(
19329												_List_fromArray(
19330													[
19331														A2(
19332														elm$parser$Parser$map,
19333														function (v) {
19334															return _Utils_ap(
19335																v,
19336																_List_fromArray(
19337																	[ws]));
19338														},
19339														pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$value()),
19340														elm$parser$Parser$succeed(
19341														_List_fromArray(
19342															[ws]))
19343													]));
19344										},
19345										pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$whitespace),
19346										pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$value(),
19347										elm$parser$Parser$succeed(_List_Nil)
19348									])));
19349					},
19350					elm$parser$Parser$symbol(':'))),
19351				A2(
19352				elm$parser$Parser$map,
19353				function (n) {
19354					return elm$parser$Parser$Loop(
19355						A2(elm$core$List$cons, n, revTokens));
19356				},
19357				A2(
19358					elm$parser$Parser$map,
19359					function (_n1) {
19360						return _Utils_Tuple2(
19361							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Object),
19362							',');
19363					},
19364					elm$parser$Parser$symbol(','))),
19365				A2(
19366				elm$parser$Parser$map,
19367				function (n) {
19368					return elm$parser$Parser$Done(
19369						A2(elm$core$List$cons, n, revTokens));
19370				},
19371				A2(
19372					elm$parser$Parser$map,
19373					function (_n2) {
19374						return _Utils_Tuple2(
19375							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Object),
19376							'}');
19377					},
19378					elm$parser$Parser$symbol('}'))),
19379				elm$parser$Parser$succeed(
19380				elm$parser$Parser$Done(revTokens))
19381			]));
19382};
19383function pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$value() {
19384	return elm$parser$Parser$oneOf(
19385		_List_fromArray(
19386			[
19387				A2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$stringLiteral, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$String, _List_Nil),
19388				A2(
19389				elm$parser$Parser$map,
19390				function (n) {
19391					return _List_fromArray(
19392						[n]);
19393				},
19394				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$number),
19395				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$object(),
19396				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$array(),
19397				A2(
19398				elm$parser$Parser$map,
19399				function (s) {
19400					return _List_fromArray(
19401						[
19402							_Utils_Tuple2(
19403							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Null),
19404							s)
19405						]);
19406				},
19407				elm$parser$Parser$getChompedString(
19408					elm$parser$Parser$keyword('null'))),
19409				A2(
19410				elm$parser$Parser$map,
19411				function (s) {
19412					return _List_fromArray(
19413						[
19414							_Utils_Tuple2(
19415							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Boolean),
19416							s)
19417						]);
19418				},
19419				elm$parser$Parser$getChompedString(
19420					elm$parser$Parser$oneOf(
19421						_List_fromArray(
19422							[
19423								elm$parser$Parser$keyword('true'),
19424								elm$parser$Parser$keyword('false')
19425							]))))
19426			]));
19427}
19428function pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$array() {
19429	return A2(
19430		elm$parser$Parser$andThen,
19431		function (_n6) {
19432			return A2(
19433				elm$parser$Parser$loop,
19434				_List_fromArray(
19435					[
19436						_Utils_Tuple2(
19437						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Array),
19438						'[')
19439					]),
19440				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$arrayLoop);
19441		},
19442		elm$parser$Parser$symbol('['));
19443}
19444function pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$object() {
19445	return A2(
19446		elm$parser$Parser$andThen,
19447		function (_n3) {
19448			return A2(
19449				elm$parser$Parser$loop,
19450				_List_fromArray(
19451					[
19452						_Utils_Tuple2(
19453						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$C(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$Object),
19454						'{')
19455					]),
19456				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$objectLoop);
19457		},
19458		elm$parser$Parser$symbol('{'));
19459}
19460try {
19461	var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$value = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$value(

19461);
19462	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$value = function () {
19463		return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$value;
19464	};
19465	var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$array = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$array();
19466	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$array = function () {
19467		return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$array;
19468	};
19469	var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$object = pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$object();
19470	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$cyclic$object = function () {
19471		return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$object;
19472	};
19473} catch ($) {
19474throw 'Some top-level definitions from `SyntaxHighlight.Language.Json` are causing infinite recursion:\n\n  ┌─────┐\n  │    value\n  │     ↓\n  │    array\n  │     ↓\n  │    arrayLoop\n  │     ↓\n  │    object\n  │     ↓\n  │    objectLoop\n  └─────┘\n\nThese errors are very tricky, so read https://elm-lang.org/0.19.0/halting-problem to learn how to fix it!';}
19475var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$mainLoop = function (revTokens) {
19476	return elm$parser$Parser$oneOf(
19477		_List_fromArray(
19478			[
19479				A2(
19480				elm$parser$Parser$map,
19481				function (n) {
19482					return elm$parser$Parser$Loop(
19483						A2(elm$core$List$cons, n, revTokens));
19484				},
19485				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$whitespace),
19486				A2(
19487				elm$parser$Parser$map,
19488				function (n) {
19489					return elm$parser$Parser$Loop(
19490						_Utils_ap(n, revTokens));
19491				},
19492				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$object),
19493				A2(
19494				elm$parser$Parser$map,
19495				function (b) {
19496					return elm$parser$Parser$Loop(
19497						A2(
19498							elm$core$List$cons,
19499							_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
19500							revTokens));
19501				},
19502				elm$parser$Parser$getChompedString(
19503					elm$parser$Parser$chompIf(
19504						elm$core$Basics$always(true)))),
19505				elm$parser$Parser$succeed(
19506				elm$parser$Parser$Done(revTokens))
19507			]));
19508};
19509var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$toRevTokens = A2(elm$parser$Parser$loop, _List_Nil, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$mainLoop);
19510var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$toLines = A2(
19511	elm$core$Basics$composeR,
19512	elm$parser$Parser$run(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$toRevTokens),
19513	elm$core$Result$map(
19514		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toLines(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$syntaxToStyle)));
19515var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$json = A2(
19516	elm$core$Basics$composeR,
19517	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Json$toLines,
19518	elm$core$Result$map(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$HCode));
19519var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$syntaxToStyle = function (syntax) {
19520	return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Default, 'nolang');
19521};
19522var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$lineBreak = A2(
19523	elm$parser$Parser$map,
19524	function (_n0) {
19525		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$LineBreak, '\n');
19526	},
19527	elm$parser$Parser$symbol('\n'));
19528var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$space = A2(
19529	elm$parser$Parser$map,
19530	function (b) {
19531		return _Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b);
19532	},
19533	elm$parser$Parser$getChompedString(
19534		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$chompIfThenWhile(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Helpers$isSpace)));
19535var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$whitespace = elm$parser$Parser$oneOf(
19536	_List_fromArray(
19537		[pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$space, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$lineBreak]));
19538var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$mainLoop = function (revTokens) {
19539	return elm$parser$Parser$oneOf(
19540		_List_fromArray(
19541			[
19542				A2(
19543				elm$parser$Parser$map,
19544				function (n) {
19545					return elm$parser$Parser$Loop(
19546						A2(elm$core$List$cons, n, revTokens));
19547				},
19548				pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$whitespace),
19549				A2(
19550				elm$parser$Parser$map,
19551				function (b) {
19552					return elm$parser$Parser$Loop(
19553						A2(
19554							elm$core$List$cons,
19555							_Utils_Tuple2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$Type$Normal, b),
19556							revTokens));
19557				},
19558				elm$parser$Parser$getChompedString(
19559					elm$parser$Parser$chompIf(
19560						elm$core$Basics$always(true)))),
19561				elm$parser$Parser$succeed(
19562				elm$parser$Parser$Done(revTokens))
19563			]));
19564};
19565var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$toRevTokens = A2(elm$parser$Parser$loop, _List_Nil, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$mainLoop);
19566var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$toLines = A2(
19567	elm$core$Basics$composeR,
19568	elm$parser$Parser$run(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$toRevTokens),
19569	elm$core$Result$map(
19570		pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Helpers$toLines(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$syntaxToStyle)));
19571var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$noLang = A2(
19572	elm$core$Basics$composeR,
19573	pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Language$NoLang$toLines,
19574	elm$core$Result$map(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$HCode));
19575var elm$virtual_dom$VirtualDom$attribute = F2(
19576	function (key, value) {
19577		return A2(
19578			_VirtualDom_attribute,
19579			_VirtualDom_noOnOrFormAction(key),
19580			_VirtualDom_noJavaScriptOrHtmlUri(value));
19581	});
19582var elm$html$Html$Attributes$attribute = elm$virtual_dom$VirtualDom$attribute;
19583var elm$core$Tuple$second = function (_n0) {
19584	var y = _n0.b;
19585	return y;
19586};
19587var elm$html$Html$Attributes$classList = function (classes) {
19588	return elm$html$Html$Attributes$class(
19589		A2(
19590			elm$core$String$join,
19591			' ',
19592			A2(
19593				elm$core$List$map,
19594				elm$core$Tuple$first,
19595				A2(elm$core$List$filter, elm$core$Tuple$second, classes))));
19596};
19597var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Add = {$: 'Add'};
19598var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Del = {$: 'Del'};
19599var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Normal = {$: 'Normal'};
19600var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$requiredStyleToString = function (required) {
19601	return 'elmsh' + function () {
19602		switch (required.$) {
19603			case 'Default':
19604				return '0';
19605			case 'Comment':
19606				return '-comm';
19607			case 'Style1':
19608				return '1';
19609			case 'Style2':
19610				return '2';
19611			case 'Style3':
19612				return '3';
19613			case 'Style4':
19614				return '4';
19615			case 'Style5':
19616				return '5';
19617			case 'Style6':
19618				return '6';
19619			default:
19620				return '7';
19621		}
19622	}();
19623};
19624var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$fragmentView = function (_n0) {
19625	var text = _n0.text;
19626	var requiredStyle = _n0.requiredStyle;
19627	var additionalClass = _n0.additionalClass;
19628	return (_Utils_eq(requiredStyle, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Default) && elm$core$String$isEmpty(additionalClass)) ? elm$html$Html$text(text) : A2(
19629		elm$html$Html$span,
19630		_List_fromArray(
19631			[
19632				elm$html$Html$Attributes$classList(
19633				_List_fromArray(
19634					[
19635						_Utils_Tuple2(
19636						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$requiredStyleToString(requiredStyle),
19637						!_Utils_eq(requiredStyle, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Style$Default)),
19638						_Utils_Tuple2('elmsh-' + additionalClass, additionalClass !== '')
19639					]))
19640			]),
19641		_List_fromArray(
19642			[
19643				elm$html$Html$text(text)
19644			]));
19645};
19646var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$lineView = F3(
19647	function (start, index, _n0) {
19648		var fragments = _n0.fragments;
19649		var highlight = _n0.highlight;
19650		return A2(
19651			elm$html$Html$div,
19652			_List_fromArray(
19653				[
19654					elm$html$Html$Attributes$classList(
19655					_List_fromArray(
19656						[
19657							_Utils_Tuple2('elmsh-line', true),
19658							_Utils_Tuple2(
19659							'elmsh-hl',
19660							_Utils_eq(
19661								highlight,
19662								elm$core$Maybe$Just(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Normal))),
19663							_Utils_Tuple2(
19664							'elmsh-add',
19665							_Utils_eq(
19666								highlight,
19667								elm$core$Maybe$Just(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Add))),
19668							_Utils_Tuple2(
19669							'elmsh-del',
19670							_Utils_eq(
19671								highlight,
19672								elm$core$Maybe$Just(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Del)))
19673						])),
19674					A2(
19675					elm$html$Html$Attributes$attribute,
19676					'data-elmsh-lc',
19677					elm$core$String$fromInt(start + index))
19678				]),
19679			A2(elm$core$List$map, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$fragmentView, fragments));
19680	});
19681var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$toInlineHtml = function (lines) {
19682	return A2(
19683		elm$html$Html$code,
19684		_List_fromArray(
19685			[
19686				elm$html$Html$Attributes$class('elmsh')
19687			]),
19688		elm$core$List$concat(
19689			A2(
19690				elm$core$List$map,
19691				function (_n0) {
19692					var highlight = _n0.highlight;
19693					var fragments = _n0.fragments;
19694					return _Utils_eq(highlight, elm$core$Maybe$Nothing) ? A2(elm$core$List$map, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$fragmentView, fragments) : _List_fromArray(
19695						[
19696							A2(
19697							elm$html$Html$span,
19698							_List_fromArray(
19699								[
19700									elm$html$Html$Attributes$classList(
19701									_List_fromArray(
19702										[
19703											_Utils_Tuple2(
19704											'elmsh-hl',
19705											_Utils_eq(
19706												highlight,
19707												elm$core$Maybe$Just(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Normal))),
19708											_Utils_Tuple2(
19709											'elmsh-add',
19710											_Utils_eq(
19711												highlight,
19712												elm$core$Maybe$Just(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Add))),
19713											_Utils_Tuple2(
19714											'elmsh-del',
19715											_Utils_eq(
19716												highlight,
19717												elm$core$Maybe$Just(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$Line$Del)))
19718										]))
19719								]),
19720							A2(elm$core$List$map, pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$fragmentView, fragments))
19721						]);
19722				},
19723				lines)));
19724};
19725var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$toBlockHtml = F2(
19726	function (maybeStart, lines) {
19727		if (maybeStart.$ === 'Nothing') {
19728			return A2(
19729				elm$html$Html$pre,
19730				_List_fromArray(
19731					[
19732						elm$html$Html$Attributes$class('elmsh')
19733					]),
19734				_List_fromArray(
19735					[
19736						pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$toInlineHtml(lines)
19737					]));
19738		} else {
19739			var start = maybeStart.a;
19740			return A2(
19741				elm$html$Html$pre,
19742				_List_fromArray(
19743					[
19744						elm$html$Html$Attributes$class('elmsh')
19745					]),
19746				elm$core$List$singleton(
19747					A2(
19748						elm$html$Html$code,
19749						_List_Nil,
19750						A2(
19751							elm$core$List$indexedMap,
19752							pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$lineView(start),
19753							lines))));
19754		}
19755	});
19756var pablohirafuji$elm_syntax_highlight$SyntaxHighlight$toBlockHtml = F2(
19757	function (maybeStart, _n0) {
19758		var lines = _n0.a;
19759		return A2(pablohirafuji$elm_syntax_highlight$SyntaxHighlight$View$toBlockHtml, maybeStart, lines);
19760	});
19761var dtwrks$elm_book$ElmBook$UI$Markdown$defaultRenderer = {
19762	blockQuote: function (children) {
19763		return A2(
19764			elm$html$Html$div,
19765			_List_fromArray(
19766				[
19767					elm$html$Html$Attributes$class('elm-book-md elm-book-serif')
19768				]),
19769			_List_fromArray(
19770				[
19771					A2(elm$html$Html$blockquote, _List_Nil, children)
19772				]));
19773	},
19774	codeBlock: function (_n0) {
19775		var body = _n0.body;
19776		var language = _n0.language;
19777		var hCode = function () {
19778			var _n1 = A2(elm$core$Maybe$withDefault, 'elm', language);
19779			switch (_n1) {
19780				case 'elm':
19781					return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$elm(body);
19782				case 'js':
19783					return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$javascript(body);
19784				case 'json':
19785					return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$json(body);
19786				case 'css':
19787					return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$css(body);
19788				default:
19789					return pablohirafuji$elm_syntax_highlight$SyntaxHighlight$noLang(body);
19790			}
19791		}();
19792		return A2(
19793			elm$core$Result$withDefault,
19794			A2(
19795				elm$html$Html$div,
19796				_List_fromArray(
19797					[
19798						elm$html$Html$Attributes$class('elm-book-md')
19799					]),
19800				_List_fromArray(
19801					[
19802						A2(
19803						elm$html$Html$pre,
19804						_List_fromArray(
19805							[
19806								elm$html$Html$Attributes$class('elm-book-md__code-default elm-book-monospace elm-book-shadows-light')
19807							]),
19808						_List_fromArray(
19809							[
19810								elm$html$Html$text(body)
19811							]))
19812					])),
19813			A2(
19814				elm$core$Result$map,
19815				function (content) {
19816					return A2(
19817						elm$html$Html$div,
19818						_List_fromArray(
19819							[
19820								elm$html$Html$Attributes$class('elm-book-md')
19821							]),
19822						_List_fromArray(
19823							[
19824								A2(
19825								elm$html$Html$div,
19826								_List_fromArray(
19827									[
19828										elm$html$Html$Attributes$class('elm-book-md__code elm-book-monospace elm-book-shadows-light')
19829									]),
19830								_List_fromArray(
19831									[content]))
19832							]));
19833				},
19834				A2(
19835					elm$core$Result$map,
19836					pablohirafuji$elm_syntax_highlight$SyntaxHighlight$toBlockHtml(elm$core$Maybe$Nothing),
19837					hCode)));
19838	},
19839	codeSpan: function (children) {
19840		return A2(
19841			elm$html$Html$span,
19842			_List_fromArray(
19843				[
19844					elm$html$Html$Attributes$class('elm-book-md')
19845				]),
19846			_List_fromArray(
19847				[
19848					A2(
19849					elm$html$Html$code,
19850					_List_fromArray(
19851						[
19852							elm$html$Html$Attributes$class('elm-book-monospace')
19853						]),
19854					_List_fromArray(
19855						[
19856							elm$html$Html$text(children)
19857						]))
19858				]));
19859	},
19860	emphasis: elm$html$Html$em(_List_Nil),
19861	hardLineBreak: A2(
19862		elm$html$Html$div,
19863		_List_fromArray(
19864			[
19865				elm$html$Html$Attributes$class('elm-book-md')
19866			]),
19867		_List_fromArray(
19868			[
19869				A2(elm$html$Html$br, _List_Nil, _List_Nil)
19870			])),
19871	heading: function (_n2) {
19872		var level = _n2.level;
19873		var children = _n2.children;
19874		var tag = function () {
19875			switch (level.$) {
19876				case 'H1':
19877					return elm$html$Html$h1(
19878						_List_fromArray(
19879							[
19880								elm$html$Html$Attributes$class('elm-book-serif')
19881							]));
19882				case 'H2':
19883					return elm$html$Html$h2(
19884						_List_fromArray(
19885							[
19886								elm$html$Html$Attributes$class('elm-book-serif')
19887							]));
19888				case 'H3':
19889					return elm$html$Html$h3(
19890						_List_fromArray(
19891							[
19892								elm$html$Html$Attributes$class('elm-book-serif')
19893							]));
19894				case 'H4':
19895					return elm$html$Html$h4(
19896						_List_fromArray(
19897							[
19898								elm$html$Html$Attributes$class('elm-book-sans')
19899							]));
19900				case 'H5':
19901					return elm$html$Html$h5(
19902						_List_fromArray(
19903							[
19904								elm$html$Html$Attributes$class('elm-book-sans')
19905							]));
19906				default:
19907					return elm$html$Html$h6(
19908						_List_fromArray(
19909							[
19910								elm$html$Html$Attributes$class('elm-book-sans')
19911							]));
19912			}
19913		}();
19914		return A2(
19915			elm$html$Html$div,
19916			_List_fromArray(
19917				[
19918					elm$html$Html$Attributes$class('elm-book-md')
19919				]),
19920			_List_fromArray(
19921				[
19922					tag(children)
19923				]));
19924	},
19925	html: dillonkearns$elm_markdown$Markdown$Html$oneOf(_List_Nil),
19926	image: function (image) {
19927		return A2(
19928			elm$html$Html$div,
19929			_List_fromArray(
19930				[
19931					elm$html$Html$Attributes$class('elm-book-md')
19932				]),
19933			_List_fromArray(
19934				[
19935					A2(
19936					elm$html$Html$img,
19937					_List_fromArray(
19938						[
19939							elm$html$Html$Attributes$src(image.src),
19940							elm$html$Html$Attributes$alt(image.alt),
19941							elm$html$Html$Attributes$title(
19942							A2(elm$core$Maybe$withDefault, '', image.title))
19943						]),
19944					_List_Nil)
19945				]));
19946	},
19947	link: F2(
19948		function (link, children) {
19949			return A2(
19950				elm$html$Html$a,
19951				_List_fromArray(
19952					[
19953						elm$html$Html$Attr

19953ibutes$href(link.destination),
19954						elm$html$Html$Attributes$title(
19955						A2(elm$core$Maybe$withDefault, '', link.title))
19956					]),
19957				children);
19958		}),
19959	orderedList: F2(
19960		function (startingIndex, items) {
19961			return A2(
19962				elm$html$Html$div,
19963				_List_fromArray(
19964					[
19965						elm$html$Html$Attributes$class('elm-book-md elm-book-serif elm-book-md__default')
19966					]),
19967				_List_fromArray(
19968					[
19969						A2(
19970						elm$html$Html$ol,
19971						_List_fromArray(
19972							[
19973								elm$html$Html$Attributes$start(startingIndex)
19974							]),
19975						A2(
19976							elm$core$List$map,
19977							elm$html$Html$li(_List_Nil),
19978							items))
19979					]));
19980		}),
19981	paragraph: function (children) {
19982		return A2(
19983			elm$html$Html$div,
19984			_List_fromArray(
19985				[
19986					elm$html$Html$Attributes$class('elm-book-md elm-book-serif elm-book-md__default')
19987				]),
19988			_List_fromArray(
19989				[
19990					A2(elm$html$Html$p, _List_Nil, children)
19991				]));
19992	},
19993	strikethrough: elm$html$Html$span(_List_Nil),
19994	strong: elm$html$Html$strong(_List_Nil),
19995	table: function (children) {
19996		return A2(
19997			elm$html$Html$div,
19998			_List_fromArray(
19999				[
20000					elm$html$Html$Attributes$class('elm-book-md elm-book-md__default elm-book-sans')
20001				]),
20002			_List_fromArray(
20003				[
20004					A2(elm$html$Html$table, _List_Nil, children)
20005				]));
20006	},
20007	tableBody: elm$html$Html$tbody(_List_Nil),
20008	tableCell: F2(
20009		function (_n4, children_) {
20010			return A2(elm$html$Html$td, _List_Nil, children_);
20011		}),
20012	tableHeader: elm$html$Html$thead(_List_Nil),
20013	tableHeaderCell: function (maybeAlignment) {
20014		var attrs = A2(
20015			elm$core$Maybe$withDefault,
20016			_List_Nil,
20017			A2(
20018				elm$core$Maybe$map,
20019				elm$core$List$singleton,
20020				A2(
20021					elm$core$Maybe$map,
20022					elm$html$Html$Attributes$align,
20023					A2(
20024						elm$core$Maybe$map,
20025						function (alignment) {
20026							switch (alignment.$) {
20027								case 'AlignLeft':
20028									return 'left';
20029								case 'AlignCenter':
20030									return 'center';
20031								default:
20032									return 'right';
20033							}
20034						},
20035						maybeAlignment))));
20036		return elm$html$Html$th(attrs);
20037	},
20038	tableRow: elm$html$Html$tr(_List_Nil),
20039	text: elm$html$Html$text,
20040	thematicBreak: A2(
20041		elm$html$Html$div,
20042		_List_fromArray(
20043			[
20044				elm$html$Html$Attributes$class('elm-book-md')
20045			]),
20046		_List_fromArray(
20047			[
20048				A2(elm$html$Html$hr, _List_Nil, _List_Nil)
20049			])),
20050	unorderedList: function (items) {
20051		return A2(
20052			elm$html$Html$div,
20053			_List_fromArray(
20054				[
20055					elm$html$Html$Attributes$class('elm-book-md elm-book-serif elm-book-md__default')
20056				]),
20057			_List_fromArray(
20058				[
20059					A2(
20060					elm$html$Html$ul,
20061					_List_Nil,
20062					A2(
20063						elm$core$List$map,
20064						function (item) {
20065							var task = item.a;
20066							var children = item.b;
20067							var checkbox = function () {
20068								switch (task.$) {
20069									case 'NoTask':
20070										return elm$html$Html$text('');
20071									case 'IncompleteTask':
20072										return A2(
20073											elm$html$Html$input,
20074											_List_fromArray(
20075												[
20076													elm$html$Html$Attributes$disabled(true),
20077													elm$html$Html$Attributes$checked(false),
20078													elm$html$Html$Attributes$type_('checkbox')
20079												]),
20080											_List_Nil);
20081									default:
20082										return A2(
20083											elm$html$Html$input,
20084											_List_fromArray(
20085												[
20086													elm$html$Html$Attributes$disabled(true),
20087													elm$html$Html$Attributes$checked(true),
20088													elm$html$Html$Attributes$type_('checkbox')
20089												]),
20090											_List_Nil);
20091								}
20092							}();
20093							return A2(
20094								elm$html$Html$li,
20095								_List_Nil,
20096								A2(elm$core$List$cons, checkbox, children));
20097						},
20098						items))
20099				]));
20100	}
20101};
20102var dtwrks$elm_book$ElmBook$UI$Markdown$componentRenderer = F3(
20103	function (chapterTitle, chapterComponents, componentOptions) {
20104		return _Utils_update(
20105			dtwrks$elm_book$ElmBook$UI$Markdown$defaultRenderer,
20106			{
20107				html: dillonkearns$elm_markdown$Markdown$Html$oneOf(
20108					_List_fromArray(
20109						[
20110							A2(
20111							dillonkearns$elm_markdown$Markdown$Html$withOptionalAttribute,
20112							'with-full-width',
20113							A2(
20114								dillonkearns$elm_markdown$Markdown$Html$withOptionalAttribute,
20115								'with-display',
20116								A2(
20117									dillonkearns$elm_markdown$Markdown$Html$withOptionalAttribute,
20118									'with-background',
20119									A2(
20120										dillonkearns$elm_markdown$Markdown$Html$withOptionalAttribute,
20121										'with-hidden-label',
20122										A2(
20123											dillonkearns$elm_markdown$Markdown$Html$withOptionalAttribute,
20124											'with-label',
20125											A2(
20126												dillonkearns$elm_markdown$Markdown$Html$tag,
20127												'component',
20128												F6(
20129													function (labelFilter, hiddenLabel_, background_, display_, fullWidth_, _n0) {
20130														var section_ = function () {
20131															if (labelFilter.$ === 'Just') {
20132																var label_ = labelFilter.a;
20133																return A2(
20134																	elm$core$Maybe$map,
20135																	function (v) {
20136																		return _Utils_Tuple2(label_, v);
20137																	},
20138																	A2(
20139																		elm$core$Dict$get,
20140																		label_,
20141																		elm$core$Dict$fromList(chapterComponents)));
20142															} else {
20143																return elm$core$List$head(chapterComponents);
20144															}
20145														}();
20146														var options_ = A2(
20147															dtwrks$elm_book$ElmBook$Internal$ComponentOptions$markdownOptions,
20148															componentOptions,
20149															{background: background_, display: display_, fullWidth: fullWidth_, hiddenLabel: hiddenLabel_});
20150														return A2(
20151															elm$core$Maybe$withDefault,
20152															A2(
20153																elm$html$Html$div,
20154																_List_fromArray(
20155																	[
20156																		elm$html$Html$Attributes$class('elm-book__component-wrapper')
20157																	]),
20158																_List_fromArray(
20159																	[
20160																		A2(
20161																		elm$html$Html$div,
20162																		_List_fromArray(
20163																			[
20164																				elm$html$Html$Attributes$class('elm-book-sans elm-book__component-empty')
20165																			]),
20166																		_List_fromArray(
20167																			[
20168																				elm$html$Html$text(
20169																				'Oops!… \"' + (A2(elm$core$Maybe$withDefault, '', labelFilter) + '\" component not found.'))
20170																			]))
20171																	])),
20172															A2(
20173																elm$core$Maybe$map,
20174																function (c) {
20175																	return _Utils_eq(options_.display, dtwrks$elm_book$ElmBook$Internal$ComponentOptions$Inline) ? c : A2(
20176																		elm$html$Html$div,
20177																		_List_fromArray(
20178																			[
20179																				elm$html$Html$Attributes$classList(
20180																				_List_fromArray(
20181																					[
20182																						_Utils_Tuple2('elm-book__component-wrapper', true),
20183																						_Utils_Tuple2('full', options_.fullWidth)
20184																					]))
20185																			]),
20186																		_List_fromArray(
20187																			[c]));
20188																},
20189																A2(
20190																	elm$core$Maybe$map,
20191																	A2(dtwrks$elm_book$ElmBook$UI$ChapterComponent$view, chapterTitle, options_),
20192																	section_)));
20193													}))))))),
20194							A2(
20195							dillonkearns$elm_markdown$Markdown$Html$withOptionalAttribute,
20196							'with-full-width',
20197							A2(
20198								dillonkearns$elm_markdown$Markdown$Html$withOptionalAttribute,
20199								'with-display',
20200								A2(
20201									dillonkearns$elm_markdown$Markdown$Html$withOptionalAttribute,
20202									'with-background',
20203									A2(
20204										dillonkearns$elm_markdown$Markdown$Html$withOptionalAttribute,
20205										'with-hidden-label',
20206										A2(
20207											dillonkearns$elm_markdown$Markdown$Html$withOptionalAttribute,
20208											'with-label',
20209											A2(
20210												dillonkearns$elm_markdown$Markdown$Html$tag,
20211												'component-list',
20212												F6(
20213													function (labelFilter, hiddenLabel_, background_, display_, fullWidth_, _n2) {
20214														var options_ = A2(
20215															dtwrks$elm_book$ElmBook$Internal$ComponentOptions$markdownOptions,
20216															componentOptions,
20217															{background: background_, display: display_, fullWidth: fullWidth_, hiddenLabel: hiddenLabel_});
20218														var components = function () {
20219															if (labelFilter.$ === 'Just') {
20220																var s = labelFilter.a;
20221																return A2(
20222																	elm$core$List$filter,
20223																	A2(
20224																		elm$core$Basics$composeR,
20225																		elm$core$Tuple$first,
20226																		elm$core$String$startsWith(s)),
20227																	chapterComponents);
20228															} else {
20229																return chapterComponents;
20230															}
20231														}();
20232														return A2(
20233															elm$html$Html$div,
20234															_List_fromArray(
20235																[
20236																	elm$html$Html$Attributes$classList(
20237																	_List_fromArray(
20238																		[
20239																			_Utils_Tuple2('elm-book__component-wrapper', true),
20240																			_Utils_Tuple2('full', options_.fullWidth)
20241																		]))
20242																]),
20243															_List_fromArray(
20244																[
20245																	A2(
20246																	elm$html$Html$ul,
20247																	_List_fromArray(
20248																		[
20249																			elm$html$Html$Attributes$class('elm-book-md__component-list')
20250																		]),
20251																	A2(
20252																		elm$core$List$map,
20253																		function (section) {
20254																			return A2(
20255																				elm$html$Html$li,
20256																				_List_fromArray(
20257																					[
20258																						elm$html$Html$Attributes$class('elm-book elm-book-md__component-list__item')
20259																					]),
20260																				_List_fromArray(
20261																					[
20262																						A3(dtwrks$elm_book$ElmBook$UI$ChapterComponent$view, chapterTitle, options_, section)
20263																					]));
20264																		},
20265																		components))
20266																]));
20267													})))))))
20268						]))
20269			});
20270	});
20271var dtwrks$elm_book$ElmBook$UI$Markdown$view = F3(
20272	function (chapterTitle, chapterComponents, componentOptions) {
20273		return A2(
20274			elm$core$Basics$composeR,
20275			dillonkearns$elm_markdown$Markdown$Parser$parse,
20276			A2(
20277				elm$core$Basics$composeR,
20278				elm$core$Result$withDefault(_List_Nil),
20279				A2(
20280					elm$core$Basics$composeR,
20281					dillonkearns$elm_markdown$Markdown$Renderer$render(
20282						A3(dtwrks$elm_book$ElmBook$UI$Markdown$componentRenderer, chapterTitle, chapterComponents, componentOptions)),
20283					A2(
20284						elm$core$Basics$composeR,
20285						elm$core$Result$withDefault(_List_Nil),
20286						function (children) {
20287							return A2(
20288								elm$html$Html$article,
20289								_List_Nil,
20290								_List_fromArray(
20291									[
20292										A2(elm$html$Html$div, _List_Nil, children)
20293									]));
20294						}))));
20295	});
20296var dtwrks$elm_book$ElmBook$UI$Chapter$view = function (props) {
20297	var body = props.chapterOptions.hiddenTitle ? props.body : ('# ' + (props.title + ('\n' + props.body)));
20298	return A2(
20299		elm$html$Html$article,
20300		_List_fromArray(
20301			[
20302				elm$html$Html$Attributes$class('elm-book elm-book-chapter')
20303			]),
20304		_List_fromArray(
20305			[
20306				A4(dtwrks$elm_book$ElmBook$UI$Markdown$view, props.title, props.components, props.componentOptions, body)
20307			]));
20308};
20309var elm$svg$Svg$trustedNode = _VirtualDom_nodeNS('http://www.w3.org/2000/svg');
20310var elm$svg$Svg$path = elm$svg$Svg$trustedNode('path');
20311var elm$svg$Svg$svg = elm$svg$Svg$trustedNode('svg');
20312var elm$svg$Svg$Attributes$d = _VirtualDom_attribute('d');
20313var elm$svg$Svg$Attributes$fill = _VirtualDom_attribute('fill');
20314var elm$svg$Svg$Attributes$height = _VirtualDom_attribute('height');
20315var elm$svg$Svg$Attributes$stroke = _VirtualDom_attribute('stroke');
20316var elm$svg$Svg$Attributes$strokeLinecap = _VirtualDom_attribute('stroke-linecap');
20317var elm$svg$Svg$Attributes$strokeLinejoin = _VirtualDom_attribute('stroke-linejoin');
20318var elm$svg$Svg$Attributes$strokeWidth = _VirtualDom_attribute('stroke-width');
20319var elm$svg$Svg$Attributes$viewBox = _VirtualDom_attribute('viewBox');
20320var elm$svg$Svg$Attributes$width = _VirtualDom_attribute('width');
20321var dtwrks$elm_book$ElmBook$UI$Icons$iconDarkMode = function (props) {
20322	return A2(
20323		elm$svg$Svg$svg,
20324		_List_fromArray(
20325			[
20326				elm$svg$Svg$Attributes$width(
20327				elm$core$String$fromInt(props.size)),
20328				elm$svg$Svg$Attributes$height(
20329				elm$core$String$fromInt(props.size)),
20330				elm$svg$Svg$Attributes$viewBox('0 0 24 24'),
20331				elm$svg$Svg$Attributes$fill('none'),
20332				elm$svg$Svg$Attributes$stroke(props.color),
20333				elm$svg$Svg$Attributes$strokeWidth('2'),

20334				elm$svg$Svg$Attributes$strokeLinecap('round'),
20335				elm$svg$Svg$Attributes$strokeLinejoin('round')
20336			]),
20337		_List_fromArray(
20338			[
20339				A2(
20340				elm$svg$Svg$path,
20341				_List_fromArray(
20342					[
20343						elm$svg$Svg$Attributes$d('M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z')
20344					]),
20345				_List_Nil)
20346			]));
20347};
20348var dtwrks$elm_book$ElmBook$UI$ChapterHeader$view = function (props) {
20349	return A2(
20350		elm$html$Html$div,
20351		_List_fromArray(
20352			[
20353				elm$html$Html$Attributes$class('elm-book elm-book-chapter-header')
20354			]),
20355		_List_fromArray(
20356			[
20357				A2(
20358				elm$html$Html$p,
20359				_List_fromArray(
20360					[
20361						elm$html$Html$Attributes$class('elm-book-chapter-header__title')
20362					]),
20363				_List_fromArray(
20364					[
20365						elm$html$Html$text(props.title)
20366					])),
20367				A2(
20368				elm$html$Html$button,
20369				_List_fromArray(
20370					[
20371						elm$html$Html$Attributes$class('elm-book-chapter-header__btn'),
20372						elm$html$Html$Events$onClick(props.onToggleDarkMode)
20373					]),
20374				_List_fromArray(
20375					[
20376						dtwrks$elm_book$ElmBook$UI$Icons$iconDarkMode(
20377						{color: 'currentColor', size: 16})
20378					]))
20379			]));
20380};
20381var dtwrks$elm_book$ElmBook$UI$Helpers$themeAccentVar = '--elm-book-accent';
20382var dtwrks$elm_book$ElmBook$UI$Helpers$themeAccent = dtwrks$elm_book$ElmBook$UI$Helpers$var_(dtwrks$elm_book$ElmBook$UI$Helpers$themeAccentVar);
20383var dtwrks$elm_book$ElmBook$UI$Icons$iconElm = function (props) {
20384	return A2(
20385		elm$svg$Svg$svg,
20386		_List_fromArray(
20387			[
20388				elm$svg$Svg$Attributes$width(
20389				elm$core$String$fromInt(props.size)),
20390				elm$svg$Svg$Attributes$height(
20391				elm$core$String$fromInt(props.size)),
20392				elm$svg$Svg$Attributes$viewBox('0 0 256 256')
20393			]),
20394		_List_fromArray(
20395			[
20396				A2(
20397				elm$svg$Svg$path,
20398				_List_fromArray(
20399					[
20400						elm$svg$Svg$Attributes$fill(props.color),
20401						elm$svg$Svg$Attributes$d('M128 135.022L7.023 256h241.955z')
20402					]),
20403				_List_Nil),
20404				A2(
20405				elm$svg$Svg$path,
20406				_List_fromArray(
20407					[
20408						elm$svg$Svg$Attributes$fill(props.color),
20409						elm$svg$Svg$Attributes$d('M202.332 195.311L256 248.98V141.643z')
20410					]),
20411				_List_Nil),
20412				A2(
20413				elm$svg$Svg$path,
20414				_List_fromArray(
20415					[
20416						elm$svg$Svg$Attributes$fill(props.color),
20417						elm$svg$Svg$Attributes$d('M120.978 128L0 7.022V248.98z')
20418					]),
20419				_List_Nil),
20420				A2(
20421				elm$svg$Svg$path,
20422				_List_fromArray(
20423					[
20424						elm$svg$Svg$Attributes$fill(props.color),
20425						elm$svg$Svg$Attributes$d('M256 113.806V0H142.193z')
20426					]),
20427				_List_Nil),
20428				A2(
20429				elm$svg$Svg$path,
20430				_List_fromArray(
20431					[
20432						elm$svg$Svg$Attributes$fill(props.color),
20433						elm$svg$Svg$Attributes$d('M195.584 67.434l60.288 60.289l-60.563 60.564l-60.29-60.29z')
20434					]),
20435				_List_Nil),
20436				A2(
20437				elm$svg$Svg$path,
20438				_List_fromArray(
20439					[
20440						elm$svg$Svg$Attributes$fill(props.color),
20441						elm$svg$Svg$Attributes$d('M7.021 0l55.725 55.726h121.13L128.15 0z')
20442					]),
20443				_List_Nil),
20444				A2(
20445				elm$svg$Svg$path,
20446				_List_fromArray(
20447					[
20448						elm$svg$Svg$Attributes$fill(props.color),
20449						elm$svg$Svg$Attributes$d('M128 120.979l55.322-55.323H72.677z')
20450					]),
20451				_List_Nil)
20452			]));
20453};
20454var elm$html$Html$Attributes$target = elm$html$Html$Attributes$stringProperty('target');
20455var dtwrks$elm_book$ElmBook$UI$Footer$view = A2(
20456	elm$html$Html$div,
20457	_List_fromArray(
20458		[
20459			elm$html$Html$Attributes$class('elm-book elm-book-sans')
20460		]),
20461	_List_fromArray(
20462		[
20463			A2(
20464			elm$html$Html$a,
20465			_List_fromArray(
20466				[
20467					elm$html$Html$Attributes$href('https://package.elm-lang.org/packages/dtwrks/elm-book/latest/'),
20468					elm$html$Html$Attributes$target('_blank'),
20469					elm$html$Html$Attributes$class('elm-book-footer'),
20470					A2(elm$html$Html$Attributes$style, 'color', dtwrks$elm_book$ElmBook$UI$Helpers$themeAccent)
20471				]),
20472			_List_fromArray(
20473				[
20474					dtwrks$elm_book$ElmBook$UI$Icons$iconElm(
20475					{color: 'currentColor', size: 16}),
20476					A2(
20477					elm$html$Html$div,
20478					_List_fromArray(
20479						[
20480							elm$html$Html$Attributes$class('elm-book-footer--text')
20481						]),
20482					_List_fromArray(
20483						[
20484							elm$html$Html$text('dtwrks/elm-book')
20485						]))
20486				]))
20487		]));
20488var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$header = function (theme) {
20489	return theme.header;
20490};
20491var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$logo = function (theme) {
20492	return theme.logo;
20493};
20494var dtwrks$elm_book$ElmBook$UI$Header$viewDefault = function (props) {
20495	return A2(
20496		elm$html$Html$span,
20497		_List_fromArray(
20498			[
20499				elm$html$Html$Attributes$class('elm-book-sans elm-book-header-default')
20500			]),
20501		_List_fromArray(
20502			[
20503				A2(
20504				elm$core$Maybe$withDefault,
20505				dtwrks$elm_book$ElmBook$UI$Icons$iconElm(
20506					{color: dtwrks$elm_book$ElmBook$UI$Helpers$themeAccent, size: 24}),
20507				A2(
20508					elm$core$Maybe$map,
20509					props.toHtml,
20510					dtwrks$elm_book$ElmBook$Internal$ThemeOptions$logo(props.theme))),
20511				A2(
20512				elm$html$Html$span,
20513				_List_fromArray(
20514					[
20515						elm$html$Html$Attributes$class('elm-book-header-default--wrapper')
20516					]),
20517				_List_fromArray(
20518					[
20519						A2(
20520						elm$html$Html$span,
20521						_List_fromArray(
20522							[
20523								elm$html$Html$Attributes$class('elm-book-header-default--title')
20524							]),
20525						_List_fromArray(
20526							[
20527								elm$html$Html$text(props.title)
20528							])),
20529						A2(
20530						elm$core$Maybe$withDefault,
20531						elm$html$Html$text(''),
20532						A2(
20533							elm$core$Maybe$map,
20534							function (subtitle) {
20535								return A2(
20536									elm$html$Html$span,
20537									_List_fromArray(
20538										[
20539											elm$html$Html$Attributes$class('elm-book-header-default--subtitle')
20540										]),
20541									_List_fromArray(
20542										[
20543											elm$html$Html$text(subtitle)
20544										]));
20545							},
20546							dtwrks$elm_book$ElmBook$Internal$ThemeOptions$subtitle(props.theme)))
20547					]))
20548			]));
20549};
20550var elm$svg$Svg$rect = elm$svg$Svg$trustedNode('rect');
20551var elm$svg$Svg$Attributes$rx = _VirtualDom_attribute('rx');
20552var elm$svg$Svg$Attributes$transform = _VirtualDom_attribute('transform');
20553var elm$svg$Svg$Attributes$x = _VirtualDom_attribute('x');
20554var elm$svg$Svg$Attributes$y = _VirtualDom_attribute('y');
20555var dtwrks$elm_book$ElmBook$UI$Icons$iconClose = function (props) {
20556	return A2(
20557		elm$svg$Svg$svg,
20558		_List_fromArray(
20559			[
20560				elm$svg$Svg$Attributes$width(
20561				elm$core$String$fromInt(props.size)),
20562				elm$svg$Svg$Attributes$height(
20563				elm$core$String$fromInt(props.size)),
20564				elm$svg$Svg$Attributes$viewBox('0 0 512 512')
20565			]),
20566		_List_fromArray(
20567			[
20568				A2(
20569				elm$svg$Svg$path,
20570				_List_fromArray(
20571					[
20572						elm$svg$Svg$Attributes$fill(props.color),
20573						elm$svg$Svg$Attributes$d('M451.792 0H59.208C26.561 0 0 26.561 0 59.208v393.084C0 484.939 26.561 511.5 59.208 511.5h392.584c32.647 0 59.208-26.561 59.208-59.208V59.208C511 26.561 484.439 0 451.792 0zM471 452.292c0 10.591-8.617 19.208-19.208 19.208H59.208C48.617 471.5 40 462.883 40 452.292V59.208C40 48.617 48.617 40 59.208 40h392.584C462.383 40 471 48.617 471 59.208v393.084z')
20574					]),
20575				_List_Nil),
20576				A2(
20577				elm$svg$Svg$rect,
20578				_List_fromArray(
20579					[
20580						elm$svg$Svg$Attributes$fill(props.color),
20581						elm$svg$Svg$Attributes$x('105'),
20582						elm$svg$Svg$Attributes$y('377.943'),
20583						elm$svg$Svg$Attributes$width('386'),
20584						elm$svg$Svg$Attributes$height('40'),
20585						elm$svg$Svg$Attributes$rx('20'),
20586						elm$svg$Svg$Attributes$transform('rotate(-45 105 377.943)')
20587					]),
20588				_List_Nil),
20589				A2(
20590				elm$svg$Svg$rect,
20591				_List_fromArray(
20592					[
20593						elm$svg$Svg$Attributes$fill(props.color),
20594						elm$svg$Svg$Attributes$x('133.284'),
20595						elm$svg$Svg$Attributes$y('105'),
20596						elm$svg$Svg$Attributes$width('386'),
20597						elm$svg$Svg$Attributes$height('40'),
20598						elm$svg$Svg$Attributes$rx('20'),
20599						elm$svg$Svg$Attributes$transform('rotate(45 133.284 105)')
20600					]),
20601				_List_Nil)
20602			]));
20603};
20604var dtwrks$elm_book$ElmBook$UI$Icons$iconMenu = function (props) {
20605	return A2(
20606		elm$svg$Svg$svg,
20607		_List_fromArray(
20608			[
20609				elm$svg$Svg$Attributes$width(
20610				elm$core$String$fromInt(props.size)),
20611				elm$svg$Svg$Attributes$height(
20612				elm$core$String$fromInt(props.size)),
20613				elm$svg$Svg$Attributes$viewBox('0 0 512 512')
20614			]),
20615		_List_fromArray(
20616			[
20617				A2(
20618				elm$svg$Svg$path,
20619				_List_fromArray(
20620					[
20621						elm$svg$Svg$Attributes$fill(props.color),
20622						elm$svg$Svg$Attributes$d('M176.792 0H59.208C26.561 0 0 26.561 0 59.208v117.584C0 209.439 26.561 236 59.208 236h117.584C209.439 236 236 209.439 236 176.792V59.208C236 26.561 209.439 0 176.792 0zM196 176.792c0 10.591-8.617 19.208-19.208 19.208H59.208C48.617 196 40 187.383 40 176.792V59.208C40 48.617 48.617 40 59.208 40h117.584C187.383 40 196 48.617 196 59.208v117.584zM452 0H336c-33.084 0-60 26.916-60 60v116c0 33.084 26.916 60 60 60h116c33.084 0 60-26.916 60-60V60c0-33.084-26.916-60-60-60zm20 176c0 11.028-8.972 20-20 20H336c-11.028 0-20-8.972-20-20V60c0-11.028 8.972-20 20-20h116c11.028 0 20 8.972 20 20v116zM176.792 276H59.208C26.561 276 0 302.561 0 335.208v117.584C0 485.439 26.561 512 59.208 512h117.584C209.439 512 236 485.439 236 452.792V335.208C236 302.561 209.439 276 176.792 276zM196 452.792c0 10.591-8.617 19.208-19.208 19.208H59.208C48.617 472 40 463.383 40 452.792V335.208C40 324.617 48.617 316 59.208 316h117.584c10.591 0 19.208 8.617 19.208 19.208v117.584zM452 276H336c-33.084 0-60 26.916-60 60v116c0 33.084 26.916 60 60 60h116c33.084 0 60-26.916 60-60V336c0-33.084-26.916-60-60-60zm20 176c0 11.028-8.972 20-20 20H336c-11.028 0-20-8.972-20-20V336c0-11.028 8.972-20 20-20h116c11.028 0 20 8.972 20 20v116z')
20623					]),
20624				_List_Nil)
20625			]));
20626};
20627var elm$html$Html$header = _VirtualDom_node('header');
20628var dtwrks$elm_book$ElmBook$UI$Header$view = function (props) {
20629	return A2(
20630		elm$html$Html$header,
20631		_List_fromArray(
20632			[
20633				elm$html$Html$Attributes$class('elm-book-header')
20634			]),
20635		_List_fromArray(
20636			[
20637				A2(
20638				elm$html$Html$a,
20639				_List_fromArray(
20640					[
20641						elm$html$Html$Attributes$href(props.href),
20642						elm$html$Html$Attributes$class('elm-book-header--link'),
20643						A2(elm$html$Html$Attributes$style, 'color', dtwrks$elm_book$ElmBook$UI$Helpers$themeAccent)
20644					]),
20645				_List_fromArray(
20646					[
20647						A2(
20648						elm$html$Html$h1,
20649						_List_fromArray(
20650							[
20651								elm$html$Html$Attributes$class('elm-book')
20652							]),
20653						_List_fromArray(
20654							[
20655								A2(
20656								elm$core$Maybe$withDefault,
20657								dtwrks$elm_book$ElmBook$UI$Header$viewDefault(
20658									{href: props.href, theme: props.theme, title: props.title, toHtml: props.toHtml}),
20659								A2(
20660									elm$core$Maybe$map,
20661									props.toHtml,
20662									dtwrks$elm_book$ElmBook$Internal$ThemeOptions$header(props.theme)))
20663							]))
20664					])),
20665				A2(
20666				elm$html$Html$button,
20667				_List_fromArray(
20668					[
20669						elm$html$Html$Attributes$class('elm-book elm-book-header--button'),
20670						elm$html$Html$Events$onClick(props.onClickMenuButton)
20671					]),
20672				_List_fromArray(
20673					[

20674						props.isMenuOpen ? dtwrks$elm_book$ElmBook$UI$Icons$iconClose(
20675						{color: dtwrks$elm_book$ElmBook$UI$Helpers$themeAccent, size: 20}) : dtwrks$elm_book$ElmBook$UI$Icons$iconMenu(
20676						{color: dtwrks$elm_book$ElmBook$UI$Helpers$themeAccent, size: 20})
20677					]))
20678			]));
20679};
20680var dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccentVar = '--elm-book-nav-accent';
20681var dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccent = dtwrks$elm_book$ElmBook$UI$Helpers$var_(dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccentVar);
20682var dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccentHighlightVar = '--elm-book-nav-accent-highlight';
20683var dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccentHighlight = dtwrks$elm_book$ElmBook$UI$Helpers$var_(dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccentHighlightVar);
20684var dtwrks$elm_book$ElmBook$UI$Helpers$themeNavBackgroundVar = '--elm-book-nav-background';
20685var dtwrks$elm_book$ElmBook$UI$Helpers$themeNavBackground = dtwrks$elm_book$ElmBook$UI$Helpers$var_(dtwrks$elm_book$ElmBook$UI$Helpers$themeNavBackgroundVar);
20686var dtwrks$elm_book$ElmBook$UI$Nav$target_ = function (internal) {
20687	return internal ? elm$html$Html$Attributes$class('') : elm$html$Html$Attributes$target('_blank');
20688};
20689var elm$html$Html$nav = _VirtualDom_node('nav');
20690var dtwrks$elm_book$ElmBook$UI$Nav$view = function (props) {
20691	var item = function (_n2) {
20692		var url = _n2.a;
20693		var label = _n2.b;
20694		var internal = _n2.c;
20695		return A2(
20696			elm$html$Html$li,
20697			_List_Nil,
20698			_List_fromArray(
20699				[
20700					A2(
20701					elm$html$Html$a,
20702					_List_fromArray(
20703						[
20704							elm$html$Html$Attributes$href(url),
20705							dtwrks$elm_book$ElmBook$UI$Nav$target_(internal),
20706							elm$html$Html$Attributes$classList(
20707							_List_fromArray(
20708								[
20709									_Utils_Tuple2('elm-book-nav-item', true),
20710									_Utils_Tuple2(
20711									'active',
20712									_Utils_eq(
20713										props.active,
20714										elm$core$Maybe$Just(url))),
20715									_Utils_Tuple2(
20716									'pre-selected',
20717									_Utils_eq(
20718										props.preSelected,
20719										elm$core$Maybe$Just(url)))
20720								])),
20721							_Utils_eq(
20722							props.active,
20723							elm$core$Maybe$Just(url)) ? A2(elm$html$Html$Attributes$style, 'color', dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccentHighlight) : A2(elm$html$Html$Attributes$style, 'color', dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccent)
20724						]),
20725					_List_fromArray(
20726						[
20727							A2(
20728							elm$html$Html$div,
20729							_List_fromArray(
20730								[
20731									elm$html$Html$Attributes$class('elm-book-inset elm-book-nav-item-bg'),
20732									A2(elm$html$Html$Attributes$style, 'background-color', dtwrks$elm_book$ElmBook$UI$Helpers$themeNavBackground)
20733								]),
20734							_List_Nil),
20735							A2(
20736							elm$html$Html$div,
20737							_List_fromArray(
20738								[
20739									elm$html$Html$Attributes$class('elm-book-nav-item-content')
20740								]),
20741							_List_fromArray(
20742								[
20743									elm$html$Html$text(label)
20744								]))
20745						]))
20746				]));
20747	};
20748	var list = function (_n1) {
20749		var title = _n1.a;
20750		var items = _n1.b;
20751		return elm$core$List$isEmpty(items) ? elm$html$Html$text('') : A2(
20752			elm$html$Html$div,
20753			_List_fromArray(
20754				[
20755					elm$html$Html$Attributes$class('elm-book-nav-list-wrapper')
20756				]),
20757			_List_fromArray(
20758				[
20759					(title === '') ? elm$html$Html$text('') : A2(
20760					elm$html$Html$p,
20761					_List_fromArray(
20762						[
20763							elm$html$Html$Attributes$class('elm-book-nav-list-title'),
20764							A2(elm$html$Html$Attributes$style, 'color', dtwrks$elm_book$ElmBook$UI$Helpers$themeAccent)
20765						]),
20766					_List_fromArray(
20767						[
20768							elm$html$Html$text(title)
20769						])),
20770					A2(
20771					elm$html$Html$ul,
20772					_List_fromArray(
20773						[
20774							elm$html$Html$Attributes$class('elm-book-nav-list')
20775						]),
20776					A2(elm$core$List$map, item, items))
20777				]));
20778	};
20779	var isEmpty = !A3(
20780		elm$core$List$foldl,
20781		F2(
20782			function (_n0, acc) {
20783				var xs = _n0.b;
20784				return acc + elm$core$List$length(xs);
20785			}),
20786		0,
20787		props.itemGroups);
20788	return A2(
20789		elm$html$Html$div,
20790		_List_fromArray(
20791			[
20792				elm$html$Html$Attributes$class('elm-book-wrapper elm-book-sans')
20793			]),
20794		_List_fromArray(
20795			[
20796				isEmpty ? A2(
20797				elm$html$Html$p,
20798				_List_fromArray(
20799					[
20800						elm$html$Html$Attributes$class('elm-book-nav-empty'),
20801						A2(elm$html$Html$Attributes$style, 'color', dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccent)
20802					]),
20803				_List_fromArray(
20804					[
20805						elm$html$Html$text('No results')
20806					])) : A2(
20807				elm$html$Html$nav,
20808				_List_fromArray(
20809					[
20810						elm$html$Html$Attributes$class('elm-book-nav')
20811					]),
20812				A2(elm$core$List$map, list, props.itemGroups))
20813			]));
20814};
20815var elm$html$Html$Attributes$id = elm$html$Html$Attributes$stringProperty('id');
20816var elm$html$Html$Attributes$placeholder = elm$html$Html$Attributes$stringProperty('placeholder');
20817var elm$html$Html$Attributes$value = elm$html$Html$Attributes$stringProperty('value');
20818var elm$html$Html$Events$onBlur = function (msg) {
20819	return A2(
20820		elm$html$Html$Events$on,
20821		'blur',
20822		elm$json$Json$Decode$succeed(msg));
20823};
20824var elm$html$Html$Events$onFocus = function (msg) {
20825	return A2(
20826		elm$html$Html$Events$on,
20827		'focus',
20828		elm$json$Json$Decode$succeed(msg));
20829};
20830var elm$html$Html$Events$alwaysStop = function (x) {
20831	return _Utils_Tuple2(x, true);
20832};
20833var elm$virtual_dom$VirtualDom$MayStopPropagation = function (a) {
20834	return {$: 'MayStopPropagation', a: a};
20835};
20836var elm$html$Html$Events$stopPropagationOn = F2(
20837	function (event, decoder) {
20838		return A2(
20839			elm$virtual_dom$VirtualDom$on,
20840			event,
20841			elm$virtual_dom$VirtualDom$MayStopPropagation(decoder));
20842	});
20843var elm$json$Json$Decode$at = F2(
20844	function (fields, decoder) {
20845		return A3(elm$core$List$foldr, elm$json$Json$Decode$field, decoder, fields);
20846	});
20847var elm$html$Html$Events$targetValue = A2(
20848	elm$json$Json$Decode$at,
20849	_List_fromArray(
20850		['target', 'value']),
20851	elm$json$Json$Decode$string);
20852var elm$html$Html$Events$onInput = function (tagger) {
20853	return A2(
20854		elm$html$Html$Events$stopPropagationOn,
20855		'input',
20856		A2(
20857			elm$json$Json$Decode$map,
20858			elm$html$Html$Events$alwaysStop,
20859			A2(elm$json$Json$Decode$map, tagger, elm$html$Html$Events$targetValue)));
20860};
20861var dtwrks$elm_book$ElmBook$UI$Search$view = function (props) {
20862	return A2(
20863		elm$html$Html$div,
20864		_List_fromArray(
20865			[
20866				elm$html$Html$Attributes$class('elm-book-wrapper elm-book-search-wrapper elm-book-sans')
20867			]),
20868		_List_fromArray(
20869			[
20870				A2(
20871				elm$html$Html$div,
20872				_List_fromArray(
20873					[
20874						elm$html$Html$Attributes$class('elm-book-search-bg elm-book-inset')
20875					]),
20876				_List_Nil),
20877				A2(
20878				elm$html$Html$div,
20879				_List_fromArray(
20880					[
20881						elm$html$Html$Attributes$class('elm-book-search-border elm-book-inset')
20882					]),
20883				_List_Nil),
20884				A2(
20885				elm$html$Html$input,
20886				_List_fromArray(
20887					[
20888						elm$html$Html$Attributes$id('elm-book-search'),
20889						elm$html$Html$Attributes$value(props.value),
20890						elm$html$Html$Events$onInput(props.onInput),
20891						elm$html$Html$Events$onFocus(props.onFocus),
20892						elm$html$Html$Events$onBlur(props.onBlur),
20893						elm$html$Html$Attributes$placeholder('Type \"⌘K\" to search…')
20894					]),
20895				_List_Nil)
20896			]));
20897};

20898var elm$virtual_dom$VirtualDom$node = function (tag) {
20899	return _VirtualDom_node(
20900		_VirtualDom_noScript(tag));
20901};
20902var elm$html$Html$node = elm$virtual_dom$VirtualDom$node;
20903var dtwrks$elm_book$ElmBook$UI$Helpers$css_ = function (x) {
20904	return A3(
20905		elm$html$Html$node,
20906		'style',
20907		_List_Nil,
20908		_List_fromArray(
20909			[
20910				elm$html$Html$text(x)
20911			]));
20912};
20913var dtwrks$elm_book$ElmBook$UI$ActionLog$styles = dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n.elm-book-action-log-preview-wrapper {\n    padding: 8px;\n}\n.elm-book-action-log-preview {\n    display: block;\n    width: 100%;\n    padding: 0;\n    margin: 0;\n    border: none;\n    border-radius: 4px;\n    background-color: transparent;\n    text-align: left;\n    font-size: 14px;\n    cursor: pointer;\n}\n.elm-book-action-log-preview:hover {\n    opacity: 0.9;\n}\n.elm-book-action-log-preview:hover {\n    opacity: 0.8;\n}\n\n.elm-book-action-log-preview-empty-wrapper {\n    padding: 8px;\n    font-size: 14px;\n    color: #aaa;\n}\n.elm-book-action-log-preview-empty {\n    padding: 12px 20px;\n    background-color: #f3f3f3;\n    border-radius: 4px;\n}\n\n.elm-book-dark-mode .elm-book-action-log-preview-empty {\n    background-color: #2f3238;\n}\n\n.elm-book-action-log-list-wrapper {\n    position: relative;\n    padding-top: 34px;\n}\n.elm-book-action-log-list-header {\n    display: flex;\n    align-items: center;\n    position: absolute;\n    top: 0;\n    left: 0;\n    right: 0;\n    height: 34px;\n    padding: 0 20px;\n    font-weight: bold;\n    font-size: 14px;\n    letter-spacing: 0.5px;\n    color: #fff;\n}\n.elm-book-action-log-list {\n    list-style-type: none;\n    max-height: 70vh;\n    overflow-y: auto;\n}\n.elm-book-action-log-list-item {\n    border-top: 1px solid #e0e0e0;\n}\n.elm-book-dark-mode .elm-book-action-log-list-item {\n    border-top-color: #3b3f47;\n}\n\n.elm-book-action-log-item-wrapper {\n    display: flex;\n    align-items: center;\n    padding: 8px 20px 8px 0;\n    font-size: 14px;\n    background-color: #f5f5f5;\n}\n.elm-book-dark-mode .elm-book-action-log-item-wrapper {\n    background-color: #2f3238;\n}\n\n.elm-book-action-log-item-index {\n    width: 60px;\n    text-align: center;\n    display: inline-block;\n    color: #a0a0a0;\n}\n.elm-book-action-log__main {\n    flex-grow: 1;\n}\n.elm-book-action-log-item-preffix {\n    padding-right: 16px;\n    color: #a0a0a0;\n    letter-spacing: 0.5px;\n    font-size: 12px;\n}\n.elm-book-action-log-item-label {\n    color: #404040;\n    font-size: 13px;\n    font-weight: bold;\n}\n.elm-book-dark-mode .elm-book-action-log-item-label {\n    color: #f5f5f5;\n}\n');
20914var dtwrks$elm_book$ElmBook$UI$Helpers$mediaMobile = '@media screen and (max-width: 768px)';
20915var dtwrks$elm_book$ElmBook$UI$Chapter$styles = dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n.elm-book-chapter {\n    padding: 40px;\n    width: 100%;\n}\n' + (dtwrks$elm_book$ElmBook$UI$Helpers$mediaMobile + ' {\n    .elm-book-chapter {\n        padding: 24px;\n    }\n}\n'));
20916var dtwrks$elm_book$ElmBook$UI$ChapterComponent$styles = dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n.elm-book__chapter-component__title {\n    padding-bottom: 12px;\n    font-size: 14px;\n    letter-spacing: 0.5px;\n    color: #999;\n}\n\n.elm-book__chapter-component__background {\n    padding: 12px;\n    border-radius: 4px;\n    background-color: #fff;\n}\n.elm-book-dark-mode .elm-book__chapter-component__background {\n    background-color: #3b3f47;\n}\n\n.elm-book__chapter-component__content {\n    border: 1px dashed transparent;\n    position: relative;\n}\n.elm-book__chapter-component__content:hover {\n    border-color: #eaeaea;\n}\n');
20917var dtwrks$elm_book$ElmBook$UI$ChapterHeader$styles = dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n.elm-book-chapter-header {\n    display: flex;\n    align-items: center;\n    justify-content: space-between;\n    margin: 0;\n    padding: 8px 12px 8px 16px;\n\n}\n.elm-book-dark-mode .elm-book-chapter-header {\n    color: #dadada;\n}\n\n.elm-book-chapter-header__title {\n    margin: 0;\n    padding: 0;\n    font-size: 12px;\n    font-weight: bold;\n    text-transform: uppercase;\n    letter-spacing: 0.5px;\n    color: #b0b4ba;\n}\n.elm-book-dark-mode .elm-book-chapter-header__title {\n    color: #dadada;\n}\n\n.elm-book-chapter-header__btn {\n    border: none;\n    background: none;\n    color: #b0b4ba;\n}\n.elm-book-chapter-header__btn:hover {\n    cursor: pointer;\n    opacity: 0.8;\n}\n.elm-book-chapter-header__btn:active {\n    opacity: 0.6;\n}\n.elm-book-dark-mode .elm-book-chapter-header__btn {\n    color: #dadada;\n}\n');
20918var dtwrks$elm_book$ElmBook$UI$Footer$styles = dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n.elm-book-footer {\n    display: flex;

20918\n    align-items: center;\n    width: 100%;\n    margin: 0;\n    padding: 13px 12px 13px;\n    opacity: 0.8;\n    transition: opacity 200ms;\n    text-decoration: none;\n}\n.elm-book-footer:hover {\n    opacity: 1;\n}\n\n.elm-book-footer--text {\n    padding-left: 12px;\n    font-size: 10px;\n    text-transform: uppercase;\n    letter-spacing: 0.5px;\n    color: currentColor;\n}\n');
20919var dtwrks$elm_book$ElmBook$UI$Header$styles = dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n.elm-book-header {\n    display: flex;\n    align-items: center;\n    justify-content: space-between;\n}\n\n.elm-book-header--link {\n    display: block;\n    padding: 8px 12px;\n    text-decoration: none;\n}\n.elm-book-header--link:hover {\n    opacity: 0.9;\n}\n.elm-book-header--link:active {\n    opacity: 0.8;\n}\n\n.elm-book-header--button {\n    display: none;\n    padding: 12px;\n    border: none;\n    border-radius: 4px;\n    box-shadow: none;\n    background-color: transparent;\n    cursor: pointer;\n}\n.elm-book-header--button:hover {\n    opacity: 0.9;\n    background-color: rgba(255, 255, 255, 0.1);\n}\n.elm-book-header--button:active {\n    opacity: 0.4;\n}\n@media screen and (max-width: 768px) {\n    .elm-book-header--button {\n        display: flex;\n        align-items: center;\n    }\n}\n\n.elm-book-header-default {\n    display: flex;\n    align-items: center;\n}\n\n.elm-book-header-default--wrapper {\n    display: block;\n    padding-left: 16px;\n    font-weight: 600;\n    font-size: 16px;\n}\n\n.elm-book-header-default--title {\n    display: block;\n    padding-right: 4px;\n}\n\n.elm-book-header-default--subtitle {\n    display: block;\n    font-weight: 400;\n}\n');
20920var dtwrks$elm_book$ElmBook$UI$Helpers$baseStyles = dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n@import url(\'https://fonts.googleapis.com/css2?family=Fira+Code:wght@400;600&family=IBM+Plex+Sans:wght@300;400;600&family=IBM+Plex+Serif:ital,wght@0,400;0,600;1,400;1,600&display=swap\');\n\n@keyframes fade-in {\n  from { opacity: 0; }\n  to   { opacity: 1; }\n}\n\n.elm-book-fade-in {\n    animation: 0.3s linear fade-in;\n}\n\n.elm-book-wrapper * {\n    box-sizing: border-box;\n    margin: 0;\n    padding: 0;\n}\n\n.elm-book-wrapper,\n.elm-book {\n    box-sizing: border-box;\n    margin: 0;\n    padding: 0;\n}\n\n.elm-book-sans {\n    font-family: "IBM Plex Sans", "sans-serif";\n}\n\n.elm-book-serif {\n    font-family: "IBM Plex Serif", "serif";\n}\n\n.elm-book-monospace {\n    font-family: "Fira Code", "monospace";\n}\n\n.elm-book-inset {\n    position: absolute;\n    top: 0;\n    left: 0;\n    right: 0;\n    bottom: 0;\n}\n\n.elm-book-shadows {\n    box-shadow: 0 0 20px rgba(0, 0, 0, 0.05);\n}\n\n.elm-book-shadows-light {\n    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.15);\n}\n');
20921var dtwrks$elm_book$ElmBook$UI$Helpers$mediaLargeScreen = '@media screen and (min-width: 1720px)';
20922var dtwrks$elm_book$ElmBook$UI$Markdown$styles = dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n.elm-book__component-wrapper {\n    max-width: 720px;\n    margin: 0 auto;\n    padding-bottom: 36px;\n}\n.elm-book__component-wrapper.full {\n    max-width: 100%;\n}\n.elm-book__component-empty {\n    padding: 20px;\n    background-color: #f9e4b5;\n    border-radius: 4px;\n    border: 2px solid #eac97d;\n    color: #ab7700;\n}\n\n.elm-book-md__component-list {\n    list-style-type: none;\n    margin: 0;\n    padding: 0;\n}\n.elm-book-md__component-list__item + .elm-book-md__component-list__item {\n    padding-top: 36px;\n}\n\n.elm-book-md {\n    max-width: 720px;\n    margin: 0 auto;\n    padding-bottom: 36px;\n    color: rgb(41,41,41);\n}\n\n.elm-book-dark-mode .elm-book-md {\n    color: rgb(180, 180, 180);    \n}\n\n.elm-book-md * {\n    margin: 0;\n    padding: 0;\n    box-sizing: border-box;\n}\n\n' + (dtwrks$elm_book$ElmBook$UI$Helpers$mediaLargeScreen + (' {\n    .elm-book__component-wrapper {\n        max-width: 960px;\n    }\n    .elm-book__component-wrapper.full {\n        max-width: 100%;\n    }\n    .elm-book-md {\n        max-width: 960px;\n    }\n}\n\n.elm-book-md h1 {\n    font-size: 46px;\n}\n.elm-book-md h2 {\n    font-size: 32px;\n}\n.elm-book-md h3 {\n    font-size: 24px;\n}\n.elm-book-md h4 {\n    font-size: 20px;\n    font-weight: normal;\n    text-transform: uppercase;\n}\n.elm-book-md h5 {\n    font-size: 18px;\n    font-weight: normal;\n    text-transform: uppercase;\n}\n.elm-book-md h6 {\n    font-size: 16px;\n    font-weight: normal;\n    text-transform: uppercase;\n    letter-spacing: 0.5px;\n}\n\n.elm-book-md h1,\n.elm-book-md h2,\n.elm-book-md h3 {\n    font-weight: bold;\n}\n\n.elm-book-md h1,\n.elm-book-md h2,\n.elm-book-md h3,\n.elm-book-md h4,\n.elm-book-md h5,\n.elm-book-md h6 {\n    padding-top: 24px;\n}\n\n.elm-book-dark-mode .elm-book-md h1,\n.elm-book-dark-mode .elm-book-md h2,\n.elm-book-dark-mode .elm-book-md h3,\n.elm-book-dark-mode .elm-book-md h4,\n.elm-book-dark-mode .elm-book-md h5,\n.elm-book-dark-mode .elm-book-md h6 {\n    color: #dadada;\n}\n\n' + (dtwrks$elm_book$ElmBook$UI$Helpers$mediaMobile + (' {\n    .elm-book-md h1 {\n        font-size: 40px;\n        padding-top: 12px;\n    }\n}\n\n.elm-book-md__default {\n    line-height: 1.8em;\n    color: rgb(80, 80, 90);\n    font-size: 20px;\n}\n' + (dtwrks$elm_book$ElmBook$UI$Helpers$mediaMobile + (' {\n    .elm-book-md__default {\n        font-size: 18px;\n    }\n}\n\n.elm-book-md a {\n    color: #000;\n    text-decoration: underline;\n}\n.elm-book-md a:hover {\n    opacity: 0.8;   \n}\n.elm-book-dark-mode .elm-book-md a {\n    color: #f0f0f0;\n}\n\n.elm-book-md blockquote {\n    font-size: 18px;\n    margin-left: 0;\n    padding: 8px 0 8px 24px;

20922\n    border-left: 4px solid #f0f0f0;\n}\n.elm-book-md code {\n    display: inline-block;\n    border-radius: 4px;\n    padding: 0 8px;\n    background-color: #f0f0f0;\n    border: 1px solid #eaeaea;\n    color: #4a4a4a;\n    font-size: 0.8em;\n    line-height: 1.8em;\n}\n.elm-book-dark-mode .elm-book-md code {\n    background-color: #333;\n    border: 1px solid #444;\n    color: #bababa;\n}\n\n\n.elm-book-md img {\n    max-width: 100%;\n}\n.elm-book-md ul {\n    padding-left: 32px;\n    list-style: disc;\n}\n.elm-book-md ol {\n    padding-left: 32px;\n}\n\n.elm-book-md hr {\n    border: none;\n    height: 2px;\n    background-color: #f0f0f0;\n}\n.elm-book-dark-mode .elm-book-md hr {\n    background-color: #3b3f47;\n}\n\n.elm-book-md table {\n    border-collapse: collapse;\n    overflow-x: auto;\n    border: 2px solid #f0f0f0;\n}\n.elm-book-md thead {\n    border: none;\n}\n.elm-book-md tbody {\n    border: none;\n}\n.elm-book-md tr {\n    border: none;\n    border-top: 2px solid #f0f0f0;\n}\n.elm-book-md th,\n.elm-book-md td {\n    border: none;\n    border-right: 2px solid #f0f0f0;\n    padding: 12px;\n}\n.elm-book-md th:last-child,\n.elm-book-md td:last-child {\n    border-right: none;\n}\n\n.elm-book-dark-mode .elm-book-md table,\n.elm-book-dark-mode .elm-book-md tr,\n.elm-book-dark-mode .elm-book-md th,\n.elm-book-dark-mode .elm-book-md td {\n    border-color: #3b3f47;\n}\n\n.elm-book-md__code,\n.elm-book-md__code code,\n.elm-book-dark-mode .elm-book-md__code,\n.elm-book-dark-mode .elm-book-md__code code {\n    font-size: 18px;\n    line-height: 22px;\n    padding: 20px 24px;\n    background-color: #2a354d;\n    border-radius: 6px;\n    border: none;\n    overflow: auto;\n}\n.elm-book-md__code-default {}\n\n' + (dtwrks$elm_book$ElmBook$UI$Helpers$mediaMobile + ' {\n    .elm-book-md__code,\n    .elm-book-md__code code,\n    .elm-book-dark-mode .elm-book-md__code,\n    .elm-book-dark-mode .elm-book-md__code code {\n        font-size: 16px;\n    }\n}\n\n.elm-book-md pre.elmsh {\n    padding: 0;\n    margin: 0;\n}\n\n.elm-book-md code.elmsh {\n    padding: 0;\n}\n\n.elm-book-md .elmsh {\n    color: #f8f8f2;\n}\n.elm-book-md .elmsh-hl {\n    background: #343434;\n}\n.elm-book-md .elmsh-add {\n    background: #003800;\n}\n.elm-book-md .elmsh-del {\n    background: #380000;\n}\n.elm-book-md .elmsh-comm {\n    color: #a4a39c;\n}\n.elm-book-md .elmsh1 {\n    color: #46f0ff;\n}\n.elm-book-md .elmsh2 {\n    color: #a5fb98;\n}\n.elm-book-md .elmsh3 {\n    color: #ff8f00;\n}\n.elm-book-md .elmsh4 {\n    color: #46f0ff;\n}\n.elm-book-md .elmsh5 {\n    color: #46f0ff;\n}\n.elm-book-md .elmsh6 {\n    color: #46f0ff;\n}\n.elm-book-md .elmsh7 {\n    color: #46f0ff;\n}\n.elm-book-md .elmsh-elm-ts, .elm-book-md .elmsh-js-dk, .elm-book-md .elmsh-css-p {\n    font-style: italic;\n    color: #46f0ff;\n}\n.elm-book-md .elmsh-js-ce {\n    font-style: italic;\n    color: #46f0ff;\n}\n.elm-book-md .elmsh-css-ar-i {\n    font-weight: bold;\n    color: #46f0ff;\n}\n'))))))));
20923var dtwrks$elm_book$ElmBook$UI$Nav$styles = dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n.elm-book-nav-empty {\n    padding: 12px 20px;\n    font-size: 14px;\n}\n\n.elm-book-nav-list-wrapper {\n    padding-bottom: 16px;\n}\n\n.elm-book-nav-list-title {\n    padding: 12px 20px 8px;\n    font-weight: bold;\n    font-size: 12px;\n    text-transform: uppercase;\n    letter-spacing: 0.5px;\n}\n\n.elm-book-nav-list {\n    list-style-type: none;\n}\n\n.elm-book-nav-item {\n    position: relative;\n    display: flex;\n    font-size: 14px;\n    letter-spacing: 1px;\n    text-decoration: none;\n}\n.elm-book-nav-item:focus {\n    outline: none;\n}\n\n.elm-book-nav-item-content {\n    position: relative;\n    z-index: 1;\n    padding: 8px 20px;\n}\n\n.elm-book-nav-item-bg {\n    opacity: 0;\n}\n.elm-book-nav-item.pre-selected .elm-book-nav-item-bg {\n    opacity: 0.1;\n}\n.elm-book-nav-item.active .elm-book-nav-item-bg {\n    opacity: 0.2;\n}\n.elm-book-nav-item.active.pre-selected .elm-book-nav-item-bg {\n    opacity: 0.25;\n}\n.elm-book-nav-item:hover .elm-book-nav-item-bg {\n    opacity: 0.15;\n}\n.elm-book-nav-item:active .elm-book-nav-item-bg {\n    opacity: 0.1;\n}\n.elm-book-nav-item.active:hover .elm-book-nav-item-bg {\n    opacity: 0.25;\n}\n.elm-book-nav-item.active:active .elm-book-nav-item-bg {\n    opacity: 0.2;\n}\n');
20924var dtwrks$elm_book$ElmBook$UI$Search$styles = dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n.elm-book-search-wrapper {\n    position: relative;\n    width: 100%;\n}\n\n#elm-book-search {\n    position: relative;\n    z-index: 1;\n    width: 100%;\n    padding: 10px 12px;\n    border: 0;\n    border-radius: 4px;\n    background: none;\n    font-size: 14px;\n    color: ' + (dtwrks$elm_book$ElmBook$UI$Helpers$themeAccent + (';\n    transition: 0.2s;\n}\n#elm-book-search:focus {\n    outline: none;\n}\n#elm-book-search::placeholder {\n    border-radius: 4px;\n    color: ' + (dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccent + (';\n    opacity: 0.7;\n}\n\n.elm-book-search-bg {\n    opacity: 0.2;\n    border-radius: 4px;\n    background-color: ' + (dtwrks$elm_book$ElmBook$UI$Helpers$themeNavBackgroun

20924d + (';\n}\n.elm-book-search-border {\n    opacity: 0.5;\n    border-radius: 4px;\n    border: 0px solid ' + (dtwrks$elm_book$ElmBook$UI$Helpers$themeAccent + ';\n    transition: 0.2s;\n}\n\n.elm-book-search-wrapper:hover .elm-book-search-bg {\n    opacity: 0.25;\n}\n.elm-book-search-wrapper:hover .elm-book-search-border {\n    border-width: 3px;\n}\n.elm-book-search-wrapper:focus-within .elm-book-search-border {\n    opacity: 1;\n    border-width: 3px;\n}\n'))))))));
20925var dtwrks$elm_book$ElmBook$UI$Wrapper$modalZ = '99999';
20926var dtwrks$elm_book$ElmBook$UI$Wrapper$sidebarSize = '300px';
20927var dtwrks$elm_book$ElmBook$UI$Wrapper$styles = dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n.elm-book--wrapper--globals {\n    display: none;\n}\n\n.elm-book--wrapper {\n    display: flex;\n    align-items: stretch;\n    background: ' + (dtwrks$elm_book$ElmBook$UI$Helpers$themeBackground + (';\n}\n' + (dtwrks$elm_book$ElmBook$UI$Helpers$mediaMobile + (' {\n    .elm-book--wrapper {\n        flex-direction: column;\n    }\n}\n\n.elm-book--wrapper--sidebar {\n    display: flex;\n    flex-direction: column;\n    width: ' + (dtwrks$elm_book$ElmBook$UI$Wrapper$sidebarSize + (';\n}\n' + (dtwrks$elm_book$ElmBook$UI$Helpers$mediaMobile + (' {\n    .elm-book--wrapper--sidebar {\n        width: 100%;\n    }\n    .elm-book--wrapper.is-open .elm-book--wrapper--sidebar {\n        flex-grow: 1;\n    }\n}\n\n.elm-book--wrapper--header {\n    padding: 8px 8px 4px;\n}\n\n.elm-book--wrapper--menu {\n    display: flex;\n    flex-direction: column;\n    flex-grow: 1;\n}\n' + (dtwrks$elm_book$ElmBook$UI$Helpers$mediaMobile + (' {\n    .elm-book--wrapper--menu {\n        display: none;\n    }\n    .elm-book--wrapper.is-open .elm-book--wrapper--menu {\n        display: flex;\n    }\n}\n\n.elm-book--wrapper--menu--header {\n    padding: 8px;\n}\n\n.elm-book--wrapper--menu--separator {\n    display: block;\n    margin: 0;\n    padding: 0;\n    opacity: 0.2;\n    border-top: none;\n    border-bottom: 1px solid ' + (dtwrks$elm_book$ElmBook$UI$Helpers$themeNavBackground + (';\n}\n\n.elm-book--wrapper--menu--main-wrapper {\n    position: relative;\n    flex-grow: 1;\n}\n\n.elm-book--wrapper--menu--main {\n    overflow: auto;\n    padding: 8px 0;\n}\n\n.elm-book--wrapper--menu--footer {\n    padding: 8px;\n}\n\n.elm-book--wrapper--main {\n    flex-grow: 1;\n    display: flex;\n    flex-direction: column;\n    padding: 8px 8px 0 0;\n}\n' + (dtwrks$elm_book$ElmBook$UI$Helpers$mediaMobile + (' {\n    .elm-book--wrapper--main {\n        display: flex;\n        padding-left: 8px;\n    }\n    .elm-book--wrapper.is-open .elm-book--wrapper--main {\n        display: none;\n    }\n}\n\n.elm-book--wrapper--main--wrapper {\n    flex-grow: 1;\n    display: flex;\n    flex-direction: column;\n    background-color: #fbfbfd;\n    border-radius: 4px 4px 0 0;\n    overflow: hidden;\n}\n.elm-book-dark-mode .elm-book--wrapper--main--wrapper {\n    background-color: #20232a;\n}\n\n.elm-book--wrapper--main--header {\n    border-bottom: 1px solid rgba(0, 0, 0, 0.1);\n}\n.elm-book-dark-mode .elm-book--wrapper--main--header {\n    border-bottom-color: rgba(255, 255, 255, 0.15);\n}\n\n.elm-book--wrapper--main--content {\n    position: relative;\n    flex-grow: 1;\n}\n\n.elm-book--wrapper--main--inner {\n    overflow: auto;\n}\n\n.elm-book--wrapper--main--footer {\n    border-top: 1px solid rgba(0, 0, 0, 0.1);\n}\n.elm-book-dark-mode .elm-book--wrapper--main--footer {\n    border-top-color: rgba(255, 255, 255, 0.15);\n}\n\n.elm-book--wrapper--modal {\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    z-index: ' + (dtwrks$elm_book$ElmBook$UI$Wrapper$modalZ + ';\n}\n\n.elm-book--wrapper--modal--bg {\n    z-index: 0;\n    cursor: pointer;\n    background-color: rgba(0, 0, 0, 0.3);\n    transition: background-color 300ms;\n}\n.elm-book--wrapper--modal--bg:hover {\n    background-color: rgba(0, 0, 0, 0.2);\n}\n\n.elm-book--wrapper--modal--content {\n    position: relative;\n    z-index: 1;\n    margin: 40px;\n    width: 640px;\n    max-width: 100%;\n    max-height: calc 100% - 120px;\n    overflow-y: auto;\n    background-color: #fff;\n    border-radius: 8px;\n}\n.elm-book-dark-mode .elm-book--wrapper--modal--content {\n    background-color: #20232a;\n}\n'))))))))))))))));
20928var dtwrks$elm_book$ElmBook$UI$Styles$view = A2(
20929	elm$html$Html$div,
20930	_List_Nil,
20931	_List_fromArray(
20932		[dtwrks$elm_book$ElmBook$UI$Helpers$baseStyles, dtwrks$elm_book$ElmBook$UI$ActionLog$styles, dtwrks$elm_book$ElmBook$UI$Chapter$styles, dtwrks$elm_book$ElmBook$UI$ChapterComponent$styles, dtwrks$elm_book$ElmBook$UI$ChapterHeader$styles, dtwrks$elm_book$ElmBook$UI$Footer$styles, dtwrks$elm_book$ElmBook$UI$Header$styles, dtwrks$elm_book$ElmBook$UI$Markdown$styles, dtwrks$elm_book$ElmBook$UI$Nav$styles, dtwrks$elm_book$ElmBook$UI$Search$styles, dtwrks$elm_book$ElmBook$UI$Wrapper$styles]));
20933var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$accent = function (theme) {
20934	return theme.accent;
20935};
20936var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$background = function (theme) {
20937	return theme.background;
20938};
20939var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$navAccent = function (theme) {
20940	return theme.navAccent;
20941};
20942var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$navAccentHighlight = function (theme) {
20943	return theme.navAccentHighlight;
20944};

20945var dtwrks$elm_book$ElmBook$Internal$ThemeOptions$navBackground = function (theme) {
20946	return theme.navBackground;
20947};
20948var elm$core$String$concat = function (strings) {
20949	return A2(elm$core$String$join, '', strings);
20950};
20951var dtwrks$elm_book$ElmBook$UI$Helpers$setTheme = function (theme) {
20952	return A2(
20953		elm$html$Html$Attributes$attribute,
20954		'style',
20955		elm$core$String$concat(
20956			A2(
20957				elm$core$List$map,
20958				function (_n0) {
20959					var k = _n0.a;
20960					var v = _n0.b;
20961					return k + (':' + (v + ';'));
20962				},
20963				_List_fromArray(
20964					[
20965						_Utils_Tuple2(
20966						dtwrks$elm_book$ElmBook$UI$Helpers$themeBackgroundVar,
20967						dtwrks$elm_book$ElmBook$Internal$ThemeOptions$background(theme)),
20968						_Utils_Tuple2(
20969						dtwrks$elm_book$ElmBook$UI$Helpers$themeAccentVar,
20970						dtwrks$elm_book$ElmBook$Internal$ThemeOptions$accent(theme)),
20971						_Utils_Tuple2(
20972						dtwrks$elm_book$ElmBook$UI$Helpers$themeNavBackgroundVar,
20973						dtwrks$elm_book$ElmBook$Internal$ThemeOptions$navBackground(theme)),
20974						_Utils_Tuple2(
20975						dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccentVar,
20976						dtwrks$elm_book$ElmBook$Internal$ThemeOptions$navAccent(theme)),
20977						_Utils_Tuple2(
20978						dtwrks$elm_book$ElmBook$UI$Helpers$themeNavAccentHighlightVar,
20979						dtwrks$elm_book$ElmBook$Internal$ThemeOptions$navAccentHighlight(theme))
20980					]))));
20981};
20982var dtwrks$elm_book$ElmBook$UI$Wrapper$view = function (props) {
20983	return A2(
20984		elm$html$Html$div,
20985		_List_fromArray(
20986			[
20987				dtwrks$elm_book$ElmBook$UI$Helpers$setTheme(props.theme),
20988				props.darkMode ? elm$html$Html$Attributes$class('elm-book-dark-mode') : elm$html$Html$Attributes$class('')
20989			]),
20990		_List_fromArray(
20991			[
20992				A2(
20993				elm$html$Html$div,
20994				_List_fromArray(
20995					[
20996						elm$html$Html$Attributes$class('elm-book--wrapper--globals')
20997					]),
20998				props.globals),
20999				A2(
21000				elm$html$Html$div,
21001				_List_fromArray(
21002					[
21003						elm$html$Html$Attributes$classList(
21004						_List_fromArray(
21005							[
21006								_Utils_Tuple2('elm-book--wrapper elm-book-inset', true),
21007								_Utils_Tuple2('is-open', props.isMenuOpen)
21008							]))
21009					]),
21010				_List_fromArray(
21011					[
21012						A2(
21013						elm$html$Html$div,
21014						_List_fromArray(
21015							[
21016								elm$html$Html$Attributes$class('elm-book--wrapper--sidebar')
21017							]),
21018						_List_fromArray(
21019							[
21020								A2(
21021								elm$html$Html$div,
21022								_List_fromArray(
21023									[
21024										elm$html$Html$Attributes$class('elm-book--wrapper--header')
21025									]),
21026								_List_fromArray(
21027									[props.header])),
21028								A2(
21029								elm$html$Html$div,
21030								_List_fromArray(
21031									[
21032										elm$html$Html$Attributes$class('elm-book--wrapper--menu')
21033									]),
21034								_List_fromArray(
21035									[
21036										A2(
21037										elm$html$Html$div,
21038										_List_fromArray(
21039											[
21040												elm$html$Html$Attributes$class('elm-book--wrapper--menu--header')
21041											]),
21042										_List_fromArray(
21043											[props.menuHeader])),
21044										A2(
21045										elm$html$Html$hr,
21046										_List_fromArray(
21047											[
21048												elm$html$Html$Attributes$class('elm-book--wrapper--menu--separator')
21049											]),
21050										_List_Nil),
21051										A2(
21052										elm$html$Html$div,
21053										_List_fromArray(
21054											[
21055												elm$html$Html$Attributes$class('elm-book--wrapper--menu--main-wrapper')
21056											]),
21057										_List_fromArray(
21058											[
21059												A2(
21060												elm$html$Html$div,
21061												_List_fromArray(
21062													[
21063														elm$html$Html$Attributes$class('elm-book--wrapper--menu--main elm-book-inset')
21064													]),
21065												_List_fromArray(
21066													[props.menu]))
21067											])),
21068										A2(
21069										elm$html$Html$hr,
21070										_List_fromArray(
21071											[
21072												elm$html$Html$Attributes$class('elm-book--wrapper--menu--separator')
21073											]),
21074										_List_Nil),
21075										A2(
21076										elm$html$Html$div,
21077										_List_fromArray(
21078											[
21079												elm$html$Html$Attributes$class('elm-book--wrapper--menu--footer')
21080											]),
21081										_List_fromArray(
21082											[props.menuFooter]))
21083									]))
21084							])),
21085						A2(
21086						elm$html$Html$div,
21087						_List_fromArray(
21088							[
21089								elm$html$Html$Attributes$class('elm-book--wrapper--main')
21090							]),
21091						_List_fromArray(
21092							[
21093								A2(
21094								elm$html$Html$div,
21095								_List_fromArray(
21096									[
21097										elm$html$Html$Attributes$class('elm-book--wrapper--main--wrapper')
21098									]),
21099								_List_fromArray(
21100									[
21101										function () {
21102										var _n0 = props.mainHeader;
21103										if (_n0.$ === 'Just') {
21104											var mainHeader = _n0.a;
21105											return A2(
21106												elm$html$Html$div,
21107												_List_fromArray(
21108													[
21109														elm$html$Html$Attributes$class('elm-book--wrapper--main--header elm-book-sans')
21110													]),
21111												_List_fromArray(
21112													[mainHeader]));
21113										} else {
21114											return elm$html$Html$text('');
21115										}
21116									}(),
21117										A2(
21118										elm$html$Html$div,
21119										_List_fromArray(
21120											[
21121												elm$html$Html$Attributes$class('elm-book--wrapper--main--content')
21122											]),
21123										_List_fromArray(
21124											[
21125												A2(
21126												elm$html$Html$div,
21127												_List_fromArray(
21128													[
21129														elm$html$Html$Attributes$id('elm-book-main'),
21130														elm$html$Html$Attributes$class('elm-book--wrapper--main--inner elm-book-inset')
21131													]),
21132												_List_fromArray(
21133													[props.main]))
21134											])),
21135										A2(
21136										elm$html$Html$div,
21137										_List_fromArray(
21138											[
21139												elm$html$Html$Attributes$class('elm-book--wrapper--main--footer')
21140											]),
21141										_List_fromArray(
21142											[props.mainFooter]))
21143									]))
21144							]))
21145					])),
21146				function () {
21147				var _n1 = props.modal;
21148				if (_n1.$ === 'Just') {
21149					var html = _n1.a;
21150					return A2(
21151						elm$html$Html$div,
21152						_List_fromArray(
21153							[
21154								elm$html$Html$Attributes$class('elm-book-inset elm-book-fade-in elm-book--wrapper--modal')
21155							]),
21156						_List_fromArray(
21157							[
21158								A2(
21159								elm$html$Html$div,
21160								_List_fromArray(
21161									[
21162										elm$html$Html$Events$onClick(props.onCloseModal),
21163										elm$html$Html$Attributes$class('elm-book-inset elm-book--wrapper--modal--bg')
21164									]),
21165								_List_Nil),
21166								A2(
21167								elm$html$Html$div,
21168								_List_fromArray(
21169									[
21170										elm$html$Html$Attributes$class('elm-book--wrapper--modal--content elm-book-shadows')
21171									]),
21172								_List_fromArray(
21173									[html]))
21174							]));
21175				} else {
21176					return elm$html$Html$text('');
21177				}
21178			}()
21179			]));
21180};
21181var dtwrks$elm_book$ElmBook$Internal$Application$view = F2(
21182	function (config, model) {
21183		var theme = A2(dtwrks$elm_book$ElmBook$Internal$ThemeOptions$applyOverrides, config.themeOptions, model.themeOverrides);
21184		var hashBasedNavigation = dtwrks$elm_book$ElmBook$Internal$ThemeOptions$hashBasedNavigation(config.themeOptions);
21185		var activeChapter = A2(dtwrks$elm_book$ElmBook$Internal$Book$chapterFromUrl, config, model.url);
21186		return {
21187			body: _List_fromArray(
21188				[
21189					dtwrks$elm_book$ElmBook$UI$Styles$view,
21190					dtwrks$elm_book$ElmBook$UI$Wrapper$view(
21191					{
21192						darkMode: model.darkMode,
21193						globals: A2(
21194							elm$core$List$map,
21195							config.toHtml,
21196							A2(elm$core$Maybe$withDefault, _List_Nil, config.themeOptions.globals)),
21197						header: dtwrks$elm_book$ElmBook$UI$Header$view(
21198							{href: '/', isMenuOpen: model.isMenuOpen, onClickHeader: dtwrks$elm_book$ElmBook$Internal$Msg$DoNothing, onClickMenuButton: dtwrks$elm_book$ElmBook$Internal$Msg$ToggleMenu, theme: config.themeOptions, title: config.title, toHtml: config.toHtml}),
21199						isMenuOpen: model.isMenuOpen,
21200						main: A2(
21201							elm$core$Maybe$withDefault,
21202							elm$html$Html$text(''),
21203							A2(
21204								elm$core$Maybe$map,
21205								function (_n0) {
21206									var activeChapter_ = _n0.a;
21207									return dtwrks$elm_book$ElmBook$UI$Chapter$view(
21208										{
21209											body: activeChapter_.body,
21210											chapterOptions: A2(dtwrks$elm_book$ElmBook$Internal$Chapter$toValidOptions, config.chapterOptions, activeChapter_.chapterOptions),
21211											componentOptions: A2(dtwrks$elm_book$ElmBook$Internal$ComponentOptions$toValidOptions, config.componentOptions, activeChapter_.componentOptions),
21212											components: A2(
21213												elm$core$List$map,
21214												function (component) {
21215													return _Utils_Tuple2(
21216														component.label,
21217														A3(dtwrks$elm_book$ElmBook$Internal$Application$componentView, config.toHtml, model.state, component.view));
21218												},
21219												activeChapter_.componentList),
21220											title: activeChapter_.title
21221										});
21222								},
21223								activeChapter)),
21224						mainFooter: A2(
21225							elm$core$Maybe$withDefault,
21226							dtwrks$elm_book$ElmBook$UI$ActionLog$previewEmpty,
21227							A2(
21228								elm$core$Maybe$map,
21229								function (lastAction) {
21230									return dtwrks$elm_book$ElmBook$UI$ActionLog$preview(
21231										{
21232											lastAction: lastAction,
21233											lastActionIndex: elm$core$List$length(model.actionLog) - 1,
21234											onClick: dtwrks$elm_book$ElmBook$Internal$Msg$ActionLogShow
21235										});
21236								},
21237								elm$core$List$head(model.actionLog))),
21238						mainHeader: A2(
21239							elm$core$Maybe$map,
21240							function (chapter) {
21241								return dtwrks$elm_book$ElmBook$UI$ChapterHeader$view(
21242									{
21243										onToggleDarkMode: dtwrks$elm_book$ElmBook$Internal$Msg$ToggleDarkMode,
21244										title: dtwrks$elm_book$ElmBook$Internal$Chapter$chapterBreadcrumb(chapter)
21245									});
21246							},
21247							activeChapter),
21248						menu: function () {
21249							var chaptersList = A2(dtwrks$elm_book$ElmBook$Internal$Application$searchChapter

21249s, model.search, config.chapters);
21250							var chaptersListSlugs = A2(
21251								elm$core$List$map,
21252								dtwrks$elm_book$ElmBook$Internal$Chapter$chapterNavUrl(hashBasedNavigation),
21253								elm$core$Array$toList(chaptersList));
21254							return dtwrks$elm_book$ElmBook$UI$Nav$view(
21255								{
21256									active: A2(
21257										elm$core$Maybe$map,
21258										dtwrks$elm_book$ElmBook$Internal$Chapter$chapterNavUrl(hashBasedNavigation),
21259										activeChapter),
21260									itemGroups: A2(
21261										elm$core$List$map,
21262										elm$core$Tuple$mapSecond(
21263											A2(
21264												elm$core$Basics$composeR,
21265												elm$core$List$map(
21266													function (index) {
21267														return A2(elm$core$Array$get, index, config.chapters);
21268													}),
21269												A2(
21270													elm$core$Basics$composeR,
21271													elm$core$List$filterMap(elm$core$Basics$identity),
21272													A2(
21273														elm$core$Basics$composeR,
21274														elm$core$List$map(
21275															function (chapter) {
21276																var title = chapter.a.title;
21277																var internal = chapter.a.internal;
21278																return _Utils_Tuple3(
21279																	A2(dtwrks$elm_book$ElmBook$Internal$Chapter$chapterNavUrl, hashBasedNavigation, chapter),
21280																	title,
21281																	internal);
21282															}),
21283														elm$core$List$filter(
21284															function (_n1) {
21285																var slug = _n1.a;
21286																return A2(elm$core$List$member, slug, chaptersListSlugs);
21287															}))))),
21288										config.chapterGroups),
21289									preSelected: model.isSearching ? A2(
21290										elm$core$Maybe$map,
21291										dtwrks$elm_book$ElmBook$Internal$Chapter$chapterNavUrl(hashBasedNavigation),
21292										A2(
21293											elm$core$Array$get,
21294											A2(
21295												elm$core$Basics$modBy,
21296												elm$core$Array$length(chaptersList),
21297												model.chapterPreSelected),
21298											chaptersList)) : elm$core$Maybe$Nothing
21299								});
21300						}(),
21301						menuFooter: dtwrks$elm_book$ElmBook$UI$Footer$view,
21302						menuHeader: dtwrks$elm_book$ElmBook$UI$Search$view(
21303							{onBlur: dtwrks$elm_book$ElmBook$Internal$Msg$SearchBlur, onFocus: dtwrks$elm_book$ElmBook$Internal$Msg$SearchFocus, onInput: dtwrks$elm_book$ElmBook$Internal$Msg$Search, value: model.search}),
21304						modal: model.actionLogModal ? elm$core$Maybe$Just(
21305							dtwrks$elm_book$ElmBook$UI$ActionLog$list(model.actionLog)) : elm$core$Maybe$Nothing,
21306						onCloseModal: dtwrks$elm_book$ElmBook$Internal$Msg$ActionLogHide,
21307						theme: theme
21308					})
21309				]),
21310			title: function () {
21311				var mainTitle = A2(
21312					elm$core$Maybe$withDefault,
21313					config.title,
21314					A2(
21315						elm$core$Maybe$map,
21316						function (s) {
21317							return config.title + (' | ' + s);
21318						},
21319						dtwrks$elm_book$ElmBook$Internal$ThemeOptions$subtitle(config.themeOptions)));
21320				if (activeChapter.$ === 'Just') {
21321					var title = activeChapter.a.a.title;
21322					return title + (' - ' + mainTitle);
21323				} else {
21324					return mainTitle;
21325				}
21326			}()
21327		};
21328	});
21329var dtwrks$elm_book$ElmBook$Internal$Application$withActionLogReset = function (previousModel) {
21330	return elm$core$Tuple$mapFirst(
21331		function (model) {
21332			return (!_Utils_eq(model.url, previousModel.url)) ? _Utils_update(
21333				model,
21334				{actionLog: _List_Nil}) : model;
21335		});
21336};
21337var elm$core$Elm$JsArray$push = _JsArray_push;
21338var elm$core$Elm$JsArray$singleton = _JsArray_singleton;
21339var elm$core$Elm$JsArray$unsafeSet = _JsArray_unsafeSet;
21340var elm$core$Array$insertTailInTree = F4(
21341	function (shift, index, tail, tree) {
21342		var pos = elm$core$Array$bitMask & (index >>> shift);
21343		if (_Utils_cmp(
21344			pos,
21345			elm$core$Elm$JsArray$length(tree)) > -1) {
21346			if (shift === 5) {
21347				return A2(
21348					elm$core$Elm$JsArray$push,
21349					elm$core$Array$Leaf(tail),
21350					tree);
21351			} else {
21352				var newSub = elm$core$Array$SubTree(
21353					A4(elm$core$Array$insertTailInTree, shift - elm$core$Array$shiftStep, index, tail, elm$core$Elm$JsArray$empty));
21354				return A2(elm$core$Elm$JsArray$push, newSub, tree);
21355			}
21356		} else {
21357			var value = A2(elm$core$Elm$JsArray$unsafeGet, pos, tree);
21358			if (value.$ === 'SubTree') {
21359				var subTree = value.a;
21360				var newSub = elm$core$Array$SubTree(
21361					A4(elm$core$Array$insertTailInTree, shift - elm$core$Array$shiftStep, index, tail, subTree));
21362				return A3(elm$core$Elm$JsArray$unsafeSet, pos, newSub, tree);
21363			} else {
21364				var newSub = elm$core$Array$SubTree(
21365					A4(
21366						elm$core$Array$insertTailInTree,
21367						shift - elm$core$Array$shiftStep,
21368						index,
21369						tail,
21370						elm$core$Elm$JsArray$singleton(value)));
21371				return A3(elm$core$Elm$JsArray$unsafeSet, pos, newSub, tree);
21372			}
21373		}
21374	});
21375var elm$core$Array$unsafeReplaceTail = F2(
21376	function (newTail, _n0) {
21377		var len = _n0.a;
21378		var startShift = _n0.b;
21379		var tree = _n0.c;
21380		var tail = _n0.d;
21381		var originalTailLen = elm$core$Elm$JsArray$length(tail);
21382		var newTailLen = elm$core$Elm$JsArray$length(newTail);
21383		var newArrayLen = len + (newTailLen - originalTailLen);
21384		if (_Utils_eq(newTailLen, elm$core$Array$branchFactor)) {
21385			var overflow = _Utils_cmp(newArrayLen >>> elm$core$Array$shiftStep, 1 << startShift) > 0;
21386			if (overflow) {
21387				var newShift = startShift + elm$core$Array$shiftStep;
21388				var newTree = A4(
21389					elm$core$Array$insertTailInTree,
21390					newShift,
21391					len,
21392					newTail,
21393					elm$core$Elm$JsArray$singleton(
21394						elm$core$Array$SubTree(tree)));
21395				return A4(elm$core$Array$Array_elm_builtin, newArrayLen, newShift, newTree, elm$core$Elm$JsArray$empty);
21396			} else {
21397				return A4(
21398					elm$core$Array$Array_elm_builtin,
21399					newArrayLen,
21400					startShift,
21401					A4(elm$core$Array$insertTailInTree, startShift, len, newTail, tree),
21402					elm$core$Elm$JsArray$empty);
21403			}
21404		} else {
21405			return A4(elm$core$Array$Array_elm_builtin, newArrayLen, startShift, tree, newTail);
21406		}
21407	});
21408var elm$core$Array$push = F2(
21409	function (a, array) {
21410		var tail = array.d;
21411		return A2(
21412			elm$core$Array$unsafeReplaceTail,
21413			A2(elm$core$Elm$JsArray$push, a, tail),
21414			array);
21415	});
21416var dtwrks$elm_book$ElmBook$Internal$Book$configFromBuilder = F2(
21417	function (chapterGroups_, _n0) {
21418		var data = _n0.a;
21419		var chapterGroups = function () {
21420			var toIndexedGroup = F2(
21421				function (initialIndex, _n6) {
21422					var groupTitle = _n6.a;
21423					var groupChapters = _n6.b;
21424					return _Utils_Tuple2(
21425						groupTitle,
21426						A2(
21427							elm$core$List$indexedMap,
21428							F2(
21429								function (i, _n5) {
21430									return i + initialIndex;
21431								}),
21432							groupChapters));
21433				});
21434			return elm$core$List$reverse(
21435				A3(
21436					elm$core$List$foldl,
21437					F2(
21438						function (_n3, _n4) {
21439							var label = _n3.a;
21440							var xs = _n3.b;
21441							var acc = _n4.a;
21442							var lastIndex = _n4.b;
21443							return _Utils_Tuple2(
21444								A2(
21445									elm$core$List$cons,
21446									A2(
21447										toIndexedGroup,
21448										lastIndex,
21449										_Utils_Tuple2(label, xs)),
21450									acc),
21451								lastIndex + elm$core$List$length(xs));
21452						}),
21453					_Utils_Tuple2(_List_Nil, 0),
21454					chapterGroups_).a);
21455		}();
21456		var chapterData = A3(
21457			elm$core$List$foldl,
21458			F2(
21459				function (_n2, acc) {
21460					var chapters_ = _n2.b;
21461					return A3(
21462						elm$core$List$foldl,
21463						F2(
21464							function (c, acc_) {
21465								return {
21466									chapterByUrl: A3(
21467										elm$core$Dict$insert,
21468										dtwrks$elm_book$ElmBook$Internal$Chapter$chapterUrl(c),
21469										acc_.chaptersCount,
21470										acc_.chapterByUrl),
21471									chapters: A2(elm$core$Array$push, c, acc_.chapters),
21472									chaptersCount: acc_.chaptersCount + 1
21473								};
21474							}),
21475						{chapterByUrl: acc.chapterByUrl, chapters: acc.chapters, chaptersCount: acc.chaptersCount},
21476						chapters_);
21477				}),
21478			{chapterByUrl: elm$core$Dict$empty, chapters: elm$core$Array$empty, chaptersCount: 0},
21479			chapterGroups_);
21480		var _n1 = chapterData;
21481		var chapters = _n1.chapters;
21482		var chapterByUrl = _n1.chapterByUrl;
21483		return {chapterByUrl: chapterByUrl, chapterGroups: chapterGroups, chapterOptions: data.chapterOptions, chapters: chapters, componentOptions: data.componentOptions, statefulOptions: data.statefulOptions, themeOptions: data.themeOptions, title: data.title, toHtml: data.toHtml};
21484	});
21485var dtwrks$elm_book$ElmBook$Internal$Msg$OnUrlChange = function (a) {
21486	return {$: 'OnUrlChange', a: a};
21487};
21488var dtwrks$elm_book$ElmBook$Internal$Msg$OnUrlRequest = function (a) {
21489	return {$: 'OnUrlRequest', a: a};
21490};
21491var elm$browser$Browser$application = _Browser_application;
21492var elm$browser$Browser$Events$Document = {$: 'Document'};
21493var elm$browser$Browser$Events$MySub = F3(
21494	function (a, b, c) {

21495		return {$: 'MySub', a: a, b: b, c: c};
21496	});
21497var elm$browser$Browser$Events$State = F2(
21498	function (subs, pids) {
21499		return {pids: pids, subs: subs};
21500	});
21501var elm$browser$Browser$Events$init = elm$core$Task$succeed(
21502	A2(elm$browser$Browser$Events$State, _List_Nil, elm$core$Dict$empty));
21503var elm$browser$Browser$Events$nodeToKey = function (node) {
21504	if (node.$ === 'Document') {
21505		return 'd_';
21506	} else {
21507		return 'w_';
21508	}
21509};
21510var elm$browser$Browser$Events$addKey = function (sub) {
21511	var node = sub.a;
21512	var name = sub.b;
21513	return _Utils_Tuple2(
21514		_Utils_ap(
21515			elm$browser$Browser$Events$nodeToKey(node),
21516			name),
21517		sub);
21518};
21519var elm$browser$Browser$Events$Event = F2(
21520	function (key, event) {
21521		return {event: event, key: key};
21522	});
21523var elm$core$Platform$sendToSelf = _Platform_sendToSelf;
21524var elm$browser$Browser$Events$spawn = F3(
21525	function (router, key, _n0) {
21526		var node = _n0.a;
21527		var name = _n0.b;
21528		var actualNode = function () {
21529			if (node.$ === 'Document') {
21530				return _Browser_doc;
21531			} else {
21532				return _Browser_window;
21533			}
21534		}();
21535		return A2(
21536			elm$core$Task$map,
21537			function (value) {
21538				return _Utils_Tuple2(key, value);
21539			},
21540			A3(
21541				_Browser_on,
21542				actualNode,
21543				name,
21544				function (event) {
21545					return A2(
21546						elm$core$Platform$sendToSelf,
21547						router,
21548						A2(elm$browser$Browser$Events$Event, key, event));
21549				}));
21550	});
21551var elm$core$Dict$merge = F6(
21552	function (leftStep, bothStep, rightStep, leftDict, rightDict, initialResult) {
21553		var stepState = F3(
21554			function (rKey, rValue, _n0) {
21555				stepState:
21556				while (true) {
21557					var list = _n0.a;
21558					var result = _n0.b;
21559					if (!list.b) {
21560						return _Utils_Tuple2(
21561							list,
21562							A3(rightStep, rKey, rValue, result));
21563					} else {
21564						var _n2 = list.a;
21565						var lKey = _n2.a;
21566						var lValue = _n2.b;
21567						var rest = list.b;
21568						if (_Utils_cmp(lKey, rKey) < 0) {
21569							var $temp$rKey = rKey,
21570								$temp$rValue = rValue,
21571								$temp$_n0 = _Utils_Tuple2(
21572								rest,
21573								A3(leftStep, lKey, lValue, result));
21574							rKey = $temp$rKey;
21575							rValue = $temp$rValue;
21576							_n0 = $temp$_n0;
21577							continue stepState;
21578						} else {
21579							if (_Utils_cmp(lKey, rKey) > 0) {
21580								return _Utils_Tuple2(
21581									list,
21582									A3(rightStep, rKey, rValue, result));
21583							} else {
21584								return _Utils_Tuple2(
21585									rest,
21586									A4(bothStep, lKey, lValue, rValue, result));
21587							}
21588						}
21589					}
21590				}
21591			});
21592		var _n3 = A3(
21593			elm$core$Dict$foldl,
21594			stepState,
21595			_Utils_Tuple2(
21596				elm$core$Dict$toList(leftDict),
21597				initialResult),
21598			rightDict);
21599		var leftovers = _n3.a;
21600		var intermediateResult = _n3.b;
21601		return A3(
21602			elm$core$List$foldl,
21603			F2(
21604				function (_n4, result) {
21605					var k = _n4.a;
21606					var v = _n4.b;
21607					return A3(leftStep, k, v, result);
21608				}),
21609			intermediateResult,
21610			leftovers);
21611	});
21612var elm$core$Process$kill = _Scheduler_kill;
21613var elm$browser$Browser$Events$onEffects = F3(
21614	function (router, subs, state) {
21615		var stepRight = F3(
21616			function (key, sub, _n6) {
21617				var deads = _n6.a;
21618				var lives = _n6.b;
21619				var news = _n6.c;
21620				return _Utils_Tuple3(
21621					deads,
21622					lives,
21623					A2(
21624						elm$core$List$cons,
21625						A3(elm$browser$Browser$Events$spawn, router, key, sub),
21626						news));
21627			});
21628		var stepLeft = F3(
21629			function (_n4, pid, _n5) {
21630				var deads = _n5.a;
21631				var lives = _n5.b;
21632				var news = _n5.c;
21633				return _Utils_Tuple3(
21634					A2(elm$core$List$cons, pid, deads),
21635					lives,
21636					news);
21637			});
21638		var stepBoth = F4(
21639			function (key, pid, _n2, _n3) {
21640				var deads = _n3.a;
21641				var lives = _n3.b;
21642				var news = _n3.c;
21643				return _Utils_Tuple3(
21644					deads,
21645					A3(elm$core$Dict$insert, key, pid, lives),
21646					news);
21647			});
21648		var newSubs = A2(elm$core$List$map, elm$browser$Browser$Events$addKey, subs);
21649		var _n0 = A6(
21650			elm$core$Dict$merge,
21651			stepLeft,
21652			stepBoth,
21653			stepRight,
21654			state.pids,
21655			elm$core$Dict$fromList(newSubs),
21656			_Utils_Tuple3(_List_Nil, elm$core$Dict$empty, _List_Nil));
21657		var deadPids = _n0.a;
21658		var livePids = _n0.b;
21659		var makeNewPids = _n0.c;
21660		return A2(
21661			elm$core$Task$andThen,
21662			function (pids) {
21663				return elm$core$Task$succeed(
21664					A2(
21665						elm$browser$Browser$Events$State,
21666						newSubs,
21667						A2(
21668							elm$core$Dict$union,
21669							livePids,
21670							elm$core$Dict$fromList(pids))));
21671			},
21672			A2(
21673				elm$core$Task$andThen,
21674				function (_n1) {
21675					return elm$core$Task$sequence(makeNewPids);
21676				},
21677				elm$core$Task$sequence(
21678					A2(elm$core$List$map, elm$core$Process$kill, deadPids))));
21679	});
21680var elm$browser$Browser$Events$onSelfMsg = F3(
21681	function (router, _n0, state) {
21682		var key = _n0.key;
21683		var event = _n0.event;
21684		var toMessage = function (_n2) {
21685			var subKey = _n2.a;
21686			var _n3 = _n2.b;
21687			var node = _n3.a;
21688			var name = _n3.b;
21689			var decoder = _n3.c;
21690			return _Utils_eq(subKey, key) ? A2(_Browser_decodeEvent, decoder, event) : elm$core$Maybe$Nothing;
21691		};
21692		var messages = A2(elm$core$List$filterMap, toMessage, state.subs);
21693		return A2(
21694			elm$core$Task$andThen,
21695			function (_n1) {
21696				return elm$core$Task$succeed(state);
21697			},
21698			elm$core$Task$sequence(
21699				A2(
21700					elm$core$List$map,
21701					elm$core$Platform$sendToApp(router),
21702					messages)));
21703	});
21704var elm$browser$Browser$Events$subMap = F2(
21705	function (func, _n0) {
21706		var node = _n0.a;
21707		var name = _n0.b;
21708		var decoder = _n0.c;
21709		return A3(
21710			elm$browser$Browser$Events$MySub,
21711			node,
21712			name,
21713			A2(elm$json$Json$Decode$map, func, decoder));
21714	});
21715_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);
21716var elm$browser$Browser$Events$subscription = _Platform_leaf('Browser.Events');
21717var elm$browser$Browser$Events$on = F3(
21718	function (node, name, decoder) {
21719		return elm$browser$Browser$Events$subscription(
21720			A3(elm$browser$Browser$Events$MySub, node, name, decoder));
21721	});
21722var elm$browser$Browser$Events$onKeyDown = A2(elm$browser$Browser$Events$on, elm$browser$Browser$Events$Document, 'keydown');
21723var elm$browser$Browser$Events$onKeyUp = A2(elm$browser$Browser$Events$on, elm$browser$Browser$Events$Document, 'keyup');
21724var elm$core$Platform$Sub$batch = _Platform_batch;
21725var dtwrks$elm_book$ElmBook$Internal$Application$application = F2(
21726	function (chapterGroups, bookBuilder) {
21727		var config = A2(dtwrks$elm_book$ElmBook$Internal$Book$configFromBuilder, chapterGroups, bookBuilder);
21728		return elm$browser$Browser$application(
21729			{
21730				init: dtwrks$elm_book$ElmBook$Internal$Application$init(config),
21731				onUrlChange: dtwrks$elm_book$ElmBook$Internal$Msg$OnUrlChange,
21732				onUrlRequest: dtwrks$elm_book$ElmBook$Internal$Msg$OnUrlRequest,
21733				subscriptions: function (_n0) {
21734					return elm$core$Platform$Sub$batch(
21735						_List_fromArray(
21736							[
21737								elm$browser$Browser$Events$onKeyDown(dtwrks$elm_book$ElmBook$Internal$Application$keyDownDecoder),
21738								elm$browser$Browser$Events$onKeyUp(dtwrks$elm_book$ElmBook$Internal$Application$keyUpDecoder),
21739								elm$core$Platform$Sub$batch(config.statefulOptions.subscriptions)
21740							]));
21741				},
21742				update: F2(
21743					function (msg, model) {
21744						return A2(
21745							dtwrks$elm_book$ElmBook$Internal$Application$withActionLogReset,
21746							model,
21747							A3(dtwrks$elm_book$ElmBook$Internal$Application$update, config, msg, model));
21748					}),
21749				view: dtwrks$elm_book$ElmBook$Internal$Application$view(config)
21750			});
21751	});
21752var dtwrks$elm_book$ElmBook$Internal$Chapter$Chapter = function (a) {
21753	return {$: 'Chapter', a: a};
21754};
21755var elm$core$Char$toLower = _Char_toLower;
21756var dtwrks$elm_book$ElmBook$Internal$Helpers$toUrlSafe = function (c) {
21757	return elm$core$Char$isAlphaNum(c) ? elm$core$Char$toLower(c) : _Utils_chr('-');
21758};
21759var elm$core$String$map = _String_map;
21760var dtwrks$elm_book$ElmBook$Internal$Helpers$toSlug = A2(
21761	elm$core$Basics$composeR,
21762	elm$core$String$trim,
21763	elm$core$String$map(dtwrks$elm_book$ElmBook$Internal$Helpers$toUrlSafe));
21764var dtwrks$elm_book$ElmBook$Internal$Chapter$chapterWithGroup = F3(
21765	function (routePrefix, group, _n0) {
21766		var chapter = _n0.a;
21767		var groupPrefix = (group === '') ? '' : ('/' + dtwrks$elm_book$ElmBook$Internal$Helpers$toSlug(group));
21768		return (!chapter.internal) ? dtwrks$elm_book$ElmBook$Internal$Chapter$Chapter(chapter) : dtwrks$elm_book$ElmBook$Internal$Chapter$Chapter(
21769			_Utils_update(
21770				chapter,
21771				{
21772					groupTitle: elm$core$Maybe$Just(group),
21773					url: _Utils_ap(
21774						routePrefix,
21775						_Utils_ap(groupPrefix, chapter.url))
21776				}));
21777	});
21778var dtwrks$elm_book$ElmBook$withChapterGroups = F2(
21779	function (chapterGroups_, _n0) {
21780		var config = _n0.a;
21781		return A2(

21782			dtwrks$elm_book$ElmBook$Internal$Application$application,
21783			A2(
21784				elm$core$List$map,
21785				function (_n1) {
21786					var group = _n1.a;
21787					var chapters = _n1.b;
21788					return _Utils_Tuple2(
21789						group,
21790						A2(
21791							elm$core$List$map,
21792							A2(dtwrks$elm_book$ElmBook$Internal$Chapter$chapterWithGroup, config.themeOptions.routePrefix, group),
21793							chapters));
21794				},
21795				chapterGroups_),
21796			dtwrks$elm_book$ElmBook$Internal$Book$BookBuilder(config));
21797	});
21798var dtwrks$elm_book$ElmBook$Internal$Helpers$applyAttributes = F2(
21799	function (fns, a) {
21800		return A3(elm$core$List$foldl, elm$core$Basics$apL, a, fns);
21801	});
21802var dtwrks$elm_book$ElmBook$withStatefulOptions = F2(
21803	function (attributes, _n0) {
21804		var config = _n0.a;
21805		return dtwrks$elm_book$ElmBook$Internal$Book$BookBuilder(
21806			_Utils_update(
21807				config,
21808				{
21809					statefulOptions: A2(dtwrks$elm_book$ElmBook$Internal$Helpers$applyAttributes, attributes, config.statefulOptions)
21810				}));
21811	});
21812var dtwrks$elm_book$ElmBook$withThemeOptions = F2(
21813	function (themeAttributes, _n0) {
21814		var config = _n0.a;
21815		return dtwrks$elm_book$ElmBook$Internal$Book$BookBuilder(
21816			_Utils_update(
21817				config,
21818				{
21819					themeOptions: A2(dtwrks$elm_book$ElmBook$Internal$Helpers$applyAttributes, themeAttributes, config.themeOptions)
21820				}));
21821	});
21822var dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterOptions = function (a) {
21823	return {$: 'ChapterOptions', a: a};
21824};
21825var dtwrks$elm_book$ElmBook$Internal$Chapter$defaultOverrides = dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterOptions(
21826	{hiddenTitle: elm$core$Maybe$Nothing});
21827var dtwrks$elm_book$ElmBook$Internal$ComponentOptions$defaultOverrides = dtwrks$elm_book$ElmBook$Internal$ComponentOptions$ComponentOptions(
21828	{background: elm$core$Maybe$Nothing, display: elm$core$Maybe$Nothing, fullWidth: elm$core$Maybe$Nothing, hiddenLabel: elm$core$Maybe$Nothing});
21829var dtwrks$elm_book$ElmBook$Chapter$chapterLink = function (props) {
21830	return dtwrks$elm_book$ElmBook$Internal$Chapter$Chapter(
21831		{body: '', chapterOptions: dtwrks$elm_book$ElmBook$Internal$Chapter$defaultOverrides, componentList: _List_Nil, componentOptions: dtwrks$elm_book$ElmBook$Internal$ComponentOptions$defaultOverrides, groupTitle: elm$core$Maybe$Nothing, init: elm$core$Maybe$Nothing, internal: false, title: props.title, url: props.url});
21832};
21833var dtwrks$elm_book$ElmBook$StatefulOptions$initialState = F2(
21834	function (state, options) {
21835		return _Utils_update(
21836			options,
21837			{
21838				initialState: elm$core$Maybe$Just(state)
21839			});
21840	});
21841var dtwrks$elm_book$ElmBook$StatefulOptions$onDarkModeChange = F2(
21842	function (onDarkModeChange_, options) {
21843		return _Utils_update(
21844			options,
21845			{onDarkModeChange: onDarkModeChange_});
21846	});
21847var dtwrks$elm_book$ElmBook$ThemeOptions$subtitle = F2(
21848	function (subtitle_, theme) {
21849		return _Utils_update(
21850			theme,
21851			{
21852				subtitle: elm$core$Maybe$Just(subtitle_)
21853			});
21854	});
21855var dtwrks$elm_book$ElmBook$Actions$logAction = function (action) {
21856	return A2(dtwrks$elm_book$ElmBook$Internal$Msg$LogAction, '', action);
21857};
21858var dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterBuilder = function (a) {
21859	return {$: 'ChapterBuilder', a: a};
21860};
21861var dtwrks$elm_book$ElmBook$Chapter$chapter = function (title) {
21862	return dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterBuilder(
21863		{
21864			body: '',
21865			chapterOptions: dtwrks$elm_book$ElmBook$Internal$Chapter$defaultOverrides,
21866			componentList: _List_Nil,
21867			componentOptions: dtwrks$elm_book$ElmBook$Internal$ComponentOptions$defaultOverrides,
21868			groupTitle: elm$core$Maybe$Nothing,
21869			init: elm$core$Maybe$Nothing,
21870			internal: true,
21871			title: title,
21872			url: '/' + dtwrks$elm_book$ElmBook$Internal$Helpers$toSlug(title)
21873		});
21874};
21875var dtwrks$elm_book$ElmBook$Chapter$renderWithComponentList = F2(
21876	function (body, _n0) {
21877		var builder = _n0.a;
21878		return dtwrks$elm_book$ElmBook$Internal$Chapter$Chapter(
21879			_Utils_update(
21880				builder,
21881				{body: builder.body + (body + '\n<component-list />')}));
21882	});
21883var dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterComponentViewStateless = function (a) {
21884	return {$: 'ChapterComponentViewStateless', a: a};
21885};
21886var dtwrks$elm_book$ElmBook$Chapter$fromTuple = function (_n0) {
21887	var label = _n0.a;
21888	var view_ = _n0.b;
21889	return {
21890		label: label,
21891		view: dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterComponentViewStateless(view_)
21892	};
21893};
21894var dtwrks$elm_book$ElmBook$Chapter$withComponentList = F2(
21895	function (componentList, _n0) {
21896		var builder = _n0.a;
21897		return dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterBuilder(
21898			_Utils_update(
21899				builder,
21900				{
21901					componentList: _Utils_ap(
21902						A2(elm$core$List$map, dtwrks$elm_book$ElmBook$Chapter$fromTuple, componentList),
21903						builder.componentList)
21904				}));
21905	});
21906var dtwrks$elm_book$ElmBook$UI$Docs$ActionLog$docs = A2(
21907	dtwrks$elm_book$ElmBook$Chapter$renderWithComponentList,
21908	'\nThe UI for action logs is something I want to spend more time on.\n\nFor example, why do we even need a blank bar at the bottom of the book unless we actually log something? We can do some fun stuff with animation so it\'s more entertaining to see actions happen on ElmBooks. Lots of opportunities here!\n\nAnyway… it works for now! 🙂\n',
21909	A2(
21910		dtwrks$elm_book$ElmBook$Chapter$withComponentList,
21911		_List_fromArray(
21912			[
21913				_Utils_Tuple2('Empty', dtwrks$elm_book$ElmBook$UI$ActionLog$previewEmpty),
21914				_Utils_Tuple2(
21915				'Preview',
21916				dtwrks$elm_book$ElmBook$UI$ActionLog$preview(
21917					{
21918						lastAction: _Utils_Tuple2('Context', 'Action'),
21919						lastActionIndex: 0,
21920						onClick: dtwrks$elm_book$ElmBook$Actions$logAction('onClick')
21921					})),
21922				_Utils_Tuple2(
21923				'List',
21924				dtwrks$elm_book$ElmBook$UI$ActionLog$list(
21925					A2(
21926						elm$core$List$map,
21927						function (index) {
21928							return _Utils_Tuple2(
21929								'Context',
21930								'Action number ' + elm$core$String$fromInt(index));
21931						},
21932						A2(elm$core$List$range, 1, 10))))
21933			]),
21934		dtwrks$elm_book$ElmBook$Chapter$chapter('ActionLog')));
21935var dtwrks$elm_book$ElmBook$Chapter$render = F2(
21936	function (body, _n0) {
21937		var builder = _n0.a;
21938		return dtwrks$elm_book$ElmBook$Internal$Chapter$Chapter(
21939			_Utils_update(
21940				builder,
21941				{
21942					body: _Utils_ap(builder.body, body)
21943				}));
21944	});
21945var dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterComponentViewStateful = function (a) {
21946	return {$: 'ChapterComponentViewStateful', a: a};
21947};
21948var dtwrks$elm_book$ElmBook$Chapter$withStatefulComponent = F2(
21949	function (view_, _n0) {
21950		var builder = _n0.a;
21951		return dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterBuilder(
21952			_Utils_update(
21953				builder,
21954				{
21955					componentList: A2(
21956						elm$core$List$cons,
21957						{
21958							label: '',
21959							view: dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterComponentViewStateful(view_)
21960						},
21961						builder.componentList)
21962				}));
21963	});
21964var dtwrks$elm_book$ElmBook$UI$Docs$DarkModeComponents$docs = A2(
21965	dtwrks$elm_book$ElmBook$Chapter$render,
21966	'\nIf want to showcase your UI components and their dark mode variants in all their glory, take a look at the `onDarkModeChange` helper. Try changing the dark/light mode and look at the component below:\n\n<component />\n\nHere is how it works:\n\n```elm\n    type alias SharedState =\n        { darkMode : Bool\n        }\n\n\n    initialState : SharedState\n    initialState =\n        { darkMode = False\n        }\n\n\n    book : Book SharedState\n    book "MyApp"\n        |> withStatefulOptions\n            [ ElmBook.StatefulOptions.initialState\n                initialState\n            , ElmBook.StatefulOptions.onDarkModeChange\n                (\\darkMode state ->\n                    { state | darkMode = darkMode }\n                )\n            ]\n        |> withChapters []\n\n\n    darkModeChapter : Chapter SharedState\n    darkModeChapter =\n        chapter "Dark Mode"\n            |>

21966 renderStatefulComponent (\n                \\{ darkMode } ->\n                    if darkMode then\n                        text "You found me!"\n                    else\n                        text "There is something hidden in the dark…"\n            )\n```\n\n',
21967	A2(
21968		dtwrks$elm_book$ElmBook$Chapter$withStatefulComponent,
21969		function (_n0) {
21970			var darkMode = _n0.darkMode;
21971			return A2(
21972				elm$html$Html$div,
21973				_List_fromArray(
21974					[
21975						elm$html$Html$Attributes$class('elm-book elm-book-serif')
21976					]),
21977				_List_fromArray(
21978					[
21979						darkMode ? A2(
21980						elm$html$Html$div,
21981						_List_Nil,
21982						_List_fromArray(
21983							[
21984								A2(
21985								elm$html$Html$p,
21986								_List_fromArray(
21987									[
21988										A2(elm$html$Html$Attributes$style, 'color', '#fff')
21989									]),
21990								_List_fromArray(
21991									[
21992										elm$html$Html$text('You found me!')
21993									]))
21994							])) : A2(
21995						elm$html$Html$p,
21996						_List_fromArray(
21997							[
21998								A2(elm$html$Html$Attributes$style, 'color', '#999')
21999							]),
22000						_List_fromArray(
22001							[
22002								elm$html$Html$text('There is something hidden in the dark…')
22003							]))
22004					]));
22005		},
22006		dtwrks$elm_book$ElmBook$Chapter$chapter('Dark Components')));
22007var dtwrks$elm_book$ElmBook$UI$Docs$Guides$Books$docs = A2(
22008	dtwrks$elm_book$ElmBook$Chapter$render,
22009	'\nAfter creating a few chapters, it\'s time to put your book together.\n\n```elm\nmodule MyBook exposing (main)\n\n\nimport ElmBook exposing (..)\nimport FirstChapter exposing (firstChapter)\nimport SecondChapter exposing (secondChapter)\n\n\nmain : Book ()\nmain =\n    book "My Book"\n        |> withChapters\n            [ firstChapter\n            , secondChapter\n            ]\n```\n\n---\n\n## Grouping Chapters\n\nLet\'s make it more organized by grouping chapters into guides and component documentations.\n\n```elm\nmodule MyBook exposing (main)\n\n\nimport ElmBook exposing (..)\n...\n\nmain : Book ()\nmain =\n    book "My Book"\n        |> withChapterGroups\n            [ ( "Guides"\n              , [ gettingStarted\n                , secondGuide\n                ]\n              )\n            , ( "Components"\n              , [ buttons\n                , forms\n                , charts\n                ]\n              )\n            ]\n```\n\n---\n\n## Customizing your book\n\nThere are a few ways to customize your book:\n\n- Make it interactive (we call those "stateful" books). Check the ["Stateful Chapters"](/guides/stateful-chapters) guide for more info.\n- Customize its visual features (colors, header, ...). See the ["Theming"](/guides/theming) guide for more details.\n- Customize the default visual features for components (hide component labels, make them full width, remove the card wrappers, ...). [Check the docs](https://package.elm-lang.org/packages/dtwrks/elm-book/latest/).\n\nEach of those are accomplished using optional "attribute" functions. Similar to what you would see when using `Html.Attribute`. Take a look:\n\n```elm\nmodule MyBook exposing (main)\n\n\nimport ElmBook exposing (..)\nimport ElmBook.StatefulOptions\nimport ElmBook.Theme\nimport ElmBook.Component\n...\n\n\nmain : Book SharedState\nmain =\n    book "My Book"\n        |> withStatefulOptions\n            [ ElmBook.StatefulOptions.globals [ resetCss ]\n            , ElmBook.StatefulOptions.initialState initialSharedState\n            ]\n        |> withThemeOptions\n            [ ElmBook.ThemeOptions.background "yellow"\n            , ElmBook.ThemeOptions.subtitle "Guides & Stuff"\n            ]\n        |> withComponentOptions\n            [ ElmBook.Component.background "black"\n            ]\n        |> withChapters\n            [ ... ]\n```\n\n',
22010	dtwrks$elm_book$ElmBook$Chapter$chapter('Books'));
22011var dtwrks$elm_book$ElmBook$UI$Docs$Guides$BuiltinServer$docs = A2(
22012	dtwrks$elm_book$ElmBook$Chapter$render,
22013	'\nElmBook is just pure Elm. You can use whatever setup you want to build it.\n\nHowever, we also provide a zero-config dev server to make things easier. If you want to use it, just install `elm-book` as an npm devDependency then run…\n\n```\nnpx elm-book {MyBookModule}.elm\n```\n\n…and you should see your brand new Book running in your browser!\n\n---\n\n## 🤫\n\nI\'ll let you in on a secret… this is just an instance of [elm-live](https://www.elm-live.com) with a few predefined arguments passed in! So any additional arguments you pass to this command will work exactly like it would with elm-live, so\n\n```bash\nnpx elm-book {MyBookModule}.elm --port=3000 --dir=./static\n```\n\nwould start your development server on port 3000 with static files from the `./static` folder.        \n',
22014	dtwrks$elm_book$ElmBook$Chapter$chapter('Development Server'));

22015var dtwrks$elm_book$ElmBook$UI$Docs$Guides$Chapters$docs = A2(
22016	dtwrks$elm_book$ElmBook$Chapter$render,
22017	'\nChapters are what books are made of. They can be library guides, component examples, design tokens showcases, you name it.\n\nCreating them is quite simple, take a look at one used to display different variants of a Button component:\n\n```elm\nmodule UI.Button exposing (view, docs)\n\n\nimport ElmBook.Actions exposing (logAction)\nimport ElmBook.Chapter exposing (..)\nimport Html exposing (..)\nimport Html.Attributes exposing (..)\nimport Html.Events exposing (onClick)\n\n\nview :\n    { label : String\n    , disabled : Bool\n    , onClick : msg\n    }\n    -> Html msg\nview props =\n    button\n        [ class "px-8 py-3 rounded-md bg-indigo-200"\n        , disabled props.disabled\n        , onClick props.onClick\n        ]\n        [ text props.label ]\n\n\ndocs : Chapter x\ndocs =\n    let\n        props =\n            { label = "Click me!"\n            , disabled = False\n            , onClick = logAction "Clicked button!"\n            }\n    in\n    chapter "Buttons"\n        |> renderComponentList\n            [ ( "Default", view props )\n            , ( "Disabled", view { props | disabled = True } )\n            ]\n\n```\n\n**Tip:** Since Elm has amazing [dead code elimination](https://elm-lang.org/news/small-assets-without-the-headache#dead-code-elimination) you don\'t need to worry about splitting your component examples from your source code. They can live side by side making your development experience much better!\n\n---\n\n## Markdown and embedded components\n\nI dare you to name one single thing that doesn\'t get more interesting with some markdown sprinkled on it. Yeah, you can\'t! …right?\n\nSo lets add some markdown to our chapter and directly embed our components in it!\n\n\n```elm\nmodule UI.Button exposing (view, docs)\n\n\nimport ElmBook.Actions exposing (logAction)\nimport ElmBook.Chapter exposing (..)\nimport Html exposing (..)\nimport Html.Attributes exposing (..)\nimport Html.Events exposing (onClick)\n\n\nview :\n    { label : String\n    , disabled : Bool\n    , onClick : msg\n    }\n    -> Html msg\nview props =\n    button\n        [ class "px-8 py-3 rounded-md bg-indigo-200"\n        , disabled props.disabled\n        , onClick props.onClick\n        ]\n        [ text props.label ]\n\n\ndocs : Chapter x\ndocs =\n    let\n        props =\n            { label = "Click me!"\n            , disabled = False\n            , onClick = logAction "Clicked button!"\n            }\n    in\n    chapter "Buttons"\n        |> withComponentList\n            [ ( "Default", view props )\n            , ( "Disabled", view { props | disabled = True } )\n            ]\n        |> render \"\"\"\nButtons are pretty amazing, right? You can click them and stuff.\n\nTry clicking on this one:\n\n<component with-label="Default" />\n\nThey can also be disabled! Unbelievable.\n\n<component with-label="Disabled" />\n\"\"\"\n```\n\n---\n\nIf you want to create interactive chapters, take a look at the ["Stateful Chapters"](/guides/stateful-chapters) guide to know more.\n\nThis is not the only thing you can do with Chapters though! You can customize how each component is displayed and more. Take a look at [the docs](https://package.elm-lang.org/packages/dtwrks/elm-book/latest/) for the details.\n\n',
22018	dtwrks$elm_book$ElmBook$Chapter$chapter('Chapters'));
22019var dtwrks$elm_book$ElmBook$UI$Docs$Guides$Interop$docs = A2(
22020	dtwrks$elm_book$ElmBook$Chapter$render,
22021	'\nWhen building our UIs with Elm, we\'re lucky to have such awesome libraries to choose from such as [Elm-UI](https://package.elm-lang.org/packages/mdgriffith/elm-ui/latest/), [Elm-CSS](https://package.elm-lang.org/packages/rtfeldman/elm-css/latest/), [Elm-Tailwind-Modules](https://package.elm-lang.org/packages/matheus23/elm-default-tailwind-modules/latest/), etc. So ElmBook is obviously compatible with all of them!\n\n## Package approach\n\nSince working with Elm-UI and Elm-CSS is so common we also provide two packages that can be used alongside ElmBook to make this process even simpler:\n\n- [elm-book-interop-elm-ui](https://package.elm-lang.org/packages/dtwrks/elm-book-interop-elm-ui/latest/)\n- [elm-book-interop-elm-css](https://package.elm-lang.org/packages/dtwrks/elm-book-interop-elm-css/latest/)\n\n## Do it yourself\n\nWe enable you to work with any custom elements via the `ElmBook.Custom` module. Lets see how we would integrate Elm-UI and ElmBook ourselves:\n\n```elm\nmodule ElmBook.ElmUI exposing (Book, Chapter, book)\n\nimport Element exposing (Element, layout)\nimport ElmBook.Custom exposing (customBook)\n\n\ntype alias Html state =\n    Element (ElmBook.Custom.Msg state)\n\n\ntype alias BookBuilder state =\n    ElmBook.Custom.BookBuilder state (Html state)\n\n\ntype alias Book state =\n    ElmBook.Custom.Book state (Html state)\n\n\ntype alias Chapter state =\n    ElmBook.Custom.Chapter state (Html state)\n\n\nbook : String -> BookBuilder state\nbook =\n    customBook (layout [])\n```\n\nAfter that you would only need to use this custom `book` function and `Book` type when creating a new book and the custom `Chapter` type when creating a new chapter. Simple as that.\n\n',
22022	dtwrks$elm_book$ElmBook$Chapter$chapter('Elm-UI and Elm-CSS'));
22023var dtwrks$elm_book$ElmBook$Actions$logActionWith = F3(
22024	function (toString, action, value) {
22025		return A2(

22026			dtwrks$elm_book$ElmBook$Internal$Msg$LogAction,
22027			'',
22028			action + (': ' + toString(value)));
22029	});
22030var dtwrks$elm_book$ElmBook$Actions$logActionWithString = dtwrks$elm_book$ElmBook$Actions$logActionWith(elm$core$Basics$identity);
22031var dtwrks$elm_book$ElmBook$Chapter$withComponentOptions = F2(
22032	function (attributes, _n0) {
22033		var config = _n0.a;
22034		return dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterBuilder(
22035			_Utils_update(
22036				config,
22037				{
22038					componentOptions: A2(dtwrks$elm_book$ElmBook$Internal$Helpers$applyAttributes, attributes, config.componentOptions)
22039				}));
22040	});
22041var dtwrks$elm_book$ElmBook$ComponentOptions$hiddenLabel = F2(
22042	function (hiddenLabel_, _n0) {
22043		var settings = _n0.a;
22044		return dtwrks$elm_book$ElmBook$Internal$ComponentOptions$ComponentOptions(
22045			_Utils_update(
22046				settings,
22047				{
22048					hiddenLabel: elm$core$Maybe$Just(hiddenLabel_)
22049				}));
22050	});
22051var dtwrks$elm_book$ElmBook$UI$Docs$Guides$LoggingActions$docs = A2(
22052	dtwrks$elm_book$ElmBook$Chapter$render,
22053	'\nWhen creating something like a UI catalogue it\'s often useful to display how each component reacts to user interaction.\n\nFor instance, a custom button might receive an `onClick` message. But is that message actually sent when the user clicks on it? And what message should I use on my docs since the button can be used anywhere?\n\n---\n\n### Introducing `logAction`\n\nElmBook provides this function to help on those scenarios. It receives a label and it will print out your message (with it\'s context) whenever it is called. Try it out below:\n\n<component with-label="button" />\n\n```elm\nimport ElmBook.Actions exposing (logAction)\n\n\nchapter "button"\n    |> withComponent (\n        myButton {\n            onClick = logAction "Clicked button!"\n        }\n    )\n```\n\n---\n\n### What about actions with parameters?\n\nSometimes your actions might not be as simple a button click – maybe your component sends some information along with the message?\n\nLet\'s try it out with a text input – it sends out a message with the string the user typed in:\n\n<component with-label="input" />\n\n```elm\nimport ElmBook.Actions exposing (logActionWithString)\n\n\nchapter "button"\n    |> withComponent (\n        myInput {\n            onInput =\n                logActionWithString\n                    "Received input with some value"\n        }\n    )\n```\n\n---\n\n### Logging url changes?\n\nIt\'s a real pain when we want to showcase a navigation link and when we click on it we\'re suddenly on some random page. This is why we have a somewhat hidden feature – any route changes that starts with `/logAction` will actually just log the url change intent!\n\nTry it here! [/logAction/external-url](/logAction/external-url)\n\n---\n\nThere are other `logAction*` functions available. Check out the [docs](https://package.elm-lang.org/packages/dtwrks/elm-book/latest/)!\n\n',
22054	A2(
22055		dtwrks$elm_book$ElmBook$Chapter$withComponentList,
22056		_List_fromArray(
22057			[
22058				_Utils_Tuple2(
22059				'button',
22060				A2(
22061					elm$html$Html$div,
22062					_List_Nil,
22063					_List_fromArray(
22064						[
22065							dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n                        .logging-actions-button {\n                            padding: 8px 20px;\n                            border: 2px solid rgba(0,135,207,1);\n                            border-radius: 2px;\n                            background-color: rgba(0,135,207,0.5);\n                            color: white;\n                            font-size: 16px;\n                            cursor: pointer;\n                        }\n                        .logging-actions-button:hover {\n                            opacity: 0.8;\n                        }\n                        .logging-actions-button:active {\n                            opacity: 0.6;\n                        }\n                    '),
22066							A2(
22067							elm$html$Html$button,
22068							_List_fromArray(
22069								[
22070									elm$html$Html$Attributes$class('logging-actions-button'),
22071									elm$html$Html$Events$onClick(
22072									dtwrks$elm_book$ElmBook$Actions$logAction('Clicked button!'))
22073								]),
22074							_List_fromArray(
22075								[
22076									elm$html$Html$text('Click me')
22077								]))
22078						]))),
22079				_Utils_Tuple2(
22080				'input',
22081				A2(
22082					elm$html$Html$div,
22083					_List_Nil,
22084					_List_fromArray(
22085						[
22086							dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n                        .logging-actions-input {\n                            padding: 8px 20px;\n                            border: 2px solid rgba(0,135,207,1);\n                            border-radius: 2px;\n                            background-color: white;\n                            font-size: 16px;\n                            cursor: pointer;\n                        }\n                    '),
22087							A2(
22088							elm$html$Html$input,
22089							_List_fromArray(
22090								[
22091									elm$html$Html$Attributes$class('logging-actions-input'),
22092									elm$html$Html$Events$onInput(
22093									dtwrks$elm_book$ElmBook$Actions$logActionWithString('Received input with some value')),
22094									elm$html$Html$Attributes$placeholder('Type something…')
22095								]),
22096							_List_Nil)
22097						])))
22098			]),
22099		A2(

22100			dtwrks$elm_book$ElmBook$Chapter$withComponentOptions,
22101			_List_fromArray(
22102				[
22103					dtwrks$elm_book$ElmBook$ComponentOptions$hiddenLabel(true)
22104				]),
22105			dtwrks$elm_book$ElmBook$Chapter$chapter('Logging Actions'))));
22106var dtwrks$elm_book$ElmBook$UI$Docs$Guides$StatefulChapters$docs = A2(
22107	dtwrks$elm_book$ElmBook$Chapter$render,
22108	'\nSometimes it\'s useful to display a complex component so people can understand how it works on an isolated environment, not only see their possible static states.\n\nBut how to accomplish this with Elm\'s static typing? Simply provide your own custom model that can be used and updated by your own components across all your chapters.\n\n---\n\n## The Shared Model\n\nEach book has one "shared state" and it\'s your job to slice in the way that makes sense for your book.\n\nLets say we have two stateful chapters, one with an input and the other one with a counter.\n\nLet\'s first define a simple model for the `InputChapter`:\n\n```elm\nmodule InputChapter exposing (Model, init)\n\n\ntype alias Model =\n    { value : String\n    }\n\n\ninit : Model\ninit =\n    { value = ""\n    }\n```\n\nThen another even simpler one for the `CounterChapter`:\n\n```elm\nmodule CounterChapter exposing (Model, init)\n\n\ntype alias Model = Int\n\n\ninit : Model\ninit = 0\n```\n\nThen, on your book, you put everything together like this:\n\n```elm\nmodule Book exposing (main)\n\n\nimport ElmBook exposing (..)\nimport ElmBook.StatefulOptions\nimport CounterChapter\nimport InputChapter\n\n\ntype alias SharedState =\n    { inputModel : InputChapter.Model\n    , counterModel : CounterChapter.Model\n    }\n\n\ninitialState : SharedState\ninitialState =\n    { inputModel = InputChapter.init\n    , counterModel = CounterChapter.init\n    }\n\n\nmain : Book SharedState\nmain =\n    book "Stateful Book"\n        |> withStatefulOptions\n            [ ElmBook.StatefulOptions.initialState initialState\n            ]\n        |> withChapters [\n            CounterChapter.chapter,\n            InputChapter.chapter\n        ]\n```\n\n---\n\n## Using the Shared State\n\nBy now we have our shared state properly setup, but how can we actually use that on our chapters? Let\'s see!\n\nYou need to tell your chapter where its state is located in your book. You also need to tell it how to update that state. It\'s pretty simple:\n\n```elm\nmodule CounterChapter exposing (Model, init, chapter)\n\n\nimport ElmBook.Chapter exposing (Chapter, chapter, renderStatefulComponent)\nimport ElmBook.Actions exposing (updateState)\n\n\ntype alias Model = Int\n\n\ntype alias SharedState x\n    = { x | counterModel : Model }\n\n\nupdateSharedState : SharedState x -> SharedState x\nupdateSharedState x =\n    { x | counterModel = x.counterModel + 1 }\n\n\nchapter : Chapter (SharedState x)\nchapter =\n    chapter "InputChapter"\n        |> renderStatefulComponent (\n            \\{ counterModel } ->\n                myCounter\n                    { value = counterModel.value\n                    , onIncrease = updateState updateSharedState\n                    }\n        )\n```\n\nThe same can be done for the InputChapter. But note that the `updateState` is replaced with `updateStateWith` now that it receives one parameter.\n\n```elm\nmodule InputChapter exposing (Model, init, chapter)\n\n\nimport ElmBook.Chapter exposing (Chapter, chapter, renderStatefulComponent)\nimport ElmBook.Actions exposing (updateStateWith)\n\n\ntype alias Model = { value : String }\n\n\ntype alias SharedState x\n    = { x | inputModel : Model }\n\n\nupdateSharedState : Int -> SharedState x -> SharedState x\nupdateSharedState value x =\n    { x | inputModel = { value = value } }\n\n\nchapter : ElmBook.Chapter (SharedState x)\nchapter =\n    ElmBook.chapter "InputChapter"\n        |> withStatefulComponent (\n            \\{ inputModel } ->\n                myInput\n                    { value = inputModel.value\n                    , onInput = updateStateWith updateSharedState\n                    }\n        )\n```\n\n---\n\n### Nested Elm Architecture\n\nSometimes we need to handle components with their own msg, model and update. Well – turns out it can be pretty simple to use that on your elm-book!\n\n```elm\nmodule InputChapter exposing (Model, init, chapter)\n\n\nimport ElmBook.Chapter exposing (Chapter, chapter, renderStatefulComponent)\nimport ElmBook.Actions exposing (mapUpdate)\n\n\n-- component\n\n\ntype alias Model = { value = 

22108String }\n\n\ntype Msg =\n    UpdateValue String\n\n\nupdate : Msg -> Model -> Model\nupdate msg model =\n    case msg of\n        UpdateValue value ->\n            { value = value }\n\n\nview : Model -> Html Msg\nview model =\n    input [ value model.value, onInput UpdateValue ] []\n\n\n-- elm-book\n\n\nchapter : ElmBook.Chapter { x | inputModel : Model }\nchapter =\n    ElmBook.chapter "InputChapter"\n        |> renderStatefulComponent (\n            \\{ inputModel } ->\n                view inputModel\n                    |> Html.map (\n                        mapUpdate\n                            { toState = \\state inputModel_ -> { state | inputModel = inputModel_ }\n                            , fromState = \\state -> state.inputModel\n                            , update = update\n                            }\n                    )\n        )\n```\n\n\n',
22109	dtwrks$elm_book$ElmBook$Chapter$chapter('Stateful Chapters'));
22110var dtwrks$elm_book$ElmBook$Chapter$fromTupleStateful = function (_n0) {
22111	var label = _n0.a;
22112	var view_ = _n0.b;
22113	return {
22114		label: label,
22115		view: dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterComponentViewStateful(view_)
22116	};
22117};
22118var dtwrks$elm_book$ElmBook$Chapter$withStatefulComponentList = F2(
22119	function (componentList, _n0) {
22120		var builder = _n0.a;
22121		return dtwrks$elm_book$ElmBook$Internal$Chapter$ChapterBuilder(
22122			_Utils_update(
22123				builder,
22124				{
22125					componentList: _Utils_ap(
22126						A2(elm$core$List$map, dtwrks$elm_book$ElmBook$Chapter$fromTupleStateful, componentList),
22127						builder.componentList)
22128				}));
22129	});
22130var dtwrks$elm_book$ElmBook$ComponentOptions$background = F2(
22131	function (background_, _n0) {
22132		var settings = _n0.a;
22133		return dtwrks$elm_book$ElmBook$Internal$ComponentOptions$ComponentOptions(
22134			_Utils_update(
22135				settings,
22136				{
22137					background: elm$core$Maybe$Just(background_)
22138				}));
22139	});
22140var dtwrks$elm_book$ElmBook$ThemeOptions$header = F2(
22141	function (header_, theme) {
22142		return _Utils_update(
22143			theme,
22144			{
22145				header: elm$core$Maybe$Just(header_)
22146			});
22147	});
22148var dtwrks$elm_book$ElmBook$ThemeOptions$logo = F2(
22149	function (logo_, theme) {
22150		return _Utils_update(
22151			theme,
22152			{
22153				logo: elm$core$Maybe$Just(logo_)
22154			});
22155	});
22156var dtwrks$elm_book$ElmBook$Internal$Msg$UpdateState = function (a) {
22157	return {$: 'UpdateState', a: a};
22158};
22159var dtwrks$elm_book$ElmBook$Actions$updateStateWithCmdWith = function (fn) {
22160	return A2(elm$core$Basics$composeL, dtwrks$elm_book$ElmBook$Internal$Msg$UpdateState, fn);
22161};
22162var dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateAccent_ = function (a) {
22163	return {$: 'UpdateAccent_', a: a};
22164};

22165var dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateBackgroundEnd = function (a) {
22166	return {$: 'UpdateBackgroundEnd', a: a};
22167};
22168var dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateBackgroundStart = function (a) {
22169	return {$: 'UpdateBackgroundStart', a: a};
22170};
22171var dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateNavAccentHighlight_ = function (a) {
22172	return {$: 'UpdateNavAccentHighlight_', a: a};
22173};
22174var dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateNavAccent_ = function (a) {
22175	return {$: 'UpdateNavAccent_', a: a};
22176};
22177var dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateNavBackground_ = function (a) {
22178	return {$: 'UpdateNavBackground_', a: a};
22179};
22180var dtwrks$elm_book$ElmBook$Internal$Msg$SetThemeAccent = function (a) {
22181	return {$: 'SetThemeAccent', a: a};
22182};
22183var dtwrks$elm_book$ElmBook$Internal$Msg$SetThemeBackgroundGradient = F2(
22184	function (a, b) {
22185		return {$: 'SetThemeBackgroundGradient', a: a, b: b};
22186	});
22187var dtwrks$elm_book$ElmBook$Internal$Msg$SetThemeNavAccent = function (a) {
22188	return {$: 'SetThemeNavAccent', a: a};
22189};
22190var dtwrks$elm_book$ElmBook$Internal$Msg$SetThemeNavAccentHighlight = function (a) {
22191	return {$: 'SetThemeNavAccentHighlight', a: a};
22192};
22193var dtwrks$elm_book$ElmBook$Internal$Msg$SetThemeNavBackground = function (a) {
22194	return {$: 'SetThemeNavBackground', a: a};
22195};
22196var dtwrks$elm_book$ElmBook$UI$ThemeGenerator$update = F2(
22197	function (msg, sharedState) {
22198		var model = sharedState.theming;
22199		var _n0 = function () {
22200			switch (msg.$) {

22201				case 'UpdateBackgroundStart':
22202					var v = msg.a;
22203					return _Utils_Tuple2(
22204						_Utils_update(
22205							model,
22206							{backgroundStart: v}),
22207						A2(
22208							elm$core$Task$perform,
22209							function (_n2) {
22210								return A2(dtwrks$elm_book$ElmBook$Internal$Msg$SetThemeBackgroundGradient, v, model.backgroundEnd);
22211							},
22212							elm$core$Task$succeed(_Utils_Tuple0)));
22213				case 'UpdateBackgroundEnd':
22214					var v = msg.a;
22215					return _Utils_Tuple2(
22216						_Utils_update(
22217							model,
22218							{backgroundEnd: v}),
22219						A2(
22220							elm$core$Task$perform,
22221							function (_n3) {
22222								return A2(dtwrks$elm_book$ElmBook$Internal$Msg$SetThemeBackgroundGradient, model.backgroundStart, v);
22223							},
22224							elm$core$Task$succeed(_Utils_Tuple0)));
22225				case 'UpdateAccent_':
22226					var v = msg.a;
22227					return _Utils_Tuple2(
22228						_Utils_update(
22229							model,
22230							{accent: v}),
22231						A2(
22232							elm$core$Task$perform,
22233							function (_n4) {
22234								return dtwrks$elm_book$ElmBook$Internal$Msg$SetThemeAccent(v);
22235							},
22236							elm$core$Task$succeed(_Utils_Tuple0)));
22237				case 'UpdateNavBackground_':
22238					var v = msg.a;
22239					return _Utils_Tuple2(
22240						_Utils_update(
22241							model,
22242							{navBackground: v}),
22243						A2(
22244							elm$core$Task$perform,
22245							function (_n5) {
22246								return dtwrks$elm_book$ElmBook$Internal$Msg$SetThemeNavBackground(v);
22247							},
22248							elm$core$Task$succeed(_Utils_Tuple0)));
22249				case 'UpdateNavAccent_':
22250					var v = msg.a;
22251					return _Utils_Tuple2(
22252						_Utils_update(
22253							model,
22254							{navAccent: v}),
22255						A2(
22256							elm$core$Task$perform,
22257							function (_n6) {
22258								return dtwrks$elm_book$ElmBook$Internal$Msg$SetThemeNavAccent(v);
22259							},
22260							elm$core$Task$succeed(_Utils_Tuple0)));
22261				default:
22262					var v = msg.a;
22263					return _Utils_Tuple2(
22264						_Utils_update(
22265							model,
22266							{navAccentHighlight: v}),
22267						A2(
22268							elm$core$Task$perform,
22269							function (_n7) {
22270								return dtwrks$elm_book$ElmBook$Internal$Msg$SetThemeNavAccentHighlight(v);
22271							},
22272							elm$core$Task$succeed(_Utils_Tuple0)));
22273			}
22274		}();
22275		var model_ = _n0.a;
22276		var cmd = _n0.b;
22277		return _Utils_Tuple2(
22278			_Utils_update(
22279				sharedState,
22280				{theming: model_}),
22281			cmd);
22282	});
22283var elm$html$Html$label = _VirtualDom_node('label');
22284var dtwrks$elm_book$ElmBook$UI$ThemeGenerator$view = function (_n0) {
22285	var theming = _n0.theming;
22286	return A2(
22287		elm$html$Html$div,
22288		_List_fromArray(
22289			[
22290				elm$html$Html$Attributes$class('elm-book-theme-builder')
22291			]),
22292		_List_fromArray(
22293			[
22294				dtwrks$elm_book$ElmBook$UI$Helpers$css_('\n            .elm-book-theme-builder {\n                background-color: #fafafa;\n                border-radius: 4px;\n                border: 1px solid #eaeaea;\n                color: #3a3a3a;\n            }\n\n            .elm-book-theme-builder__field {\n                position: relative;\n                display: flex;\n                justify-content: space-between;\n                align-items: center;\n                padding: 8px 20px 8px 28px;\n            }\n            .elm-book-theme-builder__field:nth-child(2n) {\n                background-color: #f5f5f5;\n            }\n            .elm-book-theme-sample {\n                position: absolute;\n                width: 6px;\n                top: 1px;\n                left: 1px;\n                bottom: 1px;\n            }\n            .elm-book-theme-builder__label {\n                line-height: 1em;\n                padding-right: 4px;\n                word-break: break-word;\n            }\n            .elm-book-theme-builder__label__title {\n                font-weight: bold;\n                font-size: 14px;\n                letter-spacing: 1px;\n                margin: 0;\n                padding: 0;\n            }\n            .elm-book-theme-builder__label__subtitle {\n                font-size: 12px;\n                margin: 0;\n                padding-top: 4px;\n                color: #999;\n            }\n            .elm-book-theme-builder__picker-wrapper {\n                flex-shrink: 0;\n                display: flex;\n                align-items: center;\n            }\n            .elm-book-theme-builder__value {\n                font-size: 14px;\n                padding-right: 12px;\n                color: #999;\n                line-height: 1em;\n            }\n            .elm-book-theme-builder__picker {\n                width: 20p

22294x;\n                height: 20px;\n                border-radius: 100%;\n                border: none;\n                background-color: #e0e0e0;\n            }\n            ' + (dtwrks$elm_book$ElmBook$UI$Helpers$mediaMobile + ' {\n                .elm-book-theme-builder__field {\n                    flex-direction: column-reverse;\n                    align-items: flex-start;\n                }\n                .elm-book-theme-builder__picker-wrapper {\n                    flex-direction: row-reverse;\n                    align-items: center;\n                    padding-bottom: 4px;\n                }\n                .elm-book-theme-builder__value {\n                    padding-right: 0;\n                    padding-left: 8px;\n                    font-size: 12px;\n                }\n            }\n                    ')),
22295				A2(
22296				elm$html$Html$div,
22297				_List_Nil,
22298				A2(
22299					elm$core$List$map,
22300					function (_n1) {
22301						var _n2 = _n1.a;
22302						var title = _n2.a;
22303						var subtitle = _n2.b;
22304						var value_ = _n1.b;
22305						var msg_ = _n1.c;
22306						return A2(
22307							elm$html$Html$label,
22308							_List_fromArray(
22309								[
22310									elm$html$Html$Attributes$class('elm-book-theme-builder__field')
22311								]),
22312							_List_fromArray(
22313								[
22314									A2(
22315									elm$html$Html$div,
22316									_List_fromArray(
22317										[
22318											elm$html$Html$Attributes$class('elm-book-theme-sample'),
22319											A2(elm$html$Html$Attributes$style, 'background-color', value_)
22320										]),
22321									_List_Nil),
22322									A2(
22323									elm$html$Html$div,
22324									_List_fromArray(
22325										[
22326											elm$html$Html$Attributes$class('elm-book-theme-builder__label')
22327										]),
22328									_List_fromArray(
22329										[
22330											A2(
22331											elm$html$Html$p,
22332											_List_fromArray(
22333												[
22334													elm$html$Html$Attributes$class('elm-book-theme-builder__label__title elm-book-sans')
22335												]),
22336											_List_fromArray(
22337												[
22338													elm$html$Html$text(title)
22339												])),
22340											A2(
22341											elm$html$Html$p,
22342											_List_fromArray(
22343												[
22344													elm$html$Html$Attributes$class('elm-book-theme-builder__label__subtitle elm-book-monospace')
22345												]),
22346											_List_fromArray(
22347												[
22348													elm$html$Html$text(subtitle)
22349												]))
22350										])),
22351									A2(
22352									elm$html$Html$div,
22353									_List_fromArray(
22354										[
22355											elm$html$Html$Attributes$class('elm-book-theme-builder__picker-wrapper')
22356										]),
22357									_List_fromArray(
22358										[
22359											A2(
22360											elm$html$Html$p,
22361											_List_fromArray(
22362												[
22363													elm$html$Html$Attributes$class('elm-book-theme-builder__value elm-book-monospace')
22364												]),
22365											_List_fromArray(
22366												[
22367													elm$html$Html$text(value_)
22368												])),
22369											A2(
22370											elm$html$Html$input,
22371											_List_fromArray(
22372												[
22373													elm$html$Html$Attributes$type_('color'),
22374													elm$html$Html$Attributes$class('elm-book-theme-builder__picker'),
22375													elm$html$Html$Attributes$value(value_),
22376													elm$html$Html$Events$onInput(
22377													dtwrks$elm_book$ElmBook$Actions$updateStateWithCmdWith(
22378														A2(elm$core$Basics$composeL, dtwrks$elm_book$ElmBook$UI$ThemeGenerator$update, msg_)))
22379												]),
22380											_List_Nil)
22381										]))
22382								]));
22383					},
22384					_List_fromArray(
22385						[
22386							_Utils_Tuple3(
22387							_Utils_Tuple2('backgroundGradient (Start)', 'ElmBook.ThemeOptions.backgroundGradient'),
22388							theming.backgroundStart,
22389							dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateBackgroun

22389dStart),
22390							_Utils_Tuple3(
22391							_Utils_Tuple2('backgroundGradient (End)', 'ElmBook.ThemeOptions.backgroundGradient'),
22392							theming.backgroundEnd,
22393							dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateBackgroundEnd),
22394							_Utils_Tuple3(
22395							_Utils_Tuple2('accent', 'ElmBook.ThemeOptions.accent'),
22396							theming.accent,
22397							dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateAccent_),
22398							_Utils_Tuple3(
22399							_Utils_Tuple2('navBackground', 'ElmBook.ThemeOptions.navBackground'),
22400							theming.navBackground,
22401							dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateNavBackground_),
22402							_Utils_Tuple3(
22403							_Utils_Tuple2('navAccent', 'ElmBook.ThemeOptions.navAccent'),
22404							theming.navAccent,
22405							dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateNavAccent_),
22406							_Utils_Tuple3(
22407							_Utils_Tuple2('navAccentHighlight', 'ElmBook.ThemeOptions.navAccentHighlight'),
22408							theming.navAccentHighlight,
22409							dtwrks$elm_book$ElmBook$UI$ThemeGenerator$UpdateNavAccentHighlight_)
22410						])))
22411			]));
22412};
22413var dtwrks$elm_book$ElmBook$UI$Docs$Guides$Theming$docs = function () {
22414	var headerProps = {
22415		href: '/logAction/',
22416		isMenuOpen: false,
22417		onClickHeader: dtwrks$elm_book$ElmBook$Actions$logAction('onClickHeader'),
22418		onClickMenuButton: dtwrks$elm_book$ElmBook$Actions$logAction('onClickMenuButton'),
22419		theme: A2(dtwrks$elm_book$ElmBook$ThemeOptions$subtitle, 'Custom Subtitle', dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultTheme),
22420		title: 'Custom Title',
22421		toHtml: elm$core$Basics$identity
22422	};
22423	var customHeader = A2(
22424		elm$html$Html$div,
22425		_List_fromArray(
22426			[
22427				A2(elm$html$Html$Attributes$style, 'font-size', '28px'),
22428				A2(elm$html$Html$Attributes$style, 'color', '#75c5f0')
22429			]),
22430		_List_fromArray(
22431			[
22432				elm$html$Html$text('Custom')
22433			]));
22434	return A2(
22435		dtwrks$elm_book$ElmBook$Chapter$render,
22436		'\nYour book should look and feel your own, so ElmBook provides a few ways you can customize it\'s theme.\n\n## Custom Header\n\nYou can choose a different logo, title and subtitle for your book:\n\n<component with-label="Header with custom logo" with-background=\"' + (dtwrks$elm_book$ElmBook$UI$Helpers$themeBackgroun

22436d + ('" />\n\n    main : Book x\n    main =\n        book "Custom Title"\n            |> withThemeOptions\n                [ ElmBook.ThemeOptions.subtitle "Custom Subtitle",\n                , ElmBook.ThemeOptions.logo (img [ src "/mycompanylogo.png" ] [])\n                ]\n            |> withChapters []\n\nOr you can go full custom and provide your own thing:\n\n<component with-label="Custom header" with-background=\"' + (dtwrks$elm_book$ElmBook$UI$Helpers$themeBackground + '" />\n\n```elm\nmain : Book x\nmain =\n    book "Custom Header"\n        |> withThemeOptions\n            [ ElmBook.ThemeOptions.header myCustomHeader\n            ]\n        |> withChapters []\n\n\nmyCustomHeader : Html msg\nmyCustomHeader =\n    ...\n```       \n\n---\n\n## Custom Colors\n\nI mean… we all love Elm\'s light blue but maybe it doesn\'t fit your book. Don\'t fret, you can customize a lot of what you\'re seeing.\n\n<component with-label="Theme Builder" />\n\n    main : Book x\n    main =\n        book "CustomHeader"\n            |> withThemeOptions\n                [ ElmBook.ThemeOptions.background "slategray"\n                , ElmBook.ThemeOptions.accent "white"\n                ]\n            |> withChapters [] \n---\n\n## Dark Mode\n\nAre you goth? Do you like the dark arts? Then tell your book so and it will always start already in dark mode:\n\n    main : Book x\n    main =\n        book "Goth Book"\n            |> withThemeOptions\n                [ ElmBook.ThemeOptions.darkMode\n                ]\n            |> withChapters [] \n\nDon\'t worry… the light-theme losers can turn it off quite easily.\n\n---\n\n## Roadmap\n\nThe state of our dark mode setup right now is not that great. It\'s more like a book thing than a "per user" setting since we can\'t persist what the user selected using pure elm.\n\nThere is a plan to also enable custom fonts soon. Other than that, I believe changes will be less customizable and will focus more on a better UX for all ElmBooks.\n\nThings like ready-to-be-used components like Placeholders, Design Tokens Catalogue, etc, should be handled by separate packages.\n\n'))),
22437		A2(
22438			dtwrks$elm_book$ElmBook$Chapter$withStatefulComponentList,
22439			_List_fromArray(
22440				[
22441					_Utils_Tuple2('Theme Builder', dtwrks$elm_book$ElmBook$UI$ThemeGenerator$view)
22442				]),
22443			A2(
22444				dtwrks$elm_book$ElmBook$Chapter$withComponentList,
22445				_List_fromArray(
22446					[
22447						_Utils_Tuple2(
22448						'Header with custom logo',
22449						dtwrks$elm_book$ElmBook$UI$Header$view(
22450							_Utils_update(
22451								headerProps,
22452								{
22453									theme: A2(
22454										dtwrks$elm_book$ElmBook$ThemeOptions$logo,
22455										dtwrks$elm_book$ElmBook$UI$Icons$iconElm(
22456											{color: '#75c5f0', size: 28}),
22457										headerProps.theme)
22458								}))),
22459						_Utils_Tuple2(
22460						'Custom header',
22461						dtwrks$elm_book$ElmBook$UI$Header$view(
22462							_Utils_update(
22463								headerProps,
22464								{
22465									theme: A2(dtwrks$elm_book$ElmBook$ThemeOptions$header, customHeader, headerProps.theme)
22466								})))
22467					]),
22468				A2(
22469					dtwrks$elm_book$ElmBook$Chapter$withComponentOptions,
22470					_List_fromArray(
22471						[
22472							dtwrks$elm_book$ElmBook$ComponentOptions$background(dtwrks$elm_book$ElmBook$UI$Helpers$themeBackgroun

22472d)
22473						]),
22474					dtwrks$elm_book$ElmBook$Chapter$chapter('Theming')))));
22475}();
22476var dtwrks$elm_book$ElmBook$UI$Docs$HeaderNavFooter$Header$docs = function () {
22477	var props = {
22478		href: '/logAction/href',
22479		isMenuOpen: false,
22480		onClickHeader: dtwrks$elm_book$ElmBook$Actions$logAction('onClickHeader'),
22481		onClickMenuButton: dtwrks$elm_book$ElmBook$Actions$logAction('onClickMenuButton'),
22482		theme: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultTheme,
22483		title: 'Title',
22484		toHtml: elm$core$Basics$identity
22485	};
22486	var customTitle = A2(
22487		elm$html$Html$div,
22488		_List_fromArray(
22489			[
22490				A2(elm$html$Html$Attributes$style, 'font-size', '28px'),
22491				A2(elm$html$Html$Attributes$style, 'color', '#75c5f0')
22492			]),
22493		_List_fromArray(
22494			[
22495				elm$html$Html$text('Custom')
22496			]));
22497	return _List_fromArray(
22498		[
22499			_Utils_Tuple2(
22500			'Header',
22501			dtwrks$elm_book$ElmBook$UI$Header$view(props)),
22502			_Utils_Tuple2(
22503			'Header w. Custom Logo',
22504			dtwrks$elm_book$ElmBook$UI$Header$view(
22505				_Utils_update(
22506					props,
22507					{
22508						theme: A2(
22509							dtwrks$elm_book$ElmBook$ThemeOptions$logo,
22510							dtwrks$elm_book$ElmBook$UI$Icons$iconElm(
22511								{color: '#75c5f0', size: 28}),
22512							props.theme)
22513					}))),
22514			_Utils_Tuple2(
22515			'Header w. Custom Content',
22516			dtwrks$elm_book$ElmBook$UI$Header$view(
22517				_Utils_update(
22518					props,
22519					{
22520						theme: A2(dtwrks$elm_book$ElmBook$ThemeOptions$header, customTitle, props.theme)
22521					})))
22522		]);
22523}();
22524var dtwrks$elm_book$ElmBook$UI$Docs$HeaderNavFooter$Nav$docs = function () {
22525	var itemGroup = function (index) {
22526		return _Utils_Tuple2(
22527			'',
22528			_List_fromArray(
22529				[
22530					_Utils_Tuple3(
22531					elm$core$String$fromInt(index) + '-first-slug',
22532					'First',
22533					true),
22534					_Utils_Tuple3(
22535					elm$core$String$fromInt(index) + '-second-slug',
22536					'Second',
22537					true)
22538				]));
22539	};
22540	var props = {
22541		active: elm$core$Maybe$Nothing,
22542		itemGroups: elm$core$List$singleton(
22543			itemGroup(0)),
22544		preSelected: elm$core$Maybe$Nothing
22545	};
22546	var activeProps = _Utils_update(
22547		props,
22548		{
22549			active: elm$core$Maybe$Just('0-first-slug')
22550		});
22551	return _List_fromArray(
22552		[
22553			_Utils_Tuple2(
22554			'Nav',
22555			dtwrks$elm_book$ElmBook$UI$Nav$view(props)),
22556			_Utils_Tuple2(
22557			'Nav - Selected',
22558			dtwrks$elm_book$ElmBook$UI$Nav$view(activeProps)),
22559			_Utils_Tuple2(
22560			'Nav - Selected + Pre-selected',
22561			dtwrks$elm_book$ElmBook$UI$Nav$view(
22562				_Utils_update(
22563					activeProps,
22564					{
22565						preSelected: elm$core$Maybe$Just('0-second-slug')
22566					}))),
22567			_Utils_Tuple2(
22568			'Nav w. groups',
22569			dtwrks$elm_book$ElmBook$UI$Nav$view(
22570				_Utils_update(
22571					activeProps,
22572					{
22573						itemGroups: A2(
22574							elm$core$List$map,
22575							function (_n0) {
22576								var xs = _n0.b;
22577								return _Utils_Tuple2('Group Name', xs);
22578							},
22579							A2(
22580								elm$core$List$map,
22581								itemGroup,
22582								A2(elm$core$List$range, 0, 3)))
22583					}))),
22584			_Utils_Tuple2(
22585			'Nav w. unnamed groups',
22586			dtwrks$elm_book$ElmBook$UI$Nav$view(
22587				_Utils_update(
22588					activeProps,
22589					{
22590						itemGroups: A2(
22591							elm$core$List$indexedMap,
22592							F2(
22593								function (index, _n1) {
22594									var xs = _n1.b;
22595									return _Utils_Tuple2(
22596										(!index) ? '' : 'Group Name',
22597										xs);
22598								}),
22599							A2(
22600								elm$core$List$map,
22601								itemGroup,
22602								A2(elm$core$List$range, 0, 3)))
22603					})))
22604		]);
22605}();
22606var dtwrks$elm_book$ElmBook$UI$Docs$HeaderNavFooter$docs = A2(
22607	dtwrks$elm_book$ElmBook$Chapter$render,
22608	'\n\nAll components used for the navigation area of an ElmBook.\n\nThe way we\'re generating this page is actually pretty neat – we\'re using `component-list` tags and `with-label` to pull out all components with labels that start with a given string. This is how we\'re easily grouping all title and nav components together! 💡\n\n## Header\n\n<component-list with-label="Header" />\n\n## Search\n\n<component with-label="Search" />\n\n## Nav\n\n<component-list with-label="Nav" />\n\n## Footer\n\n<component with-label="Footer" />\n\n',
22609	A2(
22610		dtwrks$elm_book$ElmBook$Chapter$withComponentList,
22611		elm$core$List$concat(
22612			_List_fromArray(
22613				[
22614					dtwrks$elm_book$ElmBook$UI$Docs$HeaderNavFooter$Header$docs,
22615					dtwrks$elm_book$ElmBook$UI$Docs$HeaderNavFooter$Nav$docs,
22616					_List_fromArray(
22617					[
22618						_Utils_Tuple2('Footer', dtwrks$elm_book$ElmBook$UI$Footer$view),
22619						_Utils_Tuple2(
22620						'Search',
22621						dtwrks$elm_book$ElmBook$UI$Search$view(
22622							{
22623								onBlur: dtwrks$elm_book$ElmBook$Actions$logAction('onBlur'),
22624								onFocus: dtwrks$elm_book$ElmBook$Actions$logAction('onFocus'),
22625								onInput: dtwrks$elm_book$ElmBook$Actions$logActionWithString('onInput'),
22626								value: ''
22627							}))
22628					])
22629				])),
22630		A2(

22631			dtwrks$elm_book$ElmBook$Chapter$withComponentOptions,
22632			_List_fromArray(
22633				[
22634					dtwrks$elm_book$ElmBook$ComponentOptions$background(dtwrks$elm_book$ElmBook$UI$Helpers$themeBackground)
22635				]),
22636			dtwrks$elm_book$ElmBook$Chapter$chapter('Header, Nav & Footer'))));
22637var dtwrks$elm_book$ElmBook$UI$Icons$iconElmColor = function (size) {
22638	return A2(
22639		elm$svg$Svg$svg,
22640		_List_fromArray(
22641			[
22642				elm$svg$Svg$Attributes$width(
22643				elm$core$String$fromInt(size)),
22644				elm$svg$Svg$Attributes$height(
22645				elm$core$String$fromInt(size)),
22646				elm$svg$Svg$Attributes$viewBox('0 0 256 256')
22647			]),
22648		_List_fromArray(
22649			[
22650				A2(
22651				elm$svg$Svg$path,
22652				_List_fromArray(
22653					[
22654						elm$svg$Svg$Attributes$fill('#5FB4CB'),
22655						elm$svg$Svg$Attributes$d('M128 135.022L7.023 256h241.955z')
22656					]),
22657				_List_Nil),
22658				A2(
22659				elm$svg$Svg$path,
22660				_List_fromArray(
22661					[
22662						elm$svg$Svg$Attributes$fill('#EEA400'),
22663						elm$svg$Svg$Attributes$d('M202.332 195.311L256 248.98V141.643z')
22664					]),
22665				_List_Nil),
22666				A2(
22667				elm$svg$Svg$path,
22668				_List_fromArray(
22669					[
22670						elm$svg$Svg$Attributes$fill('#596277'),
22671						elm$svg$Svg$Attributes$d('M120.978 128L0 7.022V248.98z')
22672					]),
22673				_List_Nil),
22674				A2(
22675				elm$svg$Svg$path,
22676				_List_fromArray(
22677					[
22678						elm$svg$Svg$Attributes$fill('#5FB4CB'),
22679						elm$svg$Svg$Attributes$d('M256 113.806V0H142.193z')
22680					]),
22681				_List_Nil),
22682				A2(
22683				elm$svg$Svg$path,
22684				_List_fromArray(
22685					[
22686						elm$svg$Svg$Attributes$fill('#8CD636'),
22687						elm$svg$Svg$Attributes$d('M195.584 67.434l60.288 60.289l-60.563 60.564l-60.29-60.29z')
22688					]),
22689				_List_Nil),
22690				A2(
22691				elm$svg$Svg$path,
22692				_List_fromArray(
22693					[
22694						elm$svg$Svg$Attributes$fill('#8CD636'),
22695						elm$svg$Svg$Attributes$d('M7.021 0l55.725 55.726h121.13L128.15 0z')
22696					]),
22697				_List_Nil),
22698				A2(
22699				elm$svg$Svg$path,
22700				_List_fromArray(
22701					[
22702						elm$svg$Svg$Attributes$fill('#EEA400'),
22703						elm$svg$Svg$Attributes$d('M128 120.979l55.322-55.323H72.677z')
22704					]),
22705				_List_Nil)
22706			]));
22707};
22708var dtwrks$elm_book$ElmBook$UI$Icons$iconGithub = function (props) {
22709	return A2(
22710		elm$svg$Svg$svg,
22711		_List_fromArray(
22712			[
22713				elm$svg$Svg$Attributes$width(
22714				elm$core$String$fromInt(props.size)),
22715				elm$svg$Svg$Attributes$height(
22716				elm$core$String$fromInt(props.size)),
22717				elm$svg$Svg$Attributes$viewBox('0 0 512 512')
22718			]),
22719		_List_fromArray(
22720			[
22721				A2(
22722				elm$svg$Svg$path,
22723				_List_fromArray(
22724					[
22725						elm$svg$Svg$Attributes$fill(props.color),
22726						elm$svg$Svg$Attributes$d('M256 0C115.39 0 0 115.39 0 256c0 119.988 84.195 228.984 196 256v-84.695c-11.078 2.425-21.273 2.496-32.55-.828-15.13-4.465-27.423-14.543-36.548-29.91-5.816-9.813-16.125-20.454-26.879-19.672l-2.636-29.883c23.254-1.992 43.37 14.168 55.312 34.23 5.305 8.922 11.41 14.153 19.246 16.465 7.575 2.23 15.707 1.16 25.184-2.187 2.379-18.973 11.07-26.075 17.637-36.075v-.015c-66.68-9.946-93.254-45.32-103.801-73.242-13.977-37.075-6.477-83.391 18.238-112.66.48-.571 1.348-2.063 1.012-3.106-11.332-34.23 2.476-62.547 2.984-65.55 13.078 3.866 15.203-3.892 56.809 21.386l7.191 4.32c3.008 1.793 2.063.77 5.07.543 17.372-4.719 35.684-7.324 53.727-7.558 18.18.234 36.375 2.84 54.465 7.75l2.328.234c-.203-.031.633-.149 2.035-.984 51.973-31.481 50.106-21.192 64.043-25.723.504 3.008 14.13 31.785 2.918 65.582-1.512 4.656 45.059 47.3 19.246 115.754-10.547 27.933-37.117 63.308-103.797 73.254v.015c8.547 13.028 18.817 19.957 18.762 46.832V512c111.809-27.016 196-136.012 196-256C512 115.39 396.61 0 256 0zm0 0')
22727					]),
22728				_List_Nil)
22729			]));
22730};
22731var dtwrks$elm_book$ElmBook$UI$Docs$Icons$docs = function () {
22732	var color = 'rgb(0,135,207)';
22733	return A2(
22734		dtwrks$elm_book$ElmBook$Chapter$renderWithComponentList,
22735		'\nSimple inline icons built with `elm/svg` – not that exciting but it works. 🤷\n',
22736		A2(
22737			dtwrks$elm_book$ElmBook$Chapter$withComponentList,
22738			_List_fromArray(
22739				[
22740					_Utils_Tuple2(
22741					'Elm (Color)',
22742					dtwrks$elm_book$ElmBook$UI$Icons$iconElmColor(20)),
22743					_Utils_Tuple2(
22744					'Elm',
22745					dtwrks$elm_book$ElmBook$UI$Icons$iconElm(
22746						{color: color, size: 20})),
22747					_Utils_Tuple2(
22748					'Github',
22749					dtwrks$elm_book$ElmBook$UI$Icons$iconGithub(
22750						{color: color, size: 20})),
22751					_Utils_Tuple2(
22752					'Menu',
22753					dtwrks$elm_book$ElmBook$UI$Icons$iconMenu(
22754						{color: color, size: 20})),
22755					_Utils_Tuple2(
22756					'Close',
22757					dtwrks$elm_book$ElmBook$UI$Icons$iconClose(
22758						{color: color, size: 20}))
22759				]),
22760			dtwrks$elm_book$ElmBook$Chapter$chapter('Icons')));
22761}();

22762var dtwrks$elm_book$ElmBook$UI$Docs$Intro$Overview$docs = A2(
22763	dtwrks$elm_book$ElmBook$Chapter$render,
22764	'\nEvery application, tool or team has their own history worth telling.\n\nElmBook tries to help them by making it easy to create rich documents that showcase their **libraries documentations**, **UI components**, **design tokens**, or anything else their creativity comes up with.\n\n---\n\n## It all starts with a chapter\n\nThey can be as simple as a markdown block or as rich as a set of interactive UI components that talk to each other. Take a look at the ["Creating Chapters"](/guides/chapters) guide for more details.\n\n```elm\nmodule FirstChapter exposing (firstChapter)\n\n\nimport ElmBook.Chapter exposing (..)\nimport Html exposing (..)\n\n\nfirstChapter : Chapter x\nfirstChapter =\n    chapter "The First Chapter"\n        |> withComponent component\n        |> render content\n\n\ncomponent : Html msg\ncomponent =\n    button [] [ text "Click me!" ]\n\n\ncontent : String\ncontent = \"\"\"\n# It all starts with a chapter\n\nOh, look – A wild real component!\n\n<component />\n\nWoof! Moving on...\n\"\"\"\n```\n\n---\n\n## Together, they become a book\n\nA book can hold a number of chapters and there are many ways to customize it from chapter grouping to custom themes. Take a look at the ["Creating Books"](/guides/books) and ["Theming"](/guides/theming) guides for more details.\n\n\n```elm\nmodule Book exposing (main)\n\n\nimport ElmBook exposing (..)\nimport FirstChapter exposing (firstChapter)\n\n\nmain : Book ()\nmain =\n    book "Book"\n        |> withChapters\n            [ firstChapter\n            ]\n\n```\n\n---\n\n## Inspiration\n\nThis library takes a lot of inspiration from two libraries:\n\n- [Storybook](http://storybook.js.org) – a JS ecosystem tool that focus on showcasing components and their states, mostly aiming at internal design systems but also enabling the pattern of creating visual components in isolation.\n\n- [HexDocs](http://hexdocs.pm) – an Erlang/Elixir ecosystem tool that enables structured library documentation with guides, function docs, links to code and external sources.\n\nBoth of these tools affected their whole ecosystems greatly. Creating good docs is a common place when you\'re in Elixir world. Using Storybook to facilitate design-engineering iteration is a common place in the JS world.\n\nWhat if the Elm ecosystem can create it\'s own thing with the best of both worlds? ElmBook aims to be just that – making it easy to create attractive documentation websites that can also work as a playground for live components built with Elm.\n\n---\n\n## Roadmap\n\nThere are two main possibilities I want to explore some time soon:\n\n- **Generating ElmBooks based on doc comments** – the same that are used to generate docs on elm-packages. This could allow published elm packages to automatically have their own ElmBook with example codes turning into live components and no code duplication.\n- **Generating ElmBooks through a custom CLI** – this package will always be "elm-only" so it can fit everyone\'s custom setup and be hosted on elm-packages but I want to create a companion CLI that would enable fancier stuff like merging `.md` files and pulling stuff out of doc comments. Whatever enables the best developer experience.\n\n---\n\nI really hope we can create something unique to the Elm ecosystem here, so please let me know what you think, ideas to improve it or if you encountered any problems. Find me as **georgesboris** on Elm Slack.\n\n',
22765	dtwrks$elm_book$ElmBook$Chapter$chapter('Overview'));
22766var dtwrks$elm_book$ElmBook$UI$Docs$Markdown$docs = A2(
22767	dtwrks$elm_book$ElmBook$Chapter$render,
22768	'\nWe use the amazing [dillonkearns/elm-markdown](https://package.elm-lang.org/packages/dillonkearns/elm-markdown/latest/) as the basis for not only our markdown content but also all the magic surrounding embedded components. Thanks, Dillon! 🎉\n\nBelow is a sample of most if not all available tags. Check it out! 🙃\n\n---\n\n# Heading 1\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, [sed do eiusmod](http://elm-lang.org) tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n## Heading 2\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, [sed do eiusmod](http://elm-lang.org) tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n### Heading 3\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, [sed do eiusmod](http://elm-lang.org) tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n---\n\n#### Heading 4\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, [sed do eiusmod](http://elm-lang.org) tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n##### Heading 5\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, [sed do eiusmod](http://elm-lang.org) tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n###### Heading 6\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, [sed do eiusmod](http://elm-lang.org) tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n---\n\n# Heading 1\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n![image](https://source.unsplash.com/WLUHO9A_xik/1600x900)\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, [sed do eiusmod](http://elm-lang.org) tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n> Lorem ipsum dolor sit amet, consectetur adipiscing elit, [sed do eiusmod](http://elm-lang.org) tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\nLorem ipsum dolor sit amet, `consectetur adipiscing elit`, [sed do eiusmod](http://elm-lang.org) tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n```elm\n-- Elm\n\nview : String -> Html msg\nview content =\n    ElmBook.UI.Markdown.view content\n        |> withOther "stuff"\n        |> withAnd [ "x" [] ]\n```\n\n```html\n<!-- HTML -->\n\n<body>\n    <h1>Title</h1>\n</body>\n```\n\n```css\n/* CSS */\n\nbody {\n    margin: 0;\n    padding: 0;\n}\n```\n\n\n```js\n// Javascript\n\nimport { Elm } from "..";\n\nconst app = Elm.Main.init({\n    node: document.getElementById(\'myapp\')\n});\n```\n\n```js\n// Typescript\n\ninterface User {\n  name: string;\n  id: number;\n}\n\nclass UserAccount {\n  name: string;\n  id: number;\n\n  constructor(name: string, id: number) {\n    this.name = name;\n    this.id = id;\n  }\n}\n\nconst user: User = new UserAccount("Murphy", 1);\n```\n\n```rust\n// Rust (Unknown)\n\nfn used_function() {}\n\n// `#[allow(dead_code)]` is an attribute that disables the `dead_code` lint\n#[allow(dead_code)]\nfn unused_function() {}\n\nfn noisy_unused_function() {}\n// FIXME ^ Add an attribute to suppress the warning\n\nfn main() {\n    used_function();\n}\n```\n\n---\n\n# Heading 1\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n* Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n* Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n* Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam.\n\n1. Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n1. Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n1. Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam.\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n| Fruits    |      Are      |   Healthy  |\n|----------|:-------------:|------:|\n| Apple |  Red | $1600 |\n| Orange |    Orange   |   $12 |\n| Banana | Yellow |    $1 |  \n',
22769	dtwrks$elm_book$ElmBook$Chapter$chapter('Markdown'));
22770var dtwrks$elm_book$ElmBook$UI$Docs$ThemeGenerator$docs = A2(
22771	dtwrks$elm_book$ElmBook$Chapter$render,
22772	'\nThis is a special component that would only work inside the ElmBook package itself since it uses private messages for changing the theme dynamically.\n\n<component />\n\n**Note**: You don\'t need to use a gradient at all! Check out the [docs](

22772https://package.elm-lang.org/packages/dtwrks/elm-book/latest/ElmBook-ThemeOptions) for all options.\n',
22773	A2(
22774		dtwrks$elm_book$ElmBook$Chapter$withStatefulComponent,
22775		dtwrks$elm_book$ElmBook$UI$ThemeGenerator$view,
22776		dtwrks$elm_book$ElmBook$Chapter$chapter('Theme Generator')));
22777var dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$placeholder = function (isLight) {
22778	var backgroundColor = isLight ? 'rgba(255, 255, 255, 0.2)' : 'rgba(0, 0, 0, 0.1)';
22779	return A2(
22780		elm$html$Html$div,
22781		_List_fromArray(
22782			[
22783				A2(elm$html$Html$Attributes$style, 'height', '40px'),
22784				A2(elm$html$Html$Attributes$style, 'background', backgroundColor)
22785			]),
22786		_List_Nil);
22787};
22788var dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$mockModalContent = A2(
22789	elm$html$Html$div,
22790	_List_fromArray(
22791		[
22792			A2(elm$html$Html$Attributes$style, 'width', '400px')
22793		]),
22794	_List_fromArray(
22795		[
22796			dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$placeholder(false)
22797		]));
22798var dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$placeholderList = function (isLight) {
22799	var item = A2(
22800		elm$html$Html$div,
22801		_List_fromArray(
22802			[
22803				A2(elm$html$Html$Attributes$style, 'padding', '8px')
22804			]),
22805		_List_fromArray(
22806			[
22807				dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$placeholder(isLight)
22808			]));
22809	var items = A2(elm$core$List$repeat, 40, item);
22810	return A2(
22811		elm$html$Html$ul,
22812		_List_fromArray(
22813			[
22814				A2(elm$html$Html$Attributes$style, 'margin', '0'),
22815				A2(elm$html$Html$Attributes$style, 'padding', '0'),
22816				A2(elm$html$Html$Attributes$style, 'width', '100%'),
22817				A2(elm$html$Html$Attributes$style, 'box-sizing', 'border-box')
22818			]),
22819		items);
22820};
22821var dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$docs = function () {
22822	var wrapper = function (child) {
22823		return A2(
22824			elm$html$Html$div,
22825			_List_fromArray(
22826				[
22827					A2(elm$html$Html$Attributes$style, 'height', '400px'),
22828					A2(elm$html$Html$Attributes$style, 'position', 'relative')
22829				]),
22830			_List_fromArray(
22831				[child]));
22832	};
22833	var props = {
22834		darkMode: false,
22835		globals: _List_Nil,
22836		header: dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$placeholder(true),
22837		isMenuOpen: false,
22838		main: dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$placeholderList(false),
22839		mainFooter: dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$placeholder(false),
22840		mainHeader: elm$core$Maybe$Nothing,
22841		menu: dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$placeholderList(true),
22842		menuFooter: dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$placeholder(true),
22843		menuHeader: dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$placeholder(true),
22844		modal: elm$core$Maybe$Nothing,
22845		onCloseModal: dtwrks$elm_book$ElmBook$Actions$logAction('onCloseModal'),
22846		theme: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultTheme
22847	};
22848	return A2(
22849		dtwrks$elm_book$ElmBook$Chapter$renderWithComponentList,
22850		'\nSince ElmBook is basically a "one layout" app – it\'s easier to maintain all its skeleton in a single place. This is all inside the `Wrapper` module. Take a look at the possible states below.\n\n',
22851		A2(
22852			dtwrks$elm_book$ElmBook$Chapter$withComponentList,
22853			_List_fromArray(
22854				[
22855					_Utils_Tuple2(
22856					'Default',
22857					wrapper(
22858						dtwrks$elm_book$ElmBook$UI$Wrapper$view(props))),
22859					_Utils_Tuple2(
22860					'Opened Menu (Visible on Mobile)',
22861					wrapper(
22862						dtwrks$elm_book$ElmBook$UI$Wrapper$view(
22863							_Utils_update(
22864								props,
22865								{isMenuOpen: true})))),
22866					_Utils_Tuple2(
22867					'With Modal',
22868					wrapper(
22869						dtwrks$elm_book$ElmBook$UI$Wrapper$view(
22870							_Utils_update(
22871								props,
22872								{
22873									modal: elm$core$Maybe$Just(dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$mockModalContent)
22874								}))))
22875				]),
22876			dtwrks$elm_book$ElmBook$Chapter$chapter('Wrapper')));
22877}();
22878var dtwrks$elm_book$ElmBook$UI$ElmBook$initialState = {
22879	darkMode: false,
22880	theming: {accent: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultAccent, backgroundEnd: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultBackgroundEnd, backgroundStart: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultBackgroundStart, navAccent: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultNavAccent, navAccentHighlight: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultNavAccentHighlight, navBackgroun

22880d: dtwrks$elm_book$ElmBook$Internal$ThemeOptions$defaultNavBackground}
22881};
22882var dtwrks$elm_book$ElmBook$UI$ElmBook$main = A2(
22883	dtwrks$elm_book$ElmBook$withChapterGroups,
22884	_List_fromArray(
22885		[
22886			_Utils_Tuple2(
22887			'',
22888			_List_fromArray(
22889				[
22890					dtwrks$elm_book$ElmBook$UI$Docs$Intro$Overview$docs,
22891					dtwrks$elm_book$ElmBook$Chapter$chapterLink(
22892					{title: 'API', url: 'https://package.elm-lang.org/packages/dtwrks/elm-book/latest/'})
22893				])),
22894			_Utils_Tuple2(
22895			'Guides',
22896			_List_fromArray(
22897				[dtwrks$elm_book$ElmBook$UI$Docs$Guides$Chapters$docs, dtwrks$elm_book$ElmBook$UI$Docs$Guides$Books$docs, dtwrks$elm_book$ElmBook$UI$Docs$Guides$Theming$docs, dtwrks$elm_book$ElmBook$UI$Docs$Guides$LoggingActions$docs, dtwrks$elm_book$ElmBook$UI$Docs$Guides$StatefulChapters$docs, dtwrks$elm_book$ElmBook$UI$Docs$Guides$Interop$docs, dtwrks$elm_book$ElmBook$UI$Docs$Guides$BuiltinServer$docs])),
22898			_Utils_Tuple2(
22899			'Design System',
22900			_List_fromArray(
22901				[dtwrks$elm_book$ElmBook$UI$Docs$Wrapper$docs, dtwrks$elm_book$ElmBook$UI$Docs$HeaderNavFooter$docs, dtwrks$elm_book$ElmBook$UI$Docs$ActionLog$docs, dtwrks$elm_book$ElmBook$UI$Docs$Icons$docs, dtwrks$elm_book$ElmBook$UI$Docs$Markdown$docs, dtwrks$elm_book$ElmBook$UI$Docs$DarkModeComponents$docs, dtwrks$elm_book$ElmBook$UI$Docs$ThemeGenerator$docs]))
22902		]),
22903	A2(
22904		dtwrks$elm_book$ElmBook$withThemeOptions,
22905		_List_fromArray(
22906			[
22907				dtwrks$elm_book$ElmBook$ThemeOptions$subtitle('Guides & Components')
22908			]),
22909		A2(
22910			dtwrks$elm_book$ElmBook$withStatefulOptions,
22911			_List_fromArray(
22912				[
22913					dtwrks$elm_book$ElmBook$StatefulOptions$initialState(dtwrks$elm_book$ElmBook$UI$ElmBook$initialState),
22914					dtwrks$elm_book$ElmBook$StatefulOptions$onDarkModeChange(
22915					F2(
22916						function (darkMode, s) {
22917							return _Utils_update(
22918								s,
22919								{darkMode: darkMode});
22920						}))
22921				]),
22922			dtwrks$elm_book$ElmBook$book('ElmBook\'s'))));
22923_Platform_export({'ElmBook':{'UI':{'ElmBook':{'init':dtwrks$elm_book$ElmBook$UI$ElmBook$main(
22924	elm$json$Json$Decode$succeed(_Utils_Tuple0))(0)}}}});}(this));