commit f4e4e2eae13060b608aff85f6c861cd5904e2634 Author: mtgmonkey Date: Thu Apr 24 22:32:10 2025 -0400 init diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..54b5350 --- /dev/null +++ b/Makefile @@ -0,0 +1,25 @@ +all: frontend backend + +produce: frontend-produce backend + +run: + stack exec ~/.local/bin/hs-server-exe + +backend: + cd backend && stack install + +frontend: frontend-format + cd frontend && elm make src/Main.elm --output=../assets/js/main.js + +frontend-produce: frontend-format + cd frontend && elm make src/Main.elm --optimize --output=../assets/js/main + uglifyjs assets/js/main.js --compress "pure_funcs=[F2,F3,F4,F5,F6,F7,F8,F9,A2,A3,A4,A5,A6,A7,A8,A9],pure_getters,keep_fargs=false,unsafe_comps,unsafe" | uglifyjs --mangle --output assets/js/main.js + +frontend-format: + elm-format frontend/src/Main.elm --yes + +clean: + touch assets/js/main.js + rm assets/js/main.js + +.PHONY: all produce run backend frontend frontend-produce frontend-format clean diff --git a/assets/js/init.js b/assets/js/init.js new file mode 100644 index 0000000..1084a0f --- /dev/null +++ b/assets/js/init.js @@ -0,0 +1 @@ +app=Elm.Main.init({flags:localStorage.getItem('cookies')?JSON.parse(localStorage.getItem('cookies')):''});app.ports.setStorage.subscribe(function(c){localStorage.setItem('cookies',JSON.stringify(c))}); diff --git a/assets/js/main.js b/assets/js/main.js new file mode 100644 index 0000000..ed325aa --- /dev/null +++ b/assets/js/main.js @@ -0,0 +1,9744 @@ +(function(scope){ +'use strict'; + +function F(arity, fun, wrapper) { + wrapper.a = arity; + wrapper.f = fun; + return wrapper; +} + +function F2(fun) { + return F(2, fun, function(a) { return function(b) { return fun(a,b); }; }) +} +function F3(fun) { + return F(3, fun, function(a) { + return function(b) { return function(c) { return fun(a, b, c); }; }; + }); +} +function F4(fun) { + return F(4, fun, function(a) { return function(b) { return function(c) { + return function(d) { return fun(a, b, c, d); }; }; }; + }); +} +function F5(fun) { + return F(5, fun, function(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; }; + }); +} +function F6(fun) { + return F(6, fun, function(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return function(f) { + return fun(a, b, c, d, e, f); }; }; }; }; }; + }); +} +function F7(fun) { + return F(7, fun, function(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return function(f) { + return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; }; + }); +} +function F8(fun) { + return F(8, fun, function(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return function(f) { + return function(g) { return function(h) { + return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; }; + }); +} +function F9(fun) { + return F(9, fun, function(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return function(f) { + return function(g) { return function(h) { return function(i) { + return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; }; + }); +} + +function A2(fun, a, b) { + return fun.a === 2 ? fun.f(a, b) : fun(a)(b); +} +function A3(fun, a, b, c) { + return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c); +} +function A4(fun, a, b, c, d) { + return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d); +} +function A5(fun, a, b, c, d, e) { + return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e); +} +function A6(fun, a, b, c, d, e, f) { + return fun.a === 6 ? fun.f(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f); +} +function A7(fun, a, b, c, d, e, f, g) { + return fun.a === 7 ? fun.f(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g); +} +function A8(fun, a, b, c, d, e, f, g, h) { + return fun.a === 8 ? fun.f(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h); +} +function A9(fun, a, b, c, d, e, f, g, h, i) { + 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); +} + +console.warn('Compiled in DEV mode. Follow the advice at https://elm-lang.org/0.19.1/optimize for better performance and smaller assets.'); + + +// EQUALITY + +function _Utils_eq(x, y) +{ + for ( + var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack); + isEqual && (pair = stack.pop()); + isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack) + ) + {} + + return isEqual; +} + +function _Utils_eqHelp(x, y, depth, stack) +{ + if (x === y) + { + return true; + } + + if (typeof x !== 'object' || x === null || y === null) + { + typeof x === 'function' && _Debug_crash(5); + return false; + } + + if (depth > 100) + { + stack.push(_Utils_Tuple2(x,y)); + return true; + } + + /**/ + if (x.$ === 'Set_elm_builtin') + { + x = $elm$core$Set$toList(x); + y = $elm$core$Set$toList(y); + } + if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin') + { + x = $elm$core$Dict$toList(x); + y = $elm$core$Dict$toList(y); + } + //*/ + + /**_UNUSED/ + if (x.$ < 0) + { + x = $elm$core$Dict$toList(x); + y = $elm$core$Dict$toList(y); + } + //*/ + + for (var key in x) + { + if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack)) + { + return false; + } + } + return true; +} + +var _Utils_equal = F2(_Utils_eq); +var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); }); + + + +// COMPARISONS + +// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on +// the particular integer values assigned to LT, EQ, and GT. + +function _Utils_cmp(x, y, ord) +{ + if (typeof x !== 'object') + { + return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1; + } + + /**/ + if (x instanceof String) + { + var a = x.valueOf(); + var b = y.valueOf(); + return a === b ? 0 : a < b ? -1 : 1; + } + //*/ + + /**_UNUSED/ + if (typeof x.$ === 'undefined') + //*/ + /**/ + if (x.$[0] === '#') + //*/ + { + return (ord = _Utils_cmp(x.a, y.a)) + ? ord + : (ord = _Utils_cmp(x.b, y.b)) + ? ord + : _Utils_cmp(x.c, y.c); + } + + // traverse conses until end of a list or a mismatch + for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES + return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0); +} + +var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; }); +var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; }); +var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; }); +var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; }); + +var _Utils_compare = F2(function(x, y) +{ + var n = _Utils_cmp(x, y); + return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ; +}); + + +// COMMON VALUES + +var _Utils_Tuple0_UNUSED = 0; +var _Utils_Tuple0 = { $: '#0' }; + +function _Utils_Tuple2_UNUSED(a, b) { return { a: a, b: b }; } +function _Utils_Tuple2(a, b) { return { $: '#2', a: a, b: b }; } + +function _Utils_Tuple3_UNUSED(a, b, c) { return { a: a, b: b, c: c }; } +function _Utils_Tuple3(a, b, c) { return { $: '#3', a: a, b: b, c: c }; } + +function _Utils_chr_UNUSED(c) { return c; } +function _Utils_chr(c) { return new String(c); } + + +// RECORDS + +function _Utils_update(oldRecord, updatedFields) +{ + var newRecord = {}; + + for (var key in oldRecord) + { + newRecord[key] = oldRecord[key]; + } + + for (var key in updatedFields) + { + newRecord[key] = updatedFields[key]; + } + + return newRecord; +} + + +// APPEND + +var _Utils_append = F2(_Utils_ap); + +function _Utils_ap(xs, ys) +{ + // append Strings + if (typeof xs === 'string') + { + return xs + ys; + } + + // append Lists + if (!xs.b) + { + return ys; + } + var root = _List_Cons(xs.a, ys); + xs = xs.b + for (var curr = root; xs.b; xs = xs.b) // WHILE_CONS + { + curr = curr.b = _List_Cons(xs.a, ys); + } + return root; +} + + + +var _List_Nil_UNUSED = { $: 0 }; +var _List_Nil = { $: '[]' }; + +function _List_Cons_UNUSED(hd, tl) { return { $: 1, a: hd, b: tl }; } +function _List_Cons(hd, tl) { return { $: '::', a: hd, b: tl }; } + + +var _List_cons = F2(_List_Cons); + +function _List_fromArray(arr) +{ + var out = _List_Nil; + for (var i = arr.length; i--; ) + { + out = _List_Cons(arr[i], out); + } + return out; +} + +function _List_toArray(xs) +{ + for (var out = []; xs.b; xs = xs.b) // WHILE_CONS + { + out.push(xs.a); + } + return out; +} + +var _List_map2 = F3(function(f, xs, ys) +{ + for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES + { + arr.push(A2(f, xs.a, ys.a)); + } + return _List_fromArray(arr); +}); + +var _List_map3 = F4(function(f, xs, ys, zs) +{ + for (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES + { + arr.push(A3(f, xs.a, ys.a, zs.a)); + } + return _List_fromArray(arr); +}); + +var _List_map4 = F5(function(f, ws, xs, ys, zs) +{ + 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 + { + arr.push(A4(f, ws.a, xs.a, ys.a, zs.a)); + } + return _List_fromArray(arr); +}); + +var _List_map5 = F6(function(f, vs, ws, xs, ys, zs) +{ + 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 + { + arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a)); + } + return _List_fromArray(arr); +}); + +var _List_sortBy = F2(function(f, xs) +{ + return _List_fromArray(_List_toArray(xs).sort(function(a, b) { + return _Utils_cmp(f(a), f(b)); + })); +}); + +var _List_sortWith = F2(function(f, xs) +{ + return _List_fromArray(_List_toArray(xs).sort(function(a, b) { + var ord = A2(f, a, b); + return ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1; + })); +}); + + + +var _JsArray_empty = []; + +function _JsArray_singleton(value) +{ + return [value]; +} + +function _JsArray_length(array) +{ + return array.length; +} + +var _JsArray_initialize = F3(function(size, offset, func) +{ + var result = new Array(size); + + for (var i = 0; i < size; i++) + { + result[i] = func(offset + i); + } + + return result; +}); + +var _JsArray_initializeFromList = F2(function (max, ls) +{ + var result = new Array(max); + + for (var i = 0; i < max && ls.b; i++) + { + result[i] = ls.a; + ls = ls.b; + } + + result.length = i; + return _Utils_Tuple2(result, ls); +}); + +var _JsArray_unsafeGet = F2(function(index, array) +{ + return array[index]; +}); + +var _JsArray_unsafeSet = F3(function(index, value, array) +{ + var length = array.length; + var result = new Array(length); + + for (var i = 0; i < length; i++) + { + result[i] = array[i]; + } + + result[index] = value; + return result; +}); + +var _JsArray_push = F2(function(value, array) +{ + var length = array.length; + var result = new Array(length + 1); + + for (var i = 0; i < length; i++) + { + result[i] = array[i]; + } + + result[length] = value; + return result; +}); + +var _JsArray_foldl = F3(function(func, acc, array) +{ + var length = array.length; + + for (var i = 0; i < length; i++) + { + acc = A2(func, array[i], acc); + } + + return acc; +}); + +var _JsArray_foldr = F3(function(func, acc, array) +{ + for (var i = array.length - 1; i >= 0; i--) + { + acc = A2(func, array[i], acc); + } + + return acc; +}); + +var _JsArray_map = F2(function(func, array) +{ + var length = array.length; + var result = new Array(length); + + for (var i = 0; i < length; i++) + { + result[i] = func(array[i]); + } + + return result; +}); + +var _JsArray_indexedMap = F3(function(func, offset, array) +{ + var length = array.length; + var result = new Array(length); + + for (var i = 0; i < length; i++) + { + result[i] = A2(func, offset + i, array[i]); + } + + return result; +}); + +var _JsArray_slice = F3(function(from, to, array) +{ + return array.slice(from, to); +}); + +var _JsArray_appendN = F3(function(n, dest, source) +{ + var destLen = dest.length; + var itemsToCopy = n - destLen; + + if (itemsToCopy > source.length) + { + itemsToCopy = source.length; + } + + var size = destLen + itemsToCopy; + var result = new Array(size); + + for (var i = 0; i < destLen; i++) + { + result[i] = dest[i]; + } + + for (var i = 0; i < itemsToCopy; i++) + { + result[i + destLen] = source[i]; + } + + return result; +}); + + + +// LOG + +var _Debug_log_UNUSED = F2(function(tag, value) +{ + return value; +}); + +var _Debug_log = F2(function(tag, value) +{ + console.log(tag + ': ' + _Debug_toString(value)); + return value; +}); + + +// TODOS + +function _Debug_todo(moduleName, region) +{ + return function(message) { + _Debug_crash(8, moduleName, region, message); + }; +} + +function _Debug_todoCase(moduleName, region, value) +{ + return function(message) { + _Debug_crash(9, moduleName, region, value, message); + }; +} + + +// TO STRING + +function _Debug_toString_UNUSED(value) +{ + return ''; +} + +function _Debug_toString(value) +{ + return _Debug_toAnsiString(false, value); +} + +function _Debug_toAnsiString(ansi, value) +{ + if (typeof value === 'function') + { + return _Debug_internalColor(ansi, ''); + } + + if (typeof value === 'boolean') + { + return _Debug_ctorColor(ansi, value ? 'True' : 'False'); + } + + if (typeof value === 'number') + { + return _Debug_numberColor(ansi, value + ''); + } + + if (value instanceof String) + { + return _Debug_charColor(ansi, "'" + _Debug_addSlashes(value, true) + "'"); + } + + if (typeof value === 'string') + { + return _Debug_stringColor(ansi, '"' + _Debug_addSlashes(value, false) + '"'); + } + + if (typeof value === 'object' && '$' in value) + { + var tag = value.$; + + if (typeof tag === 'number') + { + return _Debug_internalColor(ansi, ''); + } + + if (tag[0] === '#') + { + var output = []; + for (var k in value) + { + if (k === '$') continue; + output.push(_Debug_toAnsiString(ansi, value[k])); + } + return '(' + output.join(',') + ')'; + } + + if (tag === 'Set_elm_builtin') + { + return _Debug_ctorColor(ansi, 'Set') + + _Debug_fadeColor(ansi, '.fromList') + ' ' + + _Debug_toAnsiString(ansi, $elm$core$Set$toList(value)); + } + + if (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin') + { + return _Debug_ctorColor(ansi, 'Dict') + + _Debug_fadeColor(ansi, '.fromList') + ' ' + + _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value)); + } + + if (tag === 'Array_elm_builtin') + { + return _Debug_ctorColor(ansi, 'Array') + + _Debug_fadeColor(ansi, '.fromList') + ' ' + + _Debug_toAnsiString(ansi, $elm$core$Array$toList(value)); + } + + if (tag === '::' || tag === '[]') + { + var output = '['; + + value.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b) + + for (; value.b; value = value.b) // WHILE_CONS + { + output += ',' + _Debug_toAnsiString(ansi, value.a); + } + return output + ']'; + } + + var output = ''; + for (var i in value) + { + if (i === '$') continue; + var str = _Debug_toAnsiString(ansi, value[i]); + var c0 = str[0]; + var parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0; + output += ' ' + (parenless ? str : '(' + str + ')'); + } + return _Debug_ctorColor(ansi, tag) + output; + } + + if (typeof DataView === 'function' && value instanceof DataView) + { + return _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>'); + } + + if (typeof File !== 'undefined' && value instanceof File) + { + return _Debug_internalColor(ansi, '<' + value.name + '>'); + } + + if (typeof value === 'object') + { + var output = []; + for (var key in value) + { + var field = key[0] === '_' ? key.slice(1) : key; + output.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key])); + } + if (output.length === 0) + { + return '{}'; + } + return '{ ' + output.join(', ') + ' }'; + } + + return _Debug_internalColor(ansi, ''); +} + +function _Debug_addSlashes(str, isChar) +{ + var s = str + .replace(/\\/g, '\\\\') + .replace(/\n/g, '\\n') + .replace(/\t/g, '\\t') + .replace(/\r/g, '\\r') + .replace(/\v/g, '\\v') + .replace(/\0/g, '\\0'); + + if (isChar) + { + return s.replace(/\'/g, '\\\''); + } + else + { + return s.replace(/\"/g, '\\"'); + } +} + +function _Debug_ctorColor(ansi, string) +{ + return ansi ? '\x1b[96m' + string + '\x1b[0m' : string; +} + +function _Debug_numberColor(ansi, string) +{ + return ansi ? '\x1b[95m' + string + '\x1b[0m' : string; +} + +function _Debug_stringColor(ansi, string) +{ + return ansi ? '\x1b[93m' + string + '\x1b[0m' : string; +} + +function _Debug_charColor(ansi, string) +{ + return ansi ? '\x1b[92m' + string + '\x1b[0m' : string; +} + +function _Debug_fadeColor(ansi, string) +{ + return ansi ? '\x1b[37m' + string + '\x1b[0m' : string; +} + +function _Debug_internalColor(ansi, string) +{ + return ansi ? '\x1b[36m' + string + '\x1b[0m' : string; +} + +function _Debug_toHexDigit(n) +{ + return String.fromCharCode(n < 10 ? 48 + n : 55 + n); +} + + +// CRASH + + +function _Debug_crash_UNUSED(identifier) +{ + throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md'); +} + + +function _Debug_crash(identifier, fact1, fact2, fact3, fact4) +{ + switch(identifier) + { + case 0: + 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.'); + + case 1: + 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.'); + + case 2: + var jsonErrorString = fact1; + throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString); + + case 3: + var portName = fact1; + throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.'); + + case 4: + var portName = fact1; + var problem = fact2; + throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem); + + case 5: + 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.'); + + case 6: + var moduleName = fact1; + 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!'); + + case 8: + var moduleName = fact1; + var region = fact2; + var message = fact3; + throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message); + + case 9: + var moduleName = fact1; + var region = fact2; + var value = fact3; + var message = fact4; + throw new Error( + 'TODO in module `' + moduleName + '` from the `case` expression ' + + _Debug_regionToString(region) + '\n\nIt received the following value:\n\n ' + + _Debug_toString(value).replace('\n', '\n ') + + '\n\nBut the branch that handles it says:\n\n ' + message.replace('\n', '\n ') + ); + + case 10: + throw new Error('Bug in https://github.com/elm/virtual-dom/issues'); + + case 11: + throw new Error('Cannot perform mod 0. Division by zero error.'); + } +} + +function _Debug_regionToString(region) +{ + if (region.start.line === region.end.line) + { + return 'on line ' + region.start.line; + } + return 'on lines ' + region.start.line + ' through ' + region.end.line; +} + + + +// MATH + +var _Basics_add = F2(function(a, b) { return a + b; }); +var _Basics_sub = F2(function(a, b) { return a - b; }); +var _Basics_mul = F2(function(a, b) { return a * b; }); +var _Basics_fdiv = F2(function(a, b) { return a / b; }); +var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; }); +var _Basics_pow = F2(Math.pow); + +var _Basics_remainderBy = F2(function(b, a) { return a % b; }); + +// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf +var _Basics_modBy = F2(function(modulus, x) +{ + var answer = x % modulus; + return modulus === 0 + ? _Debug_crash(11) + : + ((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0)) + ? answer + modulus + : answer; +}); + + +// TRIGONOMETRY + +var _Basics_pi = Math.PI; +var _Basics_e = Math.E; +var _Basics_cos = Math.cos; +var _Basics_sin = Math.sin; +var _Basics_tan = Math.tan; +var _Basics_acos = Math.acos; +var _Basics_asin = Math.asin; +var _Basics_atan = Math.atan; +var _Basics_atan2 = F2(Math.atan2); + + +// MORE MATH + +function _Basics_toFloat(x) { return x; } +function _Basics_truncate(n) { return n | 0; } +function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; } + +var _Basics_ceiling = Math.ceil; +var _Basics_floor = Math.floor; +var _Basics_round = Math.round; +var _Basics_sqrt = Math.sqrt; +var _Basics_log = Math.log; +var _Basics_isNaN = isNaN; + + +// BOOLEANS + +function _Basics_not(bool) { return !bool; } +var _Basics_and = F2(function(a, b) { return a && b; }); +var _Basics_or = F2(function(a, b) { return a || b; }); +var _Basics_xor = F2(function(a, b) { return a !== b; }); + + + +var _String_cons = F2(function(chr, str) +{ + return chr + str; +}); + +function _String_uncons(string) +{ + var word = string.charCodeAt(0); + return !isNaN(word) + ? $elm$core$Maybe$Just( + 0xD800 <= word && word <= 0xDBFF + ? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2)) + : _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1)) + ) + : $elm$core$Maybe$Nothing; +} + +var _String_append = F2(function(a, b) +{ + return a + b; +}); + +function _String_length(str) +{ + return str.length; +} + +var _String_map = F2(function(func, string) +{ + var len = string.length; + var array = new Array(len); + var i = 0; + while (i < len) + { + var word = string.charCodeAt(i); + if (0xD800 <= word && word <= 0xDBFF) + { + array[i] = func(_Utils_chr(string[i] + string[i+1])); + i += 2; + continue; + } + array[i] = func(_Utils_chr(string[i])); + i++; + } + return array.join(''); +}); + +var _String_filter = F2(function(isGood, str) +{ + var arr = []; + var len = str.length; + var i = 0; + while (i < len) + { + var char = str[i]; + var word = str.charCodeAt(i); + i++; + if (0xD800 <= word && word <= 0xDBFF) + { + char += str[i]; + i++; + } + + if (isGood(_Utils_chr(char))) + { + arr.push(char); + } + } + return arr.join(''); +}); + +function _String_reverse(str) +{ + var len = str.length; + var arr = new Array(len); + var i = 0; + while (i < len) + { + var word = str.charCodeAt(i); + if (0xD800 <= word && word <= 0xDBFF) + { + arr[len - i] = str[i + 1]; + i++; + arr[len - i] = str[i - 1]; + i++; + } + else + { + arr[len - i] = str[i]; + i++; + } + } + return arr.join(''); +} + +var _String_foldl = F3(function(func, state, string) +{ + var len = string.length; + var i = 0; + while (i < len) + { + var char = string[i]; + var word = string.charCodeAt(i); + i++; + if (0xD800 <= word && word <= 0xDBFF) + { + char += string[i]; + i++; + } + state = A2(func, _Utils_chr(char), state); + } + return state; +}); + +var _String_foldr = F3(function(func, state, string) +{ + var i = string.length; + while (i--) + { + var char = string[i]; + var word = string.charCodeAt(i); + if (0xDC00 <= word && word <= 0xDFFF) + { + i--; + char = string[i] + char; + } + state = A2(func, _Utils_chr(char), state); + } + return state; +}); + +var _String_split = F2(function(sep, str) +{ + return str.split(sep); +}); + +var _String_join = F2(function(sep, strs) +{ + return strs.join(sep); +}); + +var _String_slice = F3(function(start, end, str) { + return str.slice(start, end); +}); + +function _String_trim(str) +{ + return str.trim(); +} + +function _String_trimLeft(str) +{ + return str.replace(/^\s+/, ''); +} + +function _String_trimRight(str) +{ + return str.replace(/\s+$/, ''); +} + +function _String_words(str) +{ + return _List_fromArray(str.trim().split(/\s+/g)); +} + +function _String_lines(str) +{ + return _List_fromArray(str.split(/\r\n|\r|\n/g)); +} + +function _String_toUpper(str) +{ + return str.toUpperCase(); +} + +function _String_toLower(str) +{ + return str.toLowerCase(); +} + +var _String_any = F2(function(isGood, string) +{ + var i = string.length; + while (i--) + { + var char = string[i]; + var word = string.charCodeAt(i); + if (0xDC00 <= word && word <= 0xDFFF) + { + i--; + char = string[i] + char; + } + if (isGood(_Utils_chr(char))) + { + return true; + } + } + return false; +}); + +var _String_all = F2(function(isGood, string) +{ + var i = string.length; + while (i--) + { + var char = string[i]; + var word = string.charCodeAt(i); + if (0xDC00 <= word && word <= 0xDFFF) + { + i--; + char = string[i] + char; + } + if (!isGood(_Utils_chr(char))) + { + return false; + } + } + return true; +}); + +var _String_contains = F2(function(sub, str) +{ + return str.indexOf(sub) > -1; +}); + +var _String_startsWith = F2(function(sub, str) +{ + return str.indexOf(sub) === 0; +}); + +var _String_endsWith = F2(function(sub, str) +{ + return str.length >= sub.length && + str.lastIndexOf(sub) === str.length - sub.length; +}); + +var _String_indexes = F2(function(sub, str) +{ + var subLen = sub.length; + + if (subLen < 1) + { + return _List_Nil; + } + + var i = 0; + var is = []; + + while ((i = str.indexOf(sub, i)) > -1) + { + is.push(i); + i = i + subLen; + } + + return _List_fromArray(is); +}); + + +// TO STRING + +function _String_fromNumber(number) +{ + return number + ''; +} + + +// INT CONVERSIONS + +function _String_toInt(str) +{ + var total = 0; + var code0 = str.charCodeAt(0); + var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0; + + for (var i = start; i < str.length; ++i) + { + var code = str.charCodeAt(i); + if (code < 0x30 || 0x39 < code) + { + return $elm$core$Maybe$Nothing; + } + total = 10 * total + code - 0x30; + } + + return i == start + ? $elm$core$Maybe$Nothing + : $elm$core$Maybe$Just(code0 == 0x2D ? -total : total); +} + + +// FLOAT CONVERSIONS + +function _String_toFloat(s) +{ + // check if it is a hex, octal, or binary number + if (s.length === 0 || /[\sxbo]/.test(s)) + { + return $elm$core$Maybe$Nothing; + } + var n = +s; + // faster isNaN check + return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing; +} + +function _String_fromList(chars) +{ + return _List_toArray(chars).join(''); +} + + + + +function _Char_toCode(char) +{ + var code = char.charCodeAt(0); + if (0xD800 <= code && code <= 0xDBFF) + { + return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000 + } + return code; +} + +function _Char_fromCode(code) +{ + return _Utils_chr( + (code < 0 || 0x10FFFF < code) + ? '\uFFFD' + : + (code <= 0xFFFF) + ? String.fromCharCode(code) + : + (code -= 0x10000, + String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00) + ) + ); +} + +function _Char_toUpper(char) +{ + return _Utils_chr(char.toUpperCase()); +} + +function _Char_toLower(char) +{ + return _Utils_chr(char.toLowerCase()); +} + +function _Char_toLocaleUpper(char) +{ + return _Utils_chr(char.toLocaleUpperCase()); +} + +function _Char_toLocaleLower(char) +{ + return _Utils_chr(char.toLocaleLowerCase()); +} + + + +/**/ +function _Json_errorToString(error) +{ + return $elm$json$Json$Decode$errorToString(error); +} +//*/ + + +// CORE DECODERS + +function _Json_succeed(msg) +{ + return { + $: 0, + a: msg + }; +} + +function _Json_fail(msg) +{ + return { + $: 1, + a: msg + }; +} + +function _Json_decodePrim(decoder) +{ + return { $: 2, b: decoder }; +} + +var _Json_decodeInt = _Json_decodePrim(function(value) { + return (typeof value !== 'number') + ? _Json_expecting('an INT', value) + : + (-2147483647 < value && value < 2147483647 && (value | 0) === value) + ? $elm$core$Result$Ok(value) + : + (isFinite(value) && !(value % 1)) + ? $elm$core$Result$Ok(value) + : _Json_expecting('an INT', value); +}); + +var _Json_decodeBool = _Json_decodePrim(function(value) { + return (typeof value === 'boolean') + ? $elm$core$Result$Ok(value) + : _Json_expecting('a BOOL', value); +}); + +var _Json_decodeFloat = _Json_decodePrim(function(value) { + return (typeof value === 'number') + ? $elm$core$Result$Ok(value) + : _Json_expecting('a FLOAT', value); +}); + +var _Json_decodeValue = _Json_decodePrim(function(value) { + return $elm$core$Result$Ok(_Json_wrap(value)); +}); + +var _Json_decodeString = _Json_decodePrim(function(value) { + return (typeof value === 'string') + ? $elm$core$Result$Ok(value) + : (value instanceof String) + ? $elm$core$Result$Ok(value + '') + : _Json_expecting('a STRING', value); +}); + +function _Json_decodeList(decoder) { return { $: 3, b: decoder }; } +function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; } + +function _Json_decodeNull(value) { return { $: 5, c: value }; } + +var _Json_decodeField = F2(function(field, decoder) +{ + return { + $: 6, + d: field, + b: decoder + }; +}); + +var _Json_decodeIndex = F2(function(index, decoder) +{ + return { + $: 7, + e: index, + b: decoder + }; +}); + +function _Json_decodeKeyValuePairs(decoder) +{ + return { + $: 8, + b: decoder + }; +} + +function _Json_mapMany(f, decoders) +{ + return { + $: 9, + f: f, + g: decoders + }; +} + +var _Json_andThen = F2(function(callback, decoder) +{ + return { + $: 10, + b: decoder, + h: callback + }; +}); + +function _Json_oneOf(decoders) +{ + return { + $: 11, + g: decoders + }; +} + + +// DECODING OBJECTS + +var _Json_map1 = F2(function(f, d1) +{ + return _Json_mapMany(f, [d1]); +}); + +var _Json_map2 = F3(function(f, d1, d2) +{ + return _Json_mapMany(f, [d1, d2]); +}); + +var _Json_map3 = F4(function(f, d1, d2, d3) +{ + return _Json_mapMany(f, [d1, d2, d3]); +}); + +var _Json_map4 = F5(function(f, d1, d2, d3, d4) +{ + return _Json_mapMany(f, [d1, d2, d3, d4]); +}); + +var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5) +{ + return _Json_mapMany(f, [d1, d2, d3, d4, d5]); +}); + +var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6) +{ + return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]); +}); + +var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7) +{ + return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]); +}); + +var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8) +{ + return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]); +}); + + +// DECODE + +var _Json_runOnString = F2(function(decoder, string) +{ + try + { + var value = JSON.parse(string); + return _Json_runHelp(decoder, value); + } + catch (e) + { + return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string))); + } +}); + +var _Json_run = F2(function(decoder, value) +{ + return _Json_runHelp(decoder, _Json_unwrap(value)); +}); + +function _Json_runHelp(decoder, value) +{ + switch (decoder.$) + { + case 2: + return decoder.b(value); + + case 5: + return (value === null) + ? $elm$core$Result$Ok(decoder.c) + : _Json_expecting('null', value); + + case 3: + if (!_Json_isArray(value)) + { + return _Json_expecting('a LIST', value); + } + return _Json_runArrayDecoder(decoder.b, value, _List_fromArray); + + case 4: + if (!_Json_isArray(value)) + { + return _Json_expecting('an ARRAY', value); + } + return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray); + + case 6: + var field = decoder.d; + if (typeof value !== 'object' || value === null || !(field in value)) + { + return _Json_expecting('an OBJECT with a field named `' + field + '`', value); + } + var result = _Json_runHelp(decoder.b, value[field]); + return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a)); + + case 7: + var index = decoder.e; + if (!_Json_isArray(value)) + { + return _Json_expecting('an ARRAY', value); + } + if (index >= value.length) + { + return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value); + } + var result = _Json_runHelp(decoder.b, value[index]); + return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a)); + + case 8: + if (typeof value !== 'object' || value === null || _Json_isArray(value)) + { + return _Json_expecting('an OBJECT', value); + } + + var keyValuePairs = _List_Nil; + // TODO test perf of Object.keys and switch when support is good enough + for (var key in value) + { + if (value.hasOwnProperty(key)) + { + var result = _Json_runHelp(decoder.b, value[key]); + if (!$elm$core$Result$isOk(result)) + { + return $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a)); + } + keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs); + } + } + return $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs)); + + case 9: + var answer = decoder.f; + var decoders = decoder.g; + for (var i = 0; i < decoders.length; i++) + { + var result = _Json_runHelp(decoders[i], value); + if (!$elm$core$Result$isOk(result)) + { + return result; + } + answer = answer(result.a); + } + return $elm$core$Result$Ok(answer); + + case 10: + var result = _Json_runHelp(decoder.b, value); + return (!$elm$core$Result$isOk(result)) + ? result + : _Json_runHelp(decoder.h(result.a), value); + + case 11: + var errors = _List_Nil; + for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS + { + var result = _Json_runHelp(temp.a, value); + if ($elm$core$Result$isOk(result)) + { + return result; + } + errors = _List_Cons(result.a, errors); + } + return $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors))); + + case 1: + return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value))); + + case 0: + return $elm$core$Result$Ok(decoder.a); + } +} + +function _Json_runArrayDecoder(decoder, value, toElmValue) +{ + var len = value.length; + var array = new Array(len); + for (var i = 0; i < len; i++) + { + var result = _Json_runHelp(decoder, value[i]); + if (!$elm$core$Result$isOk(result)) + { + return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a)); + } + array[i] = result.a; + } + return $elm$core$Result$Ok(toElmValue(array)); +} + +function _Json_isArray(value) +{ + return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList); +} + +function _Json_toElmArray(array) +{ + return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; }); +} + +function _Json_expecting(type, value) +{ + return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value))); +} + + +// EQUALITY + +function _Json_equality(x, y) +{ + if (x === y) + { + return true; + } + + if (x.$ !== y.$) + { + return false; + } + + switch (x.$) + { + case 0: + case 1: + return x.a === y.a; + + case 2: + return x.b === y.b; + + case 5: + return x.c === y.c; + + case 3: + case 4: + case 8: + return _Json_equality(x.b, y.b); + + case 6: + return x.d === y.d && _Json_equality(x.b, y.b); + + case 7: + return x.e === y.e && _Json_equality(x.b, y.b); + + case 9: + return x.f === y.f && _Json_listEquality(x.g, y.g); + + case 10: + return x.h === y.h && _Json_equality(x.b, y.b); + + case 11: + return _Json_listEquality(x.g, y.g); + } +} + +function _Json_listEquality(aDecoders, bDecoders) +{ + var len = aDecoders.length; + if (len !== bDecoders.length) + { + return false; + } + for (var i = 0; i < len; i++) + { + if (!_Json_equality(aDecoders[i], bDecoders[i])) + { + return false; + } + } + return true; +} + + +// ENCODE + +var _Json_encode = F2(function(indentLevel, value) +{ + return JSON.stringify(_Json_unwrap(value), null, indentLevel) + ''; +}); + +function _Json_wrap(value) { return { $: 0, a: value }; } +function _Json_unwrap(value) { return value.a; } + +function _Json_wrap_UNUSED(value) { return value; } +function _Json_unwrap_UNUSED(value) { return value; } + +function _Json_emptyArray() { return []; } +function _Json_emptyObject() { return {}; } + +var _Json_addField = F3(function(key, value, object) +{ + object[key] = _Json_unwrap(value); + return object; +}); + +function _Json_addEntry(func) +{ + return F2(function(entry, array) + { + array.push(_Json_unwrap(func(entry))); + return array; + }); +} + +var _Json_encodeNull = _Json_wrap(null); + + + +// TASKS + +function _Scheduler_succeed(value) +{ + return { + $: 0, + a: value + }; +} + +function _Scheduler_fail(error) +{ + return { + $: 1, + a: error + }; +} + +function _Scheduler_binding(callback) +{ + return { + $: 2, + b: callback, + c: null + }; +} + +var _Scheduler_andThen = F2(function(callback, task) +{ + return { + $: 3, + b: callback, + d: task + }; +}); + +var _Scheduler_onError = F2(function(callback, task) +{ + return { + $: 4, + b: callback, + d: task + }; +}); + +function _Scheduler_receive(callback) +{ + return { + $: 5, + b: callback + }; +} + + +// PROCESSES + +var _Scheduler_guid = 0; + +function _Scheduler_rawSpawn(task) +{ + var proc = { + $: 0, + e: _Scheduler_guid++, + f: task, + g: null, + h: [] + }; + + _Scheduler_enqueue(proc); + + return proc; +} + +function _Scheduler_spawn(task) +{ + return _Scheduler_binding(function(callback) { + callback(_Scheduler_succeed(_Scheduler_rawSpawn(task))); + }); +} + +function _Scheduler_rawSend(proc, msg) +{ + proc.h.push(msg); + _Scheduler_enqueue(proc); +} + +var _Scheduler_send = F2(function(proc, msg) +{ + return _Scheduler_binding(function(callback) { + _Scheduler_rawSend(proc, msg); + callback(_Scheduler_succeed(_Utils_Tuple0)); + }); +}); + +function _Scheduler_kill(proc) +{ + return _Scheduler_binding(function(callback) { + var task = proc.f; + if (task.$ === 2 && task.c) + { + task.c(); + } + + proc.f = null; + + callback(_Scheduler_succeed(_Utils_Tuple0)); + }); +} + + +/* STEP PROCESSES + +type alias Process = + { $ : tag + , id : unique_id + , root : Task + , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack } + , mailbox : [msg] + } + +*/ + + +var _Scheduler_working = false; +var _Scheduler_queue = []; + + +function _Scheduler_enqueue(proc) +{ + _Scheduler_queue.push(proc); + if (_Scheduler_working) + { + return; + } + _Scheduler_working = true; + while (proc = _Scheduler_queue.shift()) + { + _Scheduler_step(proc); + } + _Scheduler_working = false; +} + + +function _Scheduler_step(proc) +{ + while (proc.f) + { + var rootTag = proc.f.$; + if (rootTag === 0 || rootTag === 1) + { + while (proc.g && proc.g.$ !== rootTag) + { + proc.g = proc.g.i; + } + if (!proc.g) + { + return; + } + proc.f = proc.g.b(proc.f.a); + proc.g = proc.g.i; + } + else if (rootTag === 2) + { + proc.f.c = proc.f.b(function(newRoot) { + proc.f = newRoot; + _Scheduler_enqueue(proc); + }); + return; + } + else if (rootTag === 5) + { + if (proc.h.length === 0) + { + return; + } + proc.f = proc.f.b(proc.h.shift()); + } + else // if (rootTag === 3 || rootTag === 4) + { + proc.g = { + $: rootTag === 3 ? 0 : 1, + b: proc.f.b, + i: proc.g + }; + proc.f = proc.f.d; + } + } +} + + + +function _Process_sleep(time) +{ + return _Scheduler_binding(function(callback) { + var id = setTimeout(function() { + callback(_Scheduler_succeed(_Utils_Tuple0)); + }, time); + + return function() { clearTimeout(id); }; + }); +} + + + + +// PROGRAMS + + +var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args) +{ + return _Platform_initialize( + flagDecoder, + args, + impl.init, + impl.update, + impl.subscriptions, + function() { return function() {} } + ); +}); + + + +// INITIALIZE A PROGRAM + + +function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder) +{ + var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined)); + $elm$core$Result$isOk(result) || _Debug_crash(2 /**/, _Json_errorToString(result.a) /**/); + var managers = {}; + var initPair = init(result.a); + var model = initPair.a; + var stepper = stepperBuilder(sendToApp, model); + var ports = _Platform_setupEffects(managers, sendToApp); + + function sendToApp(msg, viewMetadata) + { + var pair = A2(update, msg, model); + stepper(model = pair.a, viewMetadata); + _Platform_enqueueEffects(managers, pair.b, subscriptions(model)); + } + + _Platform_enqueueEffects(managers, initPair.b, subscriptions(model)); + + return ports ? { ports: ports } : {}; +} + + + +// TRACK PRELOADS +// +// This is used by code in elm/browser and elm/http +// to register any HTTP requests that are triggered by init. +// + + +var _Platform_preload; + + +function _Platform_registerPreload(url) +{ + _Platform_preload.add(url); +} + + + +// EFFECT MANAGERS + + +var _Platform_effectManagers = {}; + + +function _Platform_setupEffects(managers, sendToApp) +{ + var ports; + + // setup all necessary effect managers + for (var key in _Platform_effectManagers) + { + var manager = _Platform_effectManagers[key]; + + if (manager.a) + { + ports = ports || {}; + ports[key] = manager.a(key, sendToApp); + } + + managers[key] = _Platform_instantiateManager(manager, sendToApp); + } + + return ports; +} + + +function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap) +{ + return { + b: init, + c: onEffects, + d: onSelfMsg, + e: cmdMap, + f: subMap + }; +} + + +function _Platform_instantiateManager(info, sendToApp) +{ + var router = { + g: sendToApp, + h: undefined + }; + + var onEffects = info.c; + var onSelfMsg = info.d; + var cmdMap = info.e; + var subMap = info.f; + + function loop(state) + { + return A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg) + { + var value = msg.a; + + if (msg.$ === 0) + { + return A3(onSelfMsg, router, value, state); + } + + return cmdMap && subMap + ? A4(onEffects, router, value.i, value.j, state) + : A3(onEffects, router, cmdMap ? value.i : value.j, state); + })); + } + + return router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b)); +} + + + +// ROUTING + + +var _Platform_sendToApp = F2(function(router, msg) +{ + return _Scheduler_binding(function(callback) + { + router.g(msg); + callback(_Scheduler_succeed(_Utils_Tuple0)); + }); +}); + + +var _Platform_sendToSelf = F2(function(router, msg) +{ + return A2(_Scheduler_send, router.h, { + $: 0, + a: msg + }); +}); + + + +// BAGS + + +function _Platform_leaf(home) +{ + return function(value) + { + return { + $: 1, + k: home, + l: value + }; + }; +} + + +function _Platform_batch(list) +{ + return { + $: 2, + m: list + }; +} + + +var _Platform_map = F2(function(tagger, bag) +{ + return { + $: 3, + n: tagger, + o: bag + } +}); + + + +// PIPE BAGS INTO EFFECT MANAGERS +// +// Effects must be queued! +// +// Say your init contains a synchronous command, like Time.now or Time.here +// +// - This will produce a batch of effects (FX_1) +// - The synchronous task triggers the subsequent `update` call +// - This will produce a batch of effects (FX_2) +// +// If we just start dispatching FX_2, subscriptions from FX_2 can be processed +// before subscriptions from FX_1. No good! Earlier versions of this code had +// this problem, leading to these reports: +// +// https://github.com/elm/core/issues/980 +// https://github.com/elm/core/pull/981 +// https://github.com/elm/compiler/issues/1776 +// +// The queue is necessary to avoid ordering issues for synchronous commands. + + +// Why use true/false here? Why not just check the length of the queue? +// The goal is to detect "are we currently dispatching effects?" If we +// are, we need to bail and let the ongoing while loop handle things. +// +// Now say the queue has 1 element. When we dequeue the final element, +// the queue will be empty, but we are still actively dispatching effects. +// So you could get queue jumping in a really tricky category of cases. +// +var _Platform_effectsQueue = []; +var _Platform_effectsActive = false; + + +function _Platform_enqueueEffects(managers, cmdBag, subBag) +{ + _Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag }); + + if (_Platform_effectsActive) return; + + _Platform_effectsActive = true; + for (var fx; fx = _Platform_effectsQueue.shift(); ) + { + _Platform_dispatchEffects(fx.p, fx.q, fx.r); + } + _Platform_effectsActive = false; +} + + +function _Platform_dispatchEffects(managers, cmdBag, subBag) +{ + var effectsDict = {}; + _Platform_gatherEffects(true, cmdBag, effectsDict, null); + _Platform_gatherEffects(false, subBag, effectsDict, null); + + for (var home in managers) + { + _Scheduler_rawSend(managers[home], { + $: 'fx', + a: effectsDict[home] || { i: _List_Nil, j: _List_Nil } + }); + } +} + + +function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers) +{ + switch (bag.$) + { + case 1: + var home = bag.k; + var effect = _Platform_toEffect(isCmd, home, taggers, bag.l); + effectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]); + return; + + case 2: + for (var list = bag.m; list.b; list = list.b) // WHILE_CONS + { + _Platform_gatherEffects(isCmd, list.a, effectsDict, taggers); + } + return; + + case 3: + _Platform_gatherEffects(isCmd, bag.o, effectsDict, { + s: bag.n, + t: taggers + }); + return; + } +} + + +function _Platform_toEffect(isCmd, home, taggers, value) +{ + function applyTaggers(x) + { + for (var temp = taggers; temp; temp = temp.t) + { + x = temp.s(x); + } + return x; + } + + var map = isCmd + ? _Platform_effectManagers[home].e + : _Platform_effectManagers[home].f; + + return A2(map, applyTaggers, value) +} + + +function _Platform_insert(isCmd, newEffect, effects) +{ + effects = effects || { i: _List_Nil, j: _List_Nil }; + + isCmd + ? (effects.i = _List_Cons(newEffect, effects.i)) + : (effects.j = _List_Cons(newEffect, effects.j)); + + return effects; +} + + + +// PORTS + + +function _Platform_checkPortName(name) +{ + if (_Platform_effectManagers[name]) + { + _Debug_crash(3, name) + } +} + + + +// OUTGOING PORTS + + +function _Platform_outgoingPort(name, converter) +{ + _Platform_checkPortName(name); + _Platform_effectManagers[name] = { + e: _Platform_outgoingPortMap, + u: converter, + a: _Platform_setupOutgoingPort + }; + return _Platform_leaf(name); +} + + +var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; }); + + +function _Platform_setupOutgoingPort(name) +{ + var subs = []; + var converter = _Platform_effectManagers[name].u; + + // CREATE MANAGER + + var init = _Process_sleep(0); + + _Platform_effectManagers[name].b = init; + _Platform_effectManagers[name].c = F3(function(router, cmdList, state) + { + for ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS + { + // grab a separate reference to subs in case unsubscribe is called + var currentSubs = subs; + var value = _Json_unwrap(converter(cmdList.a)); + for (var i = 0; i < currentSubs.length; i++) + { + currentSubs[i](value); + } + } + return init; + }); + + // PUBLIC API + + function subscribe(callback) + { + subs.push(callback); + } + + function unsubscribe(callback) + { + // copy subs into a new array in case unsubscribe is called within a + // subscribed callback + subs = subs.slice(); + var index = subs.indexOf(callback); + if (index >= 0) + { + subs.splice(index, 1); + } + } + + return { + subscribe: subscribe, + unsubscribe: unsubscribe + }; +} + + + +// INCOMING PORTS + + +function _Platform_incomingPort(name, converter) +{ + _Platform_checkPortName(name); + _Platform_effectManagers[name] = { + f: _Platform_incomingPortMap, + u: converter, + a: _Platform_setupIncomingPort + }; + return _Platform_leaf(name); +} + + +var _Platform_incomingPortMap = F2(function(tagger, finalTagger) +{ + return function(value) + { + return tagger(finalTagger(value)); + }; +}); + + +function _Platform_setupIncomingPort(name, sendToApp) +{ + var subs = _List_Nil; + var converter = _Platform_effectManagers[name].u; + + // CREATE MANAGER + + var init = _Scheduler_succeed(null); + + _Platform_effectManagers[name].b = init; + _Platform_effectManagers[name].c = F3(function(router, subList, state) + { + subs = subList; + return init; + }); + + // PUBLIC API + + function send(incomingValue) + { + var result = A2(_Json_run, converter, _Json_wrap(incomingValue)); + + $elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a); + + var value = result.a; + for (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS + { + sendToApp(temp.a(value)); + } + } + + return { send: send }; +} + + + +// EXPORT ELM MODULES +// +// Have DEBUG and PROD versions so that we can (1) give nicer errors in +// debug mode and (2) not pay for the bits needed for that in prod mode. +// + + +function _Platform_export_UNUSED(exports) +{ + scope['Elm'] + ? _Platform_mergeExportsProd(scope['Elm'], exports) + : scope['Elm'] = exports; +} + + +function _Platform_mergeExportsProd(obj, exports) +{ + for (var name in exports) + { + (name in obj) + ? (name == 'init') + ? _Debug_crash(6) + : _Platform_mergeExportsProd(obj[name], exports[name]) + : (obj[name] = exports[name]); + } +} + + +function _Platform_export(exports) +{ + scope['Elm'] + ? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports) + : scope['Elm'] = exports; +} + + +function _Platform_mergeExportsDebug(moduleName, obj, exports) +{ + for (var name in exports) + { + (name in obj) + ? (name == 'init') + ? _Debug_crash(6, moduleName) + : _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name]) + : (obj[name] = exports[name]); + } +} + + + + +// HELPERS + + +var _VirtualDom_divertHrefToApp; + +var _VirtualDom_doc = typeof document !== 'undefined' ? document : {}; + + +function _VirtualDom_appendChild(parent, child) +{ + parent.appendChild(child); +} + +var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args) +{ + // NOTE: this function needs _Platform_export available to work + + /**_UNUSED/ + var node = args['node']; + //*/ + /**/ + var node = args && args['node'] ? args['node'] : _Debug_crash(0); + //*/ + + node.parentNode.replaceChild( + _VirtualDom_render(virtualNode, function() {}), + node + ); + + return {}; +}); + + + +// TEXT + + +function _VirtualDom_text(string) +{ + return { + $: 0, + a: string + }; +} + + + +// NODE + + +var _VirtualDom_nodeNS = F2(function(namespace, tag) +{ + return F2(function(factList, kidList) + { + for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS + { + var kid = kidList.a; + descendantsCount += (kid.b || 0); + kids.push(kid); + } + descendantsCount += kids.length; + + return { + $: 1, + c: tag, + d: _VirtualDom_organizeFacts(factList), + e: kids, + f: namespace, + b: descendantsCount + }; + }); +}); + + +var _VirtualDom_node = _VirtualDom_nodeNS(undefined); + + + +// KEYED NODE + + +var _VirtualDom_keyedNodeNS = F2(function(namespace, tag) +{ + return F2(function(factList, kidList) + { + for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS + { + var kid = kidList.a; + descendantsCount += (kid.b.b || 0); + kids.push(kid); + } + descendantsCount += kids.length; + + return { + $: 2, + c: tag, + d: _VirtualDom_organizeFacts(factList), + e: kids, + f: namespace, + b: descendantsCount + }; + }); +}); + + +var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined); + + + +// CUSTOM + + +function _VirtualDom_custom(factList, model, render, diff) +{ + return { + $: 3, + d: _VirtualDom_organizeFacts(factList), + g: model, + h: render, + i: diff + }; +} + + + +// MAP + + +var _VirtualDom_map = F2(function(tagger, node) +{ + return { + $: 4, + j: tagger, + k: node, + b: 1 + (node.b || 0) + }; +}); + + + +// LAZY + + +function _VirtualDom_thunk(refs, thunk) +{ + return { + $: 5, + l: refs, + m: thunk, + k: undefined + }; +} + +var _VirtualDom_lazy = F2(function(func, a) +{ + return _VirtualDom_thunk([func, a], function() { + return func(a); + }); +}); + +var _VirtualDom_lazy2 = F3(function(func, a, b) +{ + return _VirtualDom_thunk([func, a, b], function() { + return A2(func, a, b); + }); +}); + +var _VirtualDom_lazy3 = F4(function(func, a, b, c) +{ + return _VirtualDom_thunk([func, a, b, c], function() { + return A3(func, a, b, c); + }); +}); + +var _VirtualDom_lazy4 = F5(function(func, a, b, c, d) +{ + return _VirtualDom_thunk([func, a, b, c, d], function() { + return A4(func, a, b, c, d); + }); +}); + +var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e) +{ + return _VirtualDom_thunk([func, a, b, c, d, e], function() { + return A5(func, a, b, c, d, e); + }); +}); + +var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f) +{ + return _VirtualDom_thunk([func, a, b, c, d, e, f], function() { + return A6(func, a, b, c, d, e, f); + }); +}); + +var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g) +{ + return _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() { + return A7(func, a, b, c, d, e, f, g); + }); +}); + +var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h) +{ + return _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() { + return A8(func, a, b, c, d, e, f, g, h); + }); +}); + + + +// FACTS + + +var _VirtualDom_on = F2(function(key, handler) +{ + return { + $: 'a0', + n: key, + o: handler + }; +}); +var _VirtualDom_style = F2(function(key, value) +{ + return { + $: 'a1', + n: key, + o: value + }; +}); +var _VirtualDom_property = F2(function(key, value) +{ + return { + $: 'a2', + n: key, + o: value + }; +}); +var _VirtualDom_attribute = F2(function(key, value) +{ + return { + $: 'a3', + n: key, + o: value + }; +}); +var _VirtualDom_attributeNS = F3(function(namespace, key, value) +{ + return { + $: 'a4', + n: key, + o: { f: namespace, o: value } + }; +}); + + + +// XSS ATTACK VECTOR CHECKS +// +// For some reason, tabs can appear in href protocols and it still works. +// So '\tjava\tSCRIPT:alert("!!!")' and 'javascript:alert("!!!")' are the same +// in practice. That is why _VirtualDom_RE_js and _VirtualDom_RE_js_html look +// so freaky. +// +// Pulling the regular expressions out to the top level gives a slight speed +// boost in small benchmarks (4-10%) but hoisting values to reduce allocation +// can be unpredictable in large programs where JIT may have a harder time with +// functions are not fully self-contained. The benefit is more that the js and +// js_html ones are so weird that I prefer to see them near each other. + + +var _VirtualDom_RE_script = /^script$/i; +var _VirtualDom_RE_on_formAction = /^(on|formAction$)/i; +var _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; +var _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; + + +function _VirtualDom_noScript(tag) +{ + return _VirtualDom_RE_script.test(tag) ? 'p' : tag; +} + +function _VirtualDom_noOnOrFormAction(key) +{ + return _VirtualDom_RE_on_formAction.test(key) ? 'data-' + key : key; +} + +function _VirtualDom_noInnerHtmlOrFormAction(key) +{ + return key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key; +} + +function _VirtualDom_noJavaScriptUri(value) +{ + return _VirtualDom_RE_js.test(value) + ? /**_UNUSED/''//*//**/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/ + : value; +} + +function _VirtualDom_noJavaScriptOrHtmlUri(value) +{ + return _VirtualDom_RE_js_html.test(value) + ? /**_UNUSED/''//*//**/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/ + : value; +} + +function _VirtualDom_noJavaScriptOrHtmlJson(value) +{ + return (typeof _Json_unwrap(value) === 'string' && _VirtualDom_RE_js_html.test(_Json_unwrap(value))) + ? _Json_wrap( + /**_UNUSED/''//*//**/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/ + ) : value; +} + + + +// MAP FACTS + + +var _VirtualDom_mapAttribute = F2(function(func, attr) +{ + return (attr.$ === 'a0') + ? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o)) + : attr; +}); + +function _VirtualDom_mapHandler(func, handler) +{ + var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler); + + // 0 = Normal + // 1 = MayStopPropagation + // 2 = MayPreventDefault + // 3 = Custom + + return { + $: handler.$, + a: + !tag + ? A2($elm$json$Json$Decode$map, func, handler.a) + : + A3($elm$json$Json$Decode$map2, + tag < 3 + ? _VirtualDom_mapEventTuple + : _VirtualDom_mapEventRecord, + $elm$json$Json$Decode$succeed(func), + handler.a + ) + }; +} + +var _VirtualDom_mapEventTuple = F2(function(func, tuple) +{ + return _Utils_Tuple2(func(tuple.a), tuple.b); +}); + +var _VirtualDom_mapEventRecord = F2(function(func, record) +{ + return { + message: func(record.message), + stopPropagation: record.stopPropagation, + preventDefault: record.preventDefault + } +}); + + + +// ORGANIZE FACTS + + +function _VirtualDom_organizeFacts(factList) +{ + for (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS + { + var entry = factList.a; + + var tag = entry.$; + var key = entry.n; + var value = entry.o; + + if (tag === 'a2') + { + (key === 'className') + ? _VirtualDom_addClass(facts, key, _Json_unwrap(value)) + : facts[key] = _Json_unwrap(value); + + continue; + } + + var subFacts = facts[tag] || (facts[tag] = {}); + (tag === 'a3' && key === 'class') + ? _VirtualDom_addClass(subFacts, key, value) + : subFacts[key] = value; + } + + return facts; +} + +function _VirtualDom_addClass(object, key, newClass) +{ + var classes = object[key]; + object[key] = classes ? classes + ' ' + newClass : newClass; +} + + + +// RENDER + + +function _VirtualDom_render(vNode, eventNode) +{ + var tag = vNode.$; + + if (tag === 5) + { + return _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode); + } + + if (tag === 0) + { + return _VirtualDom_doc.createTextNode(vNode.a); + } + + if (tag === 4) + { + var subNode = vNode.k; + var tagger = vNode.j; + + while (subNode.$ === 4) + { + typeof tagger !== 'object' + ? tagger = [tagger, subNode.j] + : tagger.push(subNode.j); + + subNode = subNode.k; + } + + var subEventRoot = { j: tagger, p: eventNode }; + var domNode = _VirtualDom_render(subNode, subEventRoot); + domNode.elm_event_node_ref = subEventRoot; + return domNode; + } + + if (tag === 3) + { + var domNode = vNode.h(vNode.g); + _VirtualDom_applyFacts(domNode, eventNode, vNode.d); + return domNode; + } + + // at this point `tag` must be 1 or 2 + + var domNode = vNode.f + ? _VirtualDom_doc.createElementNS(vNode.f, vNode.c) + : _VirtualDom_doc.createElement(vNode.c); + + if (_VirtualDom_divertHrefToApp && vNode.c == 'a') + { + domNode.addEventListener('click', _VirtualDom_divertHrefToApp(domNode)); + } + + _VirtualDom_applyFacts(domNode, eventNode, vNode.d); + + for (var kids = vNode.e, i = 0; i < kids.length; i++) + { + _VirtualDom_appendChild(domNode, _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode)); + } + + return domNode; +} + + + +// APPLY FACTS + + +function _VirtualDom_applyFacts(domNode, eventNode, facts) +{ + for (var key in facts) + { + var value = facts[key]; + + key === 'a1' + ? _VirtualDom_applyStyles(domNode, value) + : + key === 'a0' + ? _VirtualDom_applyEvents(domNode, eventNode, value) + : + key === 'a3' + ? _VirtualDom_applyAttrs(domNode, value) + : + key === 'a4' + ? _VirtualDom_applyAttrsNS(domNode, value) + : + ((key !== 'value' && key !== 'checked') || domNode[key] !== value) && (domNode[key] = value); + } +} + + + +// APPLY STYLES + + +function _VirtualDom_applyStyles(domNode, styles) +{ + var domNodeStyle = domNode.style; + + for (var key in styles) + { + domNodeStyle[key] = styles[key]; + } +} + + + +// APPLY ATTRS + + +function _VirtualDom_applyAttrs(domNode, attrs) +{ + for (var key in attrs) + { + var value = attrs[key]; + typeof value !== 'undefined' + ? domNode.setAttribute(key, value) + : domNode.removeAttribute(key); + } +} + + + +// APPLY NAMESPACED ATTRS + + +function _VirtualDom_applyAttrsNS(domNode, nsAttrs) +{ + for (var key in nsAttrs) + { + var pair = nsAttrs[key]; + var namespace = pair.f; + var value = pair.o; + + typeof value !== 'undefined' + ? domNode.setAttributeNS(namespace, key, value) + : domNode.removeAttributeNS(namespace, key); + } +} + + + +// APPLY EVENTS + + +function _VirtualDom_applyEvents(domNode, eventNode, events) +{ + var allCallbacks = domNode.elmFs || (domNode.elmFs = {}); + + for (var key in events) + { + var newHandler = events[key]; + var oldCallback = allCallbacks[key]; + + if (!newHandler) + { + domNode.removeEventListener(key, oldCallback); + allCallbacks[key] = undefined; + continue; + } + + if (oldCallback) + { + var oldHandler = oldCallback.q; + if (oldHandler.$ === newHandler.$) + { + oldCallback.q = newHandler; + continue; + } + domNode.removeEventListener(key, oldCallback); + } + + oldCallback = _VirtualDom_makeCallback(eventNode, newHandler); + domNode.addEventListener(key, oldCallback, + _VirtualDom_passiveSupported + && { passive: $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 } + ); + allCallbacks[key] = oldCallback; + } +} + + + +// PASSIVE EVENTS + + +var _VirtualDom_passiveSupported; + +try +{ + window.addEventListener('t', null, Object.defineProperty({}, 'passive', { + get: function() { _VirtualDom_passiveSupported = true; } + })); +} +catch(e) {} + + + +// EVENT HANDLERS + + +function _VirtualDom_makeCallback(eventNode, initialHandler) +{ + function callback(event) + { + var handler = callback.q; + var result = _Json_runHelp(handler.a, event); + + if (!$elm$core$Result$isOk(result)) + { + return; + } + + var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler); + + // 0 = Normal + // 1 = MayStopPropagation + // 2 = MayPreventDefault + // 3 = Custom + + var value = result.a; + var message = !tag ? value : tag < 3 ? value.a : value.message; + var stopPropagation = tag == 1 ? value.b : tag == 3 && value.stopPropagation; + var currentEventNode = ( + stopPropagation && event.stopPropagation(), + (tag == 2 ? value.b : tag == 3 && value.preventDefault) && event.preventDefault(), + eventNode + ); + var tagger; + var i; + while (tagger = currentEventNode.j) + { + if (typeof tagger == 'function') + { + message = tagger(message); + } + else + { + for (var i = tagger.length; i--; ) + { + message = tagger[i](message); + } + } + currentEventNode = currentEventNode.p; + } + currentEventNode(message, stopPropagation); // stopPropagation implies isSync + } + + callback.q = initialHandler; + + return callback; +} + +function _VirtualDom_equalEvents(x, y) +{ + return x.$ == y.$ && _Json_equality(x.a, y.a); +} + + + +// DIFF + + +// TODO: Should we do patches like in iOS? +// +// type Patch +// = At Int Patch +// | Batch (List Patch) +// | Change ... +// +// How could it not be better? +// +function _VirtualDom_diff(x, y) +{ + var patches = []; + _VirtualDom_diffHelp(x, y, patches, 0); + return patches; +} + + +function _VirtualDom_pushPatch(patches, type, index, data) +{ + var patch = { + $: type, + r: index, + s: data, + t: undefined, + u: undefined + }; + patches.push(patch); + return patch; +} + + +function _VirtualDom_diffHelp(x, y, patches, index) +{ + if (x === y) + { + return; + } + + var xType = x.$; + var yType = y.$; + + // Bail if you run into different types of nodes. Implies that the + // structure has changed significantly and it's not worth a diff. + if (xType !== yType) + { + if (xType === 1 && yType === 2) + { + y = _VirtualDom_dekey(y); + yType = 1; + } + else + { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } + } + + // Now we know that both nodes are the same $. + switch (yType) + { + case 5: + var xRefs = x.l; + var yRefs = y.l; + var i = xRefs.length; + var same = i === yRefs.length; + while (same && i--) + { + same = xRefs[i] === yRefs[i]; + } + if (same) + { + y.k = x.k; + return; + } + y.k = y.m(); + var subPatches = []; + _VirtualDom_diffHelp(x.k, y.k, subPatches, 0); + subPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches); + return; + + case 4: + // gather nested taggers + var xTaggers = x.j; + var yTaggers = y.j; + var nesting = false; + + var xSubNode = x.k; + while (xSubNode.$ === 4) + { + nesting = true; + + typeof xTaggers !== 'object' + ? xTaggers = [xTaggers, xSubNode.j] + : xTaggers.push(xSubNode.j); + + xSubNode = xSubNode.k; + } + + var ySubNode = y.k; + while (ySubNode.$ === 4) + { + nesting = true; + + typeof yTaggers !== 'object' + ? yTaggers = [yTaggers, ySubNode.j] + : yTaggers.push(ySubNode.j); + + ySubNode = ySubNode.k; + } + + // Just bail if different numbers of taggers. This implies the + // structure of the virtual DOM has changed. + if (nesting && xTaggers.length !== yTaggers.length) + { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } + + // check if taggers are "the same" + if (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers) + { + _VirtualDom_pushPatch(patches, 2, index, yTaggers); + } + + // diff everything below the taggers + _VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1); + return; + + case 0: + if (x.a !== y.a) + { + _VirtualDom_pushPatch(patches, 3, index, y.a); + } + return; + + case 1: + _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids); + return; + + case 2: + _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids); + return; + + case 3: + if (x.h !== y.h) + { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } + + var factsDiff = _VirtualDom_diffFacts(x.d, y.d); + factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff); + + var patch = y.i(x.g, y.g); + patch && _VirtualDom_pushPatch(patches, 5, index, patch); + + return; + } +} + +// assumes the incoming arrays are the same length +function _VirtualDom_pairwiseRefEqual(as, bs) +{ + for (var i = 0; i < as.length; i++) + { + if (as[i] !== bs[i]) + { + return false; + } + } + + return true; +} + +function _VirtualDom_diffNodes(x, y, patches, index, diffKids) +{ + // Bail if obvious indicators have changed. Implies more serious + // structural changes such that it's not worth it to diff. + if (x.c !== y.c || x.f !== y.f) + { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } + + var factsDiff = _VirtualDom_diffFacts(x.d, y.d); + factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff); + + diffKids(x, y, patches, index); +} + + + +// DIFF FACTS + + +// TODO Instead of creating a new diff object, it's possible to just test if +// there *is* a diff. During the actual patch, do the diff again and make the +// modifications directly. This way, there's no new allocations. Worth it? +function _VirtualDom_diffFacts(x, y, category) +{ + var diff; + + // look for changes and removals + for (var xKey in x) + { + if (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4') + { + var subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey); + if (subDiff) + { + diff = diff || {}; + diff[xKey] = subDiff; + } + continue; + } + + // remove if not in the new facts + if (!(xKey in y)) + { + diff = diff || {}; + diff[xKey] = + !category + ? (typeof x[xKey] === 'string' ? '' : null) + : + (category === 'a1') + ? '' + : + (category === 'a0' || category === 'a3') + ? undefined + : + { f: x[xKey].f, o: undefined }; + + continue; + } + + var xValue = x[xKey]; + var yValue = y[xKey]; + + // reference equal, so don't worry about it + if (xValue === yValue && xKey !== 'value' && xKey !== 'checked' + || category === 'a0' && _VirtualDom_equalEvents(xValue, yValue)) + { + continue; + } + + diff = diff || {}; + diff[xKey] = yValue; + } + + // add new stuff + for (var yKey in y) + { + if (!(yKey in x)) + { + diff = diff || {}; + diff[yKey] = y[yKey]; + } + } + + return diff; +} + + + +// DIFF KIDS + + +function _VirtualDom_diffKids(xParent, yParent, patches, index) +{ + var xKids = xParent.e; + var yKids = yParent.e; + + var xLen = xKids.length; + var yLen = yKids.length; + + // FIGURE OUT IF THERE ARE INSERTS OR REMOVALS + + if (xLen > yLen) + { + _VirtualDom_pushPatch(patches, 6, index, { + v: yLen, + i: xLen - yLen + }); + } + else if (xLen < yLen) + { + _VirtualDom_pushPatch(patches, 7, index, { + v: xLen, + e: yKids + }); + } + + // PAIRWISE DIFF EVERYTHING ELSE + + for (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++) + { + var xKid = xKids[i]; + _VirtualDom_diffHelp(xKid, yKids[i], patches, ++index); + index += xKid.b || 0; + } +} + + + +// KEYED DIFF + + +function _VirtualDom_diffKeyedKids(xParent, yParent, patches, rootIndex) +{ + var localPatches = []; + + var changes = {}; // Dict String Entry + var inserts = []; // Array { index : Int, entry : Entry } + // type Entry = { tag : String, vnode : VNode, index : Int, data : _ } + + var xKids = xParent.e; + var yKids = yParent.e; + var xLen = xKids.length; + var yLen = yKids.length; + var xIndex = 0; + var yIndex = 0; + + var index = rootIndex; + + while (xIndex < xLen && yIndex < yLen) + { + var x = xKids[xIndex]; + var y = yKids[yIndex]; + + var xKey = x.a; + var yKey = y.a; + var xNode = x.b; + var yNode = y.b; + + var newMatch = undefined; + var oldMatch = undefined; + + // check if keys match + + if (xKey === yKey) + { + index++; + _VirtualDom_diffHelp(xNode, yNode, localPatches, index); + index += xNode.b || 0; + + xIndex++; + yIndex++; + continue; + } + + // look ahead 1 to detect insertions and removals. + + var xNext = xKids[xIndex + 1]; + var yNext = yKids[yIndex + 1]; + + if (xNext) + { + var xNextKey = xNext.a; + var xNextNode = xNext.b; + oldMatch = yKey === xNextKey; + } + + if (yNext) + { + var yNextKey = yNext.a; + var yNextNode = yNext.b; + newMatch = xKey === yNextKey; + } + + + // swap x and y + if (newMatch && oldMatch) + { + index++; + _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index); + _VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts); + index += xNode.b || 0; + + index++; + _VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index); + index += xNextNode.b || 0; + + xIndex += 2; + yIndex += 2; + continue; + } + + // insert y + if (newMatch) + { + index++; + _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts); + _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index); + index += xNode.b || 0; + + xIndex += 1; + yIndex += 2; + continue; + } + + // remove x + if (oldMatch) + { + index++; + _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index); + index += xNode.b || 0; + + index++; + _VirtualDom_diffHelp(xNextNode, yNode, localPatches, index); + index += xNextNode.b || 0; + + xIndex += 2; + yIndex += 1; + continue; + } + + // remove x, insert y + if (xNext && xNextKey === yNextKey) + { + index++; + _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index); + _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts); + index += xNode.b || 0; + + index++; + _VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index); + index += xNextNode.b || 0; + + xIndex += 2; + yIndex += 2; + continue; + } + + break; + } + + // eat up any remaining nodes with removeNode and insertNode + + while (xIndex < xLen) + { + index++; + var x = xKids[xIndex]; + var xNode = x.b; + _VirtualDom_removeNode(changes, localPatches, x.a, xNode, index); + index += xNode.b || 0; + xIndex++; + } + + while (yIndex < yLen) + { + var endInserts = endInserts || []; + var y = yKids[yIndex]; + _VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts); + yIndex++; + } + + if (localPatches.length > 0 || inserts.length > 0 || endInserts) + { + _VirtualDom_pushPatch(patches, 8, rootIndex, { + w: localPatches, + x: inserts, + y: endInserts + }); + } +} + + + +// CHANGES FROM KEYED DIFF + + +var _VirtualDom_POSTFIX = '_elmW6BL'; + + +function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts) +{ + var entry = changes[key]; + + // never seen this key before + if (!entry) + { + entry = { + c: 0, + z: vnode, + r: yIndex, + s: undefined + }; + + inserts.push({ r: yIndex, A: entry }); + changes[key] = entry; + + return; + } + + // this key was removed earlier, a match! + if (entry.c === 1) + { + inserts.push({ r: yIndex, A: entry }); + + entry.c = 2; + var subPatches = []; + _VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r); + entry.r = yIndex; + entry.s.s = { + w: subPatches, + A: entry + }; + + return; + } + + // this key has already been inserted or moved, a duplicate! + _VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts); +} + + +function _VirtualDom_removeNode(changes, localPatches, key, vnode, index) +{ + var entry = changes[key]; + + // never seen this key before + if (!entry) + { + var patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined); + + changes[key] = { + c: 1, + z: vnode, + r: index, + s: patch + }; + + return; + } + + // this key was inserted earlier, a match! + if (entry.c === 0) + { + entry.c = 2; + var subPatches = []; + _VirtualDom_diffHelp(vnode, entry.z, subPatches, index); + + _VirtualDom_pushPatch(localPatches, 9, index, { + w: subPatches, + A: entry + }); + + return; + } + + // this key has already been removed or moved, a duplicate! + _VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, index); +} + + + +// ADD DOM NODES +// +// Each DOM node has an "index" assigned in order of traversal. It is important +// to minimize our crawl over the actual DOM, so these indexes (along with the +// descendantsCount of virtual nodes) let us skip touching entire subtrees of +// the DOM if we know there are no patches there. + + +function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode) +{ + _VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode); +} + + +// assumes `patches` is non-empty and indexes increase monotonically. +function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode) +{ + var patch = patches[i]; + var index = patch.r; + + while (index === low) + { + var patchType = patch.$; + + if (patchType === 1) + { + _VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode); + } + else if (patchType === 8) + { + patch.t = domNode; + patch.u = eventNode; + + var subPatches = patch.s.w; + if (subPatches.length > 0) + { + _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode); + } + } + else if (patchType === 9) + { + patch.t = domNode; + patch.u = eventNode; + + var data = patch.s; + if (data) + { + data.A.s = domNode; + var subPatches = data.w; + if (subPatches.length > 0) + { + _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode); + } + } + } + else + { + patch.t = domNode; + patch.u = eventNode; + } + + i++; + + if (!(patch = patches[i]) || (index = patch.r) > high) + { + return i; + } + } + + var tag = vNode.$; + + if (tag === 4) + { + var subNode = vNode.k; + + while (subNode.$ === 4) + { + subNode = subNode.k; + } + + return _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref); + } + + // tag must be 1 or 2 at this point + + var vKids = vNode.e; + var childNodes = domNode.childNodes; + for (var j = 0; j < vKids.length; j++) + { + low++; + var vKid = tag === 1 ? vKids[j] : vKids[j].b; + var nextLow = low + (vKid.b || 0); + if (low <= index && index <= nextLow) + { + i = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode); + if (!(patch = patches[i]) || (index = patch.r) > high) + { + return i; + } + } + low = nextLow; + } + return i; +} + + + +// APPLY PATCHES + + +function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode) +{ + if (patches.length === 0) + { + return rootDomNode; + } + + _VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode); + return _VirtualDom_applyPatchesHelp(rootDomNode, patches); +} + +function _VirtualDom_applyPatchesHelp(rootDomNode, patches) +{ + for (var i = 0; i < patches.length; i++) + { + var patch = patches[i]; + var localDomNode = patch.t + var newNode = _VirtualDom_applyPatch(localDomNode, patch); + if (localDomNode === rootDomNode) + { + rootDomNode = newNode; + } + } + return rootDomNode; +} + +function _VirtualDom_applyPatch(domNode, patch) +{ + switch (patch.$) + { + case 0: + return _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u); + + case 4: + _VirtualDom_applyFacts(domNode, patch.u, patch.s); + return domNode; + + case 3: + domNode.replaceData(0, domNode.length, patch.s); + return domNode; + + case 1: + return _VirtualDom_applyPatchesHelp(domNode, patch.s); + + case 2: + if (domNode.elm_event_node_ref) + { + domNode.elm_event_node_ref.j = patch.s; + } + else + { + domNode.elm_event_node_ref = { j: patch.s, p: patch.u }; + } + return domNode; + + case 6: + var data = patch.s; + for (var i = 0; i < data.i; i++) + { + domNode.removeChild(domNode.childNodes[data.v]); + } + return domNode; + + case 7: + var data = patch.s; + var kids = data.e; + var i = data.v; + var theEnd = domNode.childNodes[i]; + for (; i < kids.length; i++) + { + domNode.insertBefore(_VirtualDom_render(kids[i], patch.u), theEnd); + } + return domNode; + + case 9: + var data = patch.s; + if (!data) + { + domNode.parentNode.removeChild(domNode); + return domNode; + } + var entry = data.A; + if (typeof entry.r !== 'undefined') + { + domNode.parentNode.removeChild(domNode); + } + entry.s = _VirtualDom_applyPatchesHelp(domNode, data.w); + return domNode; + + case 8: + return _VirtualDom_applyPatchReorder(domNode, patch); + + case 5: + return patch.s(domNode); + + default: + _Debug_crash(10); // 'Ran into an unknown patch!' + } +} + + +function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode) +{ + var parentNode = domNode.parentNode; + var newNode = _VirtualDom_render(vNode, eventNode); + + if (!newNode.elm_event_node_ref) + { + newNode.elm_event_node_ref = domNode.elm_event_node_ref; + } + + if (parentNode && newNode !== domNode) + { + parentNode.replaceChild(newNode, domNode); + } + return newNode; +} + + +function _VirtualDom_applyPatchReorder(domNode, patch) +{ + var data = patch.s; + + // remove end inserts + var frag = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch); + + // removals + domNode = _VirtualDom_applyPatchesHelp(domNode, data.w); + + // inserts + var inserts = data.x; + for (var i = 0; i < inserts.length; i++) + { + var insert = inserts[i]; + var entry = insert.A; + var node = entry.c === 2 + ? entry.s + : _VirtualDom_render(entry.z, patch.u); + domNode.insertBefore(node, domNode.childNodes[insert.r]); + } + + // add end inserts + if (frag) + { + _VirtualDom_appendChild(domNode, frag); + } + + return domNode; +} + + +function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch) +{ + if (!endInserts) + { + return; + } + + var frag = _VirtualDom_doc.createDocumentFragment(); + for (var i = 0; i < endInserts.length; i++) + { + var insert = endInserts[i]; + var entry = insert.A; + _VirtualDom_appendChild(frag, entry.c === 2 + ? entry.s + : _VirtualDom_render(entry.z, patch.u) + ); + } + return frag; +} + + +function _VirtualDom_virtualize(node) +{ + // TEXT NODES + + if (node.nodeType === 3) + { + return _VirtualDom_text(node.textContent); + } + + + // WEIRD NODES + + if (node.nodeType !== 1) + { + return _VirtualDom_text(''); + } + + + // ELEMENT NODES + + var attrList = _List_Nil; + var attrs = node.attributes; + for (var i = attrs.length; i--; ) + { + var attr = attrs[i]; + var name = attr.name; + var value = attr.value; + attrList = _List_Cons( A2(_VirtualDom_attribute, name, value), attrList ); + } + + var tag = node.tagName.toLowerCase(); + var kidList = _List_Nil; + var kids = node.childNodes; + + for (var i = kids.length; i--; ) + { + kidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList); + } + return A3(_VirtualDom_node, tag, attrList, kidList); +} + +function _VirtualDom_dekey(keyedNode) +{ + var keyedKids = keyedNode.e; + var len = keyedKids.length; + var kids = new Array(len); + for (var i = 0; i < len; i++) + { + kids[i] = keyedKids[i].b; + } + + return { + $: 1, + c: keyedNode.c, + d: keyedNode.d, + e: kids, + f: keyedNode.f, + b: keyedNode.b + }; +} + + + + +// ELEMENT + + +var _Debugger_element; + +var _Browser_element = _Debugger_element || F4(function(impl, flagDecoder, debugMetadata, args) +{ + return _Platform_initialize( + flagDecoder, + args, + impl.init, + impl.update, + impl.subscriptions, + function(sendToApp, initialModel) { + var view = impl.view; + /**_UNUSED/ + var domNode = args['node']; + //*/ + /**/ + var domNode = args && args['node'] ? args['node'] : _Debug_crash(0); + //*/ + var currNode = _VirtualDom_virtualize(domNode); + + return _Browser_makeAnimator(initialModel, function(model) + { + var nextNode = view(model); + var patches = _VirtualDom_diff(currNode, nextNode); + domNode = _VirtualDom_applyPatches(domNode, currNode, patches, sendToApp); + currNode = nextNode; + }); + } + ); +}); + + + +// DOCUMENT + + +var _Debugger_document; + +var _Browser_document = _Debugger_document || F4(function(impl, flagDecoder, debugMetadata, args) +{ + return _Platform_initialize( + flagDecoder, + args, + impl.init, + impl.update, + impl.subscriptions, + function(sendToApp, initialModel) { + var divertHrefToApp = impl.setup && impl.setup(sendToApp) + var view = impl.view; + var title = _VirtualDom_doc.title; + var bodyNode = _VirtualDom_doc.body; + var currNode = _VirtualDom_virtualize(bodyNode); + return _Browser_makeAnimator(initialModel, function(model) + { + _VirtualDom_divertHrefToApp = divertHrefToApp; + var doc = view(model); + var nextNode = _VirtualDom_node('body')(_List_Nil)(doc.body); + var patches = _VirtualDom_diff(currNode, nextNode); + bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp); + currNode = nextNode; + _VirtualDom_divertHrefToApp = 0; + (title !== doc.title) && (_VirtualDom_doc.title = title = doc.title); + }); + } + ); +}); + + + +// ANIMATION + + +var _Browser_cancelAnimationFrame = + typeof cancelAnimationFrame !== 'undefined' + ? cancelAnimationFrame + : function(id) { clearTimeout(id); }; + +var _Browser_requestAnimationFrame = + typeof requestAnimationFrame !== 'undefined' + ? requestAnimationFrame + : function(callback) { return setTimeout(callback, 1000 / 60); }; + + +function _Browser_makeAnimator(model, draw) +{ + draw(model); + + var state = 0; + + function updateIfNeeded() + { + state = state === 1 + ? 0 + : ( _Browser_requestAnimationFrame(updateIfNeeded), draw(model), 1 ); + } + + return function(nextModel, isSync) + { + model = nextModel; + + isSync + ? ( draw(model), + state === 2 && (state = 1) + ) + : ( state === 0 && _Browser_requestAnimationFrame(updateIfNeeded), + state = 2 + ); + }; +} + + + +// APPLICATION + + +function _Browser_application(impl) +{ + var onUrlChange = impl.onUrlChange; + var onUrlRequest = impl.onUrlRequest; + var key = function() { key.a(onUrlChange(_Browser_getUrl())); }; + + return _Browser_document({ + setup: function(sendToApp) + { + key.a = sendToApp; + _Browser_window.addEventListener('popstate', key); + _Browser_window.navigator.userAgent.indexOf('Trident') < 0 || _Browser_window.addEventListener('hashchange', key); + + return F2(function(domNode, event) + { + if (!event.ctrlKey && !event.metaKey && !event.shiftKey && event.button < 1 && !domNode.target && !domNode.hasAttribute('download')) + { + event.preventDefault(); + var href = domNode.href; + var curr = _Browser_getUrl(); + var next = $elm$url$Url$fromString(href).a; + sendToApp(onUrlRequest( + (next + && curr.protocol === next.protocol + && curr.host === next.host + && curr.port_.a === next.port_.a + ) + ? $elm$browser$Browser$Internal(next) + : $elm$browser$Browser$External(href) + )); + } + }); + }, + init: function(flags) + { + return A3(impl.init, flags, _Browser_getUrl(), key); + }, + view: impl.view, + update: impl.update, + subscriptions: impl.subscriptions + }); +} + +function _Browser_getUrl() +{ + return $elm$url$Url$fromString(_VirtualDom_doc.location.href).a || _Debug_crash(1); +} + +var _Browser_go = F2(function(key, n) +{ + return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() { + n && history.go(n); + key(); + })); +}); + +var _Browser_pushUrl = F2(function(key, url) +{ + return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() { + history.pushState({}, '', url); + key(); + })); +}); + +var _Browser_replaceUrl = F2(function(key, url) +{ + return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() { + history.replaceState({}, '', url); + key(); + })); +}); + + + +// GLOBAL EVENTS + + +var _Browser_fakeNode = { addEventListener: function() {}, removeEventListener: function() {} }; +var _Browser_doc = typeof document !== 'undefined' ? document : _Browser_fakeNode; +var _Browser_window = typeof window !== 'undefined' ? window : _Browser_fakeNode; + +var _Browser_on = F3(function(node, eventName, sendToSelf) +{ + return _Scheduler_spawn(_Scheduler_binding(function(callback) + { + function handler(event) { _Scheduler_rawSpawn(sendToSelf(event)); } + node.addEventListener(eventName, handler, _VirtualDom_passiveSupported && { passive: true }); + return function() { node.removeEventListener(eventName, handler); }; + })); +}); + +var _Browser_decodeEvent = F2(function(decoder, event) +{ + var result = _Json_runHelp(decoder, event); + return $elm$core$Result$isOk(result) ? $elm$core$Maybe$Just(result.a) : $elm$core$Maybe$Nothing; +}); + + + +// PAGE VISIBILITY + + +function _Browser_visibilityInfo() +{ + return (typeof _VirtualDom_doc.hidden !== 'undefined') + ? { hidden: 'hidden', change: 'visibilitychange' } + : + (typeof _VirtualDom_doc.mozHidden !== 'undefined') + ? { hidden: 'mozHidden', change: 'mozvisibilitychange' } + : + (typeof _VirtualDom_doc.msHidden !== 'undefined') + ? { hidden: 'msHidden', change: 'msvisibilitychange' } + : + (typeof _VirtualDom_doc.webkitHidden !== 'undefined') + ? { hidden: 'webkitHidden', change: 'webkitvisibilitychange' } + : { hidden: 'hidden', change: 'visibilitychange' }; +} + + + +// ANIMATION FRAMES + + +function _Browser_rAF() +{ + return _Scheduler_binding(function(callback) + { + var id = _Browser_requestAnimationFrame(function() { + callback(_Scheduler_succeed(Date.now())); + }); + + return function() { + _Browser_cancelAnimationFrame(id); + }; + }); +} + + +function _Browser_now() +{ + return _Scheduler_binding(function(callback) + { + callback(_Scheduler_succeed(Date.now())); + }); +} + + + +// DOM STUFF + + +function _Browser_withNode(id, doStuff) +{ + return _Scheduler_binding(function(callback) + { + _Browser_requestAnimationFrame(function() { + var node = document.getElementById(id); + callback(node + ? _Scheduler_succeed(doStuff(node)) + : _Scheduler_fail($elm$browser$Browser$Dom$NotFound(id)) + ); + }); + }); +} + + +function _Browser_withWindow(doStuff) +{ + return _Scheduler_binding(function(callback) + { + _Browser_requestAnimationFrame(function() { + callback(_Scheduler_succeed(doStuff())); + }); + }); +} + + +// FOCUS and BLUR + + +var _Browser_call = F2(function(functionName, id) +{ + return _Browser_withNode(id, function(node) { + node[functionName](); + return _Utils_Tuple0; + }); +}); + + + +// WINDOW VIEWPORT + + +function _Browser_getViewport() +{ + return { + scene: _Browser_getScene(), + viewport: { + x: _Browser_window.pageXOffset, + y: _Browser_window.pageYOffset, + width: _Browser_doc.documentElement.clientWidth, + height: _Browser_doc.documentElement.clientHeight + } + }; +} + +function _Browser_getScene() +{ + var body = _Browser_doc.body; + var elem = _Browser_doc.documentElement; + return { + width: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth), + height: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight) + }; +} + +var _Browser_setViewport = F2(function(x, y) +{ + return _Browser_withWindow(function() + { + _Browser_window.scroll(x, y); + return _Utils_Tuple0; + }); +}); + + + +// ELEMENT VIEWPORT + + +function _Browser_getViewportOf(id) +{ + return _Browser_withNode(id, function(node) + { + return { + scene: { + width: node.scrollWidth, + height: node.scrollHeight + }, + viewport: { + x: node.scrollLeft, + y: node.scrollTop, + width: node.clientWidth, + height: node.clientHeight + } + }; + }); +} + + +var _Browser_setViewportOf = F3(function(id, x, y) +{ + return _Browser_withNode(id, function(node) + { + node.scrollLeft = x; + node.scrollTop = y; + return _Utils_Tuple0; + }); +}); + + + +// ELEMENT + + +function _Browser_getElement(id) +{ + return _Browser_withNode(id, function(node) + { + var rect = node.getBoundingClientRect(); + var x = _Browser_window.pageXOffset; + var y = _Browser_window.pageYOffset; + return { + scene: _Browser_getScene(), + viewport: { + x: x, + y: y, + width: _Browser_doc.documentElement.clientWidth, + height: _Browser_doc.documentElement.clientHeight + }, + element: { + x: x + rect.left, + y: y + rect.top, + width: rect.width, + height: rect.height + } + }; + }); +} + + + +// LOAD and RELOAD + + +function _Browser_reload(skipCache) +{ + return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback) + { + _VirtualDom_doc.location.reload(skipCache); + })); +} + +function _Browser_load(url) +{ + return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback) + { + try + { + _Browser_window.location = url; + } + catch(err) + { + // Only Firefox can throw a NS_ERROR_MALFORMED_URI exception here. + // Other browsers reload the page, so let's be consistent about that. + _VirtualDom_doc.location.reload(false); + } + })); +} + + + +var _Bitwise_and = F2(function(a, b) +{ + return a & b; +}); + +var _Bitwise_or = F2(function(a, b) +{ + return a | b; +}); + +var _Bitwise_xor = F2(function(a, b) +{ + return a ^ b; +}); + +function _Bitwise_complement(a) +{ + return ~a; +}; + +var _Bitwise_shiftLeftBy = F2(function(offset, a) +{ + return a << offset; +}); + +var _Bitwise_shiftRightBy = F2(function(offset, a) +{ + return a >> offset; +}); + +var _Bitwise_shiftRightZfBy = F2(function(offset, a) +{ + return a >>> offset; +}); +var $author$project$Main$LinkClicked = function (a) { + return {$: 'LinkClicked', a: a}; +}; +var $author$project$Main$UrlChanged = function (a) { + return {$: 'UrlChanged', a: a}; +}; +var $elm$core$Basics$EQ = {$: 'EQ'}; +var $elm$core$Basics$GT = {$: 'GT'}; +var $elm$core$Basics$LT = {$: 'LT'}; +var $elm$core$List$cons = _List_cons; +var $elm$core$Dict$foldr = F3( + function (func, acc, t) { + foldr: + while (true) { + if (t.$ === 'RBEmpty_elm_builtin') { + return acc; + } else { + var key = t.b; + var value = t.c; + var left = t.d; + var right = t.e; + var $temp$func = func, + $temp$acc = A3( + func, + key, + value, + A3($elm$core$Dict$foldr, func, acc, right)), + $temp$t = left; + func = $temp$func; + acc = $temp$acc; + t = $temp$t; + continue foldr; + } + } + }); +var $elm$core$Dict$toList = function (dict) { + return A3( + $elm$core$Dict$foldr, + F3( + function (key, value, list) { + return A2( + $elm$core$List$cons, + _Utils_Tuple2(key, value), + list); + }), + _List_Nil, + dict); +}; +var $elm$core$Dict$keys = function (dict) { + return A3( + $elm$core$Dict$foldr, + F3( + function (key, value, keyList) { + return A2($elm$core$List$cons, key, keyList); + }), + _List_Nil, + dict); +}; +var $elm$core$Set$toList = function (_v0) { + var dict = _v0.a; + return $elm$core$Dict$keys(dict); +}; +var $elm$core$Elm$JsArray$foldr = _JsArray_foldr; +var $elm$core$Array$foldr = F3( + function (func, baseCase, _v0) { + var tree = _v0.c; + var tail = _v0.d; + var helper = F2( + function (node, acc) { + if (node.$ === 'SubTree') { + var subTree = node.a; + return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree); + } else { + var values = node.a; + return A3($elm$core$Elm$JsArray$foldr, func, acc, values); + } + }); + return A3( + $elm$core$Elm$JsArray$foldr, + helper, + A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail), + tree); + }); +var $elm$core$Array$toList = function (array) { + return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array); +}; +var $elm$core$Result$Err = function (a) { + return {$: 'Err', a: a}; +}; +var $elm$json$Json$Decode$Failure = F2( + function (a, b) { + return {$: 'Failure', a: a, b: b}; + }); +var $elm$json$Json$Decode$Field = F2( + function (a, b) { + return {$: 'Field', a: a, b: b}; + }); +var $elm$json$Json$Decode$Index = F2( + function (a, b) { + return {$: 'Index', a: a, b: b}; + }); +var $elm$core$Result$Ok = function (a) { + return {$: 'Ok', a: a}; +}; +var $elm$json$Json$Decode$OneOf = function (a) { + return {$: 'OneOf', a: a}; +}; +var $elm$core$Basics$False = {$: 'False'}; +var $elm$core$Basics$add = _Basics_add; +var $elm$core$Maybe$Just = function (a) { + return {$: 'Just', a: a}; +}; +var $elm$core$Maybe$Nothing = {$: 'Nothing'}; +var $elm$core$String$all = _String_all; +var $elm$core$Basics$and = _Basics_and; +var $elm$core$Basics$append = _Utils_append; +var $elm$json$Json$Encode$encode = _Json_encode; +var $elm$core$String$fromInt = _String_fromNumber; +var $elm$core$String$join = F2( + function (sep, chunks) { + return A2( + _String_join, + sep, + _List_toArray(chunks)); + }); +var $elm$core$String$split = F2( + function (sep, string) { + return _List_fromArray( + A2(_String_split, sep, string)); + }); +var $elm$json$Json$Decode$indent = function (str) { + return A2( + $elm$core$String$join, + '\n ', + A2($elm$core$String$split, '\n', str)); +}; +var $elm$core$List$foldl = F3( + function (func, acc, list) { + foldl: + while (true) { + if (!list.b) { + return acc; + } else { + var x = list.a; + var xs = list.b; + var $temp$func = func, + $temp$acc = A2(func, x, acc), + $temp$list = xs; + func = $temp$func; + acc = $temp$acc; + list = $temp$list; + continue foldl; + } + } + }); +var $elm$core$List$length = function (xs) { + return A3( + $elm$core$List$foldl, + F2( + function (_v0, i) { + return i + 1; + }), + 0, + xs); +}; +var $elm$core$List$map2 = _List_map2; +var $elm$core$Basics$le = _Utils_le; +var $elm$core$Basics$sub = _Basics_sub; +var $elm$core$List$rangeHelp = F3( + function (lo, hi, list) { + rangeHelp: + while (true) { + if (_Utils_cmp(lo, hi) < 1) { + var $temp$lo = lo, + $temp$hi = hi - 1, + $temp$list = A2($elm$core$List$cons, hi, list); + lo = $temp$lo; + hi = $temp$hi; + list = $temp$list; + continue rangeHelp; + } else { + return list; + } + } + }); +var $elm$core$List$range = F2( + function (lo, hi) { + return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil); + }); +var $elm$core$List$indexedMap = F2( + function (f, xs) { + return A3( + $elm$core$List$map2, + f, + A2( + $elm$core$List$range, + 0, + $elm$core$List$length(xs) - 1), + xs); + }); +var $elm$core$Char$toCode = _Char_toCode; +var $elm$core$Char$isLower = function (_char) { + var code = $elm$core$Char$toCode(_char); + return (97 <= code) && (code <= 122); +}; +var $elm$core$Char$isUpper = function (_char) { + var code = $elm$core$Char$toCode(_char); + return (code <= 90) && (65 <= code); +}; +var $elm$core$Basics$or = _Basics_or; +var $elm$core$Char$isAlpha = function (_char) { + return $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char); +}; +var $elm$core$Char$isDigit = function (_char) { + var code = $elm$core$Char$toCode(_char); + return (code <= 57) && (48 <= code); +}; +var $elm$core$Char$isAlphaNum = function (_char) { + return $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char)); +}; +var $elm$core$List$reverse = function (list) { + return A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list); +}; +var $elm$core$String$uncons = _String_uncons; +var $elm$json$Json$Decode$errorOneOf = F2( + function (i, error) { + return '\n\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent( + $elm$json$Json$Decode$errorToString(error)))); + }); +var $elm$json$Json$Decode$errorToString = function (error) { + return A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil); +}; +var $elm$json$Json$Decode$errorToStringHelp = F2( + function (error, context) { + errorToStringHelp: + while (true) { + switch (error.$) { + case 'Field': + var f = error.a; + var err = error.b; + var isSimple = function () { + var _v1 = $elm$core$String$uncons(f); + if (_v1.$ === 'Nothing') { + return false; + } else { + var _v2 = _v1.a; + var _char = _v2.a; + var rest = _v2.b; + return $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest); + } + }(); + var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']')); + var $temp$error = err, + $temp$context = A2($elm$core$List$cons, fieldName, context); + error = $temp$error; + context = $temp$context; + continue errorToStringHelp; + case 'Index': + var i = error.a; + var err = error.b; + var indexName = '[' + ($elm$core$String$fromInt(i) + ']'); + var $temp$error = err, + $temp$context = A2($elm$core$List$cons, indexName, context); + error = $temp$error; + context = $temp$context; + continue errorToStringHelp; + case 'OneOf': + var errors = error.a; + if (!errors.b) { + return 'Ran into a Json.Decode.oneOf with no possibilities' + function () { + if (!context.b) { + return '!'; + } else { + return ' at json' + A2( + $elm$core$String$join, + '', + $elm$core$List$reverse(context)); + } + }(); + } else { + if (!errors.b.b) { + var err = errors.a; + var $temp$error = err, + $temp$context = context; + error = $temp$error; + context = $temp$context; + continue errorToStringHelp; + } else { + var starter = function () { + if (!context.b) { + return 'Json.Decode.oneOf'; + } else { + return 'The Json.Decode.oneOf at json' + A2( + $elm$core$String$join, + '', + $elm$core$List$reverse(context)); + } + }(); + var introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt( + $elm$core$List$length(errors)) + ' ways:')); + return A2( + $elm$core$String$join, + '\n\n', + A2( + $elm$core$List$cons, + introduction, + A2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors))); + } + } + default: + var msg = error.a; + var json = error.b; + var introduction = function () { + if (!context.b) { + return 'Problem with the given value:\n\n'; + } else { + return 'Problem with the value at json' + (A2( + $elm$core$String$join, + '', + $elm$core$List$reverse(context)) + ':\n\n '); + } + }(); + return introduction + ($elm$json$Json$Decode$indent( + A2($elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg)); + } + } + }); +var $elm$core$Array$branchFactor = 32; +var $elm$core$Array$Array_elm_builtin = F4( + function (a, b, c, d) { + return {$: 'Array_elm_builtin', a: a, b: b, c: c, d: d}; + }); +var $elm$core$Elm$JsArray$empty = _JsArray_empty; +var $elm$core$Basics$ceiling = _Basics_ceiling; +var $elm$core$Basics$fdiv = _Basics_fdiv; +var $elm$core$Basics$logBase = F2( + function (base, number) { + return _Basics_log(number) / _Basics_log(base); + }); +var $elm$core$Basics$toFloat = _Basics_toFloat; +var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling( + A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor)); +var $elm$core$Array$empty = A4($elm$core$Array$Array_elm_builtin, 0, $elm$core$Array$shiftStep, $elm$core$Elm$JsArray$empty, $elm$core$Elm$JsArray$empty); +var $elm$core$Elm$JsArray$initialize = _JsArray_initialize; +var $elm$core$Array$Leaf = function (a) { + return {$: 'Leaf', a: a}; +}; +var $elm$core$Basics$apL = F2( + function (f, x) { + return f(x); + }); +var $elm$core$Basics$apR = F2( + function (x, f) { + return f(x); + }); +var $elm$core$Basics$eq = _Utils_equal; +var $elm$core$Basics$floor = _Basics_floor; +var $elm$core$Elm$JsArray$length = _JsArray_length; +var $elm$core$Basics$gt = _Utils_gt; +var $elm$core$Basics$max = F2( + function (x, y) { + return (_Utils_cmp(x, y) > 0) ? x : y; + }); +var $elm$core$Basics$mul = _Basics_mul; +var $elm$core$Array$SubTree = function (a) { + return {$: 'SubTree', a: a}; +}; +var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList; +var $elm$core$Array$compressNodes = F2( + function (nodes, acc) { + compressNodes: + while (true) { + var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes); + var node = _v0.a; + var remainingNodes = _v0.b; + var newAcc = A2( + $elm$core$List$cons, + $elm$core$Array$SubTree(node), + acc); + if (!remainingNodes.b) { + return $elm$core$List$reverse(newAcc); + } else { + var $temp$nodes = remainingNodes, + $temp$acc = newAcc; + nodes = $temp$nodes; + acc = $temp$acc; + continue compressNodes; + } + } + }); +var $elm$core$Tuple$first = function (_v0) { + var x = _v0.a; + return x; +}; +var $elm$core$Array$treeFromBuilder = F2( + function (nodeList, nodeListSize) { + treeFromBuilder: + while (true) { + var newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor); + if (newNodeSize === 1) { + return A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a; + } else { + var $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil), + $temp$nodeListSize = newNodeSize; + nodeList = $temp$nodeList; + nodeListSize = $temp$nodeListSize; + continue treeFromBuilder; + } + } + }); +var $elm$core$Array$builderToArray = F2( + function (reverseNodeList, builder) { + if (!builder.nodeListSize) { + return A4( + $elm$core$Array$Array_elm_builtin, + $elm$core$Elm$JsArray$length(builder.tail), + $elm$core$Array$shiftStep, + $elm$core$Elm$JsArray$empty, + builder.tail); + } else { + var treeLen = builder.nodeListSize * $elm$core$Array$branchFactor; + var depth = $elm$core$Basics$floor( + A2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1)); + var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.nodeList) : builder.nodeList; + var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.nodeListSize); + return A4( + $elm$core$Array$Array_elm_builtin, + $elm$core$Elm$JsArray$length(builder.tail) + treeLen, + A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep), + tree, + builder.tail); + } + }); +var $elm$core$Basics$idiv = _Basics_idiv; +var $elm$core$Basics$lt = _Utils_lt; +var $elm$core$Array$initializeHelp = F5( + function (fn, fromIndex, len, nodeList, tail) { + initializeHelp: + while (true) { + if (fromIndex < 0) { + return A2( + $elm$core$Array$builderToArray, + false, + {nodeList: nodeList, nodeListSize: (len / $elm$core$Array$branchFactor) | 0, tail: tail}); + } else { + var leaf = $elm$core$Array$Leaf( + A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn)); + var $temp$fn = fn, + $temp$fromIndex = fromIndex - $elm$core$Array$branchFactor, + $temp$len = len, + $temp$nodeList = A2($elm$core$List$cons, leaf, nodeList), + $temp$tail = tail; + fn = $temp$fn; + fromIndex = $temp$fromIndex; + len = $temp$len; + nodeList = $temp$nodeList; + tail = $temp$tail; + continue initializeHelp; + } + } + }); +var $elm$core$Basics$remainderBy = _Basics_remainderBy; +var $elm$core$Array$initialize = F2( + function (len, fn) { + if (len <= 0) { + return $elm$core$Array$empty; + } else { + var tailLen = len % $elm$core$Array$branchFactor; + var tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn); + var initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor; + return A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail); + } + }); +var $elm$core$Basics$True = {$: 'True'}; +var $elm$core$Result$isOk = function (result) { + if (result.$ === 'Ok') { + return true; + } else { + return false; + } +}; +var $elm$json$Json$Decode$map = _Json_map1; +var $elm$json$Json$Decode$map2 = _Json_map2; +var $elm$json$Json$Decode$succeed = _Json_succeed; +var $elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) { + switch (handler.$) { + case 'Normal': + return 0; + case 'MayStopPropagation': + return 1; + case 'MayPreventDefault': + return 2; + default: + return 3; + } +}; +var $elm$browser$Browser$External = function (a) { + return {$: 'External', a: a}; +}; +var $elm$browser$Browser$Internal = function (a) { + return {$: 'Internal', a: a}; +}; +var $elm$core$Basics$identity = function (x) { + return x; +}; +var $elm$browser$Browser$Dom$NotFound = function (a) { + return {$: 'NotFound', a: a}; +}; +var $elm$url$Url$Http = {$: 'Http'}; +var $elm$url$Url$Https = {$: 'Https'}; +var $elm$url$Url$Url = F6( + function (protocol, host, port_, path, query, fragment) { + return {fragment: fragment, host: host, path: path, port_: port_, protocol: protocol, query: query}; + }); +var $elm$core$String$contains = _String_contains; +var $elm$core$String$length = _String_length; +var $elm$core$String$slice = _String_slice; +var $elm$core$String$dropLeft = F2( + function (n, string) { + return (n < 1) ? string : A3( + $elm$core$String$slice, + n, + $elm$core$String$length(string), + string); + }); +var $elm$core$String$indexes = _String_indexes; +var $elm$core$String$isEmpty = function (string) { + return string === ''; +}; +var $elm$core$String$left = F2( + function (n, string) { + return (n < 1) ? '' : A3($elm$core$String$slice, 0, n, string); + }); +var $elm$core$String$toInt = _String_toInt; +var $elm$url$Url$chompBeforePath = F5( + function (protocol, path, params, frag, str) { + if ($elm$core$String$isEmpty(str) || A2($elm$core$String$contains, '@', str)) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, ':', str); + if (!_v0.b) { + return $elm$core$Maybe$Just( + A6($elm$url$Url$Url, protocol, str, $elm$core$Maybe$Nothing, path, params, frag)); + } else { + if (!_v0.b.b) { + var i = _v0.a; + var _v1 = $elm$core$String$toInt( + A2($elm$core$String$dropLeft, i + 1, str)); + if (_v1.$ === 'Nothing') { + return $elm$core$Maybe$Nothing; + } else { + var port_ = _v1; + return $elm$core$Maybe$Just( + A6( + $elm$url$Url$Url, + protocol, + A2($elm$core$String$left, i, str), + port_, + path, + params, + frag)); + } + } else { + return $elm$core$Maybe$Nothing; + } + } + } + }); +var $elm$url$Url$chompBeforeQuery = F4( + function (protocol, params, frag, str) { + if ($elm$core$String$isEmpty(str)) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, '/', str); + if (!_v0.b) { + return A5($elm$url$Url$chompBeforePath, protocol, '/', params, frag, str); + } else { + var i = _v0.a; + return A5( + $elm$url$Url$chompBeforePath, + protocol, + A2($elm$core$String$dropLeft, i, str), + params, + frag, + A2($elm$core$String$left, i, str)); + } + } + }); +var $elm$url$Url$chompBeforeFragment = F3( + function (protocol, frag, str) { + if ($elm$core$String$isEmpty(str)) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, '?', str); + if (!_v0.b) { + return A4($elm$url$Url$chompBeforeQuery, protocol, $elm$core$Maybe$Nothing, frag, str); + } else { + var i = _v0.a; + return A4( + $elm$url$Url$chompBeforeQuery, + protocol, + $elm$core$Maybe$Just( + A2($elm$core$String$dropLeft, i + 1, str)), + frag, + A2($elm$core$String$left, i, str)); + } + } + }); +var $elm$url$Url$chompAfterProtocol = F2( + function (protocol, str) { + if ($elm$core$String$isEmpty(str)) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, '#', str); + if (!_v0.b) { + return A3($elm$url$Url$chompBeforeFragment, protocol, $elm$core$Maybe$Nothing, str); + } else { + var i = _v0.a; + return A3( + $elm$url$Url$chompBeforeFragment, + protocol, + $elm$core$Maybe$Just( + A2($elm$core$String$dropLeft, i + 1, str)), + A2($elm$core$String$left, i, str)); + } + } + }); +var $elm$core$String$startsWith = _String_startsWith; +var $elm$url$Url$fromString = function (str) { + return A2($elm$core$String$startsWith, 'http://', str) ? A2( + $elm$url$Url$chompAfterProtocol, + $elm$url$Url$Http, + A2($elm$core$String$dropLeft, 7, str)) : (A2($elm$core$String$startsWith, 'https://', str) ? A2( + $elm$url$Url$chompAfterProtocol, + $elm$url$Url$Https, + A2($elm$core$String$dropLeft, 8, str)) : $elm$core$Maybe$Nothing); +}; +var $elm$core$Basics$never = function (_v0) { + never: + while (true) { + var nvr = _v0.a; + var $temp$_v0 = nvr; + _v0 = $temp$_v0; + continue never; + } +}; +var $elm$core$Task$Perform = function (a) { + return {$: 'Perform', a: a}; +}; +var $elm$core$Task$succeed = _Scheduler_succeed; +var $elm$core$Task$init = $elm$core$Task$succeed(_Utils_Tuple0); +var $elm$core$List$foldrHelper = F4( + function (fn, acc, ctr, ls) { + if (!ls.b) { + return acc; + } else { + var a = ls.a; + var r1 = ls.b; + if (!r1.b) { + return A2(fn, a, acc); + } else { + var b = r1.a; + var r2 = r1.b; + if (!r2.b) { + return A2( + fn, + a, + A2(fn, b, acc)); + } else { + var c = r2.a; + var r3 = r2.b; + if (!r3.b) { + return A2( + fn, + a, + A2( + fn, + b, + A2(fn, c, acc))); + } else { + var d = r3.a; + var r4 = r3.b; + var res = (ctr > 500) ? A3( + $elm$core$List$foldl, + fn, + acc, + $elm$core$List$reverse(r4)) : A4($elm$core$List$foldrHelper, fn, acc, ctr + 1, r4); + return A2( + fn, + a, + A2( + fn, + b, + A2( + fn, + c, + A2(fn, d, res)))); + } + } + } + } + }); +var $elm$core$List$foldr = F3( + function (fn, acc, ls) { + return A4($elm$core$List$foldrHelper, fn, acc, 0, ls); + }); +var $elm$core$List$map = F2( + function (f, xs) { + return A3( + $elm$core$List$foldr, + F2( + function (x, acc) { + return A2( + $elm$core$List$cons, + f(x), + acc); + }), + _List_Nil, + xs); + }); +var $elm$core$Task$andThen = _Scheduler_andThen; +var $elm$core$Task$map = F2( + function (func, taskA) { + return A2( + $elm$core$Task$andThen, + function (a) { + return $elm$core$Task$succeed( + func(a)); + }, + taskA); + }); +var $elm$core$Task$map2 = F3( + function (func, taskA, taskB) { + return A2( + $elm$core$Task$andThen, + function (a) { + return A2( + $elm$core$Task$andThen, + function (b) { + return $elm$core$Task$succeed( + A2(func, a, b)); + }, + taskB); + }, + taskA); + }); +var $elm$core$Task$sequence = function (tasks) { + return A3( + $elm$core$List$foldr, + $elm$core$Task$map2($elm$core$List$cons), + $elm$core$Task$succeed(_List_Nil), + tasks); +}; +var $elm$core$Platform$sendToApp = _Platform_sendToApp; +var $elm$core$Task$spawnCmd = F2( + function (router, _v0) { + var task = _v0.a; + return _Scheduler_spawn( + A2( + $elm$core$Task$andThen, + $elm$core$Platform$sendToApp(router), + task)); + }); +var $elm$core$Task$onEffects = F3( + function (router, commands, state) { + return A2( + $elm$core$Task$map, + function (_v0) { + return _Utils_Tuple0; + }, + $elm$core$Task$sequence( + A2( + $elm$core$List$map, + $elm$core$Task$spawnCmd(router), + commands))); + }); +var $elm$core$Task$onSelfMsg = F3( + function (_v0, _v1, _v2) { + return $elm$core$Task$succeed(_Utils_Tuple0); + }); +var $elm$core$Task$cmdMap = F2( + function (tagger, _v0) { + var task = _v0.a; + return $elm$core$Task$Perform( + A2($elm$core$Task$map, tagger, task)); + }); +_Platform_effectManagers['Task'] = _Platform_createManager($elm$core$Task$init, $elm$core$Task$onEffects, $elm$core$Task$onSelfMsg, $elm$core$Task$cmdMap); +var $elm$core$Task$command = _Platform_leaf('Task'); +var $elm$core$Task$perform = F2( + function (toMessage, task) { + return $elm$core$Task$command( + $elm$core$Task$Perform( + A2($elm$core$Task$map, toMessage, task))); + }); +var $elm$browser$Browser$application = _Browser_application; +var $author$project$Main$NoInitFocus = {$: 'NoInitFocus'}; +var $author$project$Main$Pit = {$: 'Pit'}; +var $elm$core$Basics$composeL = F3( + function (g, f, x) { + return g( + f(x)); + }); +var $elm$core$Task$onError = _Scheduler_onError; +var $elm$core$Task$attempt = F2( + function (resultToMessage, task) { + return $elm$core$Task$command( + $elm$core$Task$Perform( + A2( + $elm$core$Task$onError, + A2( + $elm$core$Basics$composeL, + A2($elm$core$Basics$composeL, $elm$core$Task$succeed, resultToMessage), + $elm$core$Result$Err), + A2( + $elm$core$Task$andThen, + A2( + $elm$core$Basics$composeL, + A2($elm$core$Basics$composeL, $elm$core$Task$succeed, resultToMessage), + $elm$core$Result$Ok), + task)))); + }); +var $author$project$Main$CookiesKept = F3( + function (keepTheme, keepFont, keepPrompt) { + return {keepFont: keepFont, keepPrompt: keepPrompt, keepTheme: keepTheme}; + }); +var $elm$json$Json$Decode$field = _Json_decodeField; +var $elm$json$Json$Decode$at = F2( + function (fields, decoder) { + return A3($elm$core$List$foldr, $elm$json$Json$Decode$field, decoder, fields); + }); +var $elm$json$Json$Decode$bool = _Json_decodeBool; +var $elm$json$Json$Decode$map3 = _Json_map3; +var $author$project$Main$cookiesKeptDecoder = A4( + $elm$json$Json$Decode$map3, + $author$project$Main$CookiesKept, + A2( + $elm$json$Json$Decode$at, + _List_fromArray( + ['cookiesKept', 'keepTheme']), + $elm$json$Json$Decode$bool), + A2( + $elm$json$Json$Decode$at, + _List_fromArray( + ['cookiesKept', 'keepFont']), + $elm$json$Json$Decode$bool), + A2( + $elm$json$Json$Decode$at, + _List_fromArray( + ['cookiesKept', 'keepPrompt']), + $elm$json$Json$Decode$bool)); +var $elm$json$Json$Decode$decodeValue = _Json_run; +var $elm$browser$Browser$Dom$focus = _Browser_call('focus'); +var $author$project$Main$Font = function (fontSize) { + return {fontSize: fontSize}; +}; +var $elm$json$Json$Decode$float = _Json_decodeFloat; +var $author$project$Main$fontDecoder = A2( + $elm$json$Json$Decode$map, + $author$project$Main$Font, + A2( + $elm$json$Json$Decode$at, + _List_fromArray( + ['font', 'fontSize']), + $elm$json$Json$Decode$float)); +var $author$project$Main$Prompt = function (prompt) { + return {prompt: prompt}; +}; +var $elm$json$Json$Decode$string = _Json_decodeString; +var $author$project$Main$promptDecoder = A2( + $elm$json$Json$Decode$map, + $author$project$Main$Prompt, + A2( + $elm$json$Json$Decode$at, + _List_fromArray( + ['prompt', 'prompt']), + $elm$json$Json$Decode$string)); +var $rtfeldman$elm_css$VirtualDom$Styled$Unstyled = function (a) { + return {$: 'Unstyled', a: a}; +}; +var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text; +var $rtfeldman$elm_css$VirtualDom$Styled$text = function (str) { + return $rtfeldman$elm_css$VirtualDom$Styled$Unstyled( + $elm$virtual_dom$VirtualDom$text(str)); +}; +var $rtfeldman$elm_css$Html$Styled$text = $rtfeldman$elm_css$VirtualDom$Styled$text; +var $author$project$Main$Dim = {$: 'Dim'}; +var $author$project$Main$Sky = {$: 'Sky'}; +var $author$project$Main$Sun = {$: 'Sun'}; +var $elm$json$Json$Decode$fail = _Json_fail; +var $author$project$Main$themeDecoder = function (flags) { + var _v0 = A2( + $elm$json$Json$Decode$decodeValue, + A2($elm$json$Json$Decode$field, 'theme', $elm$json$Json$Decode$string), + flags); + if (_v0.$ === 'Ok') { + switch (_v0.a) { + case 'Pit': + return $elm$json$Json$Decode$succeed($author$project$Main$Pit); + case 'Dim': + return $elm$json$Json$Decode$succeed($author$project$Main$Dim); + case 'Sky': + return $elm$json$Json$Decode$succeed($author$project$Main$Sky); + case 'Sun': + return $elm$json$Json$Decode$succeed($author$project$Main$Sun); + default: + return $elm$json$Json$Decode$fail('Unknown value found in theme field of json'); + } + } else { + return $elm$json$Json$Decode$fail('Error decoding theme field of json'); + } +}; +var $author$project$Main$init = F3( + function (flags, url, key) { + var initContent = _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('Welcome to my website!'), + $rtfeldman$elm_css$Html$Styled$text('\nRun `help` to get started') + ]); + var cookiesKept = function () { + var _v4 = A2($elm$json$Json$Decode$decodeValue, $author$project$Main$cookiesKeptDecoder, flags); + if (_v4.$ === 'Ok') { + var cK = _v4.a; + return cK; + } else { + return {keepFont: true, keepPrompt: true, keepTheme: true}; + } + }(); + return _Utils_Tuple2( + { + cliContent: '', + content: initContent, + cookiesKept: cookiesKept, + font: function () { + if (cookiesKept.keepFont) { + var _v0 = A2($elm$json$Json$Decode$decodeValue, $author$project$Main$fontDecoder, flags); + if (_v0.$ === 'Ok') { + var font = _v0.a; + return font; + } else { + return {fontSize: 20.0}; + } + } else { + return {fontSize: 20.0}; + } + }(), + key: key, + prompt: function () { + if (cookiesKept.keepPrompt) { + var _v1 = A2($elm$json$Json$Decode$decodeValue, $author$project$Main$promptDecoder, flags); + if (_v1.$ === 'Ok') { + var prompt = _v1.a; + return prompt; + } else { + return {prompt: '>'}; + } + } else { + return {prompt: '>'}; + } + }(), + theme: function () { + if (cookiesKept.keepTheme) { + var _v2 = A2( + $elm$json$Json$Decode$decodeValue, + $author$project$Main$themeDecoder(flags), + flags); + if (_v2.$ === 'Ok') { + var theme = _v2.a; + return theme; + } else { + return $author$project$Main$Pit; + } + } else { + return $author$project$Main$Pit; + } + }(), + url: url + }, + A2( + $elm$core$Task$attempt, + function (_v3) { + return $author$project$Main$NoInitFocus; + }, + $elm$browser$Browser$Dom$focus('init-focus'))); + }); +var $author$project$Main$ReceivedTest = function (a) { + return {$: 'ReceivedTest', a: a}; +}; +var $elm$core$Basics$composeR = F3( + function (f, g, x) { + return g( + f(x)); + }); +var $elm$json$Json$Decode$value = _Json_decodeValue; +var $author$project$Main$receiveTestFromServer = _Platform_incomingPort('receiveTestFromServer', $elm$json$Json$Decode$value); +var $author$project$Main$Test = F2( + function (message0, message1) { + return {message0: message0, message1: message1}; + }); +var $author$project$Main$testDecoder = A3( + $elm$json$Json$Decode$map2, + $author$project$Main$Test, + A2($elm$json$Json$Decode$field, 'message0', $elm$json$Json$Decode$string), + A2($elm$json$Json$Decode$field, 'message1', $elm$json$Json$Decode$string)); +var $author$project$Main$subscriptions = function (model) { + return $author$project$Main$receiveTestFromServer( + A2( + $elm$core$Basics$composeR, + $elm$json$Json$Decode$decodeValue($author$project$Main$testDecoder), + $author$project$Main$ReceivedTest)); +}; +var $author$project$Main$BrightMagenta = {$: 'BrightMagenta'}; +var $rtfeldman$elm_css$Css$Preprocess$AppendProperty = function (a) { + return {$: 'AppendProperty', a: a}; +}; +var $rtfeldman$elm_css$Css$Structure$Property = function (a) { + return {$: 'Property', a: a}; +}; +var $rtfeldman$elm_css$Css$property = F2( + function (key, value) { + return $rtfeldman$elm_css$Css$Preprocess$AppendProperty( + $rtfeldman$elm_css$Css$Structure$Property(key + (':' + value))); + }); +var $rtfeldman$elm_css$Css$backgroundColor = function (c) { + return A2($rtfeldman$elm_css$Css$property, 'background-color', c.value); +}; +var $rtfeldman$elm_css$Css$prop1 = F2( + function (key, arg) { + return A2($rtfeldman$elm_css$Css$property, key, arg.value); + }); +var $rtfeldman$elm_css$Css$borderWidth = $rtfeldman$elm_css$Css$prop1('border-width'); +var $rtfeldman$elm_css$Css$color = function (c) { + return A2($rtfeldman$elm_css$Css$property, 'color', c.value); +}; +var $rtfeldman$elm_css$Css$margin = $rtfeldman$elm_css$Css$prop1('margin'); +var $rtfeldman$elm_css$Css$padding = $rtfeldman$elm_css$Css$prop1('padding'); +var $rtfeldman$elm_css$Css$PxUnits = {$: 'PxUnits'}; +var $rtfeldman$elm_css$Css$Structure$Compatible = {$: 'Compatible'}; +var $elm$core$String$fromFloat = _String_fromNumber; +var $rtfeldman$elm_css$Css$Internal$lengthConverter = F3( + function (units, unitLabel, numericValue) { + return { + absoluteLength: $rtfeldman$elm_css$Css$Structure$Compatible, + calc: $rtfeldman$elm_css$Css$Structure$Compatible, + flexBasis: $rtfeldman$elm_css$Css$Structure$Compatible, + fontSize: $rtfeldman$elm_css$Css$Structure$Compatible, + length: $rtfeldman$elm_css$Css$Structure$Compatible, + lengthOrAuto: $rtfeldman$elm_css$Css$Structure$Compatible, + lengthOrAutoOrCoverOrContain: $rtfeldman$elm_css$Css$Structure$Compatible, + lengthOrMinMaxDimension: $rtfeldman$elm_css$Css$Structure$Compatible, + lengthOrNone: $rtfeldman$elm_css$Css$Structure$Compatible, + lengthOrNoneOrMinMaxDimension: $rtfeldman$elm_css$Css$Structure$Compatible, + lengthOrNumber: $rtfeldman$elm_css$Css$Structure$Compatible, + lengthOrNumberOrAutoOrNoneOrContent: $rtfeldman$elm_css$Css$Structure$Compatible, + lineHeight: $rtfeldman$elm_css$Css$Structure$Compatible, + numericValue: numericValue, + textIndent: $rtfeldman$elm_css$Css$Structure$Compatible, + unitLabel: unitLabel, + units: units, + value: _Utils_ap( + $elm$core$String$fromFloat(numericValue), + unitLabel) + }; + }); +var $rtfeldman$elm_css$Css$px = A2($rtfeldman$elm_css$Css$Internal$lengthConverter, $rtfeldman$elm_css$Css$PxUnits, 'px'); +var $rtfeldman$elm_css$VirtualDom$Styled$Node = F3( + function (a, b, c) { + return {$: 'Node', a: a, b: b, c: c}; + }); +var $rtfeldman$elm_css$VirtualDom$Styled$node = $rtfeldman$elm_css$VirtualDom$Styled$Node; +var $rtfeldman$elm_css$Html$Styled$node = $rtfeldman$elm_css$VirtualDom$Styled$node; +var $rtfeldman$elm_css$Html$Styled$span = $rtfeldman$elm_css$Html$Styled$node('span'); +var $rtfeldman$elm_css$VirtualDom$Styled$Attribute = F3( + function (a, b, c) { + return {$: 'Attribute', a: a, b: b, c: c}; + }); +var $elm$virtual_dom$VirtualDom$attribute = F2( + function (key, value) { + return A2( + _VirtualDom_attribute, + _VirtualDom_noOnOrFormAction(key), + _VirtualDom_noJavaScriptOrHtmlUri(value)); + }); +var $elm$core$List$any = F2( + function (isOkay, list) { + any: + while (true) { + if (!list.b) { + return false; + } else { + var x = list.a; + var xs = list.b; + if (isOkay(x)) { + return true; + } else { + var $temp$isOkay = isOkay, + $temp$list = xs; + isOkay = $temp$isOkay; + list = $temp$list; + continue any; + } + } + } + }); +var $elm$core$Basics$not = _Basics_not; +var $elm$core$List$all = F2( + function (isOkay, list) { + return !A2( + $elm$core$List$any, + A2($elm$core$Basics$composeL, $elm$core$Basics$not, isOkay), + list); + }); +var $elm$core$Dict$Black = {$: 'Black'}; +var $elm$core$Dict$RBNode_elm_builtin = F5( + function (a, b, c, d, e) { + return {$: 'RBNode_elm_builtin', a: a, b: b, c: c, d: d, e: e}; + }); +var $elm$core$Dict$RBEmpty_elm_builtin = {$: 'RBEmpty_elm_builtin'}; +var $elm$core$Dict$Red = {$: 'Red'}; +var $elm$core$Dict$balance = F5( + function (color, key, value, left, right) { + if ((right.$ === 'RBNode_elm_builtin') && (right.a.$ === 'Red')) { + var _v1 = right.a; + var rK = right.b; + var rV = right.c; + var rLeft = right.d; + var rRight = right.e; + if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) { + var _v3 = left.a; + var lK = left.b; + var lV = left.c; + var lLeft = left.d; + var lRight = left.e; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Red, + key, + value, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, lK, lV, lLeft, lRight), + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, rK, rV, rLeft, rRight)); + } else { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + color, + rK, + rV, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, key, value, left, rLeft), + rRight); + } + } else { + if ((((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) && (left.d.$ === 'RBNode_elm_builtin')) && (left.d.a.$ === 'Red')) { + var _v5 = left.a; + var lK = left.b; + var lV = left.c; + var _v6 = left.d; + var _v7 = _v6.a; + var llK = _v6.b; + var llV = _v6.c; + var llLeft = _v6.d; + var llRight = _v6.e; + var lRight = left.e; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Red, + lK, + lV, + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, llK, llV, llLeft, llRight), + A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, key, value, lRight, right)); + } else { + return A5($elm$core$Dict$RBNode_elm_builtin, color, key, value, left, right); + } + } + }); +var $elm$core$Basics$compare = _Utils_compare; +var $elm$core$Dict$insertHelp = F3( + function (key, value, dict) { + if (dict.$ === 'RBEmpty_elm_builtin') { + 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); + } else { + var nColor = dict.a; + var nKey = dict.b; + var nValue = dict.c; + var nLeft = dict.d; + var nRight = dict.e; + var _v1 = A2($elm$core$Basics$compare, key, nKey); + switch (_v1.$) { + case 'LT': + return A5( + $elm$core$Dict$balance, + nColor, + nKey, + nValue, + A3($elm$core$Dict$insertHelp, key, value, nLeft), + nRight); + case 'EQ': + return A5($elm$core$Dict$RBNode_elm_builtin, nColor, nKey, value, nLeft, nRight); + default: + return A5( + $elm$core$Dict$balance, + nColor, + nKey, + nValue, + nLeft, + A3($elm$core$Dict$insertHelp, key, value, nRight)); + } + } + }); +var $elm$core$Dict$insert = F3( + function (key, value, dict) { + var _v0 = A3($elm$core$Dict$insertHelp, key, value, dict); + if ((_v0.$ === 'RBNode_elm_builtin') && (_v0.a.$ === 'Red')) { + var _v1 = _v0.a; + var k = _v0.b; + var v = _v0.c; + var l = _v0.d; + var r = _v0.e; + return A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, k, v, l, r); + } else { + var x = _v0; + return x; + } + }); +var $elm$core$List$isEmpty = function (xs) { + if (!xs.b) { + return true; + } else { + return false; + } +}; +var $rtfeldman$elm_css$Css$Structure$compactHelp = F2( + function (declaration, _v0) { + var keyframesByName = _v0.a; + var declarations = _v0.b; + switch (declaration.$) { + case 'StyleBlockDeclaration': + var _v2 = declaration.a; + var properties = _v2.c; + return $elm$core$List$isEmpty(properties) ? _Utils_Tuple2(keyframesByName, declarations) : _Utils_Tuple2( + keyframesByName, + A2($elm$core$List$cons, declaration, declarations)); + case 'MediaRule': + var styleBlocks = declaration.b; + return A2( + $elm$core$List$all, + function (_v3) { + var properties = _v3.c; + return $elm$core$List$isEmpty(properties); + }, + styleBlocks) ? _Utils_Tuple2(keyframesByName, declarations) : _Utils_Tuple2( + keyframesByName, + A2($elm$core$List$cons, declaration, declarations)); + case 'SupportsRule': + var otherDeclarations = declaration.b; + return $elm$core$List$isEmpty(otherDeclarations) ? _Utils_Tuple2(keyframesByName, declarations) : _Utils_Tuple2( + keyframesByName, + A2($elm$core$List$cons, declaration, declarations)); + case 'DocumentRule': + return _Utils_Tuple2( + keyframesByName, + A2($elm$core$List$cons, declaration, declarations)); + case 'PageRule': + var properties = declaration.a; + return $elm$core$List$isEmpty(properties) ? _Utils_Tuple2(keyframesByName, declarations) : _Utils_Tuple2( + keyframesByName, + A2($elm$core$List$cons, declaration, declarations)); + case 'FontFace': + var properties = declaration.a; + return $elm$core$List$isEmpty(properties) ? _Utils_Tuple2(keyframesByName, declarations) : _Utils_Tuple2( + keyframesByName, + A2($elm$core$List$cons, declaration, declarations)); + case 'Keyframes': + var record = declaration.a; + return $elm$core$String$isEmpty(record.declaration) ? _Utils_Tuple2(keyframesByName, declarations) : _Utils_Tuple2( + A3($elm$core$Dict$insert, record.name, record.declaration, keyframesByName), + declarations); + case 'Viewport': + var properties = declaration.a; + return $elm$core$List$isEmpty(properties) ? _Utils_Tuple2(keyframesByName, declarations) : _Utils_Tuple2( + keyframesByName, + A2($elm$core$List$cons, declaration, declarations)); + case 'CounterStyle': + var properties = declaration.a; + return $elm$core$List$isEmpty(properties) ? _Utils_Tuple2(keyframesByName, declarations) : _Utils_Tuple2( + keyframesByName, + A2($elm$core$List$cons, declaration, declarations)); + default: + var tuples = declaration.a; + return A2( + $elm$core$List$all, + function (_v4) { + var properties = _v4.b; + return $elm$core$List$isEmpty(properties); + }, + tuples) ? _Utils_Tuple2(keyframesByName, declarations) : _Utils_Tuple2( + keyframesByName, + A2($elm$core$List$cons, declaration, declarations)); + } + }); +var $elm$core$Dict$empty = $elm$core$Dict$RBEmpty_elm_builtin; +var $rtfeldman$elm_css$Css$Structure$Keyframes = function (a) { + return {$: 'Keyframes', a: a}; +}; +var $elm$core$List$append = F2( + function (xs, ys) { + if (!ys.b) { + return xs; + } else { + return A3($elm$core$List$foldr, $elm$core$List$cons, ys, xs); + } + }); +var $rtfeldman$elm_css$Css$Structure$withKeyframeDeclarations = F2( + function (keyframesByName, compactedDeclarations) { + return A2( + $elm$core$List$append, + A2( + $elm$core$List$map, + function (_v0) { + var name = _v0.a; + var decl = _v0.b; + return $rtfeldman$elm_css$Css$Structure$Keyframes( + {declaration: decl, name: name}); + }, + $elm$core$Dict$toList(keyframesByName)), + compactedDeclarations); + }); +var $rtfeldman$elm_css$Css$Structure$compactDeclarations = function (declarations) { + var _v0 = A3( + $elm$core$List$foldr, + $rtfeldman$elm_css$Css$Structure$compactHelp, + _Utils_Tuple2($elm$core$Dict$empty, _List_Nil), + declarations); + var keyframesByName = _v0.a; + var compactedDeclarations = _v0.b; + return A2($rtfeldman$elm_css$Css$Structure$withKeyframeDeclarations, keyframesByName, compactedDeclarations); +}; +var $rtfeldman$elm_css$Css$Structure$compactStylesheet = function (_v0) { + var declarations = _v0.declarations; + var namespaces = _v0.namespaces; + var imports = _v0.imports; + var charset = _v0.charset; + return { + charset: charset, + declarations: $rtfeldman$elm_css$Css$Structure$compactDeclarations(declarations), + imports: imports, + namespaces: namespaces + }; +}; +var $elm$core$Maybe$map = F2( + function (f, maybe) { + if (maybe.$ === 'Just') { + var value = maybe.a; + return $elm$core$Maybe$Just( + f(value)); + } else { + return $elm$core$Maybe$Nothing; + } + }); +var $elm$core$Maybe$withDefault = F2( + function (_default, maybe) { + if (maybe.$ === 'Just') { + var value = maybe.a; + return value; + } else { + return _default; + } + }); +var $rtfeldman$elm_css$Css$Structure$Output$charsetToString = function (charset) { + return A2( + $elm$core$Maybe$withDefault, + '', + A2( + $elm$core$Maybe$map, + function (str) { + return '@charset \"' + (str + '\"'); + }, + charset)); +}; +var $rtfeldman$elm_css$Css$String$mapJoinHelp = F4( + function (map, sep, strs, result) { + mapJoinHelp: + while (true) { + if (!strs.b) { + return result; + } else { + if (!strs.b.b) { + var first = strs.a; + return result + (map(first) + ''); + } else { + var first = strs.a; + var rest = strs.b; + var $temp$map = map, + $temp$sep = sep, + $temp$strs = rest, + $temp$result = result + (map(first) + (sep + '')); + map = $temp$map; + sep = $temp$sep; + strs = $temp$strs; + result = $temp$result; + continue mapJoinHelp; + } + } + } + }); +var $rtfeldman$elm_css$Css$String$mapJoin = F3( + function (map, sep, strs) { + return A4($rtfeldman$elm_css$Css$String$mapJoinHelp, map, sep, strs, ''); + }); +var $rtfeldman$elm_css$Css$Structure$Output$mediaExpressionToString = function (expression) { + return '(' + (expression.feature + (A2( + $elm$core$Maybe$withDefault, + '', + A2( + $elm$core$Maybe$map, + $elm$core$Basics$append(': '), + expression.value)) + ')')); +}; +var $rtfeldman$elm_css$Css$Structure$Output$mediaTypeToString = function (mediaType) { + switch (mediaType.$) { + case 'Print': + return 'print'; + case 'Screen': + return 'screen'; + default: + return 'speech'; + } +}; +var $rtfeldman$elm_css$Css$Structure$Output$mediaQueryToString = function (mediaQuery) { + var prefixWith = F3( + function (str, mediaType, expressions) { + return str + (' ' + A2( + $elm$core$String$join, + ' and ', + A2( + $elm$core$List$cons, + $rtfeldman$elm_css$Css$Structure$Output$mediaTypeToString(mediaType), + A2($elm$core$List$map, $rtfeldman$elm_css$Css$Structure$Output$mediaExpressionToString, expressions)))); + }); + switch (mediaQuery.$) { + case 'AllQuery': + var expressions = mediaQuery.a; + return A3($rtfeldman$elm_css$Css$String$mapJoin, $rtfeldman$elm_css$Css$Structure$Output$mediaExpressionToString, ' and ', expressions); + case 'OnlyQuery': + var mediaType = mediaQuery.a; + var expressions = mediaQuery.b; + return A3(prefixWith, 'only', mediaType, expressions); + case 'NotQuery': + var mediaType = mediaQuery.a; + var expressions = mediaQuery.b; + return A3(prefixWith, 'not', mediaType, expressions); + default: + var str = mediaQuery.a; + return str; + } +}; +var $rtfeldman$elm_css$Css$Structure$Output$importMediaQueryToString = F2( + function (name, mediaQuery) { + return '@import \"' + (name + ($rtfeldman$elm_css$Css$Structure$Output$mediaQueryToString(mediaQuery) + '\"')); + }); +var $rtfeldman$elm_css$Css$Structure$Output$importToString = function (_v0) { + var name = _v0.a; + var mediaQueries = _v0.b; + return A3( + $rtfeldman$elm_css$Css$String$mapJoin, + $rtfeldman$elm_css$Css$Structure$Output$importMediaQueryToString(name), + '\n', + mediaQueries); +}; +var $rtfeldman$elm_css$Css$Structure$Output$namespaceToString = function (_v0) { + var prefix = _v0.a; + var str = _v0.b; + return '@namespace ' + (prefix + ('\"' + (str + '\"'))); +}; +var $rtfeldman$elm_css$Css$Structure$Output$emitProperties = function (properties) { + return A3( + $rtfeldman$elm_css$Css$String$mapJoin, + function (_v0) { + var prop = _v0.a; + return prop + ';'; + }, + '', + properties); +}; +var $elm$core$String$append = _String_append; +var $rtfeldman$elm_css$Css$Structure$Output$pseudoElementToString = function (_v0) { + var str = _v0.a; + return '::' + str; +}; +var $rtfeldman$elm_css$Css$Structure$Output$combinatorToString = function (combinator) { + switch (combinator.$) { + case 'AdjacentSibling': + return '+'; + case 'GeneralSibling': + return '~'; + case 'Child': + return '>'; + default: + return ''; + } +}; +var $rtfeldman$elm_css$Css$Structure$Output$repeatableSimpleSelectorToString = function (repeatableSimpleSelector) { + switch (repeatableSimpleSelector.$) { + case 'ClassSelector': + var str = repeatableSimpleSelector.a; + return '.' + str; + case 'IdSelector': + var str = repeatableSimpleSelector.a; + return '#' + str; + case 'PseudoClassSelector': + var str = repeatableSimpleSelector.a; + return ':' + str; + default: + var str = repeatableSimpleSelector.a; + return '[' + (str + ']'); + } +}; +var $rtfeldman$elm_css$Css$Structure$Output$simpleSelectorSequenceToString = function (simpleSelectorSequence) { + switch (simpleSelectorSequence.$) { + case 'TypeSelectorSequence': + var str = simpleSelectorSequence.a.a; + var repeatableSimpleSelectors = simpleSelectorSequence.b; + return _Utils_ap( + str, + A3($rtfeldman$elm_css$Css$String$mapJoin, $rtfeldman$elm_css$Css$Structure$Output$repeatableSimpleSelectorToString, '', repeatableSimpleSelectors)); + case 'UniversalSelectorSequence': + var repeatableSimpleSelectors = simpleSelectorSequence.a; + return $elm$core$List$isEmpty(repeatableSimpleSelectors) ? '*' : A3($rtfeldman$elm_css$Css$String$mapJoin, $rtfeldman$elm_css$Css$Structure$Output$repeatableSimpleSelectorToString, '', repeatableSimpleSelectors); + default: + var str = simpleSelectorSequence.a; + var repeatableSimpleSelectors = simpleSelectorSequence.b; + return _Utils_ap( + str, + A3($rtfeldman$elm_css$Css$String$mapJoin, $rtfeldman$elm_css$Css$Structure$Output$repeatableSimpleSelectorToString, '', repeatableSimpleSelectors)); + } +}; +var $rtfeldman$elm_css$Css$Structure$Output$selectorChainToString = function (_v0) { + var combinator = _v0.a; + var sequence = _v0.b; + return $rtfeldman$elm_css$Css$Structure$Output$combinatorToString(combinator) + (' ' + $rtfeldman$elm_css$Css$Structure$Output$simpleSelectorSequenceToString(sequence)); +}; +var $rtfeldman$elm_css$Css$Structure$Output$selectorToString = function (_v0) { + var simpleSelectorSequence = _v0.a; + var chain = _v0.b; + var pseudoElement = _v0.c; + var segments = A2( + $elm$core$List$cons, + $rtfeldman$elm_css$Css$Structure$Output$simpleSelectorSequenceToString(simpleSelectorSequence), + A2($elm$core$List$map, $rtfeldman$elm_css$Css$Structure$Output$selectorChainToString, chain)); + var pseudoElementsString = A2( + $elm$core$Maybe$withDefault, + '', + A2($elm$core$Maybe$map, $rtfeldman$elm_css$Css$Structure$Output$pseudoElementToString, pseudoElement)); + return A2( + $elm$core$String$append, + A2($elm$core$String$join, ' ', segments), + pseudoElementsString); +}; +var $rtfeldman$elm_css$Css$Structure$Output$prettyPrintStyleBlock = function (_v0) { + var firstSelector = _v0.a; + var otherSelectors = _v0.b; + var properties = _v0.c; + var selectorStr = A3( + $rtfeldman$elm_css$Css$String$mapJoin, + $rtfeldman$elm_css$Css$Structure$Output$selectorToString, + ',', + A2($elm$core$List$cons, firstSelector, otherSelectors)); + return selectorStr + ('{' + ($rtfeldman$elm_css$Css$Structure$Output$emitProperties(properties) + '}')); +}; +var $rtfeldman$elm_css$Css$Structure$Output$prettyPrintDeclaration = function (decl) { + switch (decl.$) { + case 'StyleBlockDeclaration': + var styleBlock = decl.a; + return $rtfeldman$elm_css$Css$Structure$Output$prettyPrintStyleBlock(styleBlock); + case 'MediaRule': + var mediaQueries = decl.a; + var styleBlocks = decl.b; + var query = A3($rtfeldman$elm_css$Css$String$mapJoin, $rtfeldman$elm_css$Css$Structure$Output$mediaQueryToString, ', ', mediaQueries); + var blocks = A3($rtfeldman$elm_css$Css$String$mapJoin, $rtfeldman$elm_css$Css$Structure$Output$prettyPrintStyleBlock, '\n', styleBlocks); + return '@media ' + (query + ('{' + (blocks + '}'))); + case 'SupportsRule': + return 'TODO'; + case 'DocumentRule': + return 'TODO'; + case 'PageRule': + return 'TODO'; + case 'FontFace': + return 'TODO'; + case 'Keyframes': + var declaration = decl.a.declaration; + var name = decl.a.name; + return '@keyframes ' + (name + ('{' + (declaration + '}'))); + case 'Viewport': + return 'TODO'; + case 'CounterStyle': + return 'TODO'; + default: + return 'TODO'; + } +}; +var $rtfeldman$elm_css$Css$Structure$Output$prettyPrint = function (_v0) { + var declarations = _v0.declarations; + var namespaces = _v0.namespaces; + var imports = _v0.imports; + var charset = _v0.charset; + return $rtfeldman$elm_css$Css$Structure$Output$charsetToString(charset) + (A3($rtfeldman$elm_css$Css$String$mapJoin, $rtfeldman$elm_css$Css$Structure$Output$importToString, '\n', imports) + (A3($rtfeldman$elm_css$Css$String$mapJoin, $rtfeldman$elm_css$Css$Structure$Output$namespaceToString, '\n', namespaces) + (A3($rtfeldman$elm_css$Css$String$mapJoin, $rtfeldman$elm_css$Css$Structure$Output$prettyPrintDeclaration, '\n', declarations) + ''))); +}; +var $elm$core$List$concat = function (lists) { + return A3($elm$core$List$foldr, $elm$core$List$append, _List_Nil, lists); +}; +var $elm$core$List$concatMap = F2( + function (f, list) { + return $elm$core$List$concat( + A2($elm$core$List$map, f, list)); + }); +var $rtfeldman$elm_css$Css$Structure$CounterStyle = function (a) { + return {$: 'CounterStyle', a: a}; +}; +var $rtfeldman$elm_css$Css$Structure$FontFace = function (a) { + return {$: 'FontFace', a: a}; +}; +var $rtfeldman$elm_css$Css$Structure$PageRule = function (a) { + return {$: 'PageRule', a: a}; +}; +var $rtfeldman$elm_css$Css$Structure$Selector = F3( + function (a, b, c) { + return {$: 'Selector', a: a, b: b, c: c}; + }); +var $rtfeldman$elm_css$Css$Structure$StyleBlock = F3( + function (a, b, c) { + return {$: 'StyleBlock', a: a, b: b, c: c}; + }); +var $rtfeldman$elm_css$Css$Structure$StyleBlockDeclaration = function (a) { + return {$: 'StyleBlockDeclaration', a: a}; +}; +var $rtfeldman$elm_css$Css$Structure$SupportsRule = F2( + function (a, b) { + return {$: 'SupportsRule', a: a, b: b}; + }); +var $rtfeldman$elm_css$Css$Structure$Viewport = function (a) { + return {$: 'Viewport', a: a}; +}; +var $rtfeldman$elm_css$Css$Structure$MediaRule = F2( + function (a, b) { + return {$: 'MediaRule', a: a, b: b}; + }); +var $rtfeldman$elm_css$Css$Structure$mapLast = F2( + function (update, list) { + if (!list.b) { + return list; + } else { + if (!list.b.b) { + var only = list.a; + return _List_fromArray( + [ + update(only) + ]); + } else { + var first = list.a; + var rest = list.b; + return A2( + $elm$core$List$cons, + first, + A2($rtfeldman$elm_css$Css$Structure$mapLast, update, rest)); + } + } + }); +var $rtfeldman$elm_css$Css$Structure$withPropertyAppended = F2( + function (property, _v0) { + var firstSelector = _v0.a; + var otherSelectors = _v0.b; + var properties = _v0.c; + return A3( + $rtfeldman$elm_css$Css$Structure$StyleBlock, + firstSelector, + otherSelectors, + _Utils_ap( + properties, + _List_fromArray( + [property]))); + }); +var $rtfeldman$elm_css$Css$Structure$appendProperty = F2( + function (property, declarations) { + if (!declarations.b) { + return declarations; + } else { + if (!declarations.b.b) { + switch (declarations.a.$) { + case 'StyleBlockDeclaration': + var styleBlock = declarations.a.a; + return _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$StyleBlockDeclaration( + A2($rtfeldman$elm_css$Css$Structure$withPropertyAppended, property, styleBlock)) + ]); + case 'MediaRule': + var _v1 = declarations.a; + var mediaQueries = _v1.a; + var styleBlocks = _v1.b; + return _List_fromArray( + [ + A2( + $rtfeldman$elm_css$Css$Structure$MediaRule, + mediaQueries, + A2( + $rtfeldman$elm_css$Css$Structure$mapLast, + $rtfeldman$elm_css$Css$Structure$withPropertyAppended(property), + styleBlocks)) + ]); + default: + return declarations; + } + } else { + var first = declarations.a; + var rest = declarations.b; + return A2( + $elm$core$List$cons, + first, + A2($rtfeldman$elm_css$Css$Structure$appendProperty, property, rest)); + } + } + }); +var $rtfeldman$elm_css$Css$Structure$appendToLastSelector = F2( + function (f, styleBlock) { + if (!styleBlock.b.b) { + var only = styleBlock.a; + var properties = styleBlock.c; + return _List_fromArray( + [ + A3($rtfeldman$elm_css$Css$Structure$StyleBlock, only, _List_Nil, properties), + A3( + $rtfeldman$elm_css$Css$Structure$StyleBlock, + f(only), + _List_Nil, + _List_Nil) + ]); + } else { + var first = styleBlock.a; + var rest = styleBlock.b; + var properties = styleBlock.c; + var newRest = A2($elm$core$List$map, f, rest); + var newFirst = f(first); + return _List_fromArray( + [ + A3($rtfeldman$elm_css$Css$Structure$StyleBlock, first, rest, properties), + A3($rtfeldman$elm_css$Css$Structure$StyleBlock, newFirst, newRest, _List_Nil) + ]); + } + }); +var $rtfeldman$elm_css$Css$Structure$applyPseudoElement = F2( + function (pseudo, _v0) { + var sequence = _v0.a; + var selectors = _v0.b; + return A3( + $rtfeldman$elm_css$Css$Structure$Selector, + sequence, + selectors, + $elm$core$Maybe$Just(pseudo)); + }); +var $rtfeldman$elm_css$Css$Structure$appendPseudoElementToLastSelector = F2( + function (pseudo, styleBlock) { + return A2( + $rtfeldman$elm_css$Css$Structure$appendToLastSelector, + $rtfeldman$elm_css$Css$Structure$applyPseudoElement(pseudo), + styleBlock); + }); +var $rtfeldman$elm_css$Css$Structure$CustomSelector = F2( + function (a, b) { + return {$: 'CustomSelector', a: a, b: b}; + }); +var $rtfeldman$elm_css$Css$Structure$TypeSelectorSequence = F2( + function (a, b) { + return {$: 'TypeSelectorSequence', a: a, b: b}; + }); +var $rtfeldman$elm_css$Css$Structure$UniversalSelectorSequence = function (a) { + return {$: 'UniversalSelectorSequence', a: a}; +}; +var $rtfeldman$elm_css$Css$Structure$appendRepeatable = F2( + function (selector, sequence) { + switch (sequence.$) { + case 'TypeSelectorSequence': + var typeSelector = sequence.a; + var list = sequence.b; + return A2( + $rtfeldman$elm_css$Css$Structure$TypeSelectorSequence, + typeSelector, + _Utils_ap( + list, + _List_fromArray( + [selector]))); + case 'UniversalSelectorSequence': + var list = sequence.a; + return $rtfeldman$elm_css$Css$Structure$UniversalSelectorSequence( + _Utils_ap( + list, + _List_fromArray( + [selector]))); + default: + var str = sequence.a; + var list = sequence.b; + return A2( + $rtfeldman$elm_css$Css$Structure$CustomSelector, + str, + _Utils_ap( + list, + _List_fromArray( + [selector]))); + } + }); +var $rtfeldman$elm_css$Css$Structure$appendRepeatableWithCombinator = F2( + function (selector, list) { + if (!list.b) { + return _List_Nil; + } else { + if (!list.b.b) { + var _v1 = list.a; + var combinator = _v1.a; + var sequence = _v1.b; + return _List_fromArray( + [ + _Utils_Tuple2( + combinator, + A2($rtfeldman$elm_css$Css$Structure$appendRepeatable, selector, sequence)) + ]); + } else { + var first = list.a; + var rest = list.b; + return A2( + $elm$core$List$cons, + first, + A2($rtfeldman$elm_css$Css$Structure$appendRepeatableWithCombinator, selector, rest)); + } + } + }); +var $rtfeldman$elm_css$Css$Structure$appendRepeatableSelector = F2( + function (repeatableSimpleSelector, selector) { + if (!selector.b.b) { + var sequence = selector.a; + var pseudoElement = selector.c; + return A3( + $rtfeldman$elm_css$Css$Structure$Selector, + A2($rtfeldman$elm_css$Css$Structure$appendRepeatable, repeatableSimpleSelector, sequence), + _List_Nil, + pseudoElement); + } else { + var firstSelector = selector.a; + var tuples = selector.b; + var pseudoElement = selector.c; + return A3( + $rtfeldman$elm_css$Css$Structure$Selector, + firstSelector, + A2($rtfeldman$elm_css$Css$Structure$appendRepeatableWithCombinator, repeatableSimpleSelector, tuples), + pseudoElement); + } + }); +var $rtfeldman$elm_css$Css$Structure$appendRepeatableToLastSelector = F2( + function (selector, styleBlock) { + return A2( + $rtfeldman$elm_css$Css$Structure$appendToLastSelector, + $rtfeldman$elm_css$Css$Structure$appendRepeatableSelector(selector), + styleBlock); + }); +var $rtfeldman$elm_css$Css$Preprocess$Resolve$collectSelectors = function (declarations) { + collectSelectors: + while (true) { + if (!declarations.b) { + return _List_Nil; + } else { + if (declarations.a.$ === 'StyleBlockDeclaration') { + var _v1 = declarations.a.a; + var firstSelector = _v1.a; + var otherSelectors = _v1.b; + var rest = declarations.b; + return _Utils_ap( + A2($elm$core$List$cons, firstSelector, otherSelectors), + $rtfeldman$elm_css$Css$Preprocess$Resolve$collectSelectors(rest)); + } else { + var rest = declarations.b; + var $temp$declarations = rest; + declarations = $temp$declarations; + continue collectSelectors; + } + } + } +}; +var $rtfeldman$elm_css$Css$Structure$DocumentRule = F5( + function (a, b, c, d, e) { + return {$: 'DocumentRule', a: a, b: b, c: c, d: d, e: e}; + }); +var $rtfeldman$elm_css$Css$Structure$concatMapLastStyleBlock = F2( + function (update, declarations) { + _v0$12: + while (true) { + if (!declarations.b) { + return declarations; + } else { + if (!declarations.b.b) { + switch (declarations.a.$) { + case 'StyleBlockDeclaration': + var styleBlock = declarations.a.a; + return A2( + $elm$core$List$map, + $rtfeldman$elm_css$Css$Structure$StyleBlockDeclaration, + update(styleBlock)); + case 'MediaRule': + if (declarations.a.b.b) { + if (!declarations.a.b.b.b) { + var _v1 = declarations.a; + var mediaQueries = _v1.a; + var _v2 = _v1.b; + var styleBlock = _v2.a; + return _List_fromArray( + [ + A2( + $rtfeldman$elm_css$Css$Structure$MediaRule, + mediaQueries, + update(styleBlock)) + ]); + } else { + var _v3 = declarations.a; + var mediaQueries = _v3.a; + var _v4 = _v3.b; + var first = _v4.a; + var rest = _v4.b; + var _v5 = A2( + $rtfeldman$elm_css$Css$Structure$concatMapLastStyleBlock, + update, + _List_fromArray( + [ + A2($rtfeldman$elm_css$Css$Structure$MediaRule, mediaQueries, rest) + ])); + if ((_v5.b && (_v5.a.$ === 'MediaRule')) && (!_v5.b.b)) { + var _v6 = _v5.a; + var newMediaQueries = _v6.a; + var newStyleBlocks = _v6.b; + return _List_fromArray( + [ + A2( + $rtfeldman$elm_css$Css$Structure$MediaRule, + newMediaQueries, + A2($elm$core$List$cons, first, newStyleBlocks)) + ]); + } else { + var newDeclarations = _v5; + return newDeclarations; + } + } + } else { + break _v0$12; + } + case 'SupportsRule': + var _v7 = declarations.a; + var str = _v7.a; + var nestedDeclarations = _v7.b; + return _List_fromArray( + [ + A2( + $rtfeldman$elm_css$Css$Structure$SupportsRule, + str, + A2($rtfeldman$elm_css$Css$Structure$concatMapLastStyleBlock, update, nestedDeclarations)) + ]); + case 'DocumentRule': + var _v8 = declarations.a; + var str1 = _v8.a; + var str2 = _v8.b; + var str3 = _v8.c; + var str4 = _v8.d; + var styleBlock = _v8.e; + return A2( + $elm$core$List$map, + A4($rtfeldman$elm_css$Css$Structure$DocumentRule, str1, str2, str3, str4), + update(styleBlock)); + case 'PageRule': + return declarations; + case 'FontFace': + return declarations; + case 'Keyframes': + return declarations; + case 'Viewport': + return declarations; + case 'CounterStyle': + return declarations; + default: + return declarations; + } + } else { + break _v0$12; + } + } + } + var first = declarations.a; + var rest = declarations.b; + return A2( + $elm$core$List$cons, + first, + A2($rtfeldman$elm_css$Css$Structure$concatMapLastStyleBlock, update, rest)); + }); +var $elm$core$String$cons = _String_cons; +var $robinheghan$murmur3$Murmur3$HashData = F4( + function (shift, seed, hash, charsProcessed) { + return {charsProcessed: charsProcessed, hash: hash, seed: seed, shift: shift}; + }); +var $robinheghan$murmur3$Murmur3$c1 = 3432918353; +var $robinheghan$murmur3$Murmur3$c2 = 461845907; +var $elm$core$Bitwise$and = _Bitwise_and; +var $elm$core$Bitwise$shiftLeftBy = _Bitwise_shiftLeftBy; +var $elm$core$Bitwise$shiftRightZfBy = _Bitwise_shiftRightZfBy; +var $robinheghan$murmur3$Murmur3$multiplyBy = F2( + function (b, a) { + return ((a & 65535) * b) + ((((a >>> 16) * b) & 65535) << 16); + }); +var $elm$core$Basics$neq = _Utils_notEqual; +var $elm$core$Bitwise$or = _Bitwise_or; +var $robinheghan$murmur3$Murmur3$rotlBy = F2( + function (b, a) { + return (a << b) | (a >>> (32 - b)); + }); +var $elm$core$Bitwise$xor = _Bitwise_xor; +var $robinheghan$murmur3$Murmur3$finalize = function (data) { + var acc = (!(!data.hash)) ? (data.seed ^ A2( + $robinheghan$murmur3$Murmur3$multiplyBy, + $robinheghan$murmur3$Murmur3$c2, + A2( + $robinheghan$murmur3$Murmur3$rotlBy, + 15, + A2($robinheghan$murmur3$Murmur3$multiplyBy, $robinheghan$murmur3$Murmur3$c1, data.hash)))) : data.seed; + var h0 = acc ^ data.charsProcessed; + var h1 = A2($robinheghan$murmur3$Murmur3$multiplyBy, 2246822507, h0 ^ (h0 >>> 16)); + var h2 = A2($robinheghan$murmur3$Murmur3$multiplyBy, 3266489909, h1 ^ (h1 >>> 13)); + return (h2 ^ (h2 >>> 16)) >>> 0; +}; +var $elm$core$String$foldl = _String_foldl; +var $robinheghan$murmur3$Murmur3$mix = F2( + function (h1, k1) { + return A2( + $robinheghan$murmur3$Murmur3$multiplyBy, + 5, + A2( + $robinheghan$murmur3$Murmur3$rotlBy, + 13, + h1 ^ A2( + $robinheghan$murmur3$Murmur3$multiplyBy, + $robinheghan$murmur3$Murmur3$c2, + A2( + $robinheghan$murmur3$Murmur3$rotlBy, + 15, + A2($robinheghan$murmur3$Murmur3$multiplyBy, $robinheghan$murmur3$Murmur3$c1, k1))))) + 3864292196; + }); +var $robinheghan$murmur3$Murmur3$hashFold = F2( + function (c, data) { + var res = data.hash | ((255 & $elm$core$Char$toCode(c)) << data.shift); + var _v0 = data.shift; + if (_v0 === 24) { + return { + charsProcessed: data.charsProcessed + 1, + hash: 0, + seed: A2($robinheghan$murmur3$Murmur3$mix, data.seed, res), + shift: 0 + }; + } else { + return {charsProcessed: data.charsProcessed + 1, hash: res, seed: data.seed, shift: data.shift + 8}; + } + }); +var $robinheghan$murmur3$Murmur3$hashString = F2( + function (seed, str) { + return $robinheghan$murmur3$Murmur3$finalize( + A3( + $elm$core$String$foldl, + $robinheghan$murmur3$Murmur3$hashFold, + A4($robinheghan$murmur3$Murmur3$HashData, 0, seed, 0, 0), + str)); + }); +var $rtfeldman$elm_css$Hash$initialSeed = 15739; +var $elm$core$String$fromList = _String_fromList; +var $elm$core$Basics$negate = function (n) { + return -n; +}; +var $elm$core$Basics$modBy = _Basics_modBy; +var $rtfeldman$elm_hex$Hex$unsafeToDigit = function (num) { + unsafeToDigit: + while (true) { + switch (num) { + case 0: + return _Utils_chr('0'); + case 1: + return _Utils_chr('1'); + case 2: + return _Utils_chr('2'); + case 3: + return _Utils_chr('3'); + case 4: + return _Utils_chr('4'); + case 5: + return _Utils_chr('5'); + case 6: + return _Utils_chr('6'); + case 7: + return _Utils_chr('7'); + case 8: + return _Utils_chr('8'); + case 9: + return _Utils_chr('9'); + case 10: + return _Utils_chr('a'); + case 11: + return _Utils_chr('b'); + case 12: + return _Utils_chr('c'); + case 13: + return _Utils_chr('d'); + case 14: + return _Utils_chr('e'); + case 15: + return _Utils_chr('f'); + default: + var $temp$num = num; + num = $temp$num; + continue unsafeToDigit; + } + } +}; +var $rtfeldman$elm_hex$Hex$unsafePositiveToDigits = F2( + function (digits, num) { + unsafePositiveToDigits: + while (true) { + if (num < 16) { + return A2( + $elm$core$List$cons, + $rtfeldman$elm_hex$Hex$unsafeToDigit(num), + digits); + } else { + var $temp$digits = A2( + $elm$core$List$cons, + $rtfeldman$elm_hex$Hex$unsafeToDigit( + A2($elm$core$Basics$modBy, 16, num)), + digits), + $temp$num = (num / 16) | 0; + digits = $temp$digits; + num = $temp$num; + continue unsafePositiveToDigits; + } + } + }); +var $rtfeldman$elm_hex$Hex$toString = function (num) { + return $elm$core$String$fromList( + (num < 0) ? A2( + $elm$core$List$cons, + _Utils_chr('-'), + A2($rtfeldman$elm_hex$Hex$unsafePositiveToDigits, _List_Nil, -num)) : A2($rtfeldman$elm_hex$Hex$unsafePositiveToDigits, _List_Nil, num)); +}; +var $rtfeldman$elm_css$Hash$fromString = function (str) { + return A2( + $elm$core$String$cons, + _Utils_chr('_'), + $rtfeldman$elm_hex$Hex$toString( + A2($robinheghan$murmur3$Murmur3$hashString, $rtfeldman$elm_css$Hash$initialSeed, str))); +}; +var $elm$core$List$head = function (list) { + if (list.b) { + var x = list.a; + var xs = list.b; + return $elm$core$Maybe$Just(x); + } else { + return $elm$core$Maybe$Nothing; + } +}; +var $rtfeldman$elm_css$Css$Preprocess$Resolve$last = function (list) { + last: + while (true) { + if (!list.b) { + return $elm$core$Maybe$Nothing; + } else { + if (!list.b.b) { + var singleton = list.a; + return $elm$core$Maybe$Just(singleton); + } else { + var rest = list.b; + var $temp$list = rest; + list = $temp$list; + continue last; + } + } + } +}; +var $rtfeldman$elm_css$Css$Preprocess$Resolve$lastDeclaration = function (declarations) { + lastDeclaration: + while (true) { + if (!declarations.b) { + return $elm$core$Maybe$Nothing; + } else { + if (!declarations.b.b) { + var x = declarations.a; + return $elm$core$Maybe$Just( + _List_fromArray( + [x])); + } else { + var xs = declarations.b; + var $temp$declarations = xs; + declarations = $temp$declarations; + continue lastDeclaration; + } + } + } +}; +var $rtfeldman$elm_css$Css$Preprocess$Resolve$oneOf = function (maybes) { + oneOf: + while (true) { + if (!maybes.b) { + return $elm$core$Maybe$Nothing; + } else { + var maybe = maybes.a; + var rest = maybes.b; + if (maybe.$ === 'Nothing') { + var $temp$maybes = rest; + maybes = $temp$maybes; + continue oneOf; + } else { + return maybe; + } + } + } +}; +var $rtfeldman$elm_css$Css$Structure$FontFeatureValues = function (a) { + return {$: 'FontFeatureValues', a: a}; +}; +var $rtfeldman$elm_css$Css$Preprocess$Resolve$resolveFontFeatureValues = function (tuples) { + var expandTuples = function (tuplesToExpand) { + if (!tuplesToExpand.b) { + return _List_Nil; + } else { + var properties = tuplesToExpand.a; + var rest = tuplesToExpand.b; + return A2( + $elm$core$List$cons, + properties, + expandTuples(rest)); + } + }; + var newTuples = expandTuples(tuples); + return _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$FontFeatureValues(newTuples) + ]); +}; +var $elm$core$List$singleton = function (value) { + return _List_fromArray( + [value]); +}; +var $rtfeldman$elm_css$Css$Structure$styleBlockToMediaRule = F2( + function (mediaQueries, declaration) { + if (declaration.$ === 'StyleBlockDeclaration') { + var styleBlock = declaration.a; + return A2( + $rtfeldman$elm_css$Css$Structure$MediaRule, + mediaQueries, + _List_fromArray( + [styleBlock])); + } else { + return declaration; + } + }); +var $elm$core$List$tail = function (list) { + if (list.b) { + var x = list.a; + var xs = list.b; + return $elm$core$Maybe$Just(xs); + } else { + return $elm$core$Maybe$Nothing; + } +}; +var $elm$core$List$takeReverse = F3( + function (n, list, kept) { + takeReverse: + while (true) { + if (n <= 0) { + return kept; + } else { + if (!list.b) { + return kept; + } else { + var x = list.a; + var xs = list.b; + var $temp$n = n - 1, + $temp$list = xs, + $temp$kept = A2($elm$core$List$cons, x, kept); + n = $temp$n; + list = $temp$list; + kept = $temp$kept; + continue takeReverse; + } + } + } + }); +var $elm$core$List$takeTailRec = F2( + function (n, list) { + return $elm$core$List$reverse( + A3($elm$core$List$takeReverse, n, list, _List_Nil)); + }); +var $elm$core$List$takeFast = F3( + function (ctr, n, list) { + if (n <= 0) { + return _List_Nil; + } else { + var _v0 = _Utils_Tuple2(n, list); + _v0$1: + while (true) { + _v0$5: + while (true) { + if (!_v0.b.b) { + return list; + } else { + if (_v0.b.b.b) { + switch (_v0.a) { + case 1: + break _v0$1; + case 2: + var _v2 = _v0.b; + var x = _v2.a; + var _v3 = _v2.b; + var y = _v3.a; + return _List_fromArray( + [x, y]); + case 3: + if (_v0.b.b.b.b) { + var _v4 = _v0.b; + var x = _v4.a; + var _v5 = _v4.b; + var y = _v5.a; + var _v6 = _v5.b; + var z = _v6.a; + return _List_fromArray( + [x, y, z]); + } else { + break _v0$5; + } + default: + if (_v0.b.b.b.b && _v0.b.b.b.b.b) { + var _v7 = _v0.b; + var x = _v7.a; + var _v8 = _v7.b; + var y = _v8.a; + var _v9 = _v8.b; + var z = _v9.a; + var _v10 = _v9.b; + var w = _v10.a; + var tl = _v10.b; + return (ctr > 1000) ? A2( + $elm$core$List$cons, + x, + A2( + $elm$core$List$cons, + y, + A2( + $elm$core$List$cons, + z, + A2( + $elm$core$List$cons, + w, + A2($elm$core$List$takeTailRec, n - 4, tl))))) : A2( + $elm$core$List$cons, + x, + A2( + $elm$core$List$cons, + y, + A2( + $elm$core$List$cons, + z, + A2( + $elm$core$List$cons, + w, + A3($elm$core$List$takeFast, ctr + 1, n - 4, tl))))); + } else { + break _v0$5; + } + } + } else { + if (_v0.a === 1) { + break _v0$1; + } else { + break _v0$5; + } + } + } + } + return list; + } + var _v1 = _v0.b; + var x = _v1.a; + return _List_fromArray( + [x]); + } + }); +var $elm$core$List$take = F2( + function (n, list) { + return A3($elm$core$List$takeFast, 0, n, list); + }); +var $rtfeldman$elm_css$Css$Preprocess$Resolve$toDocumentRule = F5( + function (str1, str2, str3, str4, declaration) { + if (declaration.$ === 'StyleBlockDeclaration') { + var structureStyleBlock = declaration.a; + return A5($rtfeldman$elm_css$Css$Structure$DocumentRule, str1, str2, str3, str4, structureStyleBlock); + } else { + return declaration; + } + }); +var $rtfeldman$elm_css$Css$Preprocess$Resolve$toMediaRule = F2( + function (mediaQueries, declaration) { + switch (declaration.$) { + case 'StyleBlockDeclaration': + var structureStyleBlock = declaration.a; + return A2( + $rtfeldman$elm_css$Css$Structure$MediaRule, + mediaQueries, + _List_fromArray( + [structureStyleBlock])); + case 'MediaRule': + var newMediaQueries = declaration.a; + var structureStyleBlocks = declaration.b; + return A2( + $rtfeldman$elm_css$Css$Structure$MediaRule, + _Utils_ap(mediaQueries, newMediaQueries), + structureStyleBlocks); + case 'SupportsRule': + var str = declaration.a; + var declarations = declaration.b; + return A2( + $rtfeldman$elm_css$Css$Structure$SupportsRule, + str, + A2( + $elm$core$List$map, + $rtfeldman$elm_css$Css$Preprocess$Resolve$toMediaRule(mediaQueries), + declarations)); + case 'DocumentRule': + var str1 = declaration.a; + var str2 = declaration.b; + var str3 = declaration.c; + var str4 = declaration.d; + var structureStyleBlock = declaration.e; + return A5($rtfeldman$elm_css$Css$Structure$DocumentRule, str1, str2, str3, str4, structureStyleBlock); + case 'PageRule': + return declaration; + case 'FontFace': + return declaration; + case 'Keyframes': + return declaration; + case 'Viewport': + return declaration; + case 'CounterStyle': + return declaration; + default: + return declaration; + } + }); +var $rtfeldman$elm_css$Css$Preprocess$unwrapSnippet = function (_v0) { + var declarations = _v0.a; + return declarations; +}; +var $rtfeldman$elm_css$Css$Preprocess$Resolve$applyNestedStylesToLast = F4( + function (nestedStyles, rest, f, declarations) { + var withoutParent = function (decls) { + return A2( + $elm$core$Maybe$withDefault, + _List_Nil, + $elm$core$List$tail(decls)); + }; + var nextResult = A2( + $rtfeldman$elm_css$Css$Preprocess$Resolve$applyStyles, + rest, + A2( + $elm$core$Maybe$withDefault, + _List_Nil, + $rtfeldman$elm_css$Css$Preprocess$Resolve$lastDeclaration(declarations))); + var newDeclarations = function () { + var _v14 = _Utils_Tuple2( + $elm$core$List$head(nextResult), + $rtfeldman$elm_css$Css$Preprocess$Resolve$last(declarations)); + if ((_v14.a.$ === 'Just') && (_v14.b.$ === 'Just')) { + var nextResultParent = _v14.a.a; + var originalParent = _v14.b.a; + return _Utils_ap( + A2( + $elm$core$List$take, + $elm$core$List$length(declarations) - 1, + declarations), + _List_fromArray( + [ + (!_Utils_eq(originalParent, nextResultParent)) ? nextResultParent : originalParent + ])); + } else { + return declarations; + } + }(); + var insertStylesToNestedDecl = function (lastDecl) { + return $elm$core$List$concat( + A2( + $rtfeldman$elm_css$Css$Structure$mapLast, + $rtfeldman$elm_css$Css$Preprocess$Resolve$applyStyles(nestedStyles), + A2( + $elm$core$List$map, + $elm$core$List$singleton, + A2($rtfeldman$elm_css$Css$Structure$concatMapLastStyleBlock, f, lastDecl)))); + }; + var initialResult = A2( + $elm$core$Maybe$withDefault, + _List_Nil, + A2( + $elm$core$Maybe$map, + insertStylesToNestedDecl, + $rtfeldman$elm_css$Css$Preprocess$Resolve$lastDeclaration(declarations))); + return _Utils_ap( + newDeclarations, + _Utils_ap( + withoutParent(initialResult), + withoutParent(nextResult))); + }); +var $rtfeldman$elm_css$Css$Preprocess$Resolve$applyStyles = F2( + function (styles, declarations) { + if (!styles.b) { + return declarations; + } else { + switch (styles.a.$) { + case 'AppendProperty': + var property = styles.a.a; + var rest = styles.b; + return A2( + $rtfeldman$elm_css$Css$Preprocess$Resolve$applyStyles, + rest, + A2($rtfeldman$elm_css$Css$Structure$appendProperty, property, declarations)); + case 'ExtendSelector': + var _v4 = styles.a; + var selector = _v4.a; + var nestedStyles = _v4.b; + var rest = styles.b; + return A4( + $rtfeldman$elm_css$Css$Preprocess$Resolve$applyNestedStylesToLast, + nestedStyles, + rest, + $rtfeldman$elm_css$Css$Structure$appendRepeatableToLastSelector(selector), + declarations); + case 'NestSnippet': + var _v5 = styles.a; + var selectorCombinator = _v5.a; + var snippets = _v5.b; + var rest = styles.b; + var chain = F2( + function (_v9, _v10) { + var originalSequence = _v9.a; + var originalTuples = _v9.b; + var originalPseudoElement = _v9.c; + var newSequence = _v10.a; + var newTuples = _v10.b; + var newPseudoElement = _v10.c; + return A3( + $rtfeldman$elm_css$Css$Structure$Selector, + originalSequence, + _Utils_ap( + originalTuples, + A2( + $elm$core$List$cons, + _Utils_Tuple2(selectorCombinator, newSequence), + newTuples)), + $rtfeldman$elm_css$Css$Preprocess$Resolve$oneOf( + _List_fromArray( + [newPseudoElement, originalPseudoElement]))); + }); + var expandDeclaration = function (declaration) { + switch (declaration.$) { + case 'StyleBlockDeclaration': + var _v7 = declaration.a; + var firstSelector = _v7.a; + var otherSelectors = _v7.b; + var nestedStyles = _v7.c; + var newSelectors = A2( + $elm$core$List$concatMap, + function (originalSelector) { + return A2( + $elm$core$List$map, + chain(originalSelector), + A2($elm$core$List$cons, firstSelector, otherSelectors)); + }, + $rtfeldman$elm_css$Css$Preprocess$Resolve$collectSelectors(declarations)); + var newDeclarations = function () { + if (!newSelectors.b) { + return _List_Nil; + } else { + var first = newSelectors.a; + var remainder = newSelectors.b; + return _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$StyleBlockDeclaration( + A3($rtfeldman$elm_css$Css$Structure$StyleBlock, first, remainder, _List_Nil)) + ]); + } + }(); + return A2($rtfeldman$elm_css$Css$Preprocess$Resolve$applyStyles, nestedStyles, newDeclarations); + case 'MediaRule': + var mediaQueries = declaration.a; + var styleBlocks = declaration.b; + return A2($rtfeldman$elm_css$Css$Preprocess$Resolve$resolveMediaRule, mediaQueries, styleBlocks); + case 'SupportsRule': + var str = declaration.a; + var otherSnippets = declaration.b; + return A2($rtfeldman$elm_css$Css$Preprocess$Resolve$resolveSupportsRule, str, otherSnippets); + case 'DocumentRule': + var str1 = declaration.a; + var str2 = declaration.b; + var str3 = declaration.c; + var str4 = declaration.d; + var styleBlock = declaration.e; + return A2( + $elm$core$List$map, + A4($rtfeldman$elm_css$Css$Preprocess$Resolve$toDocumentRule, str1, str2, str3, str4), + $rtfeldman$elm_css$Css$Preprocess$Resolve$expandStyleBlock(styleBlock)); + case 'PageRule': + var properties = declaration.a; + return _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$PageRule(properties) + ]); + case 'FontFace': + var properties = declaration.a; + return _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$FontFace(properties) + ]); + case 'Viewport': + var properties = declaration.a; + return _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$Viewport(properties) + ]); + case 'CounterStyle': + var properties = declaration.a; + return _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$CounterStyle(properties) + ]); + default: + var tuples = declaration.a; + return $rtfeldman$elm_css$Css$Preprocess$Resolve$resolveFontFeatureValues(tuples); + } + }; + return $elm$core$List$concat( + _Utils_ap( + _List_fromArray( + [ + A2($rtfeldman$elm_css$Css$Preprocess$Resolve$applyStyles, rest, declarations) + ]), + A2( + $elm$core$List$map, + expandDeclaration, + A2($elm$core$List$concatMap, $rtfeldman$elm_css$Css$Preprocess$unwrapSnippet, snippets)))); + case 'WithPseudoElement': + var _v11 = styles.a; + var pseudoElement = _v11.a; + var nestedStyles = _v11.b; + var rest = styles.b; + return A4( + $rtfeldman$elm_css$Css$Preprocess$Resolve$applyNestedStylesToLast, + nestedStyles, + rest, + $rtfeldman$elm_css$Css$Structure$appendPseudoElementToLastSelector(pseudoElement), + declarations); + case 'WithKeyframes': + var str = styles.a.a; + var rest = styles.b; + var name = $rtfeldman$elm_css$Hash$fromString(str); + var newProperty = $rtfeldman$elm_css$Css$Structure$Property('animation-name:' + name); + var newDeclarations = A2( + $rtfeldman$elm_css$Css$Preprocess$Resolve$applyStyles, + rest, + A2($rtfeldman$elm_css$Css$Structure$appendProperty, newProperty, declarations)); + return A2( + $elm$core$List$append, + newDeclarations, + _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$Keyframes( + {declaration: str, name: name}) + ])); + case 'WithMedia': + var _v12 = styles.a; + var mediaQueries = _v12.a; + var nestedStyles = _v12.b; + var rest = styles.b; + var extraDeclarations = function () { + var _v13 = $rtfeldman$elm_css$Css$Preprocess$Resolve$collectSelectors(declarations); + if (!_v13.b) { + return _List_Nil; + } else { + var firstSelector = _v13.a; + var otherSelectors = _v13.b; + return A2( + $elm$core$List$map, + $rtfeldman$elm_css$Css$Structure$styleBlockToMediaRule(mediaQueries), + A2( + $rtfeldman$elm_css$Css$Preprocess$Resolve$applyStyles, + nestedStyles, + $elm$core$List$singleton( + $rtfeldman$elm_css$Css$Structure$StyleBlockDeclaration( + A3($rtfeldman$elm_css$Css$Structure$StyleBlock, firstSelector, otherSelectors, _List_Nil))))); + } + }(); + return _Utils_ap( + A2($rtfeldman$elm_css$Css$Preprocess$Resolve$applyStyles, rest, declarations), + extraDeclarations); + default: + var otherStyles = styles.a.a; + var rest = styles.b; + return A2( + $rtfeldman$elm_css$Css$Preprocess$Resolve$applyStyles, + _Utils_ap(otherStyles, rest), + declarations); + } + } + }); +var $rtfeldman$elm_css$Css$Preprocess$Resolve$expandStyleBlock = function (_v2) { + var firstSelector = _v2.a; + var otherSelectors = _v2.b; + var styles = _v2.c; + return A2( + $rtfeldman$elm_css$Css$Preprocess$Resolve$applyStyles, + styles, + _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$StyleBlockDeclaration( + A3($rtfeldman$elm_css$Css$Structure$StyleBlock, firstSelector, otherSelectors, _List_Nil)) + ])); +}; +var $rtfeldman$elm_css$Css$Preprocess$Resolve$extract = function (snippetDeclarations) { + if (!snippetDeclarations.b) { + return _List_Nil; + } else { + var first = snippetDeclarations.a; + var rest = snippetDeclarations.b; + return _Utils_ap( + $rtfeldman$elm_css$Css$Preprocess$Resolve$toDeclarations(first), + $rtfeldman$elm_css$Css$Preprocess$Resolve$extract(rest)); + } +}; +var $rtfeldman$elm_css$Css$Preprocess$Resolve$resolveMediaRule = F2( + function (mediaQueries, styleBlocks) { + var handleStyleBlock = function (styleBlock) { + return A2( + $elm$core$List$map, + $rtfeldman$elm_css$Css$Preprocess$Resolve$toMediaRule(mediaQueries), + $rtfeldman$elm_css$Css$Preprocess$Resolve$expandStyleBlock(styleBlock)); + }; + return A2($elm$core$List$concatMap, handleStyleBlock, styleBlocks); + }); +var $rtfeldman$elm_css$Css$Preprocess$Resolve$resolveSupportsRule = F2( + function (str, snippets) { + var declarations = $rtfeldman$elm_css$Css$Preprocess$Resolve$extract( + A2($elm$core$List$concatMap, $rtfeldman$elm_css$Css$Preprocess$unwrapSnippet, snippets)); + return _List_fromArray( + [ + A2($rtfeldman$elm_css$Css$Structure$SupportsRule, str, declarations) + ]); + }); +var $rtfeldman$elm_css$Css$Preprocess$Resolve$toDeclarations = function (snippetDeclaration) { + switch (snippetDeclaration.$) { + case 'StyleBlockDeclaration': + var styleBlock = snippetDeclaration.a; + return $rtfeldman$elm_css$Css$Preprocess$Resolve$expandStyleBlock(styleBlock); + case 'MediaRule': + var mediaQueries = snippetDeclaration.a; + var styleBlocks = snippetDeclaration.b; + return A2($rtfeldman$elm_css$Css$Preprocess$Resolve$resolveMediaRule, mediaQueries, styleBlocks); + case 'SupportsRule': + var str = snippetDeclaration.a; + var snippets = snippetDeclaration.b; + return A2($rtfeldman$elm_css$Css$Preprocess$Resolve$resolveSupportsRule, str, snippets); + case 'DocumentRule': + var str1 = snippetDeclaration.a; + var str2 = snippetDeclaration.b; + var str3 = snippetDeclaration.c; + var str4 = snippetDeclaration.d; + var styleBlock = snippetDeclaration.e; + return A2( + $elm$core$List$map, + A4($rtfeldman$elm_css$Css$Preprocess$Resolve$toDocumentRule, str1, str2, str3, str4), + $rtfeldman$elm_css$Css$Preprocess$Resolve$expandStyleBlock(styleBlock)); + case 'PageRule': + var properties = snippetDeclaration.a; + return _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$PageRule(properties) + ]); + case 'FontFace': + var properties = snippetDeclaration.a; + return _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$FontFace(properties) + ]); + case 'Viewport': + var properties = snippetDeclaration.a; + return _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$Viewport(properties) + ]); + case 'CounterStyle': + var properties = snippetDeclaration.a; + return _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$CounterStyle(properties) + ]); + default: + var tuples = snippetDeclaration.a; + return $rtfeldman$elm_css$Css$Preprocess$Resolve$resolveFontFeatureValues(tuples); + } +}; +var $rtfeldman$elm_css$Css$Preprocess$Resolve$toStructure = function (_v0) { + var snippets = _v0.snippets; + var namespaces = _v0.namespaces; + var imports = _v0.imports; + var charset = _v0.charset; + var declarations = $rtfeldman$elm_css$Css$Preprocess$Resolve$extract( + A2($elm$core$List$concatMap, $rtfeldman$elm_css$Css$Preprocess$unwrapSnippet, snippets)); + return {charset: charset, declarations: declarations, imports: imports, namespaces: namespaces}; +}; +var $rtfeldman$elm_css$Css$Preprocess$Resolve$compile = function (sheet) { + return $rtfeldman$elm_css$Css$Structure$Output$prettyPrint( + $rtfeldman$elm_css$Css$Structure$compactStylesheet( + $rtfeldman$elm_css$Css$Preprocess$Resolve$toStructure(sheet))); +}; +var $rtfeldman$elm_css$Css$Preprocess$Snippet = function (a) { + return {$: 'Snippet', a: a}; +}; +var $rtfeldman$elm_css$Css$Preprocess$StyleBlock = F3( + function (a, b, c) { + return {$: 'StyleBlock', a: a, b: b, c: c}; + }); +var $rtfeldman$elm_css$Css$Preprocess$StyleBlockDeclaration = function (a) { + return {$: 'StyleBlockDeclaration', a: a}; +}; +var $rtfeldman$elm_css$VirtualDom$Styled$makeSnippet = F2( + function (styles, sequence) { + var selector = A3($rtfeldman$elm_css$Css$Structure$Selector, sequence, _List_Nil, $elm$core$Maybe$Nothing); + return $rtfeldman$elm_css$Css$Preprocess$Snippet( + _List_fromArray( + [ + $rtfeldman$elm_css$Css$Preprocess$StyleBlockDeclaration( + A3($rtfeldman$elm_css$Css$Preprocess$StyleBlock, selector, _List_Nil, styles)) + ])); + }); +var $rtfeldman$elm_css$Css$Preprocess$stylesheet = function (snippets) { + return {charset: $elm$core$Maybe$Nothing, imports: _List_Nil, namespaces: _List_Nil, snippets: snippets}; +}; +var $rtfeldman$elm_css$Css$Structure$ClassSelector = function (a) { + return {$: 'ClassSelector', a: a}; +}; +var $rtfeldman$elm_css$VirtualDom$Styled$classnameStandin = '\u0007'; +var $rtfeldman$elm_css$VirtualDom$Styled$templateSelector = $rtfeldman$elm_css$Css$Structure$UniversalSelectorSequence( + _List_fromArray( + [ + $rtfeldman$elm_css$Css$Structure$ClassSelector($rtfeldman$elm_css$VirtualDom$Styled$classnameStandin) + ])); +var $rtfeldman$elm_css$VirtualDom$Styled$getCssTemplate = function (styles) { + if (!styles.b) { + return ''; + } else { + var otherwise = styles; + return $rtfeldman$elm_css$Css$Preprocess$Resolve$compile( + $rtfeldman$elm_css$Css$Preprocess$stylesheet( + _List_fromArray( + [ + A2($rtfeldman$elm_css$VirtualDom$Styled$makeSnippet, styles, $rtfeldman$elm_css$VirtualDom$Styled$templateSelector) + ]))); + } +}; +var $rtfeldman$elm_css$Html$Styled$Internal$css = function (styles) { + var cssTemplate = $rtfeldman$elm_css$VirtualDom$Styled$getCssTemplate(styles); + var classProperty = A2($elm$virtual_dom$VirtualDom$attribute, '', ''); + return A3($rtfeldman$elm_css$VirtualDom$Styled$Attribute, classProperty, true, cssTemplate); +}; +var $rtfeldman$elm_css$Html$Styled$styled = F4( + function (fn, styles, attrs, children) { + return A2( + fn, + A2( + $elm$core$List$cons, + $rtfeldman$elm_css$Html$Styled$Internal$css(styles), + attrs), + children); + }); +var $author$project$Main$coloredTextWBackground = F3( + function (fgColor, bgColor, string) { + return A4( + $rtfeldman$elm_css$Html$Styled$styled, + $rtfeldman$elm_css$Html$Styled$span, + _List_fromArray( + [ + $rtfeldman$elm_css$Css$color(fgColor), + $rtfeldman$elm_css$Css$backgroundColor(bgColor), + $rtfeldman$elm_css$Css$padding( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$margin( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$borderWidth( + $rtfeldman$elm_css$Css$px(0)) + ]), + _List_Nil, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text(string) + ])); + }); +var $rtfeldman$elm_css$Css$cssFunction = F2( + function (funcName, args) { + return funcName + ('(' + (A2($elm$core$String$join, ',', args) + ')')); + }); +var $rtfeldman$elm_css$Css$rgba = F4( + function (r, g, b, alpha) { + return { + alpha: alpha, + blue: b, + color: $rtfeldman$elm_css$Css$Structure$Compatible, + green: g, + red: r, + value: A2( + $rtfeldman$elm_css$Css$cssFunction, + 'rgba', + _Utils_ap( + A2( + $elm$core$List$map, + $elm$core$String$fromInt, + _List_fromArray( + [r, g, b])), + _List_fromArray( + [ + $elm$core$String$fromFloat(alpha) + ]))) + }; + }); +var $author$project$Main$coloredText = F2( + function (fgColor, string) { + return A3( + $author$project$Main$coloredTextWBackground, + fgColor, + A4($rtfeldman$elm_css$Css$rgba, 0, 0, 0, 0), + string); + }); +var $rtfeldman$elm_css$Css$withPrecedingHash = function (str) { + return A2($elm$core$String$startsWith, '#', str) ? str : A2( + $elm$core$String$cons, + _Utils_chr('#'), + str); +}; +var $rtfeldman$elm_css$Css$erroneousHex = function (str) { + return { + alpha: 1, + blue: 0, + color: $rtfeldman$elm_css$Css$Structure$Compatible, + green: 0, + red: 0, + value: $rtfeldman$elm_css$Css$withPrecedingHash(str) + }; +}; +var $elm$core$String$foldr = _String_foldr; +var $elm$core$String$toList = function (string) { + return A3($elm$core$String$foldr, $elm$core$List$cons, _List_Nil, string); +}; +var $elm$core$String$fromChar = function (_char) { + return A2($elm$core$String$cons, _char, ''); +}; +var $elm$core$Basics$pow = _Basics_pow; +var $rtfeldman$elm_hex$Hex$fromStringHelp = F3( + function (position, chars, accumulated) { + fromStringHelp: + while (true) { + if (!chars.b) { + return $elm$core$Result$Ok(accumulated); + } else { + var _char = chars.a; + var rest = chars.b; + switch (_char.valueOf()) { + case '0': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated; + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case '1': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case '2': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (2 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case '3': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (3 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case '4': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (4 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case '5': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (5 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case '6': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (6 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case '7': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (7 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case '8': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (8 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case '9': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (9 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case 'a': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (10 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case 'b': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (11 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case 'c': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (12 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case 'd': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (13 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case 'e': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (14 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case 'f': + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated + (15 * A2($elm$core$Basics$pow, 16, position)); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + default: + var nonHex = _char; + return $elm$core$Result$Err( + $elm$core$String$fromChar(nonHex) + ' is not a valid hexadecimal character.'); + } + } + } + }); +var $elm$core$Result$map = F2( + function (func, ra) { + if (ra.$ === 'Ok') { + var a = ra.a; + return $elm$core$Result$Ok( + func(a)); + } else { + var e = ra.a; + return $elm$core$Result$Err(e); + } + }); +var $elm$core$Result$mapError = F2( + function (f, result) { + if (result.$ === 'Ok') { + var v = result.a; + return $elm$core$Result$Ok(v); + } else { + var e = result.a; + return $elm$core$Result$Err( + f(e)); + } + }); +var $rtfeldman$elm_hex$Hex$fromString = function (str) { + if ($elm$core$String$isEmpty(str)) { + return $elm$core$Result$Err('Empty strings are not valid hexadecimal strings.'); + } else { + var result = function () { + if (A2($elm$core$String$startsWith, '-', str)) { + var list = A2( + $elm$core$Maybe$withDefault, + _List_Nil, + $elm$core$List$tail( + $elm$core$String$toList(str))); + return A2( + $elm$core$Result$map, + $elm$core$Basics$negate, + A3( + $rtfeldman$elm_hex$Hex$fromStringHelp, + $elm$core$List$length(list) - 1, + list, + 0)); + } else { + return A3( + $rtfeldman$elm_hex$Hex$fromStringHelp, + $elm$core$String$length(str) - 1, + $elm$core$String$toList(str), + 0); + } + }(); + var formatError = function (err) { + return A2( + $elm$core$String$join, + ' ', + _List_fromArray( + ['\"' + (str + '\"'), 'is not a valid hexadecimal string because', err])); + }; + return A2($elm$core$Result$mapError, formatError, result); + } +}; +var $elm$core$String$toLower = _String_toLower; +var $rtfeldman$elm_css$Css$validHex = F5( + function (str, _v0, _v1, _v2, _v3) { + var r1 = _v0.a; + var r2 = _v0.b; + var g1 = _v1.a; + var g2 = _v1.b; + var b1 = _v2.a; + var b2 = _v2.b; + var a1 = _v3.a; + var a2 = _v3.b; + var toResult = A2( + $elm$core$Basics$composeR, + $elm$core$String$fromList, + A2($elm$core$Basics$composeR, $elm$core$String$toLower, $rtfeldman$elm_hex$Hex$fromString)); + var results = _Utils_Tuple2( + _Utils_Tuple2( + toResult( + _List_fromArray( + [r1, r2])), + toResult( + _List_fromArray( + [g1, g2]))), + _Utils_Tuple2( + toResult( + _List_fromArray( + [b1, b2])), + toResult( + _List_fromArray( + [a1, a2])))); + if ((((results.a.a.$ === 'Ok') && (results.a.b.$ === 'Ok')) && (results.b.a.$ === 'Ok')) && (results.b.b.$ === 'Ok')) { + var _v5 = results.a; + var red = _v5.a.a; + var green = _v5.b.a; + var _v6 = results.b; + var blue = _v6.a.a; + var alpha = _v6.b.a; + return { + alpha: alpha / 255, + blue: blue, + color: $rtfeldman$elm_css$Css$Structure$Compatible, + green: green, + red: red, + value: $rtfeldman$elm_css$Css$withPrecedingHash(str) + }; + } else { + return $rtfeldman$elm_css$Css$erroneousHex(str); + } + }); +var $rtfeldman$elm_css$Css$hex = function (str) { + var withoutHash = A2($elm$core$String$startsWith, '#', str) ? A2($elm$core$String$dropLeft, 1, str) : str; + var _v0 = $elm$core$String$toList(withoutHash); + _v0$4: + while (true) { + if ((_v0.b && _v0.b.b) && _v0.b.b.b) { + if (!_v0.b.b.b.b) { + var r = _v0.a; + var _v1 = _v0.b; + var g = _v1.a; + var _v2 = _v1.b; + var b = _v2.a; + return A5( + $rtfeldman$elm_css$Css$validHex, + str, + _Utils_Tuple2(r, r), + _Utils_Tuple2(g, g), + _Utils_Tuple2(b, b), + _Utils_Tuple2( + _Utils_chr('f'), + _Utils_chr('f'))); + } else { + if (!_v0.b.b.b.b.b) { + var r = _v0.a; + var _v3 = _v0.b; + var g = _v3.a; + var _v4 = _v3.b; + var b = _v4.a; + var _v5 = _v4.b; + var a = _v5.a; + return A5( + $rtfeldman$elm_css$Css$validHex, + str, + _Utils_Tuple2(r, r), + _Utils_Tuple2(g, g), + _Utils_Tuple2(b, b), + _Utils_Tuple2(a, a)); + } else { + if (_v0.b.b.b.b.b.b) { + if (!_v0.b.b.b.b.b.b.b) { + var r1 = _v0.a; + var _v6 = _v0.b; + var r2 = _v6.a; + var _v7 = _v6.b; + var g1 = _v7.a; + var _v8 = _v7.b; + var g2 = _v8.a; + var _v9 = _v8.b; + var b1 = _v9.a; + var _v10 = _v9.b; + var b2 = _v10.a; + return A5( + $rtfeldman$elm_css$Css$validHex, + str, + _Utils_Tuple2(r1, r2), + _Utils_Tuple2(g1, g2), + _Utils_Tuple2(b1, b2), + _Utils_Tuple2( + _Utils_chr('f'), + _Utils_chr('f'))); + } else { + if (_v0.b.b.b.b.b.b.b.b && (!_v0.b.b.b.b.b.b.b.b.b)) { + var r1 = _v0.a; + var _v11 = _v0.b; + var r2 = _v11.a; + var _v12 = _v11.b; + var g1 = _v12.a; + var _v13 = _v12.b; + var g2 = _v13.a; + var _v14 = _v13.b; + var b1 = _v14.a; + var _v15 = _v14.b; + var b2 = _v15.a; + var _v16 = _v15.b; + var a1 = _v16.a; + var _v17 = _v16.b; + var a2 = _v17.a; + return A5( + $rtfeldman$elm_css$Css$validHex, + str, + _Utils_Tuple2(r1, r2), + _Utils_Tuple2(g1, g2), + _Utils_Tuple2(b1, b2), + _Utils_Tuple2(a1, a2)); + } else { + break _v0$4; + } + } + } else { + break _v0$4; + } + } + } + } else { + break _v0$4; + } + } + return $rtfeldman$elm_css$Css$erroneousHex(str); +}; +var $author$project$Main$coreColor = function (color) { + switch (color.$) { + case 'Red': + return $rtfeldman$elm_css$Css$hex('e14433'); + case 'Green': + return $rtfeldman$elm_css$Css$hex('#359b54'); + case 'Yellow': + return $rtfeldman$elm_css$Css$hex('#a08016'); + case 'Blue': + return $rtfeldman$elm_css$Css$hex('#5a77f2'); + case 'Magenta': + return $rtfeldman$elm_css$Css$hex('#cf2ec8'); + case 'Cyan': + return $rtfeldman$elm_css$Css$hex('1894a5'); + case 'BrightRed': + return $rtfeldman$elm_css$Css$hex('#f36552'); + case 'BrightGreen': + return $rtfeldman$elm_css$Css$hex('#3db361'); + case 'BrightYellow': + return $rtfeldman$elm_css$Css$hex('#b9941a'); + case 'BrightBlue': + return $rtfeldman$elm_css$Css$hex('#7491f8'); + case 'BrightMagenta': + return $rtfeldman$elm_css$Css$hex('#e54ede'); + default: + return $rtfeldman$elm_css$Css$hex('#1eabbf'); + } +}; +var $elm$core$String$endsWith = _String_endsWith; +var $elm$browser$Browser$Navigation$load = _Browser_load; +var $elm$core$Platform$Cmd$batch = _Platform_batch; +var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil); +var $author$project$Main$Clear = {$: 'Clear'}; +var $author$project$Main$Cookies = {$: 'Cookies'}; +var $author$project$Main$FontCommand = {$: 'FontCommand'}; +var $author$project$Main$Hello = {$: 'Hello'}; +var $author$project$Main$Help = {$: 'Help'}; +var $author$project$Main$PromptCommand = {$: 'PromptCommand'}; +var $author$project$Main$Theme = {$: 'Theme'}; +var $elm$core$List$filter = F2( + function (isGood, list) { + return A3( + $elm$core$List$foldr, + F2( + function (x, xs) { + return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs; + }), + _List_Nil, + list); + }); +var $elm$core$String$trim = _String_trim; +var $author$project$Main$parseInput = function (input) { + var tokens = A2( + $elm$core$List$map, + $elm$core$String$trim, + A2($elm$core$String$split, ' ', input)); + var command = function () { + var _v3 = $elm$core$List$head(tokens); + if (_v3.$ === 'Just') { + switch (_v3.a) { + case 'help': + return $elm$core$Result$Ok($author$project$Main$Help); + case 'clear': + return $elm$core$Result$Ok($author$project$Main$Clear); + case 'cookies': + return $elm$core$Result$Ok($author$project$Main$Cookies); + case 'font': + return $elm$core$Result$Ok($author$project$Main$FontCommand); + case 'hello': + return $elm$core$Result$Ok($author$project$Main$Hello); + case 'prompt': + return $elm$core$Result$Ok($author$project$Main$PromptCommand); + case 'theme': + return $elm$core$Result$Ok($author$project$Main$Theme); + default: + var trimput = _v3.a; + return $elm$core$Result$Err(trimput); + } + } else { + return $elm$core$Result$Err('error in parseInput parsing tokens'); + } + }(); + var args = function () { + var _v2 = $elm$core$List$tail(tokens); + if (_v2.$ === 'Just') { + var tail = _v2.a; + return $elm$core$Result$Ok( + A2( + $elm$core$List$filter, + $elm$core$Basics$neq(''), + tail)); + } else { + return $elm$core$Result$Err('error in parseInput parsing tokens'); + } + }(); + if (args.$ === 'Ok') { + var _arguments = args.a; + if (command.$ === 'Ok') { + var cmd = command.a; + return $elm$core$Result$Ok( + {args: _arguments, command: cmd}); + } else { + var err = command.a; + return $elm$core$Result$Err(err); + } + } else { + var err = args.a; + return $elm$core$Result$Err(err); + } +}; +var $elm$browser$Browser$Navigation$pushUrl = _Browser_pushUrl; +var $author$project$Main$listToString = function (list) { + return '[' + (A2($elm$core$String$join, ',', list) + ']'); +}; +var $author$project$Main$wrongArgs = F3( + function (command, expected, args) { + var comstr = function () { + switch (command.$) { + case 'Help': + return 'help'; + case 'Clear': + return 'clear'; + case 'Cookies': + return 'cookies'; + case 'FontCommand': + return 'font'; + case 'Hello': + return 'hello'; + case 'PromptCommand': + return 'prompt'; + default: + return 'theme'; + } + }(); + return _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text( + ((_Utils_cmp( + expected, + $elm$core$List$length(args)) > 0) ? ('\nToo few arguments for ' + comstr) : ((_Utils_cmp( + expected, + $elm$core$List$length(args)) < 0) ? ('\nToo many arguments for ' + comstr) : ('\nUnexpected arguments ' + $author$project$Main$listToString(args)))) + ('. Run `help ' + (comstr + '` for usage'))) + ]); + }); +var $author$project$Main$runClear = F2( + function (model, args) { + var _v0 = $elm$core$List$head(args); + if (_v0.$ === 'Nothing') { + return _Utils_update( + model, + {content: _List_Nil}); + } else { + var string = _v0.a; + return _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$Clear, 0, args)) + }); + } + }); +var $author$project$Main$boolToString = function (bool) { + if (bool) { + return 'True'; + } else { + return 'False'; + } +}; +var $author$project$Main$cookiesKeptToString = function (cookiesKept) { + return '{ keepFont = ' + ($author$project$Main$boolToString(cookiesKept.keepFont) + ('\n, keepTheme = ' + ($author$project$Main$boolToString(cookiesKept.keepTheme) + '\n}'))); +}; +var $elm$json$Json$Encode$bool = _Json_wrap; +var $elm$json$Json$Encode$float = _Json_wrap; +var $elm$json$Json$Encode$object = function (pairs) { + return _Json_wrap( + A3( + $elm$core$List$foldl, + F2( + function (_v0, obj) { + var k = _v0.a; + var v = _v0.b; + return A3(_Json_addField, k, v, obj); + }), + _Json_emptyObject(_Utils_Tuple0), + pairs)); +}; +var $elm$json$Json$Encode$string = _Json_wrap; +var $author$project$Main$encodeModel = function (model) { + return $elm$json$Json$Encode$object( + _List_fromArray( + [ + _Utils_Tuple2( + 'theme', + $elm$json$Json$Encode$string( + function () { + var _v0 = model.theme; + switch (_v0.$) { + case 'Pit': + return 'Pit'; + case 'Dim': + return 'Dim'; + case 'Sky': + return 'Sky'; + default: + return 'Sun'; + } + }())), + _Utils_Tuple2( + 'font', + $elm$json$Json$Encode$object( + _List_fromArray( + [ + _Utils_Tuple2( + 'fontSize', + $elm$json$Json$Encode$float(model.font.fontSize)) + ]))), + _Utils_Tuple2( + 'cookiesKept', + $elm$json$Json$Encode$object( + _List_fromArray( + [ + _Utils_Tuple2( + 'keepTheme', + $elm$json$Json$Encode$bool(model.cookiesKept.keepTheme)), + _Utils_Tuple2( + 'keepFont', + $elm$json$Json$Encode$bool(model.cookiesKept.keepFont)), + _Utils_Tuple2( + 'keepPrompt', + $elm$json$Json$Encode$bool(model.cookiesKept.keepPrompt)) + ]))), + _Utils_Tuple2( + 'prompt', + $elm$json$Json$Encode$object( + _List_fromArray( + [ + _Utils_Tuple2( + 'prompt', + $elm$json$Json$Encode$string(model.prompt.prompt)) + ]))) + ])); +}; +var $author$project$Main$setStorage = _Platform_outgoingPort('setStorage', $elm$core$Basics$identity); +var $author$project$Main$saveModel = function (model) { + return _Utils_Tuple2( + model, + $elm$core$Platform$Cmd$batch( + _List_fromArray( + [ + $author$project$Main$setStorage( + $author$project$Main$encodeModel(model)) + ]))); +}; +var $author$project$Main$runCookies = F2( + function (model, args) { + var _v0 = $elm$core$List$head(args); + if (_v0.$ === 'Nothing') { + var newModel = _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text( + '\n' + $author$project$Main$cookiesKeptToString(model.cookiesKept)) + ])) + }); + return _Utils_Tuple2( + newModel, + $elm$core$Platform$Cmd$batch( + _List_fromArray( + [ + $author$project$Main$setStorage( + $author$project$Main$encodeModel(newModel)) + ]))); + } else { + if (_v0.a === 'set') { + var third = function () { + var _v6 = $elm$core$List$tail(args); + if (_v6.$ === 'Just') { + var tail = _v6.a; + var _v7 = $elm$core$List$tail(tail); + if (_v7.$ === 'Just') { + var tail2 = _v7.a; + return A2( + $elm$core$Maybe$withDefault, + '', + $elm$core$List$head(tail2)); + } else { + return ''; + } + } else { + return ''; + } + }(); + var second = function () { + var _v5 = $elm$core$List$tail(args); + if (_v5.$ === 'Just') { + var tail = _v5.a; + return A2( + $elm$core$Maybe$withDefault, + '', + $elm$core$List$head(tail)); + } else { + return ''; + } + }(); + var cookiesKept = model.cookiesKept; + if (third === '') { + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$Cookies, 3, args)) + }), + $elm$core$Platform$Cmd$none); + } else { + switch (second) { + case '': + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$Cookies, 2, args)) + }), + $elm$core$Platform$Cmd$none); + case 'keepFont': + switch (third) { + case 'true': + return $author$project$Main$saveModel( + _Utils_update( + model, + { + cookiesKept: _Utils_update( + cookiesKept, + {keepFont: true}) + })); + case 'false': + return $author$project$Main$saveModel( + _Utils_update( + model, + { + cookiesKept: _Utils_update( + cookiesKept, + {keepFont: false}) + })); + default: + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$Cookies, 3, args)) + }), + $elm$core$Platform$Cmd$none); + } + case 'keepTheme': + switch (third) { + case 'true': + return $author$project$Main$saveModel( + _Utils_update( + model, + { + cookiesKept: _Utils_update( + cookiesKept, + {keepTheme: true}) + })); + case 'false': + return $author$project$Main$saveModel( + _Utils_update( + model, + { + cookiesKept: _Utils_update( + cookiesKept, + {keepTheme: false}) + })); + default: + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$Cookies, 3, args)) + }), + $elm$core$Platform$Cmd$none); + } + case 'keepPrompt': + switch (third) { + case 'true': + return $author$project$Main$saveModel( + _Utils_update( + model, + { + cookiesKept: _Utils_update( + cookiesKept, + {keepPrompt: true}) + })); + case 'false': + return $author$project$Main$saveModel( + _Utils_update( + model, + { + cookiesKept: _Utils_update( + cookiesKept, + {keepPrompt: false}) + })); + default: + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$Cookies, 3, args)) + }), + $elm$core$Platform$Cmd$none); + } + default: + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$Cookies, 2, args)) + }), + $elm$core$Platform$Cmd$none); + } + } + } else { + var string = _v0.a; + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$Cookies, 1, args)) + }), + $elm$core$Platform$Cmd$none); + } + } + }); +var $elm$core$String$toFloat = _String_toFloat; +var $author$project$Main$runFont = F2( + function (model, args) { + var _v0 = $elm$core$List$head(args); + if (_v0.$ === 'Nothing') { + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$FontCommand, 1, args)) + }), + $elm$core$Platform$Cmd$none); + } else { + switch (_v0.a) { + case 'size': + var string = function () { + var _v3 = $elm$core$List$tail(args); + if (_v3.$ === 'Just') { + var tail = _v3.a; + return A2( + $elm$core$Maybe$withDefault, + '', + $elm$core$List$head(tail)); + } else { + return ''; + } + }(); + var fl = $elm$core$String$toFloat(string); + if (fl.$ === 'Just') { + var _float = fl.a; + if (_float > 0) { + var newModel = _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nfontSize successfully set to ' + (string + 'px')) + ])), + font: {fontSize: _float} + }); + return $author$project$Main$saveModel(newModel); + } else { + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nPlease enter a valid fontSize, a Float greater than 0') + ])) + }), + $elm$core$Platform$Cmd$none); + } + } else { + switch (string) { + case '': + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text( + '\nfontSize is ' + ($elm$core$String$fromFloat(model.font.fontSize) + 'px')) + ])) + }), + $elm$core$Platform$Cmd$none); + case 'reset': + var newModel = _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nfontSize reset to 20px') + ])), + font: {fontSize: 20} + }); + return $author$project$Main$saveModel(newModel); + default: + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nfontSize ' + (string + ' not recognised; font size expected')) + ])) + }), + $elm$core$Platform$Cmd$none); + } + } + case 'reset': + var newModel = _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nfontSize reset to 20px') + ])), + font: {fontSize: 20} + }); + return _Utils_Tuple2( + newModel, + $elm$core$Platform$Cmd$batch( + _List_fromArray( + [ + $author$project$Main$setStorage( + $author$project$Main$encodeModel(newModel)) + ]))); + default: + var string = _v0.a; + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$FontCommand, 1, args)) + }), + $elm$core$Platform$Cmd$none); + } + } + }); +var $author$project$Main$runHello = F2( + function (model, args) { + var _v0 = $elm$core$List$head(args); + if (_v0.$ === 'Nothing') { + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nHello World!') + ])) + }), + $elm$core$Platform$Cmd$none); + } else { + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$Hello, 0, args)) + }), + $elm$core$Platform$Cmd$none); + } + }); +var $author$project$Main$runHelp = F2( + function (model, args) { + return _Utils_update( + model, + { + content: _Utils_ap( + model.content, + function () { + if ($elm$core$List$length(args) < 2) { + var _v0 = $elm$core$List$head(args); + if (_v0.$ === 'Nothing') { + return _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\n+--------------------------------------------------+' + ('\n|help prints this message |' + ('\n|help prints more information about |' + ('\n+--------------------------------------------------+' + ('\nclear clears the screen' + ('\ncookies [UNSTABLE] manages cookies' + ('\nhello prints hello world message' + ('\nfont manages font' + ('\nprompt [UNFINISHED] manages prompt' + '\ntheme manages theme'))))))))) + ]); + } else { + switch (_v0.a) { + case 'help': + return _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nhelp lists available commands with a short summary' + '\nhelp prints more information about ') + ]); + case 'clear': + return _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nclear clears the screen') + ]); + case 'cookies': + return _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\ncookies prints info about the current cookie settings' + ('\ncookies set [true|false] sets whether to store a certain cookie' + ('\noptions for are:' + ('\n keepFont - whether to store fontSize. Default fontSize is 20' + ('\n keepPrompt - whether to store prompt. Default prompt is >' + '\n keepTheme - whether to store theme. Default theme is pit'))))) + ]); + case 'hello': + return _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nhello prints `Hello World!`') + ]); + case 'font': + return _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nfont size prints info about the current font size' + ('\nfont size changes fontSize to if is >0' + '\nfont reset changes fontSize to the default of 20px')) + ]); + case 'prompt': + return _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nprompt prints info about the current prompt' + ('\nprompt set sets prompt text to ' + ('\n is specified in quotes' + ('\nprompt color sets prompt color to ' + '\n run `colors` to list available colors')))) + ]); + case 'theme': + return _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\ntheme sets the current theme according to ' + ('\nOptions for are:' + ('\n sun - a theme blinding like the sun' + ('\n sky - a toned-down light theme' + ('\n dim - a deep and colorful dark theme' + '\n pit - nearly black like the bottom of a pit'))))) + ]); + default: + var string = _v0.a; + return A3($author$project$Main$wrongArgs, $author$project$Main$Help, 1, args); + } + } + } else { + return A3($author$project$Main$wrongArgs, $author$project$Main$Help, 1, args); + } + }()) + }); + }); +var $author$project$Main$runPrompt = F2( + function (model, args) { + var _v0 = $elm$core$List$head(args); + if (_v0.$ === 'Nothing') { + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\ncurrent prompt is ' + model.prompt.prompt) + ])) + }), + $elm$core$Platform$Cmd$none); + } else { + var string = _v0.a; + var oldPrompt = model.prompt; + return $author$project$Main$saveModel( + _Utils_update( + model, + { + prompt: _Utils_update( + oldPrompt, + {prompt: string}) + })); + } + }); +var $author$project$Main$setTheme = F2( + function (model, theme) { + var newModel = _Utils_update( + model, + {theme: theme}); + return $author$project$Main$saveModel(newModel); + }); +var $author$project$Main$runTheme = F2( + function (model, args) { + var _v0 = $elm$core$List$head(args); + if (_v0.$ === 'Nothing') { + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text( + '\nThe current theme is ' + function () { + var _v1 = model.theme; + switch (_v1.$) { + case 'Sun': + return 'sun'; + case 'Sky': + return 'sky'; + case 'Dim': + return 'dim'; + default: + return 'pit'; + } + }()) + ])) + }), + $elm$core$Platform$Cmd$none); + } else { + switch (_v0.a) { + case 'sun': + return A2($author$project$Main$setTheme, model, $author$project$Main$Sun); + case 'sky': + return A2($author$project$Main$setTheme, model, $author$project$Main$Sky); + case 'dim': + return A2($author$project$Main$setTheme, model, $author$project$Main$Dim); + case 'pit': + return A2($author$project$Main$setTheme, model, $author$project$Main$Pit); + default: + var string = _v0.a; + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + A3($author$project$Main$wrongArgs, $author$project$Main$Theme, 1, args)) + }), + $elm$core$Platform$Cmd$none); + } + } + }); +var $author$project$Main$runCommand = F2( + function (model, input) { + if (input.$ === 'Ok') { + var args = input.a.args; + var command = input.a.command; + switch (command.$) { + case 'Help': + return _Utils_Tuple2( + A2($author$project$Main$runHelp, model, args), + $elm$core$Platform$Cmd$none); + case 'Clear': + return _Utils_Tuple2( + A2($author$project$Main$runClear, model, args), + $elm$core$Platform$Cmd$none); + case 'Cookies': + return A2($author$project$Main$runCookies, model, args); + case 'FontCommand': + return A2($author$project$Main$runFont, model, args); + case 'Hello': + return A2($author$project$Main$runHello, model, args); + case 'PromptCommand': + return A2($author$project$Main$runPrompt, model, args); + default: + return A2($author$project$Main$runTheme, model, args); + } + } else { + if (input.a === '') { + return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none); + } else { + var string = input.a; + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\ncommand ' + (string + ' not recognised. Run `help` to find a valid command')) + ])) + }), + $elm$core$Platform$Cmd$none); + } + } + }); +var $elm$url$Url$addPort = F2( + function (maybePort, starter) { + if (maybePort.$ === 'Nothing') { + return starter; + } else { + var port_ = maybePort.a; + return starter + (':' + $elm$core$String$fromInt(port_)); + } + }); +var $elm$url$Url$addPrefixed = F3( + function (prefix, maybeSegment, starter) { + if (maybeSegment.$ === 'Nothing') { + return starter; + } else { + var segment = maybeSegment.a; + return _Utils_ap( + starter, + _Utils_ap(prefix, segment)); + } + }); +var $elm$url$Url$toString = function (url) { + var http = function () { + var _v0 = url.protocol; + if (_v0.$ === 'Http') { + return 'http://'; + } else { + return 'https://'; + } + }(); + return A3( + $elm$url$Url$addPrefixed, + '#', + url.fragment, + A3( + $elm$url$Url$addPrefixed, + '?', + url.query, + _Utils_ap( + A2( + $elm$url$Url$addPort, + url.port_, + _Utils_ap(http, url.host)), + url.path))); +}; +var $author$project$Main$update = F2( + function (msg, model) { + switch (msg.$) { + case 'LinkClicked': + var urlRequest = msg.a; + if (urlRequest.$ === 'Internal') { + var url = urlRequest.a; + return _Utils_Tuple2( + model, + A2( + $elm$browser$Browser$Navigation$pushUrl, + model.key, + $elm$url$Url$toString(url))); + } else { + var href = urlRequest.a; + return _Utils_Tuple2( + model, + $elm$browser$Browser$Navigation$load(href)); + } + case 'UrlChanged': + var url = msg.a; + return _Utils_Tuple2( + _Utils_update( + model, + {url: url}), + $elm$core$Platform$Cmd$none); + case 'TakeInput': + var string = msg.a; + return A2($elm$core$String$endsWith, '\n', string) ? A2( + $author$project$Main$runCommand, + _Utils_update( + model, + { + cliContent: '', + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text( + (!_Utils_eq(model.content, _List_Nil)) ? '\n' : ''), + A2( + $author$project$Main$coloredText, + $author$project$Main$coreColor($author$project$Main$BrightMagenta), + model.prompt.prompt), + $rtfeldman$elm_css$Html$Styled$text( + $elm$core$String$trim(string)) + ])) + }), + $author$project$Main$parseInput(string)) : _Utils_Tuple2( + _Utils_update( + model, + {cliContent: string}), + $elm$core$Platform$Cmd$none); + case 'NoInitFocus': + return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none); + default: + var result = msg.a; + if (result.$ === 'Ok') { + var test = result.a; + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text('\nData got successfully') + ])) + }), + $elm$core$Platform$Cmd$none); + } else { + var err = result.a; + return _Utils_Tuple2( + _Utils_update( + model, + { + content: _Utils_ap( + model.content, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$text( + '\n' + $elm$json$Json$Decode$errorToString(err)) + ])) + }), + $elm$core$Platform$Cmd$none); + } + } + }); +var $elm$browser$Browser$Document = F2( + function (title, body) { + return {body: body, title: title}; + }); +var $rtfeldman$elm_css$VirtualDom$Styled$UnscopedStyles = function (a) { + return {$: 'UnscopedStyles', a: a}; +}; +var $elm$core$Dict$get = F2( + function (targetKey, dict) { + get: + while (true) { + if (dict.$ === 'RBEmpty_elm_builtin') { + return $elm$core$Maybe$Nothing; + } else { + var key = dict.b; + var value = dict.c; + var left = dict.d; + var right = dict.e; + var _v1 = A2($elm$core$Basics$compare, targetKey, key); + switch (_v1.$) { + case 'LT': + var $temp$targetKey = targetKey, + $temp$dict = left; + targetKey = $temp$targetKey; + dict = $temp$dict; + continue get; + case 'EQ': + return $elm$core$Maybe$Just(value); + default: + var $temp$targetKey = targetKey, + $temp$dict = right; + targetKey = $temp$targetKey; + dict = $temp$dict; + continue get; + } + } + } + }); +var $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles = F2( + function (_v0, styles) { + var isCssStyles = _v0.b; + var cssTemplate = _v0.c; + if (isCssStyles) { + var _v1 = A2($elm$core$Dict$get, cssTemplate, styles); + if (_v1.$ === 'Just') { + return styles; + } else { + return A3( + $elm$core$Dict$insert, + cssTemplate, + $rtfeldman$elm_css$Hash$fromString(cssTemplate), + styles); + } + } else { + return styles; + } + }); +var $elm$virtual_dom$VirtualDom$property = F2( + function (key, value) { + return A2( + _VirtualDom_property, + _VirtualDom_noInnerHtmlOrFormAction(key), + _VirtualDom_noJavaScriptOrHtmlJson(value)); + }); +var $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttribute = F2( + function (styles, _v0) { + var val = _v0.a; + var isCssStyles = _v0.b; + var cssTemplate = _v0.c; + if (isCssStyles) { + var _v1 = A2($elm$core$Dict$get, cssTemplate, styles); + if (_v1.$ === 'Just') { + var classname = _v1.a; + return A2( + $elm$virtual_dom$VirtualDom$property, + 'className', + $elm$json$Json$Encode$string(classname)); + } else { + return A2( + $elm$virtual_dom$VirtualDom$property, + 'className', + $elm$json$Json$Encode$string('_unstyled')); + } + } else { + return val; + } + }); +var $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttributeNS = F2( + function (styles, _v0) { + var val = _v0.a; + var isCssStyles = _v0.b; + var cssTemplate = _v0.c; + if (isCssStyles) { + var _v1 = A2($elm$core$Dict$get, cssTemplate, styles); + if (_v1.$ === 'Just') { + var classname = _v1.a; + return A2($elm$virtual_dom$VirtualDom$attribute, 'class', classname); + } else { + return A2($elm$virtual_dom$VirtualDom$attribute, 'class', '_unstyled'); + } + } else { + return val; + } + }); +var $elm$virtual_dom$VirtualDom$keyedNode = function (tag) { + return _VirtualDom_keyedNode( + _VirtualDom_noScript(tag)); +}; +var $elm$virtual_dom$VirtualDom$keyedNodeNS = F2( + function (namespace, tag) { + return A2( + _VirtualDom_keyedNodeNS, + namespace, + _VirtualDom_noScript(tag)); + }); +var $elm$virtual_dom$VirtualDom$node = function (tag) { + return _VirtualDom_node( + _VirtualDom_noScript(tag)); +}; +var $elm$virtual_dom$VirtualDom$nodeNS = F2( + function (namespace, tag) { + return A2( + _VirtualDom_nodeNS, + namespace, + _VirtualDom_noScript(tag)); + }); +var $rtfeldman$elm_css$VirtualDom$Styled$accumulateKeyedStyledHtml = F2( + function (_v6, _v7) { + var key = _v6.a; + var html = _v6.b; + var pairs = _v7.a; + var styles = _v7.b; + switch (html.$) { + case 'Unstyled': + var vdom = html.a; + return _Utils_Tuple2( + A2( + $elm$core$List$cons, + _Utils_Tuple2(key, vdom), + pairs), + styles); + case 'Node': + var elemType = html.a; + var properties = html.b; + var children = html.c; + var combinedStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, styles, properties); + var _v9 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyledHtml, + _Utils_Tuple2(_List_Nil, combinedStyles), + children); + var childNodes = _v9.a; + var finalStyles = _v9.b; + var vdom = A3( + $elm$virtual_dom$VirtualDom$node, + elemType, + A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttribute(finalStyles), + properties), + $elm$core$List$reverse(childNodes)); + return _Utils_Tuple2( + A2( + $elm$core$List$cons, + _Utils_Tuple2(key, vdom), + pairs), + finalStyles); + case 'NodeNS': + var ns = html.a; + var elemType = html.b; + var properties = html.c; + var children = html.d; + var combinedStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, styles, properties); + var _v10 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyledHtml, + _Utils_Tuple2(_List_Nil, combinedStyles), + children); + var childNodes = _v10.a; + var finalStyles = _v10.b; + var vdom = A4( + $elm$virtual_dom$VirtualDom$nodeNS, + ns, + elemType, + A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttribute(finalStyles), + properties), + $elm$core$List$reverse(childNodes)); + return _Utils_Tuple2( + A2( + $elm$core$List$cons, + _Utils_Tuple2(key, vdom), + pairs), + finalStyles); + case 'KeyedNode': + var elemType = html.a; + var properties = html.b; + var children = html.c; + var combinedStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, styles, properties); + var _v11 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateKeyedStyledHtml, + _Utils_Tuple2(_List_Nil, combinedStyles), + children); + var childNodes = _v11.a; + var finalStyles = _v11.b; + var vdom = A3( + $elm$virtual_dom$VirtualDom$keyedNode, + elemType, + A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttribute(finalStyles), + properties), + $elm$core$List$reverse(childNodes)); + return _Utils_Tuple2( + A2( + $elm$core$List$cons, + _Utils_Tuple2(key, vdom), + pairs), + finalStyles); + default: + var ns = html.a; + var elemType = html.b; + var properties = html.c; + var children = html.d; + var combinedStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, styles, properties); + var _v12 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateKeyedStyledHtml, + _Utils_Tuple2(_List_Nil, combinedStyles), + children); + var childNodes = _v12.a; + var finalStyles = _v12.b; + var vdom = A4( + $elm$virtual_dom$VirtualDom$keyedNodeNS, + ns, + elemType, + A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttribute(finalStyles), + properties), + $elm$core$List$reverse(childNodes)); + return _Utils_Tuple2( + A2( + $elm$core$List$cons, + _Utils_Tuple2(key, vdom), + pairs), + finalStyles); + } + }); +var $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyledHtml = F2( + function (html, _v0) { + var nodes = _v0.a; + var styles = _v0.b; + switch (html.$) { + case 'Unstyled': + var vdomNode = html.a; + return _Utils_Tuple2( + A2($elm$core$List$cons, vdomNode, nodes), + styles); + case 'Node': + var elemType = html.a; + var properties = html.b; + var children = html.c; + var combinedStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, styles, properties); + var _v2 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyledHtml, + _Utils_Tuple2(_List_Nil, combinedStyles), + children); + var childNodes = _v2.a; + var finalStyles = _v2.b; + var vdomNode = A3( + $elm$virtual_dom$VirtualDom$node, + elemType, + A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttribute(finalStyles), + properties), + $elm$core$List$reverse(childNodes)); + return _Utils_Tuple2( + A2($elm$core$List$cons, vdomNode, nodes), + finalStyles); + case 'NodeNS': + var ns = html.a; + var elemType = html.b; + var properties = html.c; + var children = html.d; + var combinedStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, styles, properties); + var _v3 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyledHtml, + _Utils_Tuple2(_List_Nil, combinedStyles), + children); + var childNodes = _v3.a; + var finalStyles = _v3.b; + var vdomNode = A4( + $elm$virtual_dom$VirtualDom$nodeNS, + ns, + elemType, + A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttributeNS(finalStyles), + properties), + $elm$core$List$reverse(childNodes)); + return _Utils_Tuple2( + A2($elm$core$List$cons, vdomNode, nodes), + finalStyles); + case 'KeyedNode': + var elemType = html.a; + var properties = html.b; + var children = html.c; + var combinedStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, styles, properties); + var _v4 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateKeyedStyledHtml, + _Utils_Tuple2(_List_Nil, combinedStyles), + children); + var childNodes = _v4.a; + var finalStyles = _v4.b; + var vdomNode = A3( + $elm$virtual_dom$VirtualDom$keyedNode, + elemType, + A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttribute(finalStyles), + properties), + $elm$core$List$reverse(childNodes)); + return _Utils_Tuple2( + A2($elm$core$List$cons, vdomNode, nodes), + finalStyles); + default: + var ns = html.a; + var elemType = html.b; + var properties = html.c; + var children = html.d; + var combinedStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, styles, properties); + var _v5 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateKeyedStyledHtml, + _Utils_Tuple2(_List_Nil, combinedStyles), + children); + var childNodes = _v5.a; + var finalStyles = _v5.b; + var vdomNode = A4( + $elm$virtual_dom$VirtualDom$keyedNodeNS, + ns, + elemType, + A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttributeNS(finalStyles), + properties), + $elm$core$List$reverse(childNodes)); + return _Utils_Tuple2( + A2($elm$core$List$cons, vdomNode, nodes), + finalStyles); + } + }); +var $elm$core$Dict$foldl = F3( + function (func, acc, dict) { + foldl: + while (true) { + if (dict.$ === 'RBEmpty_elm_builtin') { + return acc; + } else { + var key = dict.b; + var value = dict.c; + var left = dict.d; + var right = dict.e; + var $temp$func = func, + $temp$acc = A3( + func, + key, + value, + A3($elm$core$Dict$foldl, func, acc, left)), + $temp$dict = right; + func = $temp$func; + acc = $temp$acc; + dict = $temp$dict; + continue foldl; + } + } + }); +var $elm$core$String$replace = F3( + function (before, after, string) { + return A2( + $elm$core$String$join, + after, + A2($elm$core$String$split, before, string)); + }); +var $rtfeldman$elm_css$VirtualDom$Styled$styleToDeclaration = F3( + function (template, classname, declaration) { + return declaration + ('\n' + A3($elm$core$String$replace, $rtfeldman$elm_css$VirtualDom$Styled$classnameStandin, classname, template)); + }); +var $rtfeldman$elm_css$VirtualDom$Styled$toDeclaration = function (dict) { + return A3($elm$core$Dict$foldl, $rtfeldman$elm_css$VirtualDom$Styled$styleToDeclaration, '', dict); +}; +var $rtfeldman$elm_css$VirtualDom$Styled$toScopedDeclaration = F2( + function (scopingPrefix, dict) { + return A3( + $elm$core$Dict$foldl, + F3( + function (template, classname, declaration) { + return declaration + ('\n' + A3($elm$core$String$replace, '.' + $rtfeldman$elm_css$VirtualDom$Styled$classnameStandin, '#' + (scopingPrefix + ('.' + classname)), template)); + }), + '', + dict); + }); +var $rtfeldman$elm_css$VirtualDom$Styled$toStyleNode = F2( + function (maybeNonce, accumulatedStyles) { + var cssText = function () { + if (accumulatedStyles.$ === 'UnscopedStyles') { + var allStyles = accumulatedStyles.a; + return $rtfeldman$elm_css$VirtualDom$Styled$toDeclaration(allStyles); + } else { + var scope = accumulatedStyles.a.a; + var rootStyles = accumulatedStyles.b; + var descendantStyles = accumulatedStyles.c; + return A2($rtfeldman$elm_css$VirtualDom$Styled$toScopedDeclaration, scope, rootStyles) + ('\n' + A2($rtfeldman$elm_css$VirtualDom$Styled$toScopedDeclaration, scope + ' ', descendantStyles)); + } + }(); + return A3( + $elm$virtual_dom$VirtualDom$node, + 'span', + _List_fromArray( + [ + A2($elm$virtual_dom$VirtualDom$attribute, 'style', 'display: none;'), + A2($elm$virtual_dom$VirtualDom$attribute, 'class', 'elm-css-style-wrapper') + ]), + _List_fromArray( + [ + A3( + $elm$virtual_dom$VirtualDom$node, + 'style', + function () { + if (maybeNonce.$ === 'Just') { + var nonce = maybeNonce.a.a; + return _List_fromArray( + [ + A2($elm$virtual_dom$VirtualDom$attribute, 'nonce', nonce) + ]); + } else { + return _List_Nil; + } + }(), + $elm$core$List$singleton( + $elm$virtual_dom$VirtualDom$text(cssText))) + ])); + }); +var $rtfeldman$elm_css$VirtualDom$Styled$unstyle = F4( + function (maybeNonce, elemType, properties, children) { + var initialStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, $elm$core$Dict$empty, properties); + var _v0 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyledHtml, + _Utils_Tuple2(_List_Nil, initialStyles), + children); + var childNodes = _v0.a; + var styles = _v0.b; + var styleNode = A2( + $rtfeldman$elm_css$VirtualDom$Styled$toStyleNode, + maybeNonce, + $rtfeldman$elm_css$VirtualDom$Styled$UnscopedStyles(styles)); + var unstyledProperties = A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttribute(styles), + properties); + return A3( + $elm$virtual_dom$VirtualDom$node, + elemType, + unstyledProperties, + A2( + $elm$core$List$cons, + styleNode, + $elm$core$List$reverse(childNodes))); + }); +var $rtfeldman$elm_css$VirtualDom$Styled$containsKey = F2( + function (key, pairs) { + containsKey: + while (true) { + if (!pairs.b) { + return false; + } else { + var _v1 = pairs.a; + var str = _v1.a; + var rest = pairs.b; + if (_Utils_eq(key, str)) { + return true; + } else { + var $temp$key = key, + $temp$pairs = rest; + key = $temp$key; + pairs = $temp$pairs; + continue containsKey; + } + } + } + }); +var $rtfeldman$elm_css$VirtualDom$Styled$getUnusedKey = F2( + function (_default, pairs) { + getUnusedKey: + while (true) { + if (!pairs.b) { + return _default; + } else { + var _v1 = pairs.a; + var firstKey = _v1.a; + var rest = pairs.b; + var newKey = '_' + firstKey; + if (A2($rtfeldman$elm_css$VirtualDom$Styled$containsKey, newKey, rest)) { + var $temp$default = newKey, + $temp$pairs = rest; + _default = $temp$default; + pairs = $temp$pairs; + continue getUnusedKey; + } else { + return newKey; + } + } + } + }); +var $rtfeldman$elm_css$VirtualDom$Styled$toKeyedStyleNode = F3( + function (maybeNonce, accumulatedStyles, keyedChildNodes) { + var styleNodeKey = A2($rtfeldman$elm_css$VirtualDom$Styled$getUnusedKey, '_', keyedChildNodes); + var finalNode = A2($rtfeldman$elm_css$VirtualDom$Styled$toStyleNode, maybeNonce, accumulatedStyles); + return _Utils_Tuple2(styleNodeKey, finalNode); + }); +var $rtfeldman$elm_css$VirtualDom$Styled$unstyleKeyed = F4( + function (maybeNonce, elemType, properties, keyedChildren) { + var initialStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, $elm$core$Dict$empty, properties); + var _v0 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateKeyedStyledHtml, + _Utils_Tuple2(_List_Nil, initialStyles), + keyedChildren); + var keyedChildNodes = _v0.a; + var styles = _v0.b; + var keyedStyleNode = A3( + $rtfeldman$elm_css$VirtualDom$Styled$toKeyedStyleNode, + maybeNonce, + $rtfeldman$elm_css$VirtualDom$Styled$UnscopedStyles(styles), + keyedChildNodes); + var unstyledProperties = A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttribute(styles), + properties); + return A3( + $elm$virtual_dom$VirtualDom$keyedNode, + elemType, + unstyledProperties, + A2( + $elm$core$List$cons, + keyedStyleNode, + $elm$core$List$reverse(keyedChildNodes))); + }); +var $rtfeldman$elm_css$VirtualDom$Styled$unstyleKeyedNS = F5( + function (maybeNonce, ns, elemType, properties, keyedChildren) { + var initialStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, $elm$core$Dict$empty, properties); + var _v0 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateKeyedStyledHtml, + _Utils_Tuple2(_List_Nil, initialStyles), + keyedChildren); + var keyedChildNodes = _v0.a; + var styles = _v0.b; + var keyedStyleNode = A3( + $rtfeldman$elm_css$VirtualDom$Styled$toKeyedStyleNode, + maybeNonce, + $rtfeldman$elm_css$VirtualDom$Styled$UnscopedStyles(styles), + keyedChildNodes); + var unstyledProperties = A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttributeNS(styles), + properties); + return A4( + $elm$virtual_dom$VirtualDom$keyedNodeNS, + ns, + elemType, + unstyledProperties, + A2( + $elm$core$List$cons, + keyedStyleNode, + $elm$core$List$reverse(keyedChildNodes))); + }); +var $rtfeldman$elm_css$VirtualDom$Styled$unstyleNS = F5( + function (maybeNonce, ns, elemType, properties, children) { + var initialStyles = A3($elm$core$List$foldl, $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyles, $elm$core$Dict$empty, properties); + var _v0 = A3( + $elm$core$List$foldl, + $rtfeldman$elm_css$VirtualDom$Styled$accumulateStyledHtml, + _Utils_Tuple2(_List_Nil, initialStyles), + children); + var childNodes = _v0.a; + var styles = _v0.b; + var styleNode = A2( + $rtfeldman$elm_css$VirtualDom$Styled$toStyleNode, + maybeNonce, + $rtfeldman$elm_css$VirtualDom$Styled$UnscopedStyles(styles)); + var unstyledProperties = A2( + $elm$core$List$map, + $rtfeldman$elm_css$VirtualDom$Styled$extractUnstyledAttributeNS(styles), + properties); + return A4( + $elm$virtual_dom$VirtualDom$nodeNS, + ns, + elemType, + unstyledProperties, + A2( + $elm$core$List$cons, + styleNode, + $elm$core$List$reverse(childNodes))); + }); +var $rtfeldman$elm_css$VirtualDom$Styled$toUnstyled = function (vdom) { + switch (vdom.$) { + case 'Unstyled': + var plainNode = vdom.a; + return plainNode; + case 'Node': + var elemType = vdom.a; + var properties = vdom.b; + var children = vdom.c; + return A4($rtfeldman$elm_css$VirtualDom$Styled$unstyle, $elm$core$Maybe$Nothing, elemType, properties, children); + case 'NodeNS': + var ns = vdom.a; + var elemType = vdom.b; + var properties = vdom.c; + var children = vdom.d; + return A5($rtfeldman$elm_css$VirtualDom$Styled$unstyleNS, $elm$core$Maybe$Nothing, ns, elemType, properties, children); + case 'KeyedNode': + var elemType = vdom.a; + var properties = vdom.b; + var children = vdom.c; + return A4($rtfeldman$elm_css$VirtualDom$Styled$unstyleKeyed, $elm$core$Maybe$Nothing, elemType, properties, children); + default: + var ns = vdom.a; + var elemType = vdom.b; + var properties = vdom.c; + var children = vdom.d; + return A5($rtfeldman$elm_css$VirtualDom$Styled$unstyleKeyedNS, $elm$core$Maybe$Nothing, ns, elemType, properties, children); + } +}; +var $rtfeldman$elm_css$Html$Styled$toUnstyled = $rtfeldman$elm_css$VirtualDom$Styled$toUnstyled; +var $author$project$Main$TakeInput = function (a) { + return {$: 'TakeInput', a: a}; +}; +var $rtfeldman$elm_css$VirtualDom$Styled$property = F2( + function (key, value) { + return A3( + $rtfeldman$elm_css$VirtualDom$Styled$Attribute, + A2($elm$virtual_dom$VirtualDom$property, key, value), + false, + ''); + }); +var $rtfeldman$elm_css$Html$Styled$Attributes$stringProperty = F2( + function (key, string) { + return A2( + $rtfeldman$elm_css$VirtualDom$Styled$property, + key, + $elm$json$Json$Encode$string(string)); + }); +var $rtfeldman$elm_css$Html$Styled$Attributes$id = $rtfeldman$elm_css$Html$Styled$Attributes$stringProperty('id'); +var $rtfeldman$elm_css$Html$Styled$Events$alwaysStop = function (x) { + return _Utils_Tuple2(x, true); +}; +var $elm$virtual_dom$VirtualDom$MayStopPropagation = function (a) { + return {$: 'MayStopPropagation', a: a}; +}; +var $elm$virtual_dom$VirtualDom$on = _VirtualDom_on; +var $rtfeldman$elm_css$VirtualDom$Styled$on = F2( + function (eventName, handler) { + return A3( + $rtfeldman$elm_css$VirtualDom$Styled$Attribute, + A2($elm$virtual_dom$VirtualDom$on, eventName, handler), + false, + ''); + }); +var $rtfeldman$elm_css$Html$Styled$Events$stopPropagationOn = F2( + function (event, decoder) { + return A2( + $rtfeldman$elm_css$VirtualDom$Styled$on, + event, + $elm$virtual_dom$VirtualDom$MayStopPropagation(decoder)); + }); +var $rtfeldman$elm_css$Html$Styled$Events$targetValue = A2( + $elm$json$Json$Decode$at, + _List_fromArray( + ['target', 'value']), + $elm$json$Json$Decode$string); +var $rtfeldman$elm_css$Html$Styled$Events$onInput = function (tagger) { + return A2( + $rtfeldman$elm_css$Html$Styled$Events$stopPropagationOn, + 'input', + A2( + $elm$json$Json$Decode$map, + $rtfeldman$elm_css$Html$Styled$Events$alwaysStop, + A2($elm$json$Json$Decode$map, tagger, $rtfeldman$elm_css$Html$Styled$Events$targetValue))); +}; +var $author$project$Main$Background = {$: 'Background'}; +var $author$project$Main$Foreground = {$: 'Foreground'}; +var $rtfeldman$elm_css$Html$Styled$main_ = $rtfeldman$elm_css$Html$Styled$node('main'); +var $rtfeldman$elm_css$Css$minHeight = $rtfeldman$elm_css$Css$prop1('min-height'); +var $author$project$Main$White = {$: 'White'}; +var $author$project$Main$themeColor = F2( + function (model, color) { + themeColor: + while (true) { + var _v0 = model.theme; + switch (_v0.$) { + case 'Pit': + switch (color.$) { + case 'Background': + return $rtfeldman$elm_css$Css$hex('#120211'); + case 'Foreground': + return $rtfeldman$elm_css$Css$hex('#f3d9f0'); + case 'Cursor': + var $temp$model = model, + $temp$color = $author$project$Main$White; + model = $temp$model; + color = $temp$color; + continue themeColor; + case 'Black': + return $rtfeldman$elm_css$Css$hex('#380e36'); + case 'White': + return $rtfeldman$elm_css$Css$hex('#e29edc'); + case 'BrightBlack': + return $rtfeldman$elm_css$Css$hex('#7c2b77'); + default: + return $rtfeldman$elm_css$Css$hex('#f9ecf7'); + } + case 'Dim': + switch (color.$) { + case 'Background': + return $rtfeldman$elm_css$Css$hex('#380e36'); + case 'Foreground': + return $rtfeldman$elm_css$Css$hex('#f7e5f4'); + case 'Cursor': + var $temp$model = model, + $temp$color = $author$project$Main$White; + model = $temp$model; + color = $temp$color; + continue themeColor; + case 'Black': + return $rtfeldman$elm_css$Css$hex('#5e1c56'); + case 'White': + return $rtfeldman$elm_css$Css$hex('#e8b2e2'); + case 'BrightBlack': + return $rtfeldman$elm_css$Css$hex('#9d3c98'); + default: + return $rtfeldman$elm_css$Css$hex('#fbf4fa'); + } + case 'Sky': + switch (color.$) { + case 'Background': + return $rtfeldman$elm_css$Css$hex('#f3d9f0'); + case 'Foreground': + return $rtfeldman$elm_css$Css$hex('#380e36'); + case 'Cursor': + var $temp$model = model, + $temp$color = $author$project$Main$White; + model = $temp$model; + color = $temp$color; + continue themeColor; + case 'Black': + return $rtfeldman$elm_css$Css$hex('#eec6e9'); + case 'White': + return $rtfeldman$elm_css$Css$hex('#7c2b77'); + case 'BrightBlack': + return $rtfeldman$elm_css$Css$hex('#d575cd'); + default: + return $rtfeldman$elm_css$Css$hex('#120211'); + } + default: + switch (color.$) { + case 'Background': + return $rtfeldman$elm_css$Css$hex('#f9ecf7'); + case 'Foreground': + return $rtfeldman$elm_css$Css$hex('#5a1c56'); + case 'Cursor': + var $temp$model = model, + $temp$color = $author$project$Main$White; + model = $temp$model; + color = $temp$color; + continue themeColor; + case 'Black': + return $rtfeldman$elm_css$Css$hex('#f3d9f0'); + case 'White': + return $rtfeldman$elm_css$Css$hex('#9d3c98'); + case 'BrightBlack': + return $rtfeldman$elm_css$Css$hex('#dc8ed5'); + default: + return $rtfeldman$elm_css$Css$hex('#380e36'); + } + } + } + }); +var $rtfeldman$elm_css$Css$VhUnits = {$: 'VhUnits'}; +var $rtfeldman$elm_css$Css$vh = A2($rtfeldman$elm_css$Css$Internal$lengthConverter, $rtfeldman$elm_css$Css$VhUnits, 'vh'); +var $rtfeldman$elm_css$Css$VwUnits = {$: 'VwUnits'}; +var $rtfeldman$elm_css$Css$vw = A2($rtfeldman$elm_css$Css$Internal$lengthConverter, $rtfeldman$elm_css$Css$VwUnits, 'vw'); +var $rtfeldman$elm_css$Css$width = $rtfeldman$elm_css$Css$prop1('width'); +var $author$project$Main$styledBody = function (model) { + return A2( + $rtfeldman$elm_css$Html$Styled$styled, + $rtfeldman$elm_css$Html$Styled$main_, + _List_fromArray( + [ + $rtfeldman$elm_css$Css$backgroundColor( + A2($author$project$Main$themeColor, model, $author$project$Main$Background)), + $rtfeldman$elm_css$Css$color( + A2($author$project$Main$themeColor, model, $author$project$Main$Foreground)), + $rtfeldman$elm_css$Css$minHeight( + $rtfeldman$elm_css$Css$vh(100)), + $rtfeldman$elm_css$Css$width( + $rtfeldman$elm_css$Css$vw(100)), + $rtfeldman$elm_css$Css$margin( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$padding( + $rtfeldman$elm_css$Css$px(0)) + ])); +}; +var $rtfeldman$elm_css$Css$displayFlex = A2($rtfeldman$elm_css$Css$property, 'display', 'flex'); +var $rtfeldman$elm_css$Css$flexDirection = $rtfeldman$elm_css$Css$prop1('flex-direction'); +var $rtfeldman$elm_css$Css$flexStart = $rtfeldman$elm_css$Css$prop1('flex-start'); +var $rtfeldman$elm_css$Css$flexWrap = $rtfeldman$elm_css$Css$prop1('flex-wrap'); +var $rtfeldman$elm_css$Css$Preprocess$ApplyStyles = function (a) { + return {$: 'ApplyStyles', a: a}; +}; +var $rtfeldman$elm_css$Css$Internal$property = F2( + function (key, value) { + return $rtfeldman$elm_css$Css$Preprocess$AppendProperty( + $rtfeldman$elm_css$Css$Structure$Property(key + (':' + value))); + }); +var $rtfeldman$elm_css$Css$Internal$getOverloadedProperty = F3( + function (functionName, desiredKey, style) { + getOverloadedProperty: + while (true) { + switch (style.$) { + case 'AppendProperty': + var str = style.a.a; + var key = A2( + $elm$core$Maybe$withDefault, + '', + $elm$core$List$head( + A2($elm$core$String$split, ':', str))); + return A2($rtfeldman$elm_css$Css$Internal$property, desiredKey, key); + case 'ExtendSelector': + var selector = style.a; + return A2($rtfeldman$elm_css$Css$Internal$property, desiredKey, 'elm-css-error-cannot-apply-' + (functionName + '-with-inapplicable-Style-for-selector')); + case 'NestSnippet': + var combinator = style.a; + return A2($rtfeldman$elm_css$Css$Internal$property, desiredKey, 'elm-css-error-cannot-apply-' + (functionName + '-with-inapplicable-Style-for-combinator')); + case 'WithPseudoElement': + var pseudoElement = style.a; + return A2($rtfeldman$elm_css$Css$Internal$property, desiredKey, 'elm-css-error-cannot-apply-' + (functionName + '-with-inapplicable-Style-for-pseudo-element setter')); + case 'WithMedia': + return A2($rtfeldman$elm_css$Css$Internal$property, desiredKey, 'elm-css-error-cannot-apply-' + (functionName + '-with-inapplicable-Style-for-media-query')); + case 'WithKeyframes': + return A2($rtfeldman$elm_css$Css$Internal$property, desiredKey, 'elm-css-error-cannot-apply-' + (functionName + '-with-inapplicable-Style-for-keyframes')); + default: + if (!style.a.b) { + return A2($rtfeldman$elm_css$Css$Internal$property, desiredKey, 'elm-css-error-cannot-apply-' + (functionName + '-with-empty-Style')); + } else { + if (!style.a.b.b) { + var _v1 = style.a; + var only = _v1.a; + var $temp$functionName = functionName, + $temp$desiredKey = desiredKey, + $temp$style = only; + functionName = $temp$functionName; + desiredKey = $temp$desiredKey; + style = $temp$style; + continue getOverloadedProperty; + } else { + var _v2 = style.a; + var first = _v2.a; + var rest = _v2.b; + var $temp$functionName = functionName, + $temp$desiredKey = desiredKey, + $temp$style = $rtfeldman$elm_css$Css$Preprocess$ApplyStyles(rest); + functionName = $temp$functionName; + desiredKey = $temp$desiredKey; + style = $temp$style; + continue getOverloadedProperty; + } + } + } + } + }); +var $rtfeldman$elm_css$Css$Internal$IncompatibleUnits = {$: 'IncompatibleUnits'}; +var $rtfeldman$elm_css$Css$Internal$lengthForOverloadedProperty = A3($rtfeldman$elm_css$Css$Internal$lengthConverter, $rtfeldman$elm_css$Css$Internal$IncompatibleUnits, '', 0); +var $rtfeldman$elm_css$Css$justifyContent = function (fn) { + return A3( + $rtfeldman$elm_css$Css$Internal$getOverloadedProperty, + 'justifyContent', + 'justify-content', + fn($rtfeldman$elm_css$Css$Internal$lengthForOverloadedProperty)); +}; +var $rtfeldman$elm_css$Css$noWrap = {flexDirectionOrWrap: $rtfeldman$elm_css$Css$Structure$Compatible, flexWrap: $rtfeldman$elm_css$Css$Structure$Compatible, value: 'nowrap', whiteSpace: $rtfeldman$elm_css$Css$Structure$Compatible}; +var $rtfeldman$elm_css$Css$row = {flexDirection: $rtfeldman$elm_css$Css$Structure$Compatible, flexDirectionOrWrap: $rtfeldman$elm_css$Css$Structure$Compatible, value: 'row'}; +var $author$project$Main$styledCL = function (model) { + return A2( + $rtfeldman$elm_css$Html$Styled$styled, + $rtfeldman$elm_css$Html$Styled$span, + _List_fromArray( + [ + $rtfeldman$elm_css$Css$backgroundColor( + A2($author$project$Main$themeColor, model, $author$project$Main$Background)), + $rtfeldman$elm_css$Css$padding( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$margin( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$displayFlex, + $rtfeldman$elm_css$Css$flexDirection($rtfeldman$elm_css$Css$row), + $rtfeldman$elm_css$Css$flexWrap($rtfeldman$elm_css$Css$noWrap), + $rtfeldman$elm_css$Css$justifyContent($rtfeldman$elm_css$Css$flexStart) + ])); +}; +var $rtfeldman$elm_css$Css$flexGrow = $rtfeldman$elm_css$Css$prop1('flex-grow'); +var $rtfeldman$elm_css$Css$fontSize = $rtfeldman$elm_css$Css$prop1('font-size'); +var $rtfeldman$elm_css$Css$height = $rtfeldman$elm_css$Css$prop1('height'); +var $rtfeldman$elm_css$Css$hidden = {borderStyle: $rtfeldman$elm_css$Css$Structure$Compatible, overflow: $rtfeldman$elm_css$Css$Structure$Compatible, value: 'hidden', visibility: $rtfeldman$elm_css$Css$Structure$Compatible}; +var $rtfeldman$elm_css$Css$UnitlessInteger = {$: 'UnitlessInteger'}; +var $rtfeldman$elm_css$Css$int = function (val) { + return { + fontWeight: $rtfeldman$elm_css$Css$Structure$Compatible, + intOrAuto: $rtfeldman$elm_css$Css$Structure$Compatible, + lengthOrNumber: $rtfeldman$elm_css$Css$Structure$Compatible, + lengthOrNumberOrAutoOrNoneOrContent: $rtfeldman$elm_css$Css$Structure$Compatible, + number: $rtfeldman$elm_css$Css$Structure$Compatible, + numberOrInfinite: $rtfeldman$elm_css$Css$Structure$Compatible, + numericValue: val, + unitLabel: '', + units: $rtfeldman$elm_css$Css$UnitlessInteger, + value: $elm$core$String$fromInt(val) + }; +}; +var $rtfeldman$elm_css$Css$none = {backgroundImage: $rtfeldman$elm_css$Css$Structure$Compatible, blockAxisOverflow: $rtfeldman$elm_css$Css$Structure$Compatible, borderStyle: $rtfeldman$elm_css$Css$Structure$Compatible, cursor: $rtfeldman$elm_css$Css$Structure$Compatible, display: $rtfeldman$elm_css$Css$Structure$Compatible, hoverCapability: $rtfeldman$elm_css$Css$Structure$Compatible, inlineAxisOverflow: $rtfeldman$elm_css$Css$Structure$Compatible, keyframes: $rtfeldman$elm_css$Css$Structure$Compatible, lengthOrNone: $rtfeldman$elm_css$Css$Structure$Compatible, lengthOrNoneOrMinMaxDimension: $rtfeldman$elm_css$Css$Structure$Compatible, lengthOrNumberOrAutoOrNoneOrContent: $rtfeldman$elm_css$Css$Structure$Compatible, listStyleType: $rtfeldman$elm_css$Css$Structure$Compatible, listStyleTypeOrPositionOrImage: $rtfeldman$elm_css$Css$Structure$Compatible, none: $rtfeldman$elm_css$Css$Structure$Compatible, outline: $rtfeldman$elm_css$Css$Structure$Compatible, pointerDevice: $rtfeldman$elm_css$Css$Structure$Compatible, pointerEvents: $rtfeldman$elm_css$Css$Structure$Compatible, resize: $rtfeldman$elm_css$Css$Structure$Compatible, scriptingSupport: $rtfeldman$elm_css$Css$Structure$Compatible, textDecorationLine: $rtfeldman$elm_css$Css$Structure$Compatible, textTransform: $rtfeldman$elm_css$Css$Structure$Compatible, touchAction: $rtfeldman$elm_css$Css$Structure$Compatible, transform: $rtfeldman$elm_css$Css$Structure$Compatible, updateFrequency: $rtfeldman$elm_css$Css$Structure$Compatible, value: 'none'}; +var $rtfeldman$elm_css$Css$outlineWidth = $rtfeldman$elm_css$Css$prop1('outline-width'); +var $rtfeldman$elm_css$Css$overflow = $rtfeldman$elm_css$Css$prop1('overflow'); +var $rtfeldman$elm_css$Css$resize = $rtfeldman$elm_css$Css$prop1('resize'); +var $rtfeldman$elm_css$Html$Styled$textarea = $rtfeldman$elm_css$Html$Styled$node('textarea'); +var $author$project$Main$styledCLI = function (model) { + return A2( + $rtfeldman$elm_css$Html$Styled$styled, + $rtfeldman$elm_css$Html$Styled$textarea, + _List_fromArray( + [ + $rtfeldman$elm_css$Css$color( + A2($author$project$Main$themeColor, model, $author$project$Main$Foreground)), + $rtfeldman$elm_css$Css$fontSize( + $rtfeldman$elm_css$Css$px(model.font.fontSize)), + $rtfeldman$elm_css$Css$padding( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$margin( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$backgroundColor( + A2($author$project$Main$themeColor, model, $author$project$Main$Background)), + $rtfeldman$elm_css$Css$borderWidth( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$outlineWidth( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$height( + $rtfeldman$elm_css$Css$px(model.font.fontSize)), + $rtfeldman$elm_css$Css$resize($rtfeldman$elm_css$Css$none), + $rtfeldman$elm_css$Css$overflow($rtfeldman$elm_css$Css$hidden), + $rtfeldman$elm_css$Css$flexGrow( + $rtfeldman$elm_css$Css$int(100)) + ])); +}; +var $rtfeldman$elm_css$Css$fontFamily = $rtfeldman$elm_css$Css$prop1('font-family'); +var $rtfeldman$elm_css$Css$monospace = {fontFamily: $rtfeldman$elm_css$Css$Structure$Compatible, value: 'monospace'}; +var $rtfeldman$elm_css$Css$preWrap = {value: 'pre-wrap', whiteSpace: $rtfeldman$elm_css$Css$Structure$Compatible}; +var $rtfeldman$elm_css$Css$whiteSpace = $rtfeldman$elm_css$Css$prop1('white-space'); +var $author$project$Main$styledContent = function (model) { + return A2( + $rtfeldman$elm_css$Html$Styled$styled, + $rtfeldman$elm_css$Html$Styled$span, + _List_fromArray( + [ + $rtfeldman$elm_css$Css$color( + A2($author$project$Main$themeColor, model, $author$project$Main$Foreground)), + $rtfeldman$elm_css$Css$fontSize( + $rtfeldman$elm_css$Css$px(model.font.fontSize)), + $rtfeldman$elm_css$Css$padding( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$margin( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$backgroundColor( + A2($author$project$Main$themeColor, model, $author$project$Main$Background)), + $rtfeldman$elm_css$Css$borderWidth( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$width( + $rtfeldman$elm_css$Css$vw(100)), + $rtfeldman$elm_css$Css$whiteSpace($rtfeldman$elm_css$Css$preWrap), + $rtfeldman$elm_css$Css$fontFamily($rtfeldman$elm_css$Css$monospace) + ])); +}; +var $author$project$Main$styledPrompt = function (model) { + return A2( + $rtfeldman$elm_css$Html$Styled$styled, + $rtfeldman$elm_css$Html$Styled$span, + _List_fromArray( + [ + $rtfeldman$elm_css$Css$color( + A2($author$project$Main$themeColor, model, $author$project$Main$Foreground)), + $rtfeldman$elm_css$Css$fontSize( + $rtfeldman$elm_css$Css$px(model.font.fontSize)), + $rtfeldman$elm_css$Css$padding( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$margin( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$backgroundColor( + A2($author$project$Main$themeColor, model, $author$project$Main$Background)), + $rtfeldman$elm_css$Css$borderWidth( + $rtfeldman$elm_css$Css$px(0)), + $rtfeldman$elm_css$Css$height( + $rtfeldman$elm_css$Css$px(model.font.fontSize)), + $rtfeldman$elm_css$Css$fontFamily($rtfeldman$elm_css$Css$monospace) + ])); +}; +var $rtfeldman$elm_css$Html$Styled$Attributes$value = $rtfeldman$elm_css$Html$Styled$Attributes$stringProperty('value'); +var $author$project$Main$viewBody = function (model) { + return A3( + $author$project$Main$styledBody, + model, + _List_Nil, + _List_fromArray( + [ + A3($author$project$Main$styledContent, model, _List_Nil, model.content), + A3( + $author$project$Main$styledCL, + model, + _List_Nil, + _List_fromArray( + [ + A3( + $author$project$Main$styledPrompt, + model, + _List_Nil, + _List_fromArray( + [ + A2( + $author$project$Main$coloredText, + $author$project$Main$coreColor($author$project$Main$BrightMagenta), + model.prompt.prompt) + ])), + A3( + $author$project$Main$styledCLI, + model, + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$Events$onInput($author$project$Main$TakeInput), + $rtfeldman$elm_css$Html$Styled$Attributes$value(model.cliContent), + $rtfeldman$elm_css$Html$Styled$Attributes$id('init-focus') + ]), + _List_Nil) + ])) + ])); +}; +var $author$project$Main$view = function (model) { + return A2( + $elm$browser$Browser$Document, + 'andrew.r3tic.net', + _List_fromArray( + [ + $rtfeldman$elm_css$Html$Styled$toUnstyled( + $author$project$Main$viewBody(model)) + ])); +}; +var $author$project$Main$main = $elm$browser$Browser$application( + {init: $author$project$Main$init, onUrlChange: $author$project$Main$UrlChanged, onUrlRequest: $author$project$Main$LinkClicked, subscriptions: $author$project$Main$subscriptions, update: $author$project$Main$update, view: $author$project$Main$view}); +_Platform_export({'Main':{'init':$author$project$Main$main($elm$json$Json$Decode$value)(0)}});}(this)); \ No newline at end of file diff --git a/assets/json/init.json b/assets/json/init.json new file mode 100644 index 0000000..2c63c08 --- /dev/null +++ b/assets/json/init.json @@ -0,0 +1,2 @@ +{ +} diff --git a/assets/json/test.json b/assets/json/test.json new file mode 100644 index 0000000..da132be --- /dev/null +++ b/assets/json/test.json @@ -0,0 +1,4 @@ +{ + "message0": "Hello World!", + "message1": "This is another message. Hello World!" +} diff --git a/backend/.gitignore b/backend/.gitignore new file mode 100644 index 0000000..c368d45 --- /dev/null +++ b/backend/.gitignore @@ -0,0 +1,2 @@ +.stack-work/ +*~ \ No newline at end of file diff --git a/backend/CHANGELOG.md b/backend/CHANGELOG.md new file mode 100644 index 0000000..1e535cd --- /dev/null +++ b/backend/CHANGELOG.md @@ -0,0 +1,11 @@ +# Changelog for `hs-server` + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to the +[Haskell Package Versioning Policy](https://pvp.haskell.org/). + +## Unreleased + +## 0.1.0.0 - YYYY-MM-DD diff --git a/backend/LICENSE b/backend/LICENSE new file mode 100644 index 0000000..4810e24 --- /dev/null +++ b/backend/LICENSE @@ -0,0 +1,26 @@ +Copyright 2025 Author name here + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/backend/README.md b/backend/README.md new file mode 100644 index 0000000..de045bf --- /dev/null +++ b/backend/README.md @@ -0,0 +1,2 @@ +# hs-server +this is a custom-built single-purpose server infrastructure based on Scorry, Warp, and Wai. It holds up MTGmonkey's personal website diff --git a/backend/Setup.hs b/backend/Setup.hs new file mode 100644 index 0000000..9a994af --- /dev/null +++ b/backend/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/backend/app/Main.hs b/backend/app/Main.hs new file mode 100644 index 0000000..6a37b1f --- /dev/null +++ b/backend/app/Main.hs @@ -0,0 +1,90 @@ +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE OverloadedStrings #-} + +-- import Lib +import Data.Text.Lazy (Text) +import Network.Wai.Handler.Warp (Port) +import Text.Blaze ((!)) +import Text.Blaze.Html.Renderer.Text (renderHtml) + +import Network.HTTP.Types +import Web.Scotty as S + +import qualified Control.Exception as E +import qualified Text.Blaze.Html5 as H +import qualified Text.Blaze.Html5.Attributes as A + +-- HTML +index :: H.Html -> Text +index compiledElmApp = renderHtml $ do + H.docTypeHtml $ do + H.head $ do + H.title "TESTING Scotty+Elm" + H.style "body{margin:0px;}" + (H.body ! A.id "body") $ do + embedJs compiledElmApp + +-- CONF +port :: Port +port = 3000 + +adminContact :: String +adminContact = "[Matrix] @mtgmonkey:calitabby.net" + +compiledElmAppFile :: AssetPath +compiledElmAppFile = "/js/main.js" + +boilerplateJsFile :: AssetPath +boilerplateJsFile = "/js/init.js" + +assetsFolder :: FilePath +assetsFolder = "./assets" + +-- MAIN +main :: IO () +main = do + compiledElmAppOrExc <- E.try $ readFile $ assetsFolder ++ compiledElmAppFile :: IO (Either E.IOException String) + let compiledElmApp = case compiledElmAppOrExc of + Left e -> serverErrorReadFile e + Right contents -> H.toHtml $ contents + + boilerplateJsOrExc <- E.try $ readFile $ assetsFolder ++ boilerplateJsFile :: IO (Either E.IOException String) + let boilerplateJs = case boilerplateJsOrExc of + Left e -> serverErrorReadFile e + Right contents -> H.toHtml $ contents + + let anyRoute = regex "^.*$" + scotty port $ do + + -- GET requests + get "/" $ do + status ok200 + S.html $ index $ do + compiledElmApp + "\n" + boilerplateJs + + get "/favicon.ico/" $ do + status notFound404 + S.html $ "you want a favi-whatnow!?" + + -- ERR + notFound $ do + status methodNotAllowed405 + S.text "Verb disallowed; OR, route doesn't exist :(" + + +-- FUNC +serverErrorReadFile :: E.IOException -> Js +serverErrorReadFile e = H.toHtml $ "document.getElementById('body').innerHTML='Server-side error occurred: " + ++ (show e) + ++ "; report htis to a site administrator: " + ++ adminContact + ++ "';" + +embedJs :: Js -> H.Html +embedJs js = H.script $ js + + -- TYPES +type AssetPath = FilePath +type Js = H.Html diff --git a/backend/hs-server.cabal b/backend/hs-server.cabal new file mode 100644 index 0000000..32458cb --- /dev/null +++ b/backend/hs-server.cabal @@ -0,0 +1,80 @@ +cabal-version: 2.2 + +-- This file has been generated from package.yaml by hpack version 0.37.0. +-- +-- see: https://github.com/sol/hpack + +name: hs-server +version: 0.1.0.0 +description: Please see README.md +author: mtgmonkey +maintainer: mtgmonkey +copyright: 2025 mtgmonkey +license: BSD-3-Clause +license-file: LICENSE +build-type: Simple +extra-source-files: + README.md + CHANGELOG.md + +library + other-modules: + Paths_hs_server + autogen-modules: + Paths_hs_server + hs-source-dirs: + src + ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints + build-depends: + base >=4.19.2 && <4.20 + , blaze-html >=0.9.2 && <0.10 + , blaze-markup >=0.8.3 && <0.9 + , directory >=1.3.8 && <1.4 + , http-types >=0.12.4 && <0.13 + , scotty ==0.22.* + , text >=2.1.1 && <2.2 + , warp >=3.4.7 && <3.5 + default-language: Haskell2010 + +executable hs-server-exe + main-is: Main.hs + other-modules: + Paths_hs_server + autogen-modules: + Paths_hs_server + hs-source-dirs: + app + ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -threaded -rtsopts -with-rtsopts=-N + build-depends: + base >=4.19.2 && <4.20 + , blaze-html >=0.9.2 && <0.10 + , blaze-markup >=0.8.3 && <0.9 + , directory >=1.3.8 && <1.4 + , hs-server + , http-types >=0.12.4 && <0.13 + , scotty ==0.22.* + , text >=2.1.1 && <2.2 + , warp >=3.4.7 && <3.5 + default-language: Haskell2010 + +test-suite hs-server-test + type: exitcode-stdio-1.0 + main-is: Spec.hs + other-modules: + Paths_hs_server + autogen-modules: + Paths_hs_server + hs-source-dirs: + test + ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -threaded -rtsopts -with-rtsopts=-N + build-depends: + base >=4.19.2 && <4.20 + , blaze-html >=0.9.2 && <0.10 + , blaze-markup >=0.8.3 && <0.9 + , directory >=1.3.8 && <1.4 + , hs-server + , http-types >=0.12.4 && <0.13 + , scotty ==0.22.* + , text >=2.1.1 && <2.2 + , warp >=3.4.7 && <3.5 + default-language: Haskell2010 diff --git a/backend/package.yaml b/backend/package.yaml new file mode 100644 index 0000000..14d004e --- /dev/null +++ b/backend/package.yaml @@ -0,0 +1,65 @@ +name: hs-server +version: 0.1.0.0 +license: BSD-3-Clause +author: "mtgmonkey" +maintainer: "mtgmonkey" +copyright: "2025 mtgmonkey" + +extra-source-files: +- README.md +- CHANGELOG.md + +# Metadata used when publishing your package +# synopsis: Short description of your package +# category: Web + +# To avoid duplicated efforts in documentation and dealing with the +# complications of embedding Haddock markup inside cabal files, it is +# common to point users to the README.md file. +description: Please see README.md + +dependencies: +- base >= 4.19.2 && < 4.20 +- blaze-html >= 0.9.2 && < 0.10 +- blaze-markup >= 0.8.3 && < 0.9 +- directory >= 1.3.8 && < 1.4 +- http-types >= 0.12.4 && < 0.13 +- scotty >= 0.22 && < 0.23 +- text >= 2.1.1 && < 2.2 +- warp >= 3.4.7 && < 3.5 + +ghc-options: +- -Wall +- -Wcompat +- -Widentities +- -Wincomplete-record-updates +- -Wincomplete-uni-patterns +- -Wmissing-export-lists +- -Wmissing-home-modules +- -Wpartial-fields +- -Wredundant-constraints + +library: + source-dirs: src + +executables: + hs-server-exe: + main: Main.hs + source-dirs: app + ghc-options: + - -threaded + - -rtsopts + - -with-rtsopts=-N + dependencies: + - hs-server + +tests: + hs-server-test: + main: Spec.hs + source-dirs: test + ghc-options: + - -threaded + - -rtsopts + - -with-rtsopts=-N + dependencies: + - hs-server diff --git a/backend/stack.yaml b/backend/stack.yaml new file mode 100644 index 0000000..e4f847c --- /dev/null +++ b/backend/stack.yaml @@ -0,0 +1,74 @@ +# This file was automatically generated by 'stack init' +# +# Some commonly used options have been documented as comments in this file. +# For advanced use and comprehensive documentation of the format, please see: +# https://docs.haskellstack.org/en/stable/yaml_configuration/ + +# A 'specific' Stackage snapshot or a compiler version. +# A snapshot resolver dictates the compiler version and the set of packages +# to be used for project dependencies. For example: +# +# snapshot: lts-22.28 +# snapshot: nightly-2024-07-05 +# snapshot: ghc-9.6.6 +# +# The location of a snapshot can be provided as a file or url. Stack assumes +# a snapshot provided as a file might change, whereas a url resource does not. +# +# snapshot: ./custom-snapshot.yaml +# snapshot: https://example.com/snapshots/2024-01-01.yaml +snapshot: + url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/23/19.yaml + +# User packages to be built. +# Various formats can be used as shown in the example below. +# +# packages: +# - some-directory +# - https://example.com/foo/bar/baz-0.0.2.tar.gz +# subdirs: +# - auto-update +# - wai +# +# packages is represented in package.yaml +packages: +- . + +nix: + enable: true + packages: [zlib] + +# Dependency packages to be pulled from upstream that are not in the snapshot. +# These entries can reference officially published versions as well as +# forks / in-progress versions pinned to a git hash. For example: +# +# extra-deps: +# - acme-missiles-0.3 +# - git: https://github.com/commercialhaskell/stack.git +# commit: e7b331f14bcffb8367cd58fbfc8b40ec7642100a +# +# extra-deps: [] + +# Override default flag values for project packages and extra-deps +# flags: {} + +# Extra package databases containing global packages +# extra-package-dbs: [] + +# Control whether we use the GHC we find on the path +# system-ghc: true +# +# Require a specific version of Stack, using version ranges +# require-stack-version: -any # Default +# require-stack-version: ">=3.1" +# +# Override the architecture used by Stack, especially useful on Windows +# arch: i386 +# arch: x86_64 +# +# Extra directories used by Stack for building +# extra-include-dirs: [/path/to/dir] +# extra-lib-dirs: [/path/to/dir] +# +# Allow a newer minor version of GHC than the snapshot specifies +# compiler-check: newer-minor diff --git a/backend/stack.yaml.lock b/backend/stack.yaml.lock new file mode 100644 index 0000000..e0ca7a4 --- /dev/null +++ b/backend/stack.yaml.lock @@ -0,0 +1,13 @@ +# This file was autogenerated by Stack. +# You should not edit this file by hand. +# For more information, please see the documentation at: +# https://docs.haskellstack.org/en/stable/lock_files + +packages: [] +snapshots: +- completed: + sha256: 296a7960c37efa382432ab497161a092684191815eb92a608c5d6ea5f894ace3 + size: 683835 + url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/23/19.yaml + original: + url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/23/19.yaml diff --git a/frontend/elm-stuff/0.19.1/Main.elmi b/frontend/elm-stuff/0.19.1/Main.elmi new file mode 100644 index 0000000..e68f562 Binary files /dev/null and b/frontend/elm-stuff/0.19.1/Main.elmi differ diff --git a/frontend/elm-stuff/0.19.1/Main.elmo b/frontend/elm-stuff/0.19.1/Main.elmo new file mode 100644 index 0000000..bf3d3ed Binary files /dev/null and b/frontend/elm-stuff/0.19.1/Main.elmo differ diff --git a/frontend/elm-stuff/0.19.1/Post.elmi b/frontend/elm-stuff/0.19.1/Post.elmi new file mode 100644 index 0000000..9b8cc62 Binary files /dev/null and b/frontend/elm-stuff/0.19.1/Post.elmi differ diff --git a/frontend/elm-stuff/0.19.1/Post.elmo b/frontend/elm-stuff/0.19.1/Post.elmo new file mode 100644 index 0000000..4dd5188 Binary files /dev/null and b/frontend/elm-stuff/0.19.1/Post.elmo differ diff --git a/frontend/elm-stuff/0.19.1/d.dat b/frontend/elm-stuff/0.19.1/d.dat new file mode 100644 index 0000000..75fb522 Binary files /dev/null and b/frontend/elm-stuff/0.19.1/d.dat differ diff --git a/frontend/elm-stuff/0.19.1/i.dat b/frontend/elm-stuff/0.19.1/i.dat new file mode 100644 index 0000000..23c3427 Binary files /dev/null and b/frontend/elm-stuff/0.19.1/i.dat differ diff --git a/frontend/elm-stuff/0.19.1/lock b/frontend/elm-stuff/0.19.1/lock new file mode 100644 index 0000000..e69de29 diff --git a/frontend/elm-stuff/0.19.1/o.dat b/frontend/elm-stuff/0.19.1/o.dat new file mode 100644 index 0000000..636822e Binary files /dev/null and b/frontend/elm-stuff/0.19.1/o.dat differ diff --git a/frontend/elm.json b/frontend/elm.json new file mode 100644 index 0000000..6256f63 --- /dev/null +++ b/frontend/elm.json @@ -0,0 +1,33 @@ +{ + "type": "application", + "source-directories": [ + "src" + ], + "elm-version": "0.19.1", + "dependencies": { + "direct": { + "elm/browser": "1.0.2", + "elm/core": "1.0.5", + "elm/html": "1.0.0", + "elm/json": "1.1.3", + "elm/url": "1.0.0", + "lobanov/elm-localstorage": "1.0.1", + "rtfeldman/elm-css": "18.0.0" + }, + "indirect": { + "elm/bytes": "1.0.8", + "elm/file": "1.0.5", + "elm/http": "2.0.0", + "elm/random": "1.0.0", + "elm/time": "1.0.0", + "elm/virtual-dom": "1.0.3", + "lobanov/elm-taskport": "2.0.1", + "robinheghan/murmur3": "1.0.0", + "rtfeldman/elm-hex": "1.0.0" + } + }, + "test-dependencies": { + "direct": {}, + "indirect": {} + } +} diff --git a/frontend/index.def.html b/frontend/index.def.html new file mode 100644 index 0000000..456ce73 --- /dev/null +++ b/frontend/index.def.html @@ -0,0 +1,81 @@ + + + + + Main + + + + + + + diff --git a/frontend/shell.nix b/frontend/shell.nix new file mode 100644 index 0000000..20dc38c --- /dev/null +++ b/frontend/shell.nix @@ -0,0 +1,9 @@ +{pkgs ? import {}}: +pkgs.mkShell { + nativeBuildInputs = [ + pkgs.elmPackages.elm + pkgs.elmPackages.elm-format + pkgs.uglify-js + pkgs.ungoogled-chromium + ]; +} diff --git a/frontend/src/Main.elm b/frontend/src/Main.elm new file mode 100644 index 0000000..9ee642e --- /dev/null +++ b/frontend/src/Main.elm @@ -0,0 +1,1165 @@ +port module Main exposing (..) + +import Browser +import Browser.Dom as Dom +import Browser.Navigation as Nav +import Css exposing (..) +import Html.Styled exposing (Attribute, Html, styled, text, toUnstyled) +import Html.Styled.Attributes exposing (id, value) +import Html.Styled.Events exposing (onInput) +import Json.Decode as D +import Json.Encode as E +import Task +import Url + + + +-- MAIN + + +main : Program E.Value Model Msg +main = + Browser.application + { init = init + , view = view + , update = update + , subscriptions = subscriptions + , onUrlChange = UrlChanged + , onUrlRequest = LinkClicked + } + + + +-- MODEL + + +type alias Font = + { fontSize : Float + } + + +type alias CookiesKept = + { keepTheme : Bool + , keepFont : Bool + , keepPrompt : Bool + } + + +type alias Prompt = + { prompt : String + } + + +type alias Model = + { key : Nav.Key + , url : Url.Url + , theme : Theme + , font : Font + , cookiesKept : CookiesKept + , prompt : Prompt + , content : List (Html Msg) + , cliContent : String + } + + +init : E.Value -> Url.Url -> Nav.Key -> ( Model, Cmd Msg ) +init flags url key = + let + initContent = + [ text "Welcome to my website!" + , text "\nRun `help` to get started" + ] + + cookiesKept = + case D.decodeValue cookiesKeptDecoder flags of + Ok cK -> + cK + + Err _ -> + { keepTheme = True + , keepFont = True + , keepPrompt = True + } + in + ( { key = key + , url = url + , theme = + if cookiesKept.keepTheme then + case D.decodeValue (themeDecoder flags) flags of + Ok theme -> + theme + + Err _ -> + Pit + + else + Pit + , font = + if cookiesKept.keepFont then + case D.decodeValue fontDecoder flags of + Ok font -> + font + + Err _ -> + { fontSize = 20.0 } + + else + { fontSize = 20.0 } + , cookiesKept = cookiesKept + , prompt = + if cookiesKept.keepPrompt then + case D.decodeValue promptDecoder flags of + Ok prompt -> + prompt + + Err _ -> + { prompt = ">" } + + else + { prompt = ">" } + , content = initContent + , cliContent = "" + } + , Task.attempt (\_ -> NoInitFocus) (Dom.focus "init-focus") + ) + + + +-- UPDATE + + +type Msg + = LinkClicked Browser.UrlRequest + | UrlChanged Url.Url + | TakeInput String + | NoInitFocus + | ReceivedTest (Result D.Error Test) + + +update : Msg -> Model -> ( Model, Cmd Msg ) +update msg model = + case msg of + LinkClicked urlRequest -> + case urlRequest of + Browser.Internal url -> + ( model, Nav.pushUrl model.key (Url.toString url) ) + + Browser.External href -> + ( model, Nav.load href ) + + UrlChanged url -> + ( { model | url = url } + , Cmd.none + ) + + TakeInput string -> + if String.endsWith "\n" string then + runCommand + { model + | cliContent = "" + , content = + model.content + ++ [ text + (if model.content /= [] then + "\n" + + else + "" + ) + , coloredText (coreColor BrightMagenta) model.prompt.prompt + , text <| String.trim string + ] + } + (parseInput string) + + else + ( { model | cliContent = string }, Cmd.none ) + + NoInitFocus -> + ( model, Cmd.none ) + + ReceivedTest result -> + case result of + Ok test -> + ( { model | content = model.content ++ [ text "\nData got successfully" ] }, Cmd.none ) + + Err err -> + ( { model | content = model.content ++ [ text <| "\n" ++ D.errorToString err ] }, Cmd.none ) + + + +-- COMMANDS + + +type Command + = Help + | Clear + | Cookies + | FontCommand + | Hello + | PromptCommand + | Theme + + +type alias Input = + { command : Command + , args : List String + } + + +parseInput : String -> Result String Input +parseInput input = + let + tokens = + List.map String.trim (String.split " " input) + + command = + case List.head tokens of + Just "help" -> + Ok Help + + Just "clear" -> + Ok Clear + + Just "cookies" -> + Ok Cookies + + Just "font" -> + Ok FontCommand + + Just "hello" -> + Ok Hello + + Just "prompt" -> + Ok PromptCommand + + Just "theme" -> + Ok Theme + + Just trimput -> + Err trimput + + _ -> + Err "error in parseInput parsing tokens" + + args = + case List.tail tokens of + Just tail -> + Ok <| List.filter ((/=) "") tail + + _ -> + Err "error in parseInput parsing tokens" + in + case args of + Ok arguments -> + case command of + Ok cmd -> + Ok { command = cmd, args = arguments } + + Err err -> + Err err + + Err err -> + Err err + + +runCommand : Model -> Result String Input -> ( Model, Cmd Msg ) +runCommand model input = + case input of + Ok { command, args } -> + case command of + Help -> + ( runHelp model args, Cmd.none ) + + Clear -> + ( runClear model args, Cmd.none ) + + Cookies -> + runCookies model args + + FontCommand -> + runFont model args + + Hello -> + runHello model args + + PromptCommand -> + runPrompt model args + + Theme -> + runTheme model args + + Err "" -> + ( model, Cmd.none ) + + Err string -> + ( { model + | content = model.content ++ [ text <| "\ncommand " ++ string ++ " not recognised. Run `help` to find a valid command" ] + } + , Cmd.none + ) + + + +-- COMMANDS + + +runHelp : Model -> List String -> Model +runHelp model args = + { model + | content = + model.content + ++ (if List.length args < 2 then + case List.head args of + Nothing -> + [ text <| + "\n+--------------------------------------------------+" + ++ "\n|help prints this message |" + ++ "\n|help prints more information about |" + ++ "\n+--------------------------------------------------+" + ++ "\nclear clears the screen" + ++ "\ncookies [UNSTABLE] manages cookies" + ++ "\nhello prints hello world message" + ++ "\nfont manages font" + ++ "\nprompt [UNFINISHED] manages prompt" + ++ "\ntheme manages theme" + ] + + Just "help" -> + [ text <| + "\nhelp lists available commands with a short summary" + ++ "\nhelp prints more information about " + ] + + Just "clear" -> + [ text <| "\nclear clears the screen" + ] + + Just "cookies" -> + [ text <| + "\ncookies prints info about the current cookie settings" + ++ "\ncookies set [true|false] sets whether to store a certain cookie" + ++ "\noptions for are:" + ++ "\n keepFont - whether to store fontSize. Default fontSize is 20" + ++ "\n keepPrompt - whether to store prompt. Default prompt is >" + ++ "\n keepTheme - whether to store theme. Default theme is pit" + ] + + Just "hello" -> + [ text <| "\nhello prints `Hello World!`" + ] + + Just "font" -> + [ text <| + "\nfont size prints info about the current font size" + ++ "\nfont size changes fontSize to if is >0" + ++ "\nfont reset changes fontSize to the default of 20px" + ] + + Just "prompt" -> + [ text <| + "\nprompt prints info about the current prompt" + ++ "\nprompt set sets prompt text to " + ++ "\n is specified in quotes" + ++ "\nprompt color sets prompt color to " + ++ "\n run `colors` to list available colors" + ] + + Just "theme" -> + [ text <| + "\ntheme sets the current theme according to " + ++ "\nOptions for are:" + ++ "\n sun - a theme blinding like the sun" + ++ "\n sky - a toned-down light theme" + ++ "\n dim - a deep and colorful dark theme" + ++ "\n pit - nearly black like the bottom of a pit" + ] + + Just string -> + wrongArgs Help 1 args + + else + wrongArgs Help 1 args + ) + } + + +runClear : Model -> List String -> Model +runClear model args = + case List.head args of + Nothing -> + { model | content = [] } + + Just string -> + { model | content = model.content ++ wrongArgs Clear 0 args } + + +runCookies : Model -> List String -> ( Model, Cmd Msg ) +runCookies model args = + case List.head args of + Nothing -> + let + newModel = + { model | content = model.content ++ [ text <| "\n" ++ cookiesKeptToString model.cookiesKept ] } + in + ( newModel + , Cmd.batch [ setStorage <| encodeModel newModel ] + ) + + Just "set" -> + let + cookiesKept = + model.cookiesKept + + second = + case List.tail args of + Just tail -> + Maybe.withDefault "" (List.head tail) + + Nothing -> + "" + + third = + case List.tail args of + Just tail -> + case List.tail tail of + Just tail2 -> + Maybe.withDefault "" (List.head tail2) + + Nothing -> + "" + + Nothing -> + "" + in + if third == "" then + ( { model | content = model.content ++ wrongArgs Cookies 3 args }, Cmd.none ) + + else + case second of + "" -> + ( { model | content = model.content ++ wrongArgs Cookies 2 args }, Cmd.none ) + + "keepFont" -> + case third of + "true" -> + saveModel { model | cookiesKept = { cookiesKept | keepFont = True } } + + "false" -> + saveModel { model | cookiesKept = { cookiesKept | keepFont = False } } + + _ -> + ( { model | content = model.content ++ wrongArgs Cookies 3 args }, Cmd.none ) + + "keepTheme" -> + case third of + "true" -> + saveModel { model | cookiesKept = { cookiesKept | keepTheme = True } } + + "false" -> + saveModel { model | cookiesKept = { cookiesKept | keepTheme = False } } + + _ -> + ( { model | content = model.content ++ wrongArgs Cookies 3 args }, Cmd.none ) + + "keepPrompt" -> + case third of + "true" -> + saveModel { model | cookiesKept = { cookiesKept | keepPrompt = True } } + + "false" -> + saveModel { model | cookiesKept = { cookiesKept | keepPrompt = False } } + + _ -> + ( { model | content = model.content ++ wrongArgs Cookies 3 args }, Cmd.none ) + + _ -> + ( { model | content = model.content ++ wrongArgs Cookies 2 args }, Cmd.none ) + + Just string -> + ( { model | content = model.content ++ wrongArgs Cookies 1 args }, Cmd.none ) + + +runHello : Model -> List String -> ( Model, Cmd Msg ) +runHello model args = + case List.head args of + Nothing -> + ( { model | content = model.content ++ [ text "\nHello World!" ] }, Cmd.none ) + + _ -> + ( { model | content = model.content ++ wrongArgs Hello 0 args }, Cmd.none ) + + +runFont : Model -> List String -> ( Model, Cmd Msg ) +runFont model args = + case List.head args of + Nothing -> + ( { model | content = model.content ++ wrongArgs FontCommand 1 args }, Cmd.none ) + + Just "size" -> + let + string = + case List.tail args of + Just tail -> + Maybe.withDefault "" (List.head tail) + + Nothing -> + "" + + fl = + String.toFloat string + in + case fl of + Just float -> + if float > 0 then + let + newModel = + { model + | content = + model.content + ++ [ text <| + "\nfontSize successfully set to " + ++ string + ++ "px" + ] + , font = { fontSize = float } + } + in + saveModel newModel + + else + ( { model + | content = + model.content + ++ [ text "\nPlease enter a valid fontSize, a Float greater than 0" ] + } + , Cmd.none + ) + + Nothing -> + case string of + "" -> + ( { model | content = model.content ++ [ text <| "\nfontSize is " ++ String.fromFloat model.font.fontSize ++ "px" ] } + , Cmd.none + ) + + "reset" -> + let + newModel = + { model + | content = + model.content + ++ [ text "\nfontSize reset to 20px" ] + , font = { fontSize = 20 } + } + in + saveModel newModel + + _ -> + ( { model + | content = + model.content + ++ [ text <| + "\nfontSize " + ++ string + ++ " not recognised; font size expected" + ] + } + , Cmd.none + ) + + Just "reset" -> + let + newModel = + { model + | content = model.content ++ [ text "\nfontSize reset to 20px" ] + , font = { fontSize = 20 } + } + in + ( newModel + , Cmd.batch + [ setStorage <| encodeModel newModel + ] + ) + + Just string -> + ( { model | content = model.content ++ wrongArgs FontCommand 1 args }, Cmd.none ) + + +runPrompt : Model -> List String -> ( Model, Cmd Msg ) +runPrompt model args = + case List.head args of + Nothing -> + ( { model | content = model.content ++ [ text <| "\ncurrent prompt is " ++ model.prompt.prompt ] }, Cmd.none ) + + Just string -> + let + oldPrompt = + model.prompt + in + saveModel { model | prompt = { oldPrompt | prompt = string } } + + +runReset : Model -> List String -> ( Model, Cmd Msg ) +runReset model args = + case List.head args of + Nothing -> + ( model, Cmd.none ) + + Just _ -> + ( model, Cmd.none ) + + +runTheme : Model -> List String -> ( Model, Cmd Msg ) +runTheme model args = + case List.head args of + Nothing -> + ( { model + | content = + model.content + ++ [ text <| + "\nThe current theme is " + ++ (case model.theme of + Sun -> + "sun" + + Sky -> + "sky" + + Dim -> + "dim" + + Pit -> + "pit" + ) + ] + } + , Cmd.none + ) + + Just "sun" -> + setTheme model Sun + + Just "sky" -> + setTheme model Sky + + Just "dim" -> + setTheme model Dim + + Just "pit" -> + setTheme model Pit + + Just string -> + ( { model | content = model.content ++ wrongArgs Theme 1 args }, Cmd.none ) + + + +-- COMMAND ABSTRACTIONS + + +setTheme : Model -> Theme -> ( Model, Cmd Msg ) +setTheme model theme = + let + newModel = + { model | theme = theme } + in + saveModel newModel + + +wrongArgs : Command -> Int -> List String -> List (Html Msg) +wrongArgs command expected args = + let + comstr = + case command of + Help -> + "help" + + Clear -> + "clear" + + Cookies -> + "cookies" + + FontCommand -> + "font" + + Hello -> + "hello" + + PromptCommand -> + "prompt" + + Theme -> + "theme" + in + [ text + ((if expected > List.length args then + "\nToo few arguments for " ++ comstr + + else if expected < List.length args then + "\nToo many arguments for " ++ comstr + + else + "\nUnexpected arguments " ++ listToString args + ) + ++ ". Run `help " + ++ comstr + ++ "` for usage" + ) + ] + + +listToString : List String -> String +listToString list = + "[" ++ String.join "," list ++ "]" + + +boolToString : Bool -> String +boolToString bool = + case bool of + True -> + "True" + + False -> + "False" + + +cookiesKeptToString : CookiesKept -> String +cookiesKeptToString cookiesKept = + "{ keepFont = " + ++ boolToString cookiesKept.keepFont + ++ "\n, keepTheme = " + ++ boolToString cookiesKept.keepTheme + ++ "\n}" + + +saveModel : Model -> ( Model, Cmd Msg ) +saveModel model = + ( model, Cmd.batch [ setStorage <| encodeModel model ] ) + + + +-- PORTS +-- sets localStorage 'cookies' to E.Value + + +port setStorage : E.Value -> Cmd a + + + +-- gets from server and everything + + +port refresh : () -> Cmd a + + + +-- for testing purposes: test.json on server + + +port receiveTestFromServer : (E.Value -> msg) -> Sub msg + + + +-- JSON + + +encodeModel : Model -> E.Value +encodeModel model = + E.object + [ ( "theme" + , E.string <| + case model.theme of + Pit -> + "Pit" + + Dim -> + "Dim" + + Sky -> + "Sky" + + Sun -> + "Sun" + ) + , ( "font" + , E.object + [ ( "fontSize" + , E.float model.font.fontSize + ) + ] + ) + , ( "cookiesKept" + , E.object + [ ( "keepTheme", E.bool model.cookiesKept.keepTheme ) + , ( "keepFont", E.bool model.cookiesKept.keepFont ) + , ( "keepPrompt", E.bool model.cookiesKept.keepPrompt ) + ] + ) + , ( "prompt" + , E.object + [ ( "prompt" + , E.string model.prompt.prompt + ) + ] + ) + ] + + +themeDecoder : E.Value -> D.Decoder Theme +themeDecoder flags = + case D.decodeValue (D.field "theme" D.string) flags of + Ok "Pit" -> + D.succeed Pit + + Ok "Dim" -> + D.succeed Dim + + Ok "Sky" -> + D.succeed Sky + + Ok "Sun" -> + D.succeed Sun + + Ok _ -> + D.fail "Unknown value found in theme field of json" + + Err _ -> + D.fail "Error decoding theme field of json" + + +fontDecoder : D.Decoder Font +fontDecoder = + D.map Font + (D.at [ "font", "fontSize" ] D.float) + + +cookiesKeptDecoder : D.Decoder CookiesKept +cookiesKeptDecoder = + D.map3 CookiesKept + (D.at [ "cookiesKept", "keepTheme" ] D.bool) + (D.at [ "cookiesKept", "keepFont" ] D.bool) + (D.at [ "cookiesKept", "keepPrompt" ] D.bool) + + +promptDecoder : D.Decoder Prompt +promptDecoder = + D.map Prompt + (D.at [ "prompt", "prompt" ] D.string) + + +type alias Test = + { message0 : String + , message1 : String + } + + +testDecoder : D.Decoder Test +testDecoder = + D.map2 Test + (D.field "message0" D.string) + (D.field "message1" D.string) + + + +-- SUBSCRIPTIONS + + +subscriptions : Model -> Sub Msg +subscriptions model = + receiveTestFromServer (D.decodeValue testDecoder >> ReceivedTest) + + + +-- VIEW + + +view : Model -> Browser.Document Msg +view model = + Browser.Document "andrew.r3tic.net" + [ toUnstyled <| viewBody model ] + + +viewBody : Model -> Html Msg +viewBody model = + styledBody model + [] + [ styledContent model [] model.content + , styledCL + model + [] + [ styledPrompt model [] [ coloredText (coreColor BrightMagenta) model.prompt.prompt ] + , styledCLI model [ onInput TakeInput, value model.cliContent, id "init-focus" ] [] + ] + ] + + + +-- STYLES + + +type Theme + = Pit + | Dim + | Sky + | Sun + + +type CoreColor + = Red + | Green + | Yellow + | Blue + | Magenta + | Cyan + | BrightRed + | BrightGreen + | BrightYellow + | BrightBlue + | BrightMagenta + | BrightCyan + + +type ThemeColor + = Background + | Foreground + | Cursor + | Black + | White + | BrightBlack + | BrightWhite + + + +-- Colors from Root Loops +-- flavor: intense +-- fruit: raspberry +-- milk: each option +-- sugar: 6 +-- colors: 9 +-- sogginess: 7 + + +coreColor : CoreColor -> Color +coreColor color = + case color of + Red -> + hex "e14433" + + Green -> + hex "#359b54" + + Yellow -> + hex "#a08016" + + Blue -> + hex "#5a77f2" + + Magenta -> + hex "#cf2ec8" + + Cyan -> + hex "1894a5" + + BrightRed -> + hex "#f36552" + + BrightGreen -> + hex "#3db361" + + BrightYellow -> + hex "#b9941a" + + BrightBlue -> + hex "#7491f8" + + BrightMagenta -> + hex "#e54ede" + + BrightCyan -> + hex "#1eabbf" + + +themeColor : Model -> ThemeColor -> Color +themeColor model color = + case model.theme of + Pit -> + case color of + Background -> + hex "#120211" + + Foreground -> + hex "#f3d9f0" + + Cursor -> + themeColor model White + + Black -> + hex "#380e36" + + White -> + hex "#e29edc" + + BrightBlack -> + hex "#7c2b77" + + BrightWhite -> + hex "#f9ecf7" + + Dim -> + case color of + Background -> + hex "#380e36" + + Foreground -> + hex "#f7e5f4" + + Cursor -> + themeColor model White + + Black -> + hex "#5e1c56" + + White -> + hex "#e8b2e2" + + BrightBlack -> + hex "#9d3c98" + + BrightWhite -> + hex "#fbf4fa" + + Sky -> + case color of + Background -> + hex "#f3d9f0" + + Foreground -> + hex "#380e36" + + Cursor -> + themeColor model White + + Black -> + hex "#eec6e9" + + White -> + hex "#7c2b77" + + BrightBlack -> + hex "#d575cd" + + BrightWhite -> + hex "#120211" + + Sun -> + case color of + Background -> + hex "#f9ecf7" + + Foreground -> + hex "#5a1c56" + + Cursor -> + themeColor model White + + Black -> + hex "#f3d9f0" + + White -> + hex "#9d3c98" + + BrightBlack -> + hex "#dc8ed5" + + BrightWhite -> + hex "#380e36" + + +styledBody : Model -> List (Attribute Msg) -> List (Html Msg) -> Html Msg +styledBody model = + styled Html.Styled.main_ + [ backgroundColor <| themeColor model Background + , color <| themeColor model Foreground + , minHeight (vh 100) + , width (vw 100) + , margin (px 0) + , padding (px 0) + ] + + +styledContent : Model -> List (Attribute Msg) -> List (Html Msg) -> Html Msg +styledContent model = + styled Html.Styled.span + [ color <| themeColor model Foreground + , fontSize (px model.font.fontSize) + , padding (px 0) + , margin (px 0) + , backgroundColor <| themeColor model Background + , borderWidth (px 0) + , width (vw 100) + , whiteSpace preWrap + , fontFamily monospace + ] + + +styledCL : Model -> List (Attribute Msg) -> List (Html Msg) -> Html Msg +styledCL model = + styled Html.Styled.span + [ backgroundColor <| themeColor model Background + , padding (px 0) + , margin (px 0) + , displayFlex + , flexDirection row + , flexWrap noWrap + , justifyContent flexStart + ] + + +styledCLI : Model -> List (Attribute Msg) -> List (Html Msg) -> Html Msg +styledCLI model = + styled Html.Styled.textarea + [ color <| themeColor model Foreground + , fontSize (px model.font.fontSize) + , padding (px 0) + , margin (px 0) + , backgroundColor <| themeColor model Background + , borderWidth (px 0) + , outlineWidth (px 0) + , height (px model.font.fontSize) + , resize none + , overflow hidden + , flexGrow (Css.int 100) + ] + + +styledPrompt : Model -> List (Attribute Msg) -> List (Html Msg) -> Html Msg +styledPrompt model = + styled Html.Styled.span + [ color <| themeColor model Foreground + , fontSize (px model.font.fontSize) + , padding (px 0) + , margin (px 0) + , backgroundColor <| themeColor model Background + , borderWidth (px 0) + , height (px model.font.fontSize) + , fontFamily monospace + ] + + +coloredText : Color -> String -> Html Msg +coloredText fgColor string = + coloredTextWBackground fgColor (rgba 0 0 0 0) string + + +coloredTextWBackground : Color -> Color -> String -> Html Msg +coloredTextWBackground fgColor bgColor string = + styled Html.Styled.span + [ color fgColor + , backgroundColor bgColor + , padding (px 0) + , margin (px 0) + , borderWidth (px 0) + ] + [] + [ text string ] diff --git a/shell.nix b/shell.nix new file mode 100644 index 0000000..9fad334 --- /dev/null +++ b/shell.nix @@ -0,0 +1,21 @@ +{pkgs ? import {}}: let + elmInputs = [ + pkgs.elmPackages.elm + pkgs.elmPackages.elm-format + pkgs.uglify-js + ]; + haskellInputs = [ + pkgs.stack + ]; + cliTools = [ + pkgs.httpie + pkgs.ungoogled-chromium + ]; +in + pkgs.mkShell { + nativeBuildInputs = [ + elmInputs + haskellInputs + cliTools + ]; + } diff --git a/src/Main.elm b/src/Main.elm new file mode 120000 index 0000000..0e01ba0 --- /dev/null +++ b/src/Main.elm @@ -0,0 +1 @@ +../frontend/src/Main.elm \ No newline at end of file diff --git a/src/Main.hs b/src/Main.hs new file mode 120000 index 0000000..d97d299 --- /dev/null +++ b/src/Main.hs @@ -0,0 +1 @@ +../backend/app/Main.hs \ No newline at end of file