From cf3c84526055fe416697a086be241dcb0ed76b6c Mon Sep 17 00:00:00 2001 From: Jean-Christophe Jameux Date: Sat, 16 Oct 2021 19:15:54 +0200 Subject: [PATCH] On avance --- elm-stuff/0.19.1/ParserMaths.elmi | Bin 1746 -> 1852 bytes elm-stuff/0.19.1/ParserMaths.elmo | Bin 12657 -> 14102 bytes elm-stuff/0.19.1/QCM.elmo | Bin 72120 -> 72020 bytes elm-stuff/0.19.1/d.dat | Bin 1630 -> 1873 bytes elm.js | 5233 ++++++++++++++++++++ elm.min.js | 1 + index.html | 5699 +++++++++++++++------- qcm.js | 7360 +++++++++++++++++++++++++++++ qcm.min.js | 1 + qcmUgly.js | 1 + src/ParserMaths.elm | 31 + src/QCM.elm | 9 +- 12 files changed, 16546 insertions(+), 1789 deletions(-) create mode 100644 elm.js create mode 100644 elm.min.js create mode 100644 qcm.js create mode 100644 qcm.min.js create mode 100644 qcmUgly.js diff --git a/elm-stuff/0.19.1/ParserMaths.elmi b/elm-stuff/0.19.1/ParserMaths.elmi index acd12a337b29cacf7f4eab071264ed364c9af2ae..af18370f5a3911a86d0873011b05580537ac899a 100644 GIT binary patch delta 70 zcmcb_yN7SX874-~&1ac9nPgc4@^dN~Aby}Sc`bvQt8H}`X+fZEfk!^%sua(x!?0PO1DfU#GV{{&1UqbK8@ZASt+=$Y_QOTy>GPMGM>;AQ6xbikd6-A0I` zPEC<#i8WU@%vlc!&0w$+)7-)CB?L(|10Uk!?0Bjx4qrNpP*=}+v3PHIFd9v0m+;~h zi&R(<$e(9(xX@_thPOQ_u+)JO*~XXWuvx}FHOUN-!)C?*4_)L92iKsHio?-P6`pFD zY_l=N#&w2PaN*u1%L>j@yM4W7Xl%hpS zMx}yHR!GRN_o_Uv6GJamx7ErChG}B5!|#Eco-c$#GQl+LJg!7(FVz}fwg~1dNS}}7eV{z+=iuAoZWD;_x@N=k9bVCjj}Bi^{S2kHw=0|(!gbZ3au4-=v`Rq z_WNRS_%mbqv?5zzYV*!HfWp{C$r-;gXZkwAm0@l)SDCC~!sx$*S&YJ&NDm(^X% z#iLAy@ADcgkMzUy4jF!o4rM#Ul40t^zXOOXTUCG9o~$5W$n~~%791O9u#cA3P89~H Yf))C-O}+UiOl>}Ft&pK`AT;0o5A;wd`v3p{ delta 406 zcmYk0F-QV&7{&eHo!;ry3FaM#o_cAWSx}UE1wl?lLx?pxBm@aUT@le*ZcPzAXe*mq z!~R3m8iWlEwG>5DIP2{}nOOM^AK!cYKHfXF>=n18Gddm zv&R%Vm0UE_8*`F0Y*oXq?}bY-8=F`gOVh)?0wGM>e;9S6ENOH}-Xo~#AvBZ)ng|FC zo|F*HYS)Bg3pBe&ML>R_jt1j`Ed+5Qi8veF!g)$U&MRQX7{P_^#J+KgoWx^3 do@{X%y^PBeL^DZvWXvFnW`JW$);21p@eKhndpZCB diff --git a/elm-stuff/0.19.1/QCM.elmo b/elm-stuff/0.19.1/QCM.elmo index edd1e4eace0a6f12e2412345ad327a44667e1161..3143c2437ea393764e69662b05cc748e1dfaa031 100644 GIT binary patch delta 71 zcmdn7ndQnRmJJ%Blbaq2O@G40D9Wfa*QZWZ6&D$Z!k1OSNf7We=F delta 145 zcmcbziDk!TmJJ%Blleu2SY0yHGfO51h+0gJ6XBd(a7mOYzi4vf4G~f2jKm`L%wn)S z0|YR#0u?B7S1`i(x|27ERxk=q{+KQ{*>!s%8GBQF%ITvJ{+u7tDS~Ynl zW2_dtQ&E0-acU8ZM@eoDH;B-4ElbTSDTXPBnO-_snK4hWq5G}3(PO- delta 102 zcmcb}caLX+K4&Te1Tasucs*H&DUag;@9W1U$4~W6?q-ag{FF&Rf-NAis5rF 100) + { + stack.push(_Utils_Tuple2(x,y)); + return true; + } + + /**_UNUSED/ + 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); + } + //*/ + + /**/ + 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; + } + + /**_UNUSED/ + if (x instanceof String) + { + var a = x.valueOf(); + var b = y.valueOf(); + return a === b ? 0 : a < b ? -1 : 1; + } + //*/ + + /**/ + if (typeof x.$ === 'undefined') + //*/ + /**_UNUSED/ + 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 = 0; +var _Utils_Tuple0_UNUSED = { $: '#0' }; + +function _Utils_Tuple2(a, b) { return { a: a, b: b }; } +function _Utils_Tuple2_UNUSED(a, b) { return { $: '#2', a: a, b: b }; } + +function _Utils_Tuple3(a, b, c) { return { a: a, b: b, c: c }; } +function _Utils_Tuple3_UNUSED(a, b, c) { return { $: '#3', a: a, b: b, c: c }; } + +function _Utils_chr(c) { return c; } +function _Utils_chr_UNUSED(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 = { $: 0 }; +var _List_Nil_UNUSED = { $: '[]' }; + +function _List_Cons(hd, tl) { return { $: 1, a: hd, b: tl }; } +function _List_Cons_UNUSED(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 = F2(function(tag, value) +{ + return value; +}); + +var _Debug_log_UNUSED = 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(value) +{ + return ''; +} + +function _Debug_toString_UNUSED(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(identifier) +{ + throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md'); +} + + +function _Debug_crash_UNUSED(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.M.D === region.T.D) + { + return 'on line ' + region.M.D; + } + return 'on lines ' + region.M.D + ' through ' + region.T.D; +} + + + +// 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()); +} + + + +/**_UNUSED/ +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_UNUSED(value) { return { $: 0, a: value }; } +function _Json_unwrap_UNUSED(value) { return value.a; } + +function _Json_wrap(value) { return value; } +function _Json_unwrap(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.aM, + impl.aV, + impl.aT, + 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 /**_UNUSED/, _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(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_UNUSED(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 + + /**/ + var node = args['node']; + //*/ + /**_UNUSED/ + 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 + + +function _VirtualDom_noScript(tag) +{ + return tag == 'script' ? 'p' : tag; +} + +function _VirtualDom_noOnOrFormAction(key) +{ + return /^(on|formAction$)/i.test(key) ? 'data-' + key : key; +} + +function _VirtualDom_noInnerHtmlOrFormAction(key) +{ + return key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key; +} + +function _VirtualDom_noJavaScriptUri(value) +{ + return /^javascript:/i.test(value.replace(/\s/g,'')) ? '' : value; +} + +function _VirtualDom_noJavaScriptUri_UNUSED(value) +{ + return /^javascript:/i.test(value.replace(/\s/g,'')) + ? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")' + : value; +} + +function _VirtualDom_noJavaScriptOrHtmlUri(value) +{ + return /^\s*(javascript:|data:text\/html)/i.test(value) ? '' : value; +} + +function _VirtualDom_noJavaScriptOrHtmlUri_UNUSED(value) +{ + return /^\s*(javascript:|data:text\/html)/i.test(value) + ? '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 { + s: func(record.s), + N: record.N, + K: record.K + } +}); + + + +// 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.s; + var stopPropagation = tag == 1 ? value.b : tag == 3 && value.N; + var currentEventNode = ( + stopPropagation && event.stopPropagation(), + (tag == 2 ? value.b : tag == 3 && value.K) && 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.aM, + impl.aV, + impl.aT, + function(sendToApp, initialModel) { + var view = impl.aW; + /**/ + var domNode = args['node']; + //*/ + /**_UNUSED/ + 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.aM, + impl.aV, + impl.aT, + function(sendToApp, initialModel) { + var divertHrefToApp = impl.L && impl.L(sendToApp) + var view = impl.aW; + 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.aE); + var patches = _VirtualDom_diff(currNode, nextNode); + bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp); + currNode = nextNode; + _VirtualDom_divertHrefToApp = 0; + (title !== doc.aU) && (_VirtualDom_doc.title = title = doc.aU); + }); + } + ); +}); + + + +// 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.aP; + var onUrlRequest = impl.aQ; + var key = function() { key.a(onUrlChange(_Browser_getUrl())); }; + + return _Browser_document({ + L: 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.am === next.am + && curr._ === next._ + && curr.ai.a === next.ai.a + ) + ? $elm$browser$Browser$Internal(next) + : $elm$browser$Browser$External(href) + )); + } + }); + }, + aM: function(flags) + { + return A3(impl.aM, flags, _Browser_getUrl(), key); + }, + aW: impl.aW, + aV: impl.aV, + aT: impl.aT + }); +} + +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') + ? { aK: 'hidden', aF: 'visibilitychange' } + : + (typeof _VirtualDom_doc.mozHidden !== 'undefined') + ? { aK: 'mozHidden', aF: 'mozvisibilitychange' } + : + (typeof _VirtualDom_doc.msHidden !== 'undefined') + ? { aK: 'msHidden', aF: 'msvisibilitychange' } + : + (typeof _VirtualDom_doc.webkitHidden !== 'undefined') + ? { aK: 'webkitHidden', aF: 'webkitvisibilitychange' } + : { aK: 'hidden', aF: '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 { + as: _Browser_getScene(), + ay: { + aA: _Browser_window.pageXOffset, + aB: _Browser_window.pageYOffset, + az: _Browser_doc.documentElement.clientWidth, + Y: _Browser_doc.documentElement.clientHeight + } + }; +} + +function _Browser_getScene() +{ + var body = _Browser_doc.body; + var elem = _Browser_doc.documentElement; + return { + az: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth), + Y: 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 { + as: { + az: node.scrollWidth, + Y: node.scrollHeight + }, + ay: { + aA: node.scrollLeft, + aB: node.scrollTop, + az: node.clientWidth, + Y: 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 { + as: _Browser_getScene(), + ay: { + aA: x, + aB: y, + az: _Browser_doc.documentElement.clientWidth, + Y: _Browser_doc.documentElement.clientHeight + }, + aI: { + aA: x + rect.left, + aB: y + rect.top, + az: rect.width, + Y: 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 $author$project$Main$init = 0; +var $elm$core$Basics$EQ = 1; +var $elm$core$Basics$GT = 2; +var $elm$core$Basics$LT = 0; +var $elm$core$List$cons = _List_cons; +var $elm$core$Dict$foldr = F3( + function (func, acc, t) { + foldr: + while (true) { + if (t.$ === -2) { + 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; + 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.$) { + 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 {$: 1, a: a}; +}; +var $elm$json$Json$Decode$Failure = F2( + function (a, b) { + return {$: 3, a: a, b: b}; + }); +var $elm$json$Json$Decode$Field = F2( + function (a, b) { + return {$: 0, a: a, b: b}; + }); +var $elm$json$Json$Decode$Index = F2( + function (a, b) { + return {$: 1, a: a, b: b}; + }); +var $elm$core$Result$Ok = function (a) { + return {$: 0, a: a}; +}; +var $elm$json$Json$Decode$OneOf = function (a) { + return {$: 2, a: a}; +}; +var $elm$core$Basics$False = 1; +var $elm$core$Basics$add = _Basics_add; +var $elm$core$Maybe$Just = function (a) { + return {$: 0, a: a}; +}; +var $elm$core$Maybe$Nothing = {$: 1}; +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 0: + var f = error.a; + var err = error.b; + var isSimple = function () { + var _v1 = $elm$core$String$uncons(f); + if (_v1.$ === 1) { + 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 1: + 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 2: + 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 {$: 0, 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 {$: 1, 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 {$: 0, 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.e) { + return A4( + $elm$core$Array$Array_elm_builtin, + $elm$core$Elm$JsArray$length(builder.g), + $elm$core$Array$shiftStep, + $elm$core$Elm$JsArray$empty, + builder.g); + } else { + var treeLen = builder.e * $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.h) : builder.h; + var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.e); + return A4( + $elm$core$Array$Array_elm_builtin, + $elm$core$Elm$JsArray$length(builder.g) + treeLen, + A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep), + tree, + builder.g); + } + }); +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, + {h: nodeList, e: (len / $elm$core$Array$branchFactor) | 0, g: 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 = 0; +var $elm$core$Result$isOk = function (result) { + if (!result.$) { + 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 0: + return 0; + case 1: + return 1; + case 2: + return 2; + default: + return 3; + } +}; +var $elm$browser$Browser$External = function (a) { + return {$: 1, a: a}; +}; +var $elm$browser$Browser$Internal = function (a) { + return {$: 0, a: a}; +}; +var $elm$core$Basics$identity = function (x) { + return x; +}; +var $elm$browser$Browser$Dom$NotFound = $elm$core$Basics$identity; +var $elm$url$Url$Http = 0; +var $elm$url$Url$Https = 1; +var $elm$url$Url$Url = F6( + function (protocol, host, port_, path, query, fragment) { + return {X: fragment, _: host, ag: path, ai: port_, am: protocol, an: 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.$ === 1) { + 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, + 0, + A2($elm$core$String$dropLeft, 7, str)) : (A2($elm$core$String$startsWith, 'https://', str) ? A2( + $elm$url$Url$chompAfterProtocol, + 1, + A2($elm$core$String$dropLeft, 8, str)) : $elm$core$Maybe$Nothing); +}; +var $elm$core$Basics$never = function (_v0) { + never: + while (true) { + var nvr = _v0; + var $temp$_v0 = nvr; + _v0 = $temp$_v0; + continue never; + } +}; +var $elm$core$Task$Perform = $elm$core$Basics$identity; +var $elm$core$Task$succeed = _Scheduler_succeed; +var $elm$core$Task$init = $elm$core$Task$succeed(0); +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; + 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 0; + }, + $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(0); + }); +var $elm$core$Task$cmdMap = F2( + function (tagger, _v0) { + var task = _v0; + return 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( + A2($elm$core$Task$map, toMessage, task)); + }); +var $elm$core$Platform$Cmd$batch = _Platform_batch; +var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil); +var $elm$core$Platform$Sub$batch = _Platform_batch; +var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil); +var $elm$browser$Browser$sandbox = function (impl) { + return _Browser_element( + { + aM: function (_v0) { + return _Utils_Tuple2(impl.aM, $elm$core$Platform$Cmd$none); + }, + aT: function (_v1) { + return $elm$core$Platform$Sub$none; + }, + aV: F2( + function (msg, model) { + return _Utils_Tuple2( + A2(impl.aV, msg, model), + $elm$core$Platform$Cmd$none); + }), + aW: impl.aW + }); +}; +var $author$project$Main$update = F2( + function (msg, model) { + if (!msg) { + return model + 1; + } else { + return model - 1; + } + }); +var $author$project$Main$Decrement = 1; +var $author$project$Main$Increment = 0; +var $elm$html$Html$button = _VirtualDom_node('button'); +var $elm$html$Html$div = _VirtualDom_node('div'); +var $elm$virtual_dom$VirtualDom$Normal = function (a) { + return {$: 0, a: a}; +}; +var $elm$virtual_dom$VirtualDom$on = _VirtualDom_on; +var $elm$html$Html$Events$on = F2( + function (event, decoder) { + return A2( + $elm$virtual_dom$VirtualDom$on, + event, + $elm$virtual_dom$VirtualDom$Normal(decoder)); + }); +var $elm$html$Html$Events$onClick = function (msg) { + return A2( + $elm$html$Html$Events$on, + 'click', + $elm$json$Json$Decode$succeed(msg)); +}; +var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text; +var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text; +var $author$project$Main$view = function (model) { + return A2( + $elm$html$Html$div, + _List_Nil, + _List_fromArray( + [ + A2( + $elm$html$Html$button, + _List_fromArray( + [ + $elm$html$Html$Events$onClick(1) + ]), + _List_fromArray( + [ + $elm$html$Html$text('-') + ])), + A2( + $elm$html$Html$div, + _List_Nil, + _List_fromArray( + [ + $elm$html$Html$text( + $elm$core$String$fromInt(model)) + ])), + A2( + $elm$html$Html$button, + _List_fromArray( + [ + $elm$html$Html$Events$onClick(0) + ]), + _List_fromArray( + [ + $elm$html$Html$text('+') + ])) + ])); +}; +var $author$project$Main$main = $elm$browser$Browser$sandbox( + {aM: $author$project$Main$init, aV: $author$project$Main$update, aW: $author$project$Main$view}); +_Platform_export({'Main':{'init':$author$project$Main$main( + $elm$json$Json$Decode$succeed(0))(0)}});}(this)); \ No newline at end of file diff --git a/elm.min.js b/elm.min.js new file mode 100644 index 0000000..2a916dd --- /dev/null +++ b/elm.min.js @@ -0,0 +1 @@ +!function(scope){"use strict";function F(arity,fun,wrapper){return wrapper.a=arity,wrapper.f=fun,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 A2(fun,a,b){return 2===fun.a?fun.f(a,b):fun(a)(b)}function A3(fun,a,b,c){return 3===fun.a?fun.f(a,b,c):fun(a)(b)(c)}function A4(fun,a,b,c,d){return 4===fun.a?fun.f(a,b,c,d):fun(a)(b)(c)(d)}function A5(fun,a,b,c,d,e){return 5===fun.a?fun.f(a,b,c,d,e):fun(a)(b)(c)(d)(e)}function _Utils_cmp(x,y,ord){if("object"!=typeof x)return x===y?0:xhigh)return i}var tag=vNode.$;if(4===tag){for(var subNode=vNode.k;4===subNode.$;)subNode=subNode.k;return _VirtualDom_addDomNodesHelp(domNode,subNode,patches,i,low+1,high,domNode.elm_event_node_ref)}var vKids=vNode.e;var childNodes=domNode.childNodes;for(var j=0;jhigh))return i;low=nextLow}return i}(domNode,vNode,patches,0,0,vNode.b,eventNode)}function _VirtualDom_applyPatches(rootDomNode,oldVirtualNode,patches,eventNode){return 0===patches.length?rootDomNode:(_VirtualDom_addDomNodes(rootDomNode,oldVirtualNode,patches,eventNode),_VirtualDom_applyPatchesHelp(rootDomNode,patches))}function _VirtualDom_applyPatchesHelp(rootDomNode,patches){for(var i=0;i - Main + QCM @@ -94,429 +94,164 @@ function A9(fun, a, b, c, d, e, f, g, h, i) { -// EQUALITY +var _JsArray_empty = []; -function _Utils_eq(x, y) +function _JsArray_singleton(value) { - 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; + return [value]; } -function _Utils_eqHelp(x, y, depth, stack) +function _JsArray_length(array) { - if (x === y) - { - return true; - } + return array.length; +} - if (typeof x !== 'object' || x === null || y === null) - { - typeof x === 'function' && _Debug_crash(5); - return false; - } +var _JsArray_initialize = F3(function(size, offset, func) +{ + var result = new Array(size); - if (depth > 100) - { - stack.push(_Utils_Tuple2(x,y)); - return true; - } + for (var i = 0; i < size; i++) + { + result[i] = func(offset + i); + } - /**_UNUSED/ - 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); - } - //*/ + return result; +}); - /**/ - if (x.$ < 0) - { - x = $elm$core$Dict$toList(x); - y = $elm$core$Dict$toList(y); - } - //*/ +var _JsArray_initializeFromList = F2(function (max, ls) +{ + var result = new Array(max); - for (var key in x) - { - if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack)) - { - return false; - } - } - return true; -} + for (var i = 0; i < max && ls.b; i++) + { + result[i] = ls.a; + ls = ls.b; + } -var _Utils_equal = F2(_Utils_eq); -var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,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); -// COMPARISONS + for (var i = 0; i < length; i++) + { + result[i] = array[i]; + } -// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on -// the particular integer values assigned to LT, EQ, and GT. + result[index] = value; + return result; +}); -function _Utils_cmp(x, y, ord) +var _JsArray_push = F2(function(value, array) { - if (typeof x !== 'object') - { - return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1; - } + var length = array.length; + var result = new Array(length + 1); - /**_UNUSED/ - if (x instanceof String) - { - var a = x.valueOf(); - var b = y.valueOf(); - return a === b ? 0 : a < b ? -1 : 1; - } - //*/ + for (var i = 0; i < length; i++) + { + result[i] = array[i]; + } - /**/ - if (typeof x.$ === 'undefined') - //*/ - /**_UNUSED/ - 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); - } + result[length] = value; + return result; +}); - // 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 _JsArray_foldl = F3(function(func, acc, array) +{ + var length = array.length; -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; }); + for (var i = 0; i < length; i++) + { + acc = A2(func, array[i], acc); + } -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; + 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); + } -// COMMON VALUES + return acc; +}); -var _Utils_Tuple0 = 0; -var _Utils_Tuple0_UNUSED = { $: '#0' }; +var _JsArray_map = F2(function(func, array) +{ + var length = array.length; + var result = new Array(length); -function _Utils_Tuple2(a, b) { return { a: a, b: b }; } -function _Utils_Tuple2_UNUSED(a, b) { return { $: '#2', a: a, b: b }; } + for (var i = 0; i < length; i++) + { + result[i] = func(array[i]); + } -function _Utils_Tuple3(a, b, c) { return { a: a, b: b, c: c }; } -function _Utils_Tuple3_UNUSED(a, b, c) { return { $: '#3', a: a, b: b, c: c }; } + return result; +}); -function _Utils_chr(c) { return c; } -function _Utils_chr_UNUSED(c) { return new String(c); } +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]); + } -// RECORDS + return result; +}); -function _Utils_update(oldRecord, updatedFields) +var _JsArray_slice = F3(function(from, to, array) { - var newRecord = {}; + return array.slice(from, to); +}); - for (var key in oldRecord) - { - newRecord[key] = oldRecord[key]; - } +var _JsArray_appendN = F3(function(n, dest, source) +{ + var destLen = dest.length; + var itemsToCopy = n - destLen; - for (var key in updatedFields) - { - newRecord[key] = updatedFields[key]; - } + if (itemsToCopy > source.length) + { + itemsToCopy = source.length; + } - return newRecord; -} + var size = destLen + itemsToCopy; + var result = new Array(size); + for (var i = 0; i < destLen; i++) + { + result[i] = dest[i]; + } -// APPEND + for (var i = 0; i < itemsToCopy; i++) + { + result[i + destLen] = source[i]; + } -var _Utils_append = F2(_Utils_ap); + return result; +}); -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; -} +// LOG - -var _List_Nil = { $: 0 }; -var _List_Nil_UNUSED = { $: '[]' }; - -function _List_Cons(hd, tl) { return { $: 1, a: hd, b: tl }; } -function _List_Cons_UNUSED(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 = F2(function(tag, value) -{ - return value; -}); +var _Debug_log = F2(function(tag, value) +{ + return value; +}); var _Debug_log_UNUSED = F2(function(tag, value) { @@ -798,1621 +533,1886 @@ function _Debug_crash_UNUSED(identifier, fact1, fact2, fact3, fact4) function _Debug_regionToString(region) { - if (region.I.z === region.N.z) + if (region.am.F === region.aE.F) { - return 'on line ' + region.I.z; + return 'on line ' + region.am.F; } - return 'on lines ' + region.I.z + ' through ' + region.N.z; + return 'on lines ' + region.am.F + ' through ' + region.aE.F; } -// 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; }); +// EQUALITY -// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf -var _Basics_modBy = F2(function(modulus, x) +function _Utils_eq(x, y) { - 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)) + for ( + var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack); + isEqual && (pair = stack.pop()); + isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack) ) - : $elm$core$Maybe$Nothing; -} - -var _String_append = F2(function(a, b) -{ - return a + b; -}); + {} -function _String_length(str) -{ - return str.length; + return isEqual; } -var _String_map = F2(function(func, string) +function _Utils_eqHelp(x, y, depth, stack) { - var len = string.length; - var array = new Array(len); - var i = 0; - while (i < len) + if (x === y) { - 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 true; } - return array.join(''); -}); -var _String_filter = F2(function(isGood, str) -{ - var arr = []; - var len = str.length; - var i = 0; - while (i < len) + if (typeof x !== 'object' || x === null || y === null) { - var char = str[i]; - var word = str.charCodeAt(i); - i++; - if (0xD800 <= word && word <= 0xDBFF) - { - char += str[i]; - i++; - } + typeof x === 'function' && _Debug_crash(5); + return false; + } - if (isGood(_Utils_chr(char))) - { - arr.push(char); - } + if (depth > 100) + { + stack.push(_Utils_Tuple2(x,y)); + return true; } - return arr.join(''); -}); -function _String_reverse(str) -{ - var len = str.length; - var arr = new Array(len); - var i = 0; - while (i < len) + /**_UNUSED/ + if (x.$ === 'Set_elm_builtin') { - 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++; - } + x = $elm$core$Set$toList(x); + y = $elm$core$Set$toList(y); } - return arr.join(''); -} + if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin') + { + x = $elm$core$Dict$toList(x); + y = $elm$core$Dict$toList(y); + } + //*/ -var _String_foldl = F3(function(func, state, string) -{ - var len = string.length; - var i = 0; - while (i < len) + /**/ + if (x.$ < 0) { - 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); + x = $elm$core$Dict$toList(x); + y = $elm$core$Dict$toList(y); } - return state; -}); + //*/ -var _String_foldr = F3(function(func, state, string) -{ - var i = string.length; - while (i--) + for (var key in x) { - var char = string[i]; - var word = string.charCodeAt(i); - if (0xDC00 <= word && word <= 0xDFFF) + if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack)) { - i--; - char = string[i] + char; + return false; } - state = A2(func, _Utils_chr(char), state); } - return state; -}); + return true; +} -var _String_split = F2(function(sep, str) -{ - return str.split(sep); -}); +var _Utils_equal = F2(_Utils_eq); +var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); }); -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(); -} +// COMPARISONS -function _String_trimLeft(str) -{ - return str.replace(/^\s+/, ''); -} +// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on +// the particular integer values assigned to LT, EQ, and GT. -function _String_trimRight(str) +function _Utils_cmp(x, y, ord) { - return str.replace(/\s+$/, ''); -} + if (typeof x !== 'object') + { + return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1; + } -function _String_words(str) -{ - return _List_fromArray(str.trim().split(/\s+/g)); -} + /**_UNUSED/ + if (x instanceof String) + { + var a = x.valueOf(); + var b = y.valueOf(); + return a === b ? 0 : a < b ? -1 : 1; + } + //*/ -function _String_lines(str) -{ - return _List_fromArray(str.split(/\r\n|\r|\n/g)); -} + /**/ + if (typeof x.$ === 'undefined') + //*/ + /**_UNUSED/ + 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); + } -function _String_toUpper(str) -{ - return str.toUpperCase(); + // 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); } -function _String_toLower(str) -{ - return str.toLowerCase(); -} +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 _String_any = F2(function(isGood, string) +var _Utils_compare = F2(function(x, y) { - 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 n = _Utils_cmp(x, y); + return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ; }); -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; -}); +// COMMON VALUES -var _String_startsWith = F2(function(sub, str) -{ - return str.indexOf(sub) === 0; -}); +var _Utils_Tuple0 = 0; +var _Utils_Tuple0_UNUSED = { $: '#0' }; -var _String_endsWith = F2(function(sub, str) -{ - return str.length >= sub.length && - str.lastIndexOf(sub) === str.length - sub.length; -}); +function _Utils_Tuple2(a, b) { return { a: a, b: b }; } +function _Utils_Tuple2_UNUSED(a, b) { return { $: '#2', a: a, b: b }; } -var _String_indexes = F2(function(sub, str) +function _Utils_Tuple3(a, b, c) { return { a: a, b: b, c: c }; } +function _Utils_Tuple3_UNUSED(a, b, c) { return { $: '#3', a: a, b: b, c: c }; } + +function _Utils_chr(c) { return c; } +function _Utils_chr_UNUSED(c) { return new String(c); } + + +// RECORDS + +function _Utils_update(oldRecord, updatedFields) { - var subLen = sub.length; + var newRecord = {}; - if (subLen < 1) + for (var key in oldRecord) { - return _List_Nil; + newRecord[key] = oldRecord[key]; } - var i = 0; - var is = []; - - while ((i = str.indexOf(sub, i)) > -1) + for (var key in updatedFields) { - is.push(i); - i = i + subLen; + newRecord[key] = updatedFields[key]; } - return _List_fromArray(is); -}); - - -// TO STRING - -function _String_fromNumber(number) -{ - return number + ''; + return newRecord; } -// INT CONVERSIONS +// APPEND -function _String_toInt(str) -{ - var total = 0; - var code0 = str.charCodeAt(0); - var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0; +var _Utils_append = F2(_Utils_ap); - for (var i = start; i < str.length; ++i) +function _Utils_ap(xs, ys) +{ + // append Strings + if (typeof xs === 'string') { - var code = str.charCodeAt(i); - if (code < 0x30 || 0x39 < code) - { - return $elm$core$Maybe$Nothing; - } - total = 10 * total + code - 0x30; + return xs + ys; } - return i == start - ? $elm$core$Maybe$Nothing - : $elm$core$Maybe$Just(code0 == 0x2D ? -total : total); + // 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; } -// FLOAT CONVERSIONS -function _String_toFloat(s) +var _List_Nil = { $: 0 }; +var _List_Nil_UNUSED = { $: '[]' }; + +function _List_Cons(hd, tl) { return { $: 1, a: hd, b: tl }; } +function _List_Cons_UNUSED(hd, tl) { return { $: '::', a: hd, b: tl }; } + + +var _List_cons = F2(_List_Cons); + +function _List_fromArray(arr) { - // check if it is a hex, octal, or binary number - if (s.length === 0 || /[\sxbo]/.test(s)) + var out = _List_Nil; + for (var i = arr.length; i--; ) { - return $elm$core$Maybe$Nothing; + out = _List_Cons(arr[i], out); } - var n = +s; - // faster isNaN check - return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing; + return out; } -function _String_fromList(chars) +function _List_toArray(xs) { - return _List_toArray(chars).join(''); + for (var out = []; xs.b; xs = xs.b) // WHILE_CONS + { + out.push(xs.a); + } + return out; } - - - -function _Char_toCode(char) +var _List_map2 = F3(function(f, xs, ys) { - var code = char.charCodeAt(0); - if (0xD800 <= code && code <= 0xDBFF) + for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES { - return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000 + arr.push(A2(f, xs.a, ys.a)); } - return code; -} + return _List_fromArray(arr); +}); -function _Char_fromCode(code) +var _List_map3 = F4(function(f, xs, ys, zs) { - 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) - ) - ); -} + 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); +}); -function _Char_toUpper(char) +var _List_map4 = F5(function(f, ws, xs, ys, zs) { - return _Utils_chr(char.toUpperCase()); -} + 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); +}); -function _Char_toLower(char) +var _List_map5 = F6(function(f, vs, ws, xs, ys, zs) { - return _Utils_chr(char.toLowerCase()); -} + 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); +}); -function _Char_toLocaleUpper(char) +var _List_sortBy = F2(function(f, xs) { - return _Utils_chr(char.toLocaleUpperCase()); -} + return _List_fromArray(_List_toArray(xs).sort(function(a, b) { + return _Utils_cmp(f(a), f(b)); + })); +}); -function _Char_toLocaleLower(char) +var _List_sortWith = F2(function(f, xs) { - return _Utils_chr(char.toLocaleLowerCase()); -} + 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; + })); +}); -/**_UNUSED/ -function _Json_errorToString(error) -{ - return $elm$json$Json$Decode$errorToString(error); -} -//*/ +// 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); -// CORE DECODERS +var _Basics_remainderBy = F2(function(b, a) { return a % b; }); -function _Json_succeed(msg) +// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf +var _Basics_modBy = F2(function(modulus, x) { - return { - $: 0, - a: msg - }; -} + var answer = x % modulus; + return modulus === 0 + ? _Debug_crash(11) + : + ((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0)) + ? answer + modulus + : answer; +}); -function _Json_fail(msg) -{ - return { - $: 1, - a: msg - }; -} -function _Json_decodePrim(decoder) -{ - return { $: 2, b: decoder }; -} +// TRIGONOMETRY -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 _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); -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); -}); +// MORE MATH -var _Json_decodeValue = _Json_decodePrim(function(value) { - return $elm$core$Result$Ok(_Json_wrap(value)); -}); +function _Basics_toFloat(x) { return x; } +function _Basics_truncate(n) { return n | 0; } +function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; } -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); -}); +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; -function _Json_decodeList(decoder) { return { $: 3, b: decoder }; } -function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; } -function _Json_decodeNull(value) { return { $: 5, c: value }; } +// BOOLEANS -var _Json_decodeField = F2(function(field, decoder) -{ - return { - $: 6, - d: field, - b: decoder - }; -}); +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 _Json_decodeIndex = F2(function(index, decoder) -{ - return { - $: 7, - e: index, - b: decoder - }; -}); -function _Json_decodeKeyValuePairs(decoder) + +var _String_cons = F2(function(chr, str) { - return { - $: 8, - b: decoder - }; -} + return chr + str; +}); -function _Json_mapMany(f, decoders) +function _String_uncons(string) { - return { - $: 9, - f: f, - g: decoders - }; + 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 _Json_andThen = F2(function(callback, decoder) +var _String_append = F2(function(a, b) { - return { - $: 10, - b: decoder, - h: callback - }; + return a + b; }); -function _Json_oneOf(decoders) +function _String_length(str) { - return { - $: 11, - g: decoders - }; + return str.length; } - -// DECODING OBJECTS - -var _Json_map1 = F2(function(f, d1) +var _String_map = F2(function(func, string) { - return _Json_mapMany(f, [d1]); + 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 _Json_map2 = F3(function(f, d1, d2) +var _String_filter = F2(function(isGood, str) { - return _Json_mapMany(f, [d1, d2]); -}); + 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++; + } -var _Json_map3 = F4(function(f, d1, d2, d3) -{ - return _Json_mapMany(f, [d1, d2, d3]); + if (isGood(_Utils_chr(char))) + { + arr.push(char); + } + } + return arr.join(''); }); -var _Json_map4 = F5(function(f, d1, d2, d3, d4) +function _String_reverse(str) { - return _Json_mapMany(f, [d1, d2, d3, d4]); -}); + 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 _Json_map5 = F6(function(f, d1, d2, d3, d4, d5) +var _String_foldl = F3(function(func, state, string) { - return _Json_mapMany(f, [d1, d2, d3, d4, d5]); + 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 _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6) +var _String_foldr = F3(function(func, state, string) { - return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]); + 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 _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7) +var _String_split = F2(function(sep, str) { - return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]); + return str.split(sep); }); -var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8) +var _String_join = F2(function(sep, strs) { - return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]); + return strs.join(sep); }); +var _String_slice = F3(function(start, end, str) { + return str.slice(start, end); +}); -// DECODE - -var _Json_runOnString = F2(function(decoder, string) +function _String_trim(str) { - try + 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 value = JSON.parse(string); - return _Json_runHelp(decoder, value); + 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; + } } - catch (e) + return false; +}); + +var _String_all = F2(function(isGood, string) +{ + var i = string.length; + while (i--) { - return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string))); + 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 _Json_run = F2(function(decoder, value) +var _String_contains = F2(function(sub, str) { - return _Json_runHelp(decoder, _Json_unwrap(value)); + return str.indexOf(sub) > -1; }); -function _Json_runHelp(decoder, value) +var _String_startsWith = F2(function(sub, str) { - switch (decoder.$) - { - case 2: - return decoder.b(value); - - case 5: - return (value === null) - ? $elm$core$Result$Ok(decoder.c) - : _Json_expecting('null', value); + return str.indexOf(sub) === 0; +}); - case 3: - if (!_Json_isArray(value)) - { - return _Json_expecting('a LIST', value); - } - return _Json_runArrayDecoder(decoder.b, value, _List_fromArray); +var _String_endsWith = F2(function(sub, str) +{ + return str.length >= sub.length && + str.lastIndexOf(sub) === str.length - sub.length; +}); - case 4: - if (!_Json_isArray(value)) - { - return _Json_expecting('an ARRAY', value); - } - return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray); +var _String_indexes = F2(function(sub, str) +{ + var subLen = sub.length; - 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)); + if (subLen < 1) + { + return _List_Nil; + } - 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)); + var i = 0; + var is = []; - case 8: - if (typeof value !== 'object' || value === null || _Json_isArray(value)) - { - return _Json_expecting('an OBJECT', value); - } + while ((i = str.indexOf(sub, i)) > -1) + { + is.push(i); + i = i + subLen; + } - 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)); + return _List_fromArray(is); +}); - 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); +// TO STRING - 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))); +function _String_fromNumber(number) +{ + return number + ''; +} - 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); - } -} +// INT CONVERSIONS -function _Json_runArrayDecoder(decoder, value, toElmValue) +function _String_toInt(str) { - var len = value.length; - var array = new Array(len); - for (var i = 0; i < len; i++) + 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 result = _Json_runHelp(decoder, value[i]); - if (!$elm$core$Result$isOk(result)) + var code = str.charCodeAt(i); + if (code < 0x30 || 0x39 < code) { - return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a)); + return $elm$core$Maybe$Nothing; } - array[i] = result.a; + total = 10 * total + code - 0x30; } - return $elm$core$Result$Ok(toElmValue(array)); -} -function _Json_isArray(value) -{ - return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList); + return i == start + ? $elm$core$Maybe$Nothing + : $elm$core$Maybe$Just(code0 == 0x2D ? -total : total); } -function _Json_toElmArray(array) + +// FLOAT CONVERSIONS + +function _String_toFloat(s) { - return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; }); + // 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 _Json_expecting(type, value) +function _String_fromList(chars) { - return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value))); + return _List_toArray(chars).join(''); } -// EQUALITY -function _Json_equality(x, y) + +function _Char_toCode(char) { - if (x === y) - { - return true; - } - - if (x.$ !== y.$) + var code = char.charCodeAt(0); + if (0xD800 <= code && code <= 0xDBFF) { - return false; + return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000 } + return code; +} - 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); +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) + ) + ); +} - case 9: - return x.f === y.f && _Json_listEquality(x.g, y.g); +function _Char_toUpper(char) +{ + return _Utils_chr(char.toUpperCase()); +} - case 10: - return x.h === y.h && _Json_equality(x.b, y.b); +function _Char_toLower(char) +{ + return _Utils_chr(char.toLowerCase()); +} - case 11: - return _Json_listEquality(x.g, y.g); - } +function _Char_toLocaleUpper(char) +{ + return _Utils_chr(char.toLocaleUpperCase()); } -function _Json_listEquality(aDecoders, bDecoders) +function _Char_toLocaleLower(char) { - 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; + return _Utils_chr(char.toLocaleLowerCase()); } -// ENCODE -var _Json_encode = F2(function(indentLevel, value) +/**_UNUSED/ +function _Json_errorToString(error) { - return JSON.stringify(_Json_unwrap(value), null, indentLevel) + ''; -}); + return $elm$json$Json$Decode$errorToString(error); +} +//*/ -function _Json_wrap_UNUSED(value) { return { $: 0, a: value }; } -function _Json_unwrap_UNUSED(value) { return value.a; } -function _Json_wrap(value) { return value; } -function _Json_unwrap(value) { return value; } +// CORE DECODERS -function _Json_emptyArray() { return []; } -function _Json_emptyObject() { return {}; } +function _Json_succeed(msg) +{ + return { + $: 0, + a: msg + }; +} -var _Json_addField = F3(function(key, value, object) +function _Json_fail(msg) { - object[key] = _Json_unwrap(value); - return object; -}); + return { + $: 1, + a: msg + }; +} -function _Json_addEntry(func) +function _Json_decodePrim(decoder) { - return F2(function(entry, array) - { - array.push(_Json_unwrap(func(entry))); - return array; - }); + return { $: 2, b: decoder }; } -var _Json_encodeNull = _Json_wrap(null); +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); +}); -// TASKS +var _Json_decodeValue = _Json_decodePrim(function(value) { + return $elm$core$Result$Ok(_Json_wrap(value)); +}); -function _Scheduler_succeed(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 { - $: 0, - a: value + $: 6, + d: field, + b: decoder }; -} +}); -function _Scheduler_fail(error) +var _Json_decodeIndex = F2(function(index, decoder) { return { - $: 1, - a: error + $: 7, + e: index, + b: decoder }; -} +}); -function _Scheduler_binding(callback) +function _Json_decodeKeyValuePairs(decoder) { return { - $: 2, - b: callback, - c: null + $: 8, + b: decoder }; } -var _Scheduler_andThen = F2(function(callback, task) +function _Json_mapMany(f, decoders) { return { - $: 3, - b: callback, - d: task + $: 9, + f: f, + g: decoders }; -}); +} -var _Scheduler_onError = F2(function(callback, task) +var _Json_andThen = F2(function(callback, decoder) { return { - $: 4, - b: callback, - d: task + $: 10, + b: decoder, + h: callback }; }); -function _Scheduler_receive(callback) +function _Json_oneOf(decoders) { return { - $: 5, - b: callback + $: 11, + g: decoders }; } -// PROCESSES - -var _Scheduler_guid = 0; +// DECODING OBJECTS -function _Scheduler_rawSpawn(task) +var _Json_map1 = F2(function(f, d1) { - var proc = { - $: 0, - e: _Scheduler_guid++, - f: task, - g: null, - h: [] - }; - - _Scheduler_enqueue(proc); + return _Json_mapMany(f, [d1]); +}); - return proc; -} +var _Json_map2 = F3(function(f, d1, d2) +{ + return _Json_mapMany(f, [d1, d2]); +}); -function _Scheduler_spawn(task) +var _Json_map3 = F4(function(f, d1, d2, d3) { - return _Scheduler_binding(function(callback) { - callback(_Scheduler_succeed(_Scheduler_rawSpawn(task))); - }); -} + return _Json_mapMany(f, [d1, d2, d3]); +}); -function _Scheduler_rawSend(proc, msg) +var _Json_map4 = F5(function(f, d1, d2, d3, d4) { - proc.h.push(msg); - _Scheduler_enqueue(proc); -} + return _Json_mapMany(f, [d1, d2, d3, d4]); +}); -var _Scheduler_send = F2(function(proc, msg) +var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5) { - return _Scheduler_binding(function(callback) { - _Scheduler_rawSend(proc, msg); - callback(_Scheduler_succeed(_Utils_Tuple0)); - }); + return _Json_mapMany(f, [d1, d2, d3, d4, d5]); }); -function _Scheduler_kill(proc) +var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6) { - 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] - } + 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]); +}); -var _Scheduler_working = false; -var _Scheduler_queue = []; +// DECODE -function _Scheduler_enqueue(proc) +var _Json_runOnString = F2(function(decoder, string) { - _Scheduler_queue.push(proc); - if (_Scheduler_working) + try { - return; + var value = JSON.parse(string); + return _Json_runHelp(decoder, value); } - _Scheduler_working = true; - while (proc = _Scheduler_queue.shift()) + catch (e) { - _Scheduler_step(proc); + return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string))); } - _Scheduler_working = false; -} +}); +var _Json_run = F2(function(decoder, value) +{ + return _Json_runHelp(decoder, _Json_unwrap(value)); +}); -function _Scheduler_step(proc) +function _Json_runHelp(decoder, value) { - while (proc.f) + switch (decoder.$) { - var rootTag = proc.f.$; - if (rootTag === 0 || rootTag === 1) - { - while (proc.g && proc.g.$ !== rootTag) + 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)) { - proc.g = proc.g.i; + return _Json_expecting('a LIST', value); } - if (!proc.g) + return _Json_runArrayDecoder(decoder.b, value, _List_fromArray); + + case 4: + if (!_Json_isArray(value)) { - return; + return _Json_expecting('an ARRAY', value); } - 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 _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray); + + case 6: + var field = decoder.d; + if (typeof value !== 'object' || value === null || !(field in value)) { - return; + return _Json_expecting('an OBJECT with a field named `' + field + '`', value); } - 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; - } - } -} + 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); + } -function _Process_sleep(time) -{ - return _Scheduler_binding(function(callback) { - var id = setTimeout(function() { - callback(_Scheduler_succeed(_Utils_Tuple0)); - }, time); + 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)); - return function() { clearTimeout(id); }; - }); -} + 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))); -// PROGRAMS + 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)); +} -var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args) +function _Json_isArray(value) { - return _Platform_initialize( - flagDecoder, - args, - impl.at, - impl.aB, - impl.az, - function() { return function() {} } - ); -}); + 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))); +} -// INITIALIZE A PROGRAM +// EQUALITY -function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder) +function _Json_equality(x, y) { - var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined)); - $elm$core$Result$isOk(result) || _Debug_crash(2 /**_UNUSED/, _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) + if (x === y) { - var pair = A2(update, msg, model); - stepper(model = pair.a, viewMetadata); - _Platform_enqueueEffects(managers, pair.b, subscriptions(model)); + return true; } - _Platform_enqueueEffects(managers, initPair.b, subscriptions(model)); + if (x.$ !== y.$) + { + return false; + } - 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; + switch (x.$) + { + case 0: + case 1: + return x.a === y.a; + case 2: + return x.b === y.b; -function _Platform_registerPreload(url) -{ - _Platform_preload.add(url); -} + 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); -// EFFECT MANAGERS + 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); -var _Platform_effectManagers = {}; + case 10: + return x.h === y.h && _Json_equality(x.b, y.b); + case 11: + return _Json_listEquality(x.g, y.g); + } +} -function _Platform_setupEffects(managers, sendToApp) +function _Json_listEquality(aDecoders, bDecoders) { - var ports; - - // setup all necessary effect managers - for (var key in _Platform_effectManagers) + var len = aDecoders.length; + if (len !== bDecoders.length) { - var manager = _Platform_effectManagers[key]; - - if (manager.a) + return false; + } + for (var i = 0; i < len; i++) + { + if (!_Json_equality(aDecoders[i], bDecoders[i])) { - ports = ports || {}; - ports[key] = manager.a(key, sendToApp); + return false; } - - managers[key] = _Platform_instantiateManager(manager, sendToApp); } - - return ports; + return true; } -function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap) -{ - return { - b: init, - c: onEffects, - d: onSelfMsg, - e: cmdMap, - f: subMap - }; -} - +// ENCODE -function _Platform_instantiateManager(info, sendToApp) +var _Json_encode = F2(function(indentLevel, value) { - 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)); -} - + return JSON.stringify(_Json_unwrap(value), null, indentLevel) + ''; +}); +function _Json_wrap_UNUSED(value) { return { $: 0, a: value }; } +function _Json_unwrap_UNUSED(value) { return value.a; } -// ROUTING +function _Json_wrap(value) { return value; } +function _Json_unwrap(value) { return value; } +function _Json_emptyArray() { return []; } +function _Json_emptyObject() { return {}; } -var _Platform_sendToApp = F2(function(router, msg) +var _Json_addField = F3(function(key, value, object) { - return _Scheduler_binding(function(callback) - { - router.g(msg); - callback(_Scheduler_succeed(_Utils_Tuple0)); - }); + object[key] = _Json_unwrap(value); + return object; }); - -var _Platform_sendToSelf = F2(function(router, msg) +function _Json_addEntry(func) { - return A2(_Scheduler_send, router.h, { - $: 0, - a: msg + return F2(function(entry, array) + { + array.push(_Json_unwrap(func(entry))); + return array; }); -}); +} +var _Json_encodeNull = _Json_wrap(null); -// BAGS +// TASKS -function _Platform_leaf(home) +function _Scheduler_succeed(value) { - return function(value) - { - return { - $: 1, - k: home, - l: value - }; + return { + $: 0, + a: value }; } +function _Scheduler_fail(error) +{ + return { + $: 1, + a: error + }; +} -function _Platform_batch(list) +function _Scheduler_binding(callback) { return { $: 2, - m: list + b: callback, + c: null }; } - -var _Platform_map = F2(function(tagger, bag) +var _Scheduler_andThen = F2(function(callback, task) { return { $: 3, - n: tagger, - o: bag - } + b: callback, + d: task + }; }); +var _Scheduler_onError = F2(function(callback, task) +{ + return { + $: 4, + b: callback, + d: task + }; +}); - -// 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. +function _Scheduler_receive(callback) +{ + return { + $: 5, + b: callback + }; +} -// 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; +// PROCESSES +var _Scheduler_guid = 0; -function _Platform_enqueueEffects(managers, cmdBag, subBag) +function _Scheduler_rawSpawn(task) { - _Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag }); + var proc = { + $: 0, + e: _Scheduler_guid++, + f: task, + g: null, + h: [] + }; - if (_Platform_effectsActive) return; + _Scheduler_enqueue(proc); - _Platform_effectsActive = true; - for (var fx; fx = _Platform_effectsQueue.shift(); ) - { - _Platform_dispatchEffects(fx.p, fx.q, fx.r); - } - _Platform_effectsActive = false; + return proc; } +function _Scheduler_spawn(task) +{ + return _Scheduler_binding(function(callback) { + callback(_Scheduler_succeed(_Scheduler_rawSpawn(task))); + }); +} -function _Platform_dispatchEffects(managers, cmdBag, subBag) +function _Scheduler_rawSend(proc, msg) { - var effectsDict = {}; - _Platform_gatherEffects(true, cmdBag, effectsDict, null); - _Platform_gatherEffects(false, subBag, effectsDict, null); + proc.h.push(msg); + _Scheduler_enqueue(proc); +} - for (var home in managers) +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) { - _Scheduler_rawSend(managers[home], { - $: 'fx', - a: effectsDict[home] || { i: _List_Nil, j: _List_Nil } - }); + return; + } + _Scheduler_working = true; + while (proc = _Scheduler_queue.shift()) + { + _Scheduler_step(proc); } + _Scheduler_working = false; } -function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers) +function _Scheduler_step(proc) { - switch (bag.$) + while (proc.f) { - 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 + var rootTag = proc.f.$; + if (rootTag === 0 || rootTag === 1) + { + while (proc.g && proc.g.$ !== rootTag) { - _Platform_gatherEffects(isCmd, list.a, effectsDict, taggers); + proc.g = proc.g.i; } - return; - - case 3: - _Platform_gatherEffects(isCmd, bag.o, effectsDict, { - s: bag.n, - t: taggers + 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 _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; +function _Process_sleep(time) +{ + return _Scheduler_binding(function(callback) { + var id = setTimeout(function() { + callback(_Scheduler_succeed(_Utils_Tuple0)); + }, time); - return A2(map, applyTaggers, value) + return function() { clearTimeout(id); }; + }); } -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; -} +// PROGRAMS + + +var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args) +{ + return _Platform_initialize( + flagDecoder, + args, + impl.aK, + impl.a0, + impl.aZ, + function() { return function() {} } + ); +}); -// PORTS +// INITIALIZE A PROGRAM -function _Platform_checkPortName(name) +function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder) { - if (_Platform_effectManagers[name]) + var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined)); + $elm$core$Result$isOk(result) || _Debug_crash(2 /**_UNUSED/, _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) { - _Debug_crash(3, name) + 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 } : {}; } -// OUTGOING PORTS +// TRACK PRELOADS +// +// This is used by code in elm/browser and elm/http +// to register any HTTP requests that are triggered by init. +// -function _Platform_outgoingPort(name, converter) +var _Platform_preload; + + +function _Platform_registerPreload(url) { - _Platform_checkPortName(name); - _Platform_effectManagers[name] = { - e: _Platform_outgoingPortMap, - u: converter, - a: _Platform_setupOutgoingPort - }; - return _Platform_leaf(name); + _Platform_preload.add(url); } -var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; }); - -function _Platform_setupOutgoingPort(name) -{ - var subs = []; - var converter = _Platform_effectManagers[name].u; +// EFFECT MANAGERS - // CREATE MANAGER - var init = _Process_sleep(0); +var _Platform_effectManagers = {}; - _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 _Platform_setupEffects(managers, sendToApp) +{ + var ports; - function subscribe(callback) + // setup all necessary effect managers + for (var key in _Platform_effectManagers) { - subs.push(callback); - } + var manager = _Platform_effectManagers[key]; - 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) + if (manager.a) { - subs.splice(index, 1); + 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 { - subscribe: subscribe, - unsubscribe: unsubscribe + b: init, + c: onEffects, + d: onSelfMsg, + e: cmdMap, + f: subMap }; } - -// INCOMING PORTS - - -function _Platform_incomingPort(name, converter) +function _Platform_instantiateManager(info, sendToApp) { - _Platform_checkPortName(name); - _Platform_effectManagers[name] = { - f: _Platform_incomingPortMap, - u: converter, - a: _Platform_setupIncomingPort + var router = { + g: sendToApp, + h: undefined }; - return _Platform_leaf(name); + + 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)); } -var _Platform_incomingPortMap = F2(function(tagger, finalTagger) + +// ROUTING + + +var _Platform_sendToApp = F2(function(router, msg) { - return function(value) + return _Scheduler_binding(function(callback) { - return tagger(finalTagger(value)); - }; + router.g(msg); + callback(_Scheduler_succeed(_Utils_Tuple0)); + }); }); -function _Platform_setupIncomingPort(name, sendToApp) +var _Platform_sendToSelf = F2(function(router, msg) { - var subs = _List_Nil; - var converter = _Platform_effectManagers[name].u; + return A2(_Scheduler_send, router.h, { + $: 0, + a: msg + }); +}); - // 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; - }); +// BAGS - // PUBLIC API - function send(incomingValue) +function _Platform_leaf(home) +{ + return function(value) { - var result = A2(_Json_run, converter, _Json_wrap(incomingValue)); + return { + $: 1, + k: home, + l: value + }; + }; +} - $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)); - } +function _Platform_batch(list) +{ + return { + $: 2, + m: list + }; +} + + +var _Platform_map = F2(function(tagger, bag) +{ + return { + $: 3, + n: tagger, + o: bag } +}); + - return { send: send }; -} +// 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. -// EXPORT ELM MODULES +// 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. // -// 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. +// 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_export(exports) +function _Platform_enqueueEffects(managers, cmdBag, subBag) { - scope['Elm'] - ? _Platform_mergeExportsProd(scope['Elm'], exports) - : scope['Elm'] = exports; -} + _Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag }); + if (_Platform_effectsActive) return; -function _Platform_mergeExportsProd(obj, exports) -{ - for (var name in exports) + _Platform_effectsActive = true; + for (var fx; fx = _Platform_effectsQueue.shift(); ) { - (name in obj) - ? (name == 'init') - ? _Debug_crash(6) - : _Platform_mergeExportsProd(obj[name], exports[name]) - : (obj[name] = exports[name]); + _Platform_dispatchEffects(fx.p, fx.q, fx.r); } + _Platform_effectsActive = false; } -function _Platform_export_UNUSED(exports) +function _Platform_dispatchEffects(managers, cmdBag, subBag) { - scope['Elm'] - ? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports) - : scope['Elm'] = exports; + 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_mergeExportsDebug(moduleName, obj, exports) +function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers) { - for (var name in exports) + switch (bag.$) { - (name in obj) - ? (name == 'init') - ? _Debug_crash(6, moduleName) - : _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name]) - : (obj[name] = exports[name]); + 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; -// HELPERS - + return A2(map, applyTaggers, value) +} -var _VirtualDom_divertHrefToApp; -var _VirtualDom_doc = typeof document !== 'undefined' ? document : {}; +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)); -function _VirtualDom_appendChild(parent, child) -{ - parent.appendChild(child); + return effects; } -var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args) -{ - // NOTE: this function needs _Platform_export available to work - /**/ - var node = args['node']; - //*/ - /**_UNUSED/ - var node = args && args['node'] ? args['node'] : _Debug_crash(0); - //*/ - node.parentNode.replaceChild( - _VirtualDom_render(virtualNode, function() {}), - node - ); +// PORTS - return {}; -}); +function _Platform_checkPortName(name) +{ + if (_Platform_effectManagers[name]) + { + _Debug_crash(3, name) + } +} -// TEXT +// OUTGOING PORTS -function _VirtualDom_text(string) -{ + +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(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_UNUSED(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 + + /**/ + var node = args['node']; + //*/ + /**_UNUSED/ + 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 @@ -2718,9 +2718,9 @@ var _VirtualDom_mapEventTuple = F2(function(func, tuple) var _VirtualDom_mapEventRecord = F2(function(func, record) { return { - o: func(record.o), - J: record.J, - G: record.G + u: func(record.u), + R: record.R, + P: record.P } }); @@ -2988,11 +2988,11 @@ function _VirtualDom_makeCallback(eventNode, initialHandler) // 3 = Custom var value = result.a; - var message = !tag ? value : tag < 3 ? value.a : value.o; - var stopPropagation = tag == 1 ? value.b : tag == 3 && value.J; + var message = !tag ? value : tag < 3 ? value.a : value.u; + var stopPropagation = tag == 1 ? value.b : tag == 3 && value.R; var currentEventNode = ( stopPropagation && event.stopPropagation(), - (tag == 2 ? value.b : tag == 3 && value.G) && event.preventDefault(), + (tag == 2 ? value.b : tag == 3 && value.P) && event.preventDefault(), eventNode ); var tagger; @@ -3942,11 +3942,11 @@ var _Browser_element = _Debugger_element || F4(function(impl, flagDecoder, debug return _Platform_initialize( flagDecoder, args, - impl.at, - impl.aB, - impl.az, + impl.aK, + impl.a0, + impl.aZ, function(sendToApp, initialModel) { - var view = impl.aC; + var view = impl.a1; /**/ var domNode = args['node']; //*/ @@ -3978,12 +3978,12 @@ var _Browser_document = _Debugger_document || F4(function(impl, flagDecoder, deb return _Platform_initialize( flagDecoder, args, - impl.at, - impl.aB, - impl.az, + impl.aK, + impl.a0, + impl.aZ, function(sendToApp, initialModel) { - var divertHrefToApp = impl.H && impl.H(sendToApp) - var view = impl.aC; + var divertHrefToApp = impl.Q && impl.Q(sendToApp) + var view = impl.a1; var title = _VirtualDom_doc.title; var bodyNode = _VirtualDom_doc.body; var currNode = _VirtualDom_virtualize(bodyNode); @@ -3991,12 +3991,12 @@ var _Browser_document = _Debugger_document || F4(function(impl, flagDecoder, deb { _VirtualDom_divertHrefToApp = divertHrefToApp; var doc = view(model); - var nextNode = _VirtualDom_node('body')(_List_Nil)(doc.am); + var nextNode = _VirtualDom_node('body')(_List_Nil)(doc.ay); var patches = _VirtualDom_diff(currNode, nextNode); bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp); currNode = nextNode; _VirtualDom_divertHrefToApp = 0; - (title !== doc.aA) && (_VirtualDom_doc.title = title = doc.aA); + (title !== doc.a_) && (_VirtualDom_doc.title = title = doc.a_); }); } ); @@ -4052,12 +4052,12 @@ function _Browser_makeAnimator(model, draw) function _Browser_application(impl) { - var onUrlChange = impl.av; - var onUrlRequest = impl.aw; + var onUrlChange = impl.aR; + var onUrlRequest = impl.aS; var key = function() { key.a(onUrlChange(_Browser_getUrl())); }; return _Browser_document({ - H: function(sendToApp) + Q: function(sendToApp) { key.a = sendToApp; _Browser_window.addEventListener('popstate', key); @@ -4073,9 +4073,9 @@ function _Browser_application(impl) var next = $elm$url$Url$fromString(href).a; sendToApp(onUrlRequest( (next - && curr._ === next._ - && curr.R === next.R - && curr.X.a === next.X.a + && curr.ag === next.ag + && curr.Z === next.Z + && curr.ad.a === next.ad.a ) ? $elm$browser$Browser$Internal(next) : $elm$browser$Browser$External(href) @@ -4083,13 +4083,13 @@ function _Browser_application(impl) } }); }, - at: function(flags) + aK: function(flags) { - return A3(impl.at, flags, _Browser_getUrl(), key); + return A3(impl.aK, flags, _Browser_getUrl(), key); }, - aC: impl.aC, - aB: impl.aB, - az: impl.az + a1: impl.a1, + a0: impl.a0, + aZ: impl.aZ }); } @@ -4155,17 +4155,17 @@ var _Browser_decodeEvent = F2(function(decoder, event) function _Browser_visibilityInfo() { return (typeof _VirtualDom_doc.hidden !== 'undefined') - ? { ar: 'hidden', an: 'visibilitychange' } + ? { aI: 'hidden', az: 'visibilitychange' } : (typeof _VirtualDom_doc.mozHidden !== 'undefined') - ? { ar: 'mozHidden', an: 'mozvisibilitychange' } + ? { aI: 'mozHidden', az: 'mozvisibilitychange' } : (typeof _VirtualDom_doc.msHidden !== 'undefined') - ? { ar: 'msHidden', an: 'msvisibilitychange' } + ? { aI: 'msHidden', az: 'msvisibilitychange' } : (typeof _VirtualDom_doc.webkitHidden !== 'undefined') - ? { ar: 'webkitHidden', an: 'webkitvisibilitychange' } - : { ar: 'hidden', an: 'visibilitychange' }; + ? { aI: 'webkitHidden', az: 'webkitvisibilitychange' } + : { aI: 'hidden', az: 'visibilitychange' }; } @@ -4246,12 +4246,12 @@ var _Browser_call = F2(function(functionName, id) function _Browser_getViewport() { return { - ad: _Browser_getScene(), - ag: { - ai: _Browser_window.pageXOffset, - aj: _Browser_window.pageYOffset, - ah: _Browser_doc.documentElement.clientWidth, - Q: _Browser_doc.documentElement.clientHeight + al: _Browser_getScene(), + ar: { + at: _Browser_window.pageXOffset, + au: _Browser_window.pageYOffset, + as: _Browser_doc.documentElement.clientWidth, + Y: _Browser_doc.documentElement.clientHeight } }; } @@ -4261,8 +4261,8 @@ function _Browser_getScene() var body = _Browser_doc.body; var elem = _Browser_doc.documentElement; return { - ah: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth), - Q: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight) + as: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth), + Y: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight) }; } @@ -4285,15 +4285,15 @@ function _Browser_getViewportOf(id) return _Browser_withNode(id, function(node) { return { - ad: { - ah: node.scrollWidth, - Q: node.scrollHeight + al: { + as: node.scrollWidth, + Y: node.scrollHeight }, - ag: { - ai: node.scrollLeft, - aj: node.scrollTop, - ah: node.clientWidth, - Q: node.clientHeight + ar: { + at: node.scrollLeft, + au: node.scrollTop, + as: node.clientWidth, + Y: node.clientHeight } }; }); @@ -4323,18 +4323,18 @@ function _Browser_getElement(id) var x = _Browser_window.pageXOffset; var y = _Browser_window.pageYOffset; return { - ad: _Browser_getScene(), - ag: { - ai: x, - aj: y, - ah: _Browser_doc.documentElement.clientWidth, - Q: _Browser_doc.documentElement.clientHeight + al: _Browser_getScene(), + ar: { + at: x, + au: y, + as: _Browser_doc.documentElement.clientWidth, + Y: _Browser_doc.documentElement.clientHeight }, - ap: { - ai: x + rect.left, - aj: y + rect.top, - ah: rect.width, - Q: rect.height + aD: { + at: x + rect.left, + au: y + rect.top, + as: rect.width, + Y: rect.height } }; }); @@ -4369,63 +4369,137 @@ function _Browser_load(url) } })); } -var $author$project$Main$init = 0; -var $elm$core$Basics$EQ = 1; -var $elm$core$Basics$GT = 2; -var $elm$core$Basics$LT = 0; -var $elm$core$List$cons = _List_cons; -var $elm$core$Dict$foldr = F3( - function (func, acc, t) { - foldr: - while (true) { - if (t.$ === -2) { - 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; - return $elm$core$Dict$keys(dict); -}; + + + + +// STRINGS + + +var _Parser_isSubString = F5(function(smallString, offset, row, col, bigString) +{ + var smallLength = smallString.length; + var isGood = offset + smallLength <= bigString.length; + + for (var i = 0; isGood && i < smallLength; ) + { + var code = bigString.charCodeAt(offset); + isGood = + smallString[i++] === bigString[offset++] + && ( + code === 0x000A /* \n */ + ? ( row++, col=1 ) + : ( col++, (code & 0xF800) === 0xD800 ? smallString[i++] === bigString[offset++] : 1 ) + ) + } + + return _Utils_Tuple3(isGood ? offset : -1, row, col); +}); + + + +// CHARS + + +var _Parser_isSubChar = F3(function(predicate, offset, string) +{ + return ( + string.length <= offset + ? -1 + : + (string.charCodeAt(offset) & 0xF800) === 0xD800 + ? (predicate(_Utils_chr(string.substr(offset, 2))) ? offset + 2 : -1) + : + (predicate(_Utils_chr(string[offset])) + ? ((string[offset] === '\n') ? -2 : (offset + 1)) + : -1 + ) + ); +}); + + +var _Parser_isAsciiCode = F3(function(code, offset, string) +{ + return string.charCodeAt(offset) === code; +}); + + + +// NUMBERS + + +var _Parser_chompBase10 = F2(function(offset, string) +{ + for (; offset < string.length; offset++) + { + var code = string.charCodeAt(offset); + if (code < 0x30 || 0x39 < code) + { + return offset; + } + } + return offset; +}); + + +var _Parser_consumeBase = F3(function(base, offset, string) +{ + for (var total = 0; offset < string.length; offset++) + { + var digit = string.charCodeAt(offset) - 0x30; + if (digit < 0 || base <= digit) break; + total = base * total + digit; + } + return _Utils_Tuple2(offset, total); +}); + + +var _Parser_consumeBase16 = F2(function(offset, string) +{ + for (var total = 0; offset < string.length; offset++) + { + var code = string.charCodeAt(offset); + if (0x30 <= code && code <= 0x39) + { + total = 16 * total + code - 0x30; + } + else if (0x41 <= code && code <= 0x46) + { + total = 16 * total + code - 55; + } + else if (0x61 <= code && code <= 0x66) + { + total = 16 * total + code - 87; + } + else + { + break; + } + } + return _Utils_Tuple2(offset, total); +}); + + + +// FIND STRING + + +var _Parser_findSubString = F5(function(smallString, offset, row, col, bigString) +{ + var newOffset = bigString.indexOf(smallString, offset); + var target = newOffset < 0 ? bigString.length : newOffset + smallString.length; + + while (offset < target) + { + var code = bigString.charCodeAt(offset++); + code === 0x000A /* \n */ + ? ( col=1, row++ ) + : ( col++, (code & 0xF800) === 0xD800 && offset++ ) + } + + return _Utils_Tuple3(newOffset, row, col); +}); +var $elm$core$List$cons = _List_cons; var $elm$core$Elm$JsArray$foldr = _JsArray_foldr; var $elm$core$Array$foldr = F3( function (func, baseCase, _v0) { @@ -4450,6 +4524,67 @@ var $elm$core$Array$foldr = F3( var $elm$core$Array$toList = function (array) { return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array); }; +var $elm$core$Dict$foldr = F3( + function (func, acc, t) { + foldr: + while (true) { + if (t.$ === -2) { + 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; + return $elm$core$Dict$keys(dict); +}; +var $elm$core$Basics$EQ = 1; +var $elm$core$Basics$GT = 2; +var $elm$core$Basics$LT = 0; +var $author$project$QCM$init = { + G: '', + M: _List_fromArray( + ['']), + L: '' +}; var $elm$core$Result$Err = function (a) { return {$: 1, a: a}; }; @@ -4776,25 +4911,25 @@ var $elm$core$Array$treeFromBuilder = F2( }); var $elm$core$Array$builderToArray = F2( function (reverseNodeList, builder) { - if (!builder.a) { + if (!builder.g) { return A4( $elm$core$Array$Array_elm_builtin, - $elm$core$Elm$JsArray$length(builder.c), + $elm$core$Elm$JsArray$length(builder.i), $elm$core$Array$shiftStep, $elm$core$Elm$JsArray$empty, - builder.c); + builder.i); } else { - var treeLen = builder.a * $elm$core$Array$branchFactor; + var treeLen = builder.g * $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.d) : builder.d; - var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.a); + var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.j) : builder.j; + var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.g); return A4( $elm$core$Array$Array_elm_builtin, - $elm$core$Elm$JsArray$length(builder.c) + treeLen, + $elm$core$Elm$JsArray$length(builder.i) + treeLen, A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep), tree, - builder.c); + builder.i); } }); var $elm$core$Basics$idiv = _Basics_idiv; @@ -4807,7 +4942,7 @@ var $elm$core$Array$initializeHelp = F5( return A2( $elm$core$Array$builderToArray, false, - {d: nodeList, a: (len / $elm$core$Array$branchFactor) | 0, c: tail}); + {j: nodeList, g: (len / $elm$core$Array$branchFactor) | 0, i: tail}); } else { var leaf = $elm$core$Array$Leaf( A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn)); @@ -4874,7 +5009,7 @@ var $elm$url$Url$Http = 0; var $elm$url$Url$Https = 1; var $elm$url$Url$Url = F6( function (protocol, host, port_, path, query, fragment) { - return {P: fragment, R: host, V: path, X: port_, _: protocol, aa: query}; + return {X: fragment, Z: host, ab: path, ad: port_, ag: protocol, ah: query}; }); var $elm$core$String$contains = _String_contains; var $elm$core$String$length = _String_length; @@ -5062,128 +5197,2054 @@ var $elm$core$List$foldrHelper = F4( } } }); -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) { +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; + 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 0; + }, + $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(0); + }); +var $elm$core$Task$cmdMap = F2( + function (tagger, _v0) { + var task = _v0; + return 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( + A2($elm$core$Task$map, toMessage, task)); + }); +var $elm$core$Platform$Cmd$batch = _Platform_batch; +var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil); +var $elm$core$Platform$Sub$batch = _Platform_batch; +var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil); +var $elm$browser$Browser$sandbox = function (impl) { + return _Browser_element( + { + aK: function (_v0) { + return _Utils_Tuple2(impl.aK, $elm$core$Platform$Cmd$none); + }, + aZ: function (_v1) { + return $elm$core$Platform$Sub$none; + }, + a0: F2( + function (msg, model) { + return _Utils_Tuple2( + A2(impl.a0, msg, model), + $elm$core$Platform$Cmd$none); + }), + a1: impl.a1 + }); +}; +var $elm$core$String$lines = _String_lines; +var $author$project$QCM$Aremplacer = F2( + function (_var, vals) { + return {ap: vals, aq: _var}; + }); +var $elm$parser$Parser$Optional = 1; +var $elm$core$Set$Set_elm_builtin = $elm$core$Basics$identity; +var $elm$core$Dict$RBEmpty_elm_builtin = {$: -2}; +var $elm$core$Dict$empty = $elm$core$Dict$RBEmpty_elm_builtin; +var $elm$core$Set$empty = $elm$core$Dict$empty; +var $elm$core$Dict$Black = 1; +var $elm$core$Dict$RBNode_elm_builtin = F5( + function (a, b, c, d, e) { + return {$: -1, a: a, b: b, c: c, d: d, e: e}; + }); +var $elm$core$Dict$Red = 0; +var $elm$core$Dict$balance = F5( + function (color, key, value, left, right) { + if ((right.$ === -1) && (!right.a)) { + var _v1 = right.a; + var rK = right.b; + var rV = right.c; + var rLeft = right.d; + var rRight = right.e; + if ((left.$ === -1) && (!left.a)) { + 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, + 0, + key, + value, + A5($elm$core$Dict$RBNode_elm_builtin, 1, lK, lV, lLeft, lRight), + A5($elm$core$Dict$RBNode_elm_builtin, 1, rK, rV, rLeft, rRight)); + } else { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + color, + rK, + rV, + A5($elm$core$Dict$RBNode_elm_builtin, 0, key, value, left, rLeft), + rRight); + } + } else { + if ((((left.$ === -1) && (!left.a)) && (left.d.$ === -1)) && (!left.d.a)) { + 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, + 0, + lK, + lV, + A5($elm$core$Dict$RBNode_elm_builtin, 1, llK, llV, llLeft, llRight), + A5($elm$core$Dict$RBNode_elm_builtin, 1, 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.$ === -2) { + return A5($elm$core$Dict$RBNode_elm_builtin, 0, 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 0: + return A5( + $elm$core$Dict$balance, + nColor, + nKey, + nValue, + A3($elm$core$Dict$insertHelp, key, value, nLeft), + nRight); + case 1: + 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.$ === -1) && (!_v0.a)) { + 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, 1, k, v, l, r); + } else { + var x = _v0; + return x; + } + }); +var $elm$core$Set$insert = F2( + function (key, _v0) { + var dict = _v0; + return A3($elm$core$Dict$insert, key, 0, dict); + }); +var $elm$core$Set$fromList = function (list) { + return A3($elm$core$List$foldl, $elm$core$Set$insert, $elm$core$Set$empty, list); +}; +var $elm$core$Basics$always = F2( + function (a, _v0) { + return a; + }); +var $elm$parser$Parser$Advanced$Bad = F2( + function (a, b) { + return {$: 1, a: a, b: b}; + }); +var $elm$parser$Parser$Advanced$Good = F3( + function (a, b, c) { + return {$: 0, a: a, b: b, c: c}; + }); +var $elm$parser$Parser$Advanced$Parser = $elm$core$Basics$identity; +var $elm$parser$Parser$Advanced$map2 = F3( + function (func, _v0, _v1) { + var parseA = _v0; + var parseB = _v1; + return function (s0) { + var _v2 = parseA(s0); + if (_v2.$ === 1) { + var p = _v2.a; + var x = _v2.b; + return A2($elm$parser$Parser$Advanced$Bad, p, x); + } else { + var p1 = _v2.a; + var a = _v2.b; + var s1 = _v2.c; + var _v3 = parseB(s1); + if (_v3.$ === 1) { + var p2 = _v3.a; + var x = _v3.b; + return A2($elm$parser$Parser$Advanced$Bad, p1 || p2, x); + } else { + var p2 = _v3.a; + var b = _v3.b; + var s2 = _v3.c; + return A3( + $elm$parser$Parser$Advanced$Good, + p1 || p2, + A2(func, a, b), + s2); + } + } + }; + }); +var $elm$parser$Parser$Advanced$ignorer = F2( + function (keepParser, ignoreParser) { + return A3($elm$parser$Parser$Advanced$map2, $elm$core$Basics$always, keepParser, ignoreParser); + }); +var $elm$parser$Parser$ignorer = $elm$parser$Parser$Advanced$ignorer; +var $elm$parser$Parser$Advanced$keeper = F2( + function (parseFunc, parseArg) { + return A3($elm$parser$Parser$Advanced$map2, $elm$core$Basics$apL, parseFunc, parseArg); + }); +var $elm$parser$Parser$keeper = $elm$parser$Parser$Advanced$keeper; +var $elm$core$Basics$neq = _Utils_notEqual; +var $elm$parser$Parser$Advanced$andThen = F2( + function (callback, _v0) { + var parseA = _v0; + return function (s0) { + var _v1 = parseA(s0); + if (_v1.$ === 1) { + var p = _v1.a; + var x = _v1.b; + return A2($elm$parser$Parser$Advanced$Bad, p, x); + } else { + var p1 = _v1.a; + var a = _v1.b; + var s1 = _v1.c; + var _v2 = callback(a); + var parseB = _v2; + var _v3 = parseB(s1); + if (_v3.$ === 1) { + var p2 = _v3.a; + var x = _v3.b; + return A2($elm$parser$Parser$Advanced$Bad, p1 || p2, x); + } else { + var p2 = _v3.a; + var b = _v3.b; + var s2 = _v3.c; + return A3($elm$parser$Parser$Advanced$Good, p1 || p2, b, s2); + } + } + }; + }); +var $elm$parser$Parser$Advanced$loopHelp = F4( + function (p, state, callback, s0) { + loopHelp: + while (true) { + var _v0 = callback(state); + var parse = _v0; + var _v1 = parse(s0); + if (!_v1.$) { + var p1 = _v1.a; + var step = _v1.b; + var s1 = _v1.c; + if (!step.$) { + var newState = step.a; + var $temp$p = p || p1, + $temp$state = newState, + $temp$callback = callback, + $temp$s0 = s1; + p = $temp$p; + state = $temp$state; + callback = $temp$callback; + s0 = $temp$s0; + continue loopHelp; + } else { + var result = step.a; + return A3($elm$parser$Parser$Advanced$Good, p || p1, result, s1); + } + } else { + var p1 = _v1.a; + var x = _v1.b; + return A2($elm$parser$Parser$Advanced$Bad, p || p1, x); + } + } + }); +var $elm$parser$Parser$Advanced$loop = F2( + function (state, callback) { + return function (s) { + return A4($elm$parser$Parser$Advanced$loopHelp, false, state, callback, s); + }; + }); +var $elm$parser$Parser$Advanced$map = F2( + function (func, _v0) { + var parse = _v0; + return function (s0) { + var _v1 = parse(s0); + if (!_v1.$) { + var p = _v1.a; + var a = _v1.b; + var s1 = _v1.c; + return A3( + $elm$parser$Parser$Advanced$Good, + p, + func(a), + s1); + } else { + var p = _v1.a; + var x = _v1.b; + return A2($elm$parser$Parser$Advanced$Bad, p, x); + } + }; + }); +var $elm$parser$Parser$Advanced$Empty = {$: 0}; +var $elm$parser$Parser$Advanced$Append = F2( + function (a, b) { + return {$: 2, a: a, b: b}; + }); +var $elm$parser$Parser$Advanced$oneOfHelp = F3( + function (s0, bag, parsers) { + oneOfHelp: + while (true) { + if (!parsers.b) { + return A2($elm$parser$Parser$Advanced$Bad, false, bag); + } else { + var parse = parsers.a; + var remainingParsers = parsers.b; + var _v1 = parse(s0); + if (!_v1.$) { + var step = _v1; + return step; + } else { + var step = _v1; + var p = step.a; + var x = step.b; + if (p) { + return step; + } else { + var $temp$s0 = s0, + $temp$bag = A2($elm$parser$Parser$Advanced$Append, bag, x), + $temp$parsers = remainingParsers; + s0 = $temp$s0; + bag = $temp$bag; + parsers = $temp$parsers; + continue oneOfHelp; + } + } + } + } + }); +var $elm$parser$Parser$Advanced$oneOf = function (parsers) { + return function (s) { + return A3($elm$parser$Parser$Advanced$oneOfHelp, s, $elm$parser$Parser$Advanced$Empty, parsers); + }; +}; +var $elm$parser$Parser$Advanced$Done = function (a) { + return {$: 1, a: a}; +}; +var $elm$parser$Parser$Advanced$Loop = function (a) { + return {$: 0, a: a}; +}; +var $elm$parser$Parser$Advanced$revAlways = F2( + function (_v0, b) { + return b; + }); +var $elm$parser$Parser$Advanced$skip = F2( + function (iParser, kParser) { + return A3($elm$parser$Parser$Advanced$map2, $elm$parser$Parser$Advanced$revAlways, iParser, kParser); + }); +var $elm$parser$Parser$Advanced$sequenceEndForbidden = F5( + function (ender, ws, parseItem, sep, revItems) { + var chompRest = function (item) { + return A5( + $elm$parser$Parser$Advanced$sequenceEndForbidden, + ender, + ws, + parseItem, + sep, + A2($elm$core$List$cons, item, revItems)); + }; + return A2( + $elm$parser$Parser$Advanced$skip, + ws, + $elm$parser$Parser$Advanced$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$Advanced$skip, + sep, + A2( + $elm$parser$Parser$Advanced$skip, + ws, + A2( + $elm$parser$Parser$Advanced$map, + function (item) { + return $elm$parser$Parser$Advanced$Loop( + A2($elm$core$List$cons, item, revItems)); + }, + parseItem))), + A2( + $elm$parser$Parser$Advanced$map, + function (_v0) { + return $elm$parser$Parser$Advanced$Done( + $elm$core$List$reverse(revItems)); + }, + ender) + ]))); + }); +var $elm$parser$Parser$Advanced$succeed = function (a) { + return function (s) { + return A3($elm$parser$Parser$Advanced$Good, false, a, s); + }; +}; +var $elm$parser$Parser$Advanced$sequenceEndMandatory = F4( + function (ws, parseItem, sep, revItems) { + return $elm$parser$Parser$Advanced$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$Advanced$map, + function (item) { + return $elm$parser$Parser$Advanced$Loop( + A2($elm$core$List$cons, item, revItems)); + }, + A2( + $elm$parser$Parser$Advanced$ignorer, + parseItem, + A2( + $elm$parser$Parser$Advanced$ignorer, + ws, + A2($elm$parser$Parser$Advanced$ignorer, sep, ws)))), + A2( + $elm$parser$Parser$Advanced$map, + function (_v0) { + return $elm$parser$Parser$Advanced$Done( + $elm$core$List$reverse(revItems)); + }, + $elm$parser$Parser$Advanced$succeed(0)) + ])); + }); +var $elm$parser$Parser$Advanced$sequenceEndOptional = F5( + function (ender, ws, parseItem, sep, revItems) { + var parseEnd = A2( + $elm$parser$Parser$Advanced$map, + function (_v0) { + return $elm$parser$Parser$Advanced$Done( + $elm$core$List$reverse(revItems)); + }, + ender); + return A2( + $elm$parser$Parser$Advanced$skip, + ws, + $elm$parser$Parser$Advanced$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$Advanced$skip, + sep, + A2( + $elm$parser$Parser$Advanced$skip, + ws, + $elm$parser$Parser$Advanced$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$Advanced$map, + function (item) { + return $elm$parser$Parser$Advanced$Loop( + A2($elm$core$List$cons, item, revItems)); + }, + parseItem), + parseEnd + ])))), + parseEnd + ]))); + }); +var $elm$parser$Parser$Advanced$sequenceEnd = F5( + function (ender, ws, parseItem, sep, trailing) { + var chompRest = function (item) { + switch (trailing) { + case 0: + return A2( + $elm$parser$Parser$Advanced$loop, + _List_fromArray( + [item]), + A4($elm$parser$Parser$Advanced$sequenceEndForbidden, ender, ws, parseItem, sep)); + case 1: + return A2( + $elm$parser$Parser$Advanced$loop, + _List_fromArray( + [item]), + A4($elm$parser$Parser$Advanced$sequenceEndOptional, ender, ws, parseItem, sep)); + default: + return A2( + $elm$parser$Parser$Advanced$ignorer, + A2( + $elm$parser$Parser$Advanced$skip, + ws, + A2( + $elm$parser$Parser$Advanced$skip, + sep, + A2( + $elm$parser$Parser$Advanced$skip, + ws, + A2( + $elm$parser$Parser$Advanced$loop, + _List_fromArray( + [item]), + A3($elm$parser$Parser$Advanced$sequenceEndMandatory, ws, parseItem, sep))))), + ender); + } + }; + return $elm$parser$Parser$Advanced$oneOf( + _List_fromArray( + [ + A2($elm$parser$Parser$Advanced$andThen, chompRest, parseItem), + A2( + $elm$parser$Parser$Advanced$map, + function (_v0) { + return _List_Nil; + }, + ender) + ])); + }); +var $elm$parser$Parser$Advanced$AddRight = F2( + function (a, b) { + return {$: 1, a: a, b: b}; + }); +var $elm$parser$Parser$Advanced$DeadEnd = F4( + function (row, col, problem, contextStack) { + return {aA: col, aB: contextStack, aU: problem, ak: row}; + }); +var $elm$parser$Parser$Advanced$fromState = F2( + function (s, x) { + return A2( + $elm$parser$Parser$Advanced$AddRight, + $elm$parser$Parser$Advanced$Empty, + A4($elm$parser$Parser$Advanced$DeadEnd, s.ak, s.aA, x, s.c)); + }); +var $elm$parser$Parser$Advanced$isSubString = _Parser_isSubString; +var $elm$core$Basics$negate = function (n) { + return -n; +}; +var $elm$core$Basics$not = _Basics_not; +var $elm$parser$Parser$Advanced$token = function (_v0) { + var str = _v0.a; + var expecting = _v0.b; + var progress = !$elm$core$String$isEmpty(str); + return function (s) { + var _v1 = A5($elm$parser$Parser$Advanced$isSubString, str, s.b, s.ak, s.aA, s.a); + var newOffset = _v1.a; + var newRow = _v1.b; + var newCol = _v1.c; + return _Utils_eq(newOffset, -1) ? A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : A3( + $elm$parser$Parser$Advanced$Good, + progress, + 0, + {aA: newCol, c: s.c, d: s.d, b: newOffset, ak: newRow, a: s.a}); + }; +}; +var $elm$parser$Parser$Advanced$sequence = function (i) { + return A2( + $elm$parser$Parser$Advanced$skip, + $elm$parser$Parser$Advanced$token(i.am), + A2( + $elm$parser$Parser$Advanced$skip, + i.aY, + A5( + $elm$parser$Parser$Advanced$sequenceEnd, + $elm$parser$Parser$Advanced$token(i.aE), + i.aY, + i.aO, + $elm$parser$Parser$Advanced$token(i.aX), + i.a$))); +}; +var $elm$parser$Parser$Advanced$Forbidden = 0; +var $elm$parser$Parser$Advanced$Mandatory = 2; +var $elm$parser$Parser$Advanced$Optional = 1; +var $elm$parser$Parser$toAdvancedTrailing = function (trailing) { + switch (trailing) { + case 0: + return 0; + case 1: + return 1; + default: + return 2; + } +}; +var $elm$parser$Parser$Expecting = function (a) { + return {$: 0, a: a}; +}; +var $elm$parser$Parser$Advanced$Token = F2( + function (a, b) { + return {$: 0, a: a, b: b}; + }); +var $elm$parser$Parser$toToken = function (str) { + return A2( + $elm$parser$Parser$Advanced$Token, + str, + $elm$parser$Parser$Expecting(str)); +}; +var $elm$parser$Parser$sequence = function (i) { + return $elm$parser$Parser$Advanced$sequence( + { + aE: $elm$parser$Parser$toToken(i.aE), + aO: i.aO, + aX: $elm$parser$Parser$toToken(i.aX), + aY: i.aY, + am: $elm$parser$Parser$toToken(i.am), + a$: $elm$parser$Parser$toAdvancedTrailing(i.a$) + }); +}; +var $elm$parser$Parser$Advanced$isSubChar = _Parser_isSubChar; +var $elm$parser$Parser$Advanced$chompWhileHelp = F5( + function (isGood, offset, row, col, s0) { + chompWhileHelp: + while (true) { + var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, offset, s0.a); + if (_Utils_eq(newOffset, -1)) { + return A3( + $elm$parser$Parser$Advanced$Good, + _Utils_cmp(s0.b, offset) < 0, + 0, + {aA: col, c: s0.c, d: s0.d, b: offset, ak: row, a: s0.a}); + } else { + if (_Utils_eq(newOffset, -2)) { + var $temp$isGood = isGood, + $temp$offset = offset + 1, + $temp$row = row + 1, + $temp$col = 1, + $temp$s0 = s0; + isGood = $temp$isGood; + offset = $temp$offset; + row = $temp$row; + col = $temp$col; + s0 = $temp$s0; + continue chompWhileHelp; + } else { + var $temp$isGood = isGood, + $temp$offset = newOffset, + $temp$row = row, + $temp$col = col + 1, + $temp$s0 = s0; + isGood = $temp$isGood; + offset = $temp$offset; + row = $temp$row; + col = $temp$col; + s0 = $temp$s0; + continue chompWhileHelp; + } + } + } + }); +var $elm$parser$Parser$Advanced$chompWhile = function (isGood) { + return function (s) { + return A5($elm$parser$Parser$Advanced$chompWhileHelp, isGood, s.b, s.ak, s.aA, s); + }; +}; +var $elm$parser$Parser$Advanced$spaces = $elm$parser$Parser$Advanced$chompWhile( + function (c) { + return (c === ' ') || ((c === '\n') || (c === '\r')); + }); +var $elm$parser$Parser$spaces = $elm$parser$Parser$Advanced$spaces; +var $elm$parser$Parser$succeed = $elm$parser$Parser$Advanced$succeed; +var $elm$parser$Parser$ExpectingSymbol = function (a) { + return {$: 8, a: a}; +}; +var $elm$parser$Parser$Advanced$symbol = $elm$parser$Parser$Advanced$token; +var $elm$parser$Parser$symbol = function (str) { + return $elm$parser$Parser$Advanced$symbol( + A2( + $elm$parser$Parser$Advanced$Token, + str, + $elm$parser$Parser$ExpectingSymbol(str))); +}; +var $elm$parser$Parser$ExpectingVariable = {$: 7}; +var $elm$core$Dict$get = F2( + function (targetKey, dict) { + get: + while (true) { + if (dict.$ === -2) { + 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 0: + var $temp$targetKey = targetKey, + $temp$dict = left; + targetKey = $temp$targetKey; + dict = $temp$dict; + continue get; + case 1: + return $elm$core$Maybe$Just(value); + default: + var $temp$targetKey = targetKey, + $temp$dict = right; + targetKey = $temp$targetKey; + dict = $temp$dict; + continue get; + } + } + } + }); +var $elm$core$Dict$member = F2( + function (key, dict) { + var _v0 = A2($elm$core$Dict$get, key, dict); + if (!_v0.$) { + return true; + } else { + return false; + } + }); +var $elm$core$Set$member = F2( + function (key, _v0) { + var dict = _v0; + return A2($elm$core$Dict$member, key, dict); + }); +var $elm$parser$Parser$Advanced$varHelp = F7( + function (isGood, offset, row, col, src, indent, context) { + varHelp: + while (true) { + var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, offset, src); + if (_Utils_eq(newOffset, -1)) { + return {aA: col, c: context, d: indent, b: offset, ak: row, a: src}; + } else { + if (_Utils_eq(newOffset, -2)) { + var $temp$isGood = isGood, + $temp$offset = offset + 1, + $temp$row = row + 1, + $temp$col = 1, + $temp$src = src, + $temp$indent = indent, + $temp$context = context; + isGood = $temp$isGood; + offset = $temp$offset; + row = $temp$row; + col = $temp$col; + src = $temp$src; + indent = $temp$indent; + context = $temp$context; + continue varHelp; + } else { + var $temp$isGood = isGood, + $temp$offset = newOffset, + $temp$row = row, + $temp$col = col + 1, + $temp$src = src, + $temp$indent = indent, + $temp$context = context; + isGood = $temp$isGood; + offset = $temp$offset; + row = $temp$row; + col = $temp$col; + src = $temp$src; + indent = $temp$indent; + context = $temp$context; + continue varHelp; + } + } + } + }); +var $elm$parser$Parser$Advanced$variable = function (i) { + return function (s) { + var firstOffset = A3($elm$parser$Parser$Advanced$isSubChar, i.am, s.b, s.a); + if (_Utils_eq(firstOffset, -1)) { + return A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, i.W)); + } else { + var s1 = _Utils_eq(firstOffset, -2) ? A7($elm$parser$Parser$Advanced$varHelp, i.aL, s.b + 1, s.ak + 1, 1, s.a, s.d, s.c) : A7($elm$parser$Parser$Advanced$varHelp, i.aL, firstOffset, s.ak, s.aA + 1, s.a, s.d, s.c); + var name = A3($elm$core$String$slice, s.b, s1.b, s.a); + return A2($elm$core$Set$member, name, i.aV) ? A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, i.W)) : A3($elm$parser$Parser$Advanced$Good, true, name, s1); + } + }; +}; +var $elm$parser$Parser$variable = function (i) { + return $elm$parser$Parser$Advanced$variable( + {W: $elm$parser$Parser$ExpectingVariable, aL: i.aL, aV: i.aV, am: i.am}); +}; +var $author$project$QCM$aRemplacer = A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed($author$project$QCM$Aremplacer), + $elm$parser$Parser$spaces), + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$variable( + { + aL: $elm$core$Char$isAlpha, + aV: $elm$core$Set$fromList(_List_Nil), + am: function (_v0) { + return true; + } + }), + $elm$parser$Parser$spaces), + $elm$parser$Parser$symbol(':'))), + $elm$parser$Parser$sequence( + { + aE: '', + aO: $elm$parser$Parser$variable( + { + aL: $elm$core$Basics$neq(','), + aV: $elm$core$Set$fromList(_List_Nil), + am: $elm$core$Basics$neq(',') + }), + aX: ',', + aY: $elm$parser$Parser$spaces, + am: '', + a$: 1 + })); +var $elm$parser$Parser$DeadEnd = F3( + function (row, col, problem) { + return {aA: col, aU: problem, ak: row}; + }); +var $elm$parser$Parser$problemToDeadEnd = function (p) { + return A3($elm$parser$Parser$DeadEnd, p.ak, p.aA, p.aU); +}; +var $elm$parser$Parser$Advanced$bagToList = F2( + function (bag, list) { + bagToList: + while (true) { + switch (bag.$) { + case 0: + return list; + case 1: + var bag1 = bag.a; + var x = bag.b; + var $temp$bag = bag1, + $temp$list = A2($elm$core$List$cons, x, list); + bag = $temp$bag; + list = $temp$list; + continue bagToList; + default: + var bag1 = bag.a; + var bag2 = bag.b; + var $temp$bag = bag1, + $temp$list = A2($elm$parser$Parser$Advanced$bagToList, bag2, list); + bag = $temp$bag; + list = $temp$list; + continue bagToList; + } + } + }); +var $elm$parser$Parser$Advanced$run = F2( + function (_v0, src) { + var parse = _v0; + var _v1 = parse( + {aA: 1, c: _List_Nil, d: 1, b: 0, ak: 1, a: src}); + if (!_v1.$) { + var value = _v1.b; + return $elm$core$Result$Ok(value); + } else { + var bag = _v1.b; + return $elm$core$Result$Err( + A2($elm$parser$Parser$Advanced$bagToList, bag, _List_Nil)); + } + }); +var $elm$parser$Parser$run = F2( + function (parser, source) { + var _v0 = A2($elm$parser$Parser$Advanced$run, parser, source); + if (!_v0.$) { + var a = _v0.a; + return $elm$core$Result$Ok(a); + } else { + var problems = _v0.a; + return $elm$core$Result$Err( + A2($elm$core$List$map, $elm$parser$Parser$problemToDeadEnd, problems)); + } + }); +var $author$project$QCM$parserAremplacer = function (variables) { + var _v0 = A2($elm$parser$Parser$run, $author$project$QCM$aRemplacer, variables); + if (!_v0.$) { + var ars = _v0.a; + return ars; + } else { + return A2($author$project$QCM$Aremplacer, '', _List_Nil); + } +}; +var $elm$parser$Parser$map = $elm$parser$Parser$Advanced$map; +var $elm$parser$Parser$toAdvancedStep = function (step) { + if (!step.$) { + var s = step.a; + return $elm$parser$Parser$Advanced$Loop(s); + } else { + var a = step.a; + return $elm$parser$Parser$Advanced$Done(a); + } +}; +var $elm$parser$Parser$loop = F2( + function (state, callback) { + return A2( + $elm$parser$Parser$Advanced$loop, + state, + function (s) { + return A2( + $elm$parser$Parser$map, + $elm$parser$Parser$toAdvancedStep, + callback(s)); + }); + }); +var $elm$parser$Parser$Done = function (a) { + return {$: 1, a: a}; +}; +var $elm$parser$Parser$Loop = function (a) { + return {$: 0, a: a}; +}; +var $author$project$QCM$Variable = function (a) { + return {$: 1, a: a}; +}; +var $elm$parser$Parser$Advanced$findSubString = _Parser_findSubString; +var $elm$parser$Parser$Advanced$fromInfo = F4( + function (row, col, x, context) { + return A2( + $elm$parser$Parser$Advanced$AddRight, + $elm$parser$Parser$Advanced$Empty, + A4($elm$parser$Parser$Advanced$DeadEnd, row, col, x, context)); + }); +var $elm$parser$Parser$Advanced$chompUntil = function (_v0) { + var str = _v0.a; + var expecting = _v0.b; + return function (s) { + var _v1 = A5($elm$parser$Parser$Advanced$findSubString, str, s.b, s.ak, s.aA, s.a); + var newOffset = _v1.a; + var newRow = _v1.b; + var newCol = _v1.c; + return _Utils_eq(newOffset, -1) ? A2( + $elm$parser$Parser$Advanced$Bad, + false, + A4($elm$parser$Parser$Advanced$fromInfo, newRow, newCol, expecting, s.c)) : A3( + $elm$parser$Parser$Advanced$Good, + _Utils_cmp(s.b, newOffset) < 0, + 0, + {aA: newCol, c: s.c, d: s.d, b: newOffset, ak: newRow, a: s.a}); + }; +}; +var $elm$parser$Parser$chompUntil = function (str) { + return $elm$parser$Parser$Advanced$chompUntil( + $elm$parser$Parser$toToken(str)); +}; +var $elm$parser$Parser$Advanced$mapChompedString = F2( + function (func, _v0) { + var parse = _v0; + return function (s0) { + var _v1 = parse(s0); + if (_v1.$ === 1) { + var p = _v1.a; + var x = _v1.b; + return A2($elm$parser$Parser$Advanced$Bad, p, x); + } else { + var p = _v1.a; + var a = _v1.b; + var s1 = _v1.c; + return A3( + $elm$parser$Parser$Advanced$Good, + p, + A2( + func, + A3($elm$core$String$slice, s0.b, s1.b, s0.a), + a), + s1); + } + }; + }); +var $elm$parser$Parser$Advanced$getChompedString = function (parser) { + return A2($elm$parser$Parser$Advanced$mapChompedString, $elm$core$Basics$always, parser); +}; +var $elm$parser$Parser$getChompedString = $elm$parser$Parser$Advanced$getChompedString; +var $author$project$QCM$expressionVariable = A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed($author$project$QCM$Variable), + $elm$parser$Parser$symbol('#')), + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$getChompedString( + $elm$parser$Parser$chompUntil('#')), + $elm$parser$Parser$symbol('#'))); +var $elm$parser$Parser$oneOf = $elm$parser$Parser$Advanced$oneOf; +var $author$project$QCM$Texte = function (a) { + return {$: 0, a: a}; +}; +var $elm$parser$Parser$UnexpectedChar = {$: 11}; +var $elm$parser$Parser$Advanced$chompIf = F2( + function (isGood, expecting) { + return function (s) { + var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, s.b, s.a); + return _Utils_eq(newOffset, -1) ? A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : (_Utils_eq(newOffset, -2) ? A3( + $elm$parser$Parser$Advanced$Good, + true, + 0, + {aA: 1, c: s.c, d: s.d, b: s.b + 1, ak: s.ak + 1, a: s.a}) : A3( + $elm$parser$Parser$Advanced$Good, + true, + 0, + {aA: s.aA + 1, c: s.c, d: s.d, b: newOffset, ak: s.ak, a: s.a})); + }; + }); +var $elm$parser$Parser$chompIf = function (isGood) { + return A2($elm$parser$Parser$Advanced$chompIf, isGood, $elm$parser$Parser$UnexpectedChar); +}; +var $elm$parser$Parser$chompWhile = $elm$parser$Parser$Advanced$chompWhile; +var $author$project$QCM$texteSansVariables = A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($author$project$QCM$Texte), + $elm$parser$Parser$getChompedString( + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed(0), + $elm$parser$Parser$chompIf( + $elm$core$Basics$neq('#'))), + $elm$parser$Parser$chompWhile( + $elm$core$Basics$neq('#'))))); +var $author$project$QCM$questionsBis = function (ls) { + return $elm$parser$Parser$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed( + function (l) { + return $elm$parser$Parser$Loop( + A2($elm$core$List$cons, l, ls)); + }), + $elm$parser$Parser$oneOf( + _List_fromArray( + [$author$project$QCM$expressionVariable, $author$project$QCM$texteSansVariables]))), + A2( + $elm$parser$Parser$map, + function (_v0) { + return $elm$parser$Parser$Done( + $elm$core$List$reverse(ls)); + }, + $elm$parser$Parser$succeed(0)) + ])); +}; +var $author$project$QCM$questions = A2($elm$parser$Parser$loop, _List_Nil, $author$project$QCM$questionsBis); +var $author$project$QCM$parserQuestion = function (question) { + var _v0 = A2($elm$parser$Parser$run, $author$project$QCM$questions, question); + if (!_v0.$) { + var macro = _v0.a; + return macro; + } else { + return _List_Nil; + } +}; +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 $elm$core$List$concat = function (lists) { + return A3($elm$core$List$foldr, $elm$core$List$append, _List_Nil, lists); +}; +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 $author$project$QCM$remplacerLaVariableParLaValeurDansLeTexteVariable = F3( + function (_var, val, tv) { + if (!tv.$) { + var chaine = tv.a; + return $author$project$QCM$Texte(chaine); + } else { + var chaine = tv.a; + return $author$project$QCM$Variable( + A3($elm$core$String$replace, _var, val, chaine)); + } + }); +var $author$project$QCM$remplacerLaVariableParLaValeurDansLaMacro = F3( + function (_var, val, macro) { + return A2( + $elm$core$List$map, + A2($author$project$QCM$remplacerLaVariableParLaValeurDansLeTexteVariable, _var, val), + macro); + }); +var $author$project$QCM$remplacerLaVariableDansLaMacro = F2( + function (ar, macro) { + var f = function (val) { + return A3($author$project$QCM$remplacerLaVariableParLaValeurDansLaMacro, ar.aq, val, macro); + }; + return A2($elm$core$List$map, f, ar.ap); + }); +var $author$project$QCM$remplacerLesVariablesDansLaMacroBis = F2( + function (ars, macros) { + if (!ars.b) { + return macros; + } else { + var ar = ars.a; + var arss = ars.b; + return A2( + $author$project$QCM$remplacerLesVariablesDansLaMacroBis, + arss, + $elm$core$List$concat( + A2( + $elm$core$List$map, + $author$project$QCM$remplacerLaVariableDansLaMacro(ar), + macros))); + } + }); +var $elm$core$String$concat = function (strings) { + return A2($elm$core$String$join, '', strings); +}; +var $author$project$Fractions$Frac = F2( + function (num, den) { + return {f: den, e: num}; + }); +var $elm$core$Basics$abs = function (n) { + return (n < 0) ? (-n) : n; +}; +var $elm$core$Basics$modBy = _Basics_modBy; +var $lynn$elm_arithmetic$Arithmetic$gcd = F2( + function (a, b) { + var gcd_ = F2( + function (x, y) { + gcd_: + while (true) { + if (!y) { + return x; + } else { + var $temp$x = y, + $temp$y = A2($elm$core$Basics$modBy, y, x); + x = $temp$x; + y = $temp$y; + continue gcd_; + } + } + }); + return A2( + gcd_, + $elm$core$Basics$abs(a), + $elm$core$Basics$abs(b)); + }); +var $author$project$Fractions$simplifier = function (a) { + var sgnDuDen = (a.f < 0) ? (-1) : 1; + var pgcd = A2($lynn$elm_arithmetic$Arithmetic$gcd, a.e, a.f); + return A2($author$project$Fractions$Frac, ((sgnDuDen * a.e) / pgcd) | 0, ((sgnDuDen * a.f) / pgcd) | 0); +}; +var $author$project$Fractions$add = F2( + function (a, b) { + return $author$project$Fractions$simplifier( + A2($author$project$Fractions$Frac, (a.e * b.f) + (a.f * b.e), a.f * b.f)); + }); +var $author$project$Fractions$inv = function (a) { + return $author$project$Fractions$simplifier( + A2($author$project$Fractions$Frac, a.f, a.e)); +}; +var $author$project$Fractions$mul = F2( + function (a, b) { + return $author$project$Fractions$simplifier( + A2($author$project$Fractions$Frac, a.e * b.e, a.f * b.f)); + }); +var $author$project$Fractions$div = F2( + function (a, b) { + return $author$project$Fractions$simplifier( + A2( + $author$project$Fractions$mul, + a, + $author$project$Fractions$inv(b))); + }); +var $elm$core$Basics$pow = _Basics_pow; +var $author$project$Fractions$exp = F2( + function (a, b) { + var bb = $author$project$Fractions$simplifier(b); + var sgnDeB = (bb.e < 0) ? (-1) : 1; + var aa = $author$project$Fractions$simplifier(a); + var sgnDeA = (aa.e < 0) ? (-1) : 1; + return ((bb.f === 1) && (bb.e < 0)) ? $elm$core$Maybe$Just( + A2( + $author$project$Fractions$Frac, + A2($elm$core$Basics$pow, sgnDeA * aa.f, sgnDeB * bb.e), + A2($elm$core$Basics$pow, sgnDeA * aa.e, sgnDeB * bb.e))) : ((bb.f === 1) ? $elm$core$Maybe$Just( + A2( + $author$project$Fractions$Frac, + A2($elm$core$Basics$pow, aa.e, bb.e), + A2($elm$core$Basics$pow, aa.f, bb.e))) : $elm$core$Maybe$Nothing); + }); +var $elm$core$Maybe$map = F2( + function (f, maybe) { + if (!maybe.$) { + var value = maybe.a; + return $elm$core$Maybe$Just( + f(value)); + } else { + return $elm$core$Maybe$Nothing; + } + }); +var $elm$core$Maybe$map2 = F3( + function (func, ma, mb) { + if (ma.$ === 1) { + return $elm$core$Maybe$Nothing; + } else { + var a = ma.a; + if (mb.$ === 1) { + return $elm$core$Maybe$Nothing; + } else { + var b = mb.a; + return $elm$core$Maybe$Just( + A2(func, a, b)); + } + } + }); +var $author$project$Fractions$neg = function (a) { + return $author$project$Fractions$simplifier( + A2($author$project$Fractions$Frac, -a.e, a.f)); +}; +var $author$project$Fractions$sub = F2( + function (a, b) { + return $author$project$Fractions$simplifier( + A2( + $author$project$Fractions$add, + a, + $author$project$Fractions$neg(b))); + }); +var $author$project$ParserMaths$evaluer = function (expression) { + evaluer: + while (true) { + switch (expression.$) { + case 0: + var a = expression.a; + var b = expression.b; + return A3( + $elm$core$Maybe$map2, + $author$project$Fractions$add, + $author$project$ParserMaths$evaluer(a), + $author$project$ParserMaths$evaluer(b)); + case 1: + var a = expression.a; + var b = expression.b; + return A3( + $elm$core$Maybe$map2, + $author$project$Fractions$sub, + $author$project$ParserMaths$evaluer(a), + $author$project$ParserMaths$evaluer(b)); + case 2: + var a = expression.a; + var b = expression.b; + return A3( + $elm$core$Maybe$map2, + $author$project$Fractions$mul, + $author$project$ParserMaths$evaluer(a), + $author$project$ParserMaths$evaluer(b)); + case 3: + var a = expression.a; + var b = expression.b; + return A3( + $elm$core$Maybe$map2, + $author$project$Fractions$div, + $author$project$ParserMaths$evaluer(a), + $author$project$ParserMaths$evaluer(b)); + case 4: + var a = expression.a; + var b = expression.b; + var _v1 = A3( + $elm$core$Maybe$map2, + $author$project$Fractions$exp, + $author$project$ParserMaths$evaluer(a), + $author$project$ParserMaths$evaluer(b)); + if (_v1.$ === 1) { + return $elm$core$Maybe$Nothing; + } else { + var p = _v1.a; + return p; + } + case 5: + var a = expression.a; + return A2( + $elm$core$Maybe$map, + $author$project$Fractions$neg, + $author$project$ParserMaths$evaluer(a)); + case 7: + var l = expression.a; + var $temp$expression = l; + expression = $temp$expression; + continue evaluer; + case 6: + var n = expression.a; + return $elm$core$Maybe$Just( + A2($author$project$Fractions$Frac, n, 1)); + default: + var a_i = expression.a; + var x = expression.b; + return $elm$core$Maybe$Just( + A2($author$project$Fractions$Frac, 50, 1)); + } + } +}; +var $author$project$ParserMaths$AddOp = 2; +var $author$project$ParserMaths$DivOp = 1; +var $author$project$ParserMaths$ExpOp = 4; +var $elm$parser$Parser$Forbidden = 0; +var $author$project$ParserMaths$Grouping = function (a) { + return {$: 7, a: a}; +}; +var $author$project$ParserMaths$MulOp = 0; +var $author$project$ParserMaths$Neg = function (a) { + return {$: 5, a: a}; +}; +var $author$project$ParserMaths$NoOperand = {$: 0}; +var $author$project$ParserMaths$Operand = F2( + function (a, b) { + return {$: 1, a: a, b: b}; + }); +var $author$project$ParserMaths$Poly = F2( + function (a, b) { + return {$: 8, a: a, b: b}; + }); +var $author$project$ParserMaths$SubOp = 3; +var $author$project$ParserMaths$Add = F2( + function (a, b) { + return {$: 0, a: a, b: b}; + }); +var $author$project$ParserMaths$Div = F2( + function (a, b) { + return {$: 3, a: a, b: b}; + }); +var $author$project$ParserMaths$Exp = F2( + function (a, b) { + return {$: 4, a: a, b: b}; + }); +var $author$project$ParserMaths$Mul = F2( + function (a, b) { + return {$: 2, a: a, b: b}; + }); +var $author$project$ParserMaths$Sub = F2( + function (a, b) { + return {$: 1, a: a, b: b}; + }); +var $author$project$ParserMaths$binary = F2( + function (a, b) { + if (!b.$) { + return a; + } else { + var op = b.a; + var e = b.b; + switch (op) { + case 0: + return A2($author$project$ParserMaths$Mul, a, e); + case 1: + return A2($author$project$ParserMaths$Div, a, e); + case 2: + return A2($author$project$ParserMaths$Add, a, e); + case 3: + return A2($author$project$ParserMaths$Sub, a, e); + default: + return A2($author$project$ParserMaths$Exp, a, e); + } + } + }); +var $author$project$ParserMaths$foldBinary = F2( + function (left, operands) { return A3( $elm$core$List$foldr, F2( - function (x, acc) { - return A2( - $elm$core$List$cons, - f(x), - acc); + function (operand, expression) { + return A2($author$project$ParserMaths$binary, expression, operand); }), - _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); + left, + operands); }); -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); +var $elm$parser$Parser$ExpectingKeyword = function (a) { + return {$: 9, a: a}; +}; +var $elm$parser$Parser$Advanced$keyword = function (_v0) { + var kwd = _v0.a; + var expecting = _v0.b; + var progress = !$elm$core$String$isEmpty(kwd); + return function (s) { + var _v1 = A5($elm$parser$Parser$Advanced$isSubString, kwd, s.b, s.ak, s.aA, s.a); + var newOffset = _v1.a; + var newRow = _v1.b; + var newCol = _v1.c; + return (_Utils_eq(newOffset, -1) || (0 <= A3( + $elm$parser$Parser$Advanced$isSubChar, + function (c) { + return $elm$core$Char$isAlphaNum(c) || (c === '_'); }, - 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); + newOffset, + s.a))) ? A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : A3( + $elm$parser$Parser$Advanced$Good, + progress, + 0, + {aA: newCol, c: s.c, d: s.d, b: newOffset, ak: newRow, a: s.a}); + }; }; -var $elm$core$Platform$sendToApp = _Platform_sendToApp; -var $elm$core$Task$spawnCmd = F2( - function (router, _v0) { - var task = _v0; - return _Scheduler_spawn( - A2( - $elm$core$Task$andThen, - $elm$core$Platform$sendToApp(router), - task)); +var $elm$parser$Parser$keyword = function (kwd) { + return $elm$parser$Parser$Advanced$keyword( + A2( + $elm$parser$Parser$Advanced$Token, + kwd, + $elm$parser$Parser$ExpectingKeyword(kwd))); +}; +var $elm$parser$Parser$Advanced$lazy = function (thunk) { + return function (s) { + var _v0 = thunk(0); + var parse = _v0; + return parse(s); + }; +}; +var $elm$parser$Parser$lazy = $elm$parser$Parser$Advanced$lazy; +var $author$project$ParserMaths$Entier = function (a) { + return {$: 6, a: a}; +}; +var $elm$parser$Parser$ExpectingBinary = {$: 4}; +var $elm$parser$Parser$ExpectingFloat = {$: 5}; +var $elm$parser$Parser$ExpectingHex = {$: 2}; +var $elm$parser$Parser$ExpectingInt = {$: 1}; +var $elm$parser$Parser$ExpectingNumber = {$: 6}; +var $elm$parser$Parser$ExpectingOctal = {$: 3}; +var $elm$core$Result$fromMaybe = F2( + function (err, maybe) { + if (!maybe.$) { + var v = maybe.a; + return $elm$core$Result$Ok(v); + } else { + return $elm$core$Result$Err(err); + } }); -var $elm$core$Task$onEffects = F3( - function (router, commands, state) { - return A2( - $elm$core$Task$map, - function (_v0) { - return 0; - }, - $elm$core$Task$sequence( - A2( - $elm$core$List$map, - $elm$core$Task$spawnCmd(router), - commands))); +var $elm$parser$Parser$Advanced$consumeBase = _Parser_consumeBase; +var $elm$parser$Parser$Advanced$consumeBase16 = _Parser_consumeBase16; +var $elm$parser$Parser$Advanced$bumpOffset = F2( + function (newOffset, s) { + return {aA: s.aA + (newOffset - s.b), c: s.c, d: s.d, b: newOffset, ak: s.ak, a: s.a}; }); -var $elm$core$Task$onSelfMsg = F3( - function (_v0, _v1, _v2) { - return $elm$core$Task$succeed(0); +var $elm$parser$Parser$Advanced$chompBase10 = _Parser_chompBase10; +var $elm$parser$Parser$Advanced$isAsciiCode = _Parser_isAsciiCode; +var $elm$parser$Parser$Advanced$consumeExp = F2( + function (offset, src) { + if (A3($elm$parser$Parser$Advanced$isAsciiCode, 101, offset, src) || A3($elm$parser$Parser$Advanced$isAsciiCode, 69, offset, src)) { + var eOffset = offset + 1; + var expOffset = (A3($elm$parser$Parser$Advanced$isAsciiCode, 43, eOffset, src) || A3($elm$parser$Parser$Advanced$isAsciiCode, 45, eOffset, src)) ? (eOffset + 1) : eOffset; + var newOffset = A2($elm$parser$Parser$Advanced$chompBase10, expOffset, src); + return _Utils_eq(expOffset, newOffset) ? (-newOffset) : newOffset; + } else { + return offset; + } }); -var $elm$core$Task$cmdMap = F2( - function (tagger, _v0) { - var task = _v0; - return A2($elm$core$Task$map, tagger, task); +var $elm$parser$Parser$Advanced$consumeDotAndExp = F2( + function (offset, src) { + return A3($elm$parser$Parser$Advanced$isAsciiCode, 46, offset, src) ? A2( + $elm$parser$Parser$Advanced$consumeExp, + A2($elm$parser$Parser$Advanced$chompBase10, offset + 1, src), + src) : A2($elm$parser$Parser$Advanced$consumeExp, offset, src); }); -_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( - A2($elm$core$Task$map, toMessage, task)); +var $elm$parser$Parser$Advanced$finalizeInt = F5( + function (invalid, handler, startOffset, _v0, s) { + var endOffset = _v0.a; + var n = _v0.b; + if (handler.$ === 1) { + var x = handler.a; + return A2( + $elm$parser$Parser$Advanced$Bad, + true, + A2($elm$parser$Parser$Advanced$fromState, s, x)); + } else { + var toValue = handler.a; + return _Utils_eq(startOffset, endOffset) ? A2( + $elm$parser$Parser$Advanced$Bad, + _Utils_cmp(s.b, startOffset) < 0, + A2($elm$parser$Parser$Advanced$fromState, s, invalid)) : A3( + $elm$parser$Parser$Advanced$Good, + true, + toValue(n), + A2($elm$parser$Parser$Advanced$bumpOffset, endOffset, s)); + } }); -var $elm$core$Platform$Cmd$batch = _Platform_batch; -var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil); -var $elm$core$Platform$Sub$batch = _Platform_batch; -var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil); -var $elm$browser$Browser$sandbox = function (impl) { - return _Browser_element( +var $elm$core$String$toFloat = _String_toFloat; +var $elm$parser$Parser$Advanced$finalizeFloat = F6( + function (invalid, expecting, intSettings, floatSettings, intPair, s) { + var intOffset = intPair.a; + var floatOffset = A2($elm$parser$Parser$Advanced$consumeDotAndExp, intOffset, s.a); + if (floatOffset < 0) { + return A2( + $elm$parser$Parser$Advanced$Bad, + true, + A4($elm$parser$Parser$Advanced$fromInfo, s.ak, s.aA - (floatOffset + s.b), invalid, s.c)); + } else { + if (_Utils_eq(s.b, floatOffset)) { + return A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, expecting)); + } else { + if (_Utils_eq(intOffset, floatOffset)) { + return A5($elm$parser$Parser$Advanced$finalizeInt, invalid, intSettings, s.b, intPair, s); + } else { + if (floatSettings.$ === 1) { + var x = floatSettings.a; + return A2( + $elm$parser$Parser$Advanced$Bad, + true, + A2($elm$parser$Parser$Advanced$fromState, s, invalid)); + } else { + var toValue = floatSettings.a; + var _v1 = $elm$core$String$toFloat( + A3($elm$core$String$slice, s.b, floatOffset, s.a)); + if (_v1.$ === 1) { + return A2( + $elm$parser$Parser$Advanced$Bad, + true, + A2($elm$parser$Parser$Advanced$fromState, s, invalid)); + } else { + var n = _v1.a; + return A3( + $elm$parser$Parser$Advanced$Good, + true, + toValue(n), + A2($elm$parser$Parser$Advanced$bumpOffset, floatOffset, s)); + } + } + } + } + } + }); +var $elm$parser$Parser$Advanced$number = function (c) { + return function (s) { + if (A3($elm$parser$Parser$Advanced$isAsciiCode, 48, s.b, s.a)) { + var zeroOffset = s.b + 1; + var baseOffset = zeroOffset + 1; + return A3($elm$parser$Parser$Advanced$isAsciiCode, 120, zeroOffset, s.a) ? A5( + $elm$parser$Parser$Advanced$finalizeInt, + c.aN, + c.aH, + baseOffset, + A2($elm$parser$Parser$Advanced$consumeBase16, baseOffset, s.a), + s) : (A3($elm$parser$Parser$Advanced$isAsciiCode, 111, zeroOffset, s.a) ? A5( + $elm$parser$Parser$Advanced$finalizeInt, + c.aN, + c.aQ, + baseOffset, + A3($elm$parser$Parser$Advanced$consumeBase, 8, baseOffset, s.a), + s) : (A3($elm$parser$Parser$Advanced$isAsciiCode, 98, zeroOffset, s.a) ? A5( + $elm$parser$Parser$Advanced$finalizeInt, + c.aN, + c.ax, + baseOffset, + A3($elm$parser$Parser$Advanced$consumeBase, 2, baseOffset, s.a), + s) : A6( + $elm$parser$Parser$Advanced$finalizeFloat, + c.aN, + c.W, + c.aM, + c.aG, + _Utils_Tuple2(zeroOffset, 0), + s))); + } else { + return A6( + $elm$parser$Parser$Advanced$finalizeFloat, + c.aN, + c.W, + c.aM, + c.aG, + A3($elm$parser$Parser$Advanced$consumeBase, 10, s.b, s.a), + s); + } + }; +}; +var $elm$parser$Parser$number = function (i) { + return $elm$parser$Parser$Advanced$number( { - at: function (_v0) { - return _Utils_Tuple2(impl.at, $elm$core$Platform$Cmd$none); - }, - az: function (_v1) { - return $elm$core$Platform$Sub$none; - }, - aB: F2( - function (msg, model) { - return _Utils_Tuple2( - A2(impl.aB, msg, model), - $elm$core$Platform$Cmd$none); - }), - aC: impl.aC + ax: A2($elm$core$Result$fromMaybe, $elm$parser$Parser$ExpectingBinary, i.ax), + W: $elm$parser$Parser$ExpectingNumber, + aG: A2($elm$core$Result$fromMaybe, $elm$parser$Parser$ExpectingFloat, i.aG), + aH: A2($elm$core$Result$fromMaybe, $elm$parser$Parser$ExpectingHex, i.aH), + aM: A2($elm$core$Result$fromMaybe, $elm$parser$Parser$ExpectingInt, i.aM), + aN: $elm$parser$Parser$ExpectingNumber, + aQ: A2($elm$core$Result$fromMaybe, $elm$parser$Parser$ExpectingOctal, i.aQ) }); }; -var $author$project$Main$update = F2( - function (msg, model) { - if (!msg) { - return model + 1; +var $author$project$ParserMaths$nombre = A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($author$project$ParserMaths$Entier), + $elm$parser$Parser$number( + { + ax: $elm$core$Maybe$Nothing, + aG: $elm$core$Maybe$Nothing, + aH: $elm$core$Maybe$Nothing, + aM: $elm$core$Maybe$Just($elm$core$Basics$identity), + aQ: $elm$core$Maybe$Nothing + })); +var $author$project$ParserMaths$addHelper = function (operands) { + return $elm$parser$Parser$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed( + function (right) { + return $elm$parser$Parser$Loop( + A2( + $elm$core$List$cons, + A2($author$project$ParserMaths$Operand, 2, right), + operands)); + }), + $elm$parser$Parser$symbol('+')), + $elm$parser$Parser$spaces), + $elm$parser$Parser$lazy( + function (_v9) { + return $author$project$ParserMaths$cyclic$mul(); + })), + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed( + function (right) { + return $elm$parser$Parser$Loop( + A2( + $elm$core$List$cons, + A2($author$project$ParserMaths$Operand, 3, right), + operands)); + }), + $elm$parser$Parser$symbol('-')), + $elm$parser$Parser$spaces), + $elm$parser$Parser$lazy( + function (_v10) { + return $author$project$ParserMaths$cyclic$mul(); + })), + A2( + $elm$parser$Parser$map, + function (_v11) { + return $elm$parser$Parser$Done(operands); + }, + $elm$parser$Parser$succeed(0)) + ])); +}; +var $author$project$ParserMaths$mulHelper = function (operands) { + return $elm$parser$Parser$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed( + function (right) { + return $elm$parser$Parser$Loop( + A2( + $elm$core$List$cons, + A2($author$project$ParserMaths$Operand, 0, right), + operands)); + }), + $elm$parser$Parser$symbol('*')), + $elm$parser$Parser$spaces), + $elm$parser$Parser$lazy( + function (_v3) { + return $author$project$ParserMaths$cyclic$exp(); + })), + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed( + function (right) { + return $elm$parser$Parser$Loop( + A2( + $elm$core$List$cons, + A2($author$project$ParserMaths$Operand, 1, right), + operands)); + }), + $elm$parser$Parser$symbol('/')), + $elm$parser$Parser$spaces), + $elm$parser$Parser$lazy( + function (_v4) { + return $author$project$ParserMaths$cyclic$exp(); + })), + A2( + $elm$parser$Parser$map, + function (_v5) { + return $elm$parser$Parser$Done(operands); + }, + $elm$parser$Parser$succeed(0)) + ])); +}; +function $author$project$ParserMaths$cyclic$expr() { + return $author$project$ParserMaths$cyclic$add(); +} +function $author$project$ParserMaths$cyclic$add() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($author$project$ParserMaths$foldBinary), + A2( + $elm$parser$Parser$ignorer, + $author$project$ParserMaths$cyclic$mul(), + $elm$parser$Parser$spaces)), + A2($elm$parser$Parser$loop, _List_Nil, $author$project$ParserMaths$addHelper)); +} +function $author$project$ParserMaths$cyclic$mul() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($author$project$ParserMaths$foldBinary), + A2( + $elm$parser$Parser$ignorer, + $author$project$ParserMaths$cyclic$exp(), + $elm$parser$Parser$spaces)), + A2($elm$parser$Parser$loop, _List_Nil, $author$project$ParserMaths$mulHelper)); +} +function $author$project$ParserMaths$cyclic$exp() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($author$project$ParserMaths$binary), + A2( + $elm$parser$Parser$ignorer, + $author$project$ParserMaths$cyclic$primary(), + $elm$parser$Parser$spaces)), + $elm$parser$Parser$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed( + $author$project$ParserMaths$Operand(4)), + $elm$parser$Parser$symbol('^')), + $elm$parser$Parser$spaces), + $elm$parser$Parser$lazy( + function (_v8) { + return $author$project$ParserMaths$cyclic$exp(); + })), + $elm$parser$Parser$succeed($author$project$ParserMaths$NoOperand) + ]))); +} +function $author$project$ParserMaths$cyclic$primary() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed( + F2( + function (op, literal) { + if (op.$ === 1) { + return literal; + } else { + return $author$project$ParserMaths$Neg(literal); + } + })), + $elm$parser$Parser$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($elm$core$Maybe$Just), + $elm$parser$Parser$symbol('-')), + $elm$parser$Parser$succeed($elm$core$Maybe$Nothing) + ]))), + $elm$parser$Parser$oneOf( + _List_fromArray( + [ + $author$project$ParserMaths$cyclic$grouping(), + $author$project$ParserMaths$cyclic$poly(), + $author$project$ParserMaths$nombre + ]))); +} +function $author$project$ParserMaths$cyclic$grouping() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed($author$project$ParserMaths$Grouping), + $elm$parser$Parser$symbol('(')), + $elm$parser$Parser$spaces), + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$lazy( + function (_v6) { + return $author$project$ParserMaths$cyclic$expr(); + }), + $elm$parser$Parser$spaces), + $elm$parser$Parser$symbol(')'))); +} +function $author$project$ParserMaths$cyclic$poly() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed($author$project$ParserMaths$Poly), + $elm$parser$Parser$keyword('Poly')), + $elm$parser$Parser$spaces), + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$sequence( + { + aE: ']', + aO: $elm$parser$Parser$lazy( + function (_v0) { + return $author$project$ParserMaths$cyclic$expr(); + }), + aX: ',', + aY: $elm$parser$Parser$spaces, + am: '[', + a$: 0 + }), + $elm$parser$Parser$spaces)), + $elm$parser$Parser$variable( + { + aL: function (_v1) { + return false; + }, + aV: $elm$core$Set$fromList(_List_Nil), + am: function (_v2) { + return true; + } + })); +} +var $author$project$ParserMaths$expr = $author$project$ParserMaths$cyclic$expr(); +$author$project$ParserMaths$cyclic$expr = function () { + return $author$project$ParserMaths$expr; +}; +var $author$project$ParserMaths$add = $author$project$ParserMaths$cyclic$add(); +$author$project$ParserMaths$cyclic$add = function () { + return $author$project$ParserMaths$add; +}; +var $author$project$ParserMaths$mul = $author$project$ParserMaths$cyclic$mul(); +$author$project$ParserMaths$cyclic$mul = function () { + return $author$project$ParserMaths$mul; +}; +var $author$project$ParserMaths$exp = $author$project$ParserMaths$cyclic$exp(); +$author$project$ParserMaths$cyclic$exp = function () { + return $author$project$ParserMaths$exp; +}; +var $author$project$ParserMaths$primary = $author$project$ParserMaths$cyclic$primary(); +$author$project$ParserMaths$cyclic$primary = function () { + return $author$project$ParserMaths$primary; +}; +var $author$project$ParserMaths$grouping = $author$project$ParserMaths$cyclic$grouping(); +$author$project$ParserMaths$cyclic$grouping = function () { + return $author$project$ParserMaths$grouping; +}; +var $author$project$ParserMaths$poly = $author$project$ParserMaths$cyclic$poly(); +$author$project$ParserMaths$cyclic$poly = function () { + return $author$project$ParserMaths$poly; +}; +var $author$project$ParserMaths$parseMaths = function (source) { + return A2($elm$parser$Parser$run, $author$project$ParserMaths$expr, source); +}; +var $author$project$Fractions$teX = function (a) { + var _v0 = a.f; + if (_v0 === 1) { + return $elm$core$String$fromInt(a.e); + } else { + return (a.e < 0) ? ('-\\frac{' + ($elm$core$String$fromInt(-a.e) + ('}{' + ($elm$core$String$fromInt(a.f) + '}')))) : ('\\frac{' + ($elm$core$String$fromInt(a.e) + ('}{' + ($elm$core$String$fromInt(a.f) + '}')))); + } +}; +var $author$project$QCM$voirTexteVariable = function (txtvar) { + if (!txtvar.$) { + var txt = txtvar.a; + return txt; + } else { + var _var = txtvar.a; + var expressionParseePotentielle = $author$project$ParserMaths$parseMaths(_var); + if (expressionParseePotentielle.$ === 1) { + var erreur = expressionParseePotentielle.a; + return 'L\'expression est mal formée.'; } else { - return model - 1; + var expressionParsee = expressionParseePotentielle.a; + var _v2 = A2( + $elm$core$Maybe$map, + $author$project$Fractions$teX, + $author$project$ParserMaths$evaluer(expressionParsee)); + if (!_v2.$) { + var a = _v2.a; + return a; + } else { + return 'Les puissances non-entières ne sont pas acceptées.'; + } + } + } +}; +var $author$project$QCM$voirMacro = function (macro) { + return $elm$core$String$concat( + A2($elm$core$List$map, $author$project$QCM$voirTexteVariable, macro)); +}; +var $author$project$QCM$remplacerLesVariablesDansLaMacro = F2( + function (ars, macro) { + return A2( + $elm$core$List$map, + $author$project$QCM$voirMacro, + A2( + $author$project$QCM$remplacerLesVariablesDansLaMacroBis, + ars, + _List_fromArray( + [macro]))); + }); +var $author$project$QCM$remplacer = F2( + function (variables, question) { + var macro = $author$project$QCM$parserQuestion(question); + var ars = A2( + $elm$core$List$map, + $author$project$QCM$parserAremplacer, + $elm$core$String$lines(variables)); + return A2($author$project$QCM$remplacerLesVariablesDansLaMacro, ars, macro); + }); +var $author$project$QCM$update = F2( + function (msg, model) { + switch (msg.$) { + case 0: + var nouvelleQuestion = msg.a; + return _Utils_update( + model, + {G: nouvelleQuestion}); + case 1: + var nouvellesVariables = msg.a; + return _Utils_update( + model, + {L: nouvellesVariables}); + default: + return _Utils_update( + model, + { + M: A2($author$project$QCM$remplacer, model.L, model.G) + }); } }); -var $author$project$Main$Decrement = 1; -var $author$project$Main$Increment = 0; +var $author$project$QCM$GenererQuestion = {$: 2}; +var $author$project$QCM$Question = function (a) { + return {$: 0, a: a}; +}; +var $author$project$QCM$Variables = function (a) { + return {$: 1, a: a}; +}; var $elm$html$Html$button = _VirtualDom_node('button'); var $elm$html$Html$div = _VirtualDom_node('div'); var $elm$virtual_dom$VirtualDom$Normal = function (a) { @@ -5203,50 +7264,116 @@ var $elm$html$Html$Events$onClick = function (msg) { 'click', $elm$json$Json$Decode$succeed(msg)); }; +var $elm$html$Html$Events$alwaysStop = function (x) { + return _Utils_Tuple2(x, true); +}; +var $elm$virtual_dom$VirtualDom$MayStopPropagation = function (a) { + return {$: 1, a: a}; +}; +var $elm$html$Html$Events$stopPropagationOn = F2( + function (event, decoder) { + return A2( + $elm$virtual_dom$VirtualDom$on, + event, + $elm$virtual_dom$VirtualDom$MayStopPropagation(decoder)); + }); +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$string = _Json_decodeString; +var $elm$html$Html$Events$targetValue = A2( + $elm$json$Json$Decode$at, + _List_fromArray( + ['target', 'value']), + $elm$json$Json$Decode$string); +var $elm$html$Html$Events$onInput = function (tagger) { + return A2( + $elm$html$Html$Events$stopPropagationOn, + 'input', + A2( + $elm$json$Json$Decode$map, + $elm$html$Html$Events$alwaysStop, + A2($elm$json$Json$Decode$map, tagger, $elm$html$Html$Events$targetValue))); +}; +var $elm$html$Html$p = _VirtualDom_node('p'); +var $elm$json$Json$Encode$string = _Json_wrap; +var $elm$html$Html$Attributes$stringProperty = F2( + function (key, string) { + return A2( + _VirtualDom_property, + key, + $elm$json$Json$Encode$string(string)); + }); +var $elm$html$Html$Attributes$placeholder = $elm$html$Html$Attributes$stringProperty('placeholder'); var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text; var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text; -var $author$project$Main$view = function (model) { +var $elm$html$Html$textarea = _VirtualDom_node('textarea'); +var $elm$html$Html$Attributes$value = $elm$html$Html$Attributes$stringProperty('value'); +var $author$project$QCM$view = function (model) { return A2( $elm$html$Html$div, _List_Nil, - _List_fromArray( - [ - A2( - $elm$html$Html$button, + A2( + $elm$core$List$cons, + A2( + $elm$html$Html$textarea, _List_fromArray( [ - $elm$html$Html$Events$onClick(1) + $elm$html$Html$Attributes$placeholder('Liste des variables'), + $elm$html$Html$Attributes$value(model.L), + $elm$html$Html$Events$onInput($author$project$QCM$Variables) ]), - _List_fromArray( - [ - $elm$html$Html$text('-') - ])), + _List_Nil), + A2( + $elm$core$List$cons, A2( - $elm$html$Html$div, - _List_Nil, - _List_fromArray( - [ - $elm$html$Html$text( - $elm$core$String$fromInt(model)) - ])), + $elm$html$Html$textarea, + _List_fromArray( + [ + $elm$html$Html$Attributes$placeholder('Format de la question'), + $elm$html$Html$Attributes$value(model.G), + $elm$html$Html$Events$onInput($author$project$QCM$Question) + ]), + _List_Nil), A2( - $elm$html$Html$button, - _List_fromArray( - [ - $elm$html$Html$Events$onClick(0) - ]), - _List_fromArray( - [ - $elm$html$Html$text('+') - ])) - ])); + $elm$core$List$cons, + A2( + $elm$html$Html$button, + _List_fromArray( + [ + $elm$html$Html$Events$onClick($author$project$QCM$GenererQuestion) + ]), + _List_fromArray( + [ + $elm$html$Html$text('Générer les questions') + ])), + _List_fromArray( + [ + A2( + $elm$html$Html$p, + _List_Nil, + A2( + $elm$core$List$map, + function (q) { + return A2( + $elm$html$Html$p, + _List_Nil, + _List_fromArray( + [ + $elm$html$Html$text(q) + ])); + }, + model.M)) + ]))))); }; -var $author$project$Main$main = $elm$browser$Browser$sandbox( - {at: $author$project$Main$init, aB: $author$project$Main$update, aC: $author$project$Main$view}); -_Platform_export({'Main':{'init':$author$project$Main$main( +var $author$project$QCM$main = $elm$browser$Browser$sandbox( + {aK: $author$project$QCM$init, a0: $author$project$QCM$update, a1: $author$project$QCM$view}); +_Platform_export({'QCM':{'init':$author$project$QCM$main( $elm$json$Json$Decode$succeed(0))(0)}});}(this)); - var app = Elm.Main.init({ node: document.getElementById("elm") }); + var app = Elm.QCM.init({ node: document.getElementById("elm") }); } catch (e) { diff --git a/qcm.js b/qcm.js new file mode 100644 index 0000000..c859210 --- /dev/null +++ b/qcm.js @@ -0,0 +1,7360 @@ +(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); +} + + + + +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 = F2(function(tag, value) +{ + return value; +}); + +var _Debug_log_UNUSED = 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(value) +{ + return ''; +} + +function _Debug_toString_UNUSED(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(identifier) +{ + throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md'); +} + + +function _Debug_crash_UNUSED(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.am.F === region.aE.F) + { + return 'on line ' + region.am.F; + } + return 'on lines ' + region.am.F + ' through ' + region.aE.F; +} + + + +// 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; + } + + /**_UNUSED/ + 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); + } + //*/ + + /**/ + 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; + } + + /**_UNUSED/ + if (x instanceof String) + { + var a = x.valueOf(); + var b = y.valueOf(); + return a === b ? 0 : a < b ? -1 : 1; + } + //*/ + + /**/ + if (typeof x.$ === 'undefined') + //*/ + /**_UNUSED/ + 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 = 0; +var _Utils_Tuple0_UNUSED = { $: '#0' }; + +function _Utils_Tuple2(a, b) { return { a: a, b: b }; } +function _Utils_Tuple2_UNUSED(a, b) { return { $: '#2', a: a, b: b }; } + +function _Utils_Tuple3(a, b, c) { return { a: a, b: b, c: c }; } +function _Utils_Tuple3_UNUSED(a, b, c) { return { $: '#3', a: a, b: b, c: c }; } + +function _Utils_chr(c) { return c; } +function _Utils_chr_UNUSED(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 = { $: 0 }; +var _List_Nil_UNUSED = { $: '[]' }; + +function _List_Cons(hd, tl) { return { $: 1, a: hd, b: tl }; } +function _List_Cons_UNUSED(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; + })); +}); + + + +// 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()); +} + + + +/**_UNUSED/ +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_UNUSED(value) { return { $: 0, a: value }; } +function _Json_unwrap_UNUSED(value) { return value.a; } + +function _Json_wrap(value) { return value; } +function _Json_unwrap(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.aK, + impl.a0, + impl.aZ, + 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 /**_UNUSED/, _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(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_UNUSED(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 + + /**/ + var node = args['node']; + //*/ + /**_UNUSED/ + 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 + + +function _VirtualDom_noScript(tag) +{ + return tag == 'script' ? 'p' : tag; +} + +function _VirtualDom_noOnOrFormAction(key) +{ + return /^(on|formAction$)/i.test(key) ? 'data-' + key : key; +} + +function _VirtualDom_noInnerHtmlOrFormAction(key) +{ + return key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key; +} + +function _VirtualDom_noJavaScriptUri(value) +{ + return /^javascript:/i.test(value.replace(/\s/g,'')) ? '' : value; +} + +function _VirtualDom_noJavaScriptUri_UNUSED(value) +{ + return /^javascript:/i.test(value.replace(/\s/g,'')) + ? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")' + : value; +} + +function _VirtualDom_noJavaScriptOrHtmlUri(value) +{ + return /^\s*(javascript:|data:text\/html)/i.test(value) ? '' : value; +} + +function _VirtualDom_noJavaScriptOrHtmlUri_UNUSED(value) +{ + return /^\s*(javascript:|data:text\/html)/i.test(value) + ? '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 { + u: func(record.u), + R: record.R, + P: record.P + } +}); + + + +// 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.u; + var stopPropagation = tag == 1 ? value.b : tag == 3 && value.R; + var currentEventNode = ( + stopPropagation && event.stopPropagation(), + (tag == 2 ? value.b : tag == 3 && value.P) && 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.aK, + impl.a0, + impl.aZ, + function(sendToApp, initialModel) { + var view = impl.a1; + /**/ + var domNode = args['node']; + //*/ + /**_UNUSED/ + 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.aK, + impl.a0, + impl.aZ, + function(sendToApp, initialModel) { + var divertHrefToApp = impl.Q && impl.Q(sendToApp) + var view = impl.a1; + 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.ay); + var patches = _VirtualDom_diff(currNode, nextNode); + bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp); + currNode = nextNode; + _VirtualDom_divertHrefToApp = 0; + (title !== doc.a_) && (_VirtualDom_doc.title = title = doc.a_); + }); + } + ); +}); + + + +// 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.aR; + var onUrlRequest = impl.aS; + var key = function() { key.a(onUrlChange(_Browser_getUrl())); }; + + return _Browser_document({ + Q: 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.ag === next.ag + && curr.Z === next.Z + && curr.ad.a === next.ad.a + ) + ? $elm$browser$Browser$Internal(next) + : $elm$browser$Browser$External(href) + )); + } + }); + }, + aK: function(flags) + { + return A3(impl.aK, flags, _Browser_getUrl(), key); + }, + a1: impl.a1, + a0: impl.a0, + aZ: impl.aZ + }); +} + +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') + ? { aI: 'hidden', az: 'visibilitychange' } + : + (typeof _VirtualDom_doc.mozHidden !== 'undefined') + ? { aI: 'mozHidden', az: 'mozvisibilitychange' } + : + (typeof _VirtualDom_doc.msHidden !== 'undefined') + ? { aI: 'msHidden', az: 'msvisibilitychange' } + : + (typeof _VirtualDom_doc.webkitHidden !== 'undefined') + ? { aI: 'webkitHidden', az: 'webkitvisibilitychange' } + : { aI: 'hidden', az: '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 { + al: _Browser_getScene(), + ar: { + at: _Browser_window.pageXOffset, + au: _Browser_window.pageYOffset, + as: _Browser_doc.documentElement.clientWidth, + Y: _Browser_doc.documentElement.clientHeight + } + }; +} + +function _Browser_getScene() +{ + var body = _Browser_doc.body; + var elem = _Browser_doc.documentElement; + return { + as: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth), + Y: 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 { + al: { + as: node.scrollWidth, + Y: node.scrollHeight + }, + ar: { + at: node.scrollLeft, + au: node.scrollTop, + as: node.clientWidth, + Y: 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 { + al: _Browser_getScene(), + ar: { + at: x, + au: y, + as: _Browser_doc.documentElement.clientWidth, + Y: _Browser_doc.documentElement.clientHeight + }, + aD: { + at: x + rect.left, + au: y + rect.top, + as: rect.width, + Y: 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); + } + })); +} + + + + +// STRINGS + + +var _Parser_isSubString = F5(function(smallString, offset, row, col, bigString) +{ + var smallLength = smallString.length; + var isGood = offset + smallLength <= bigString.length; + + for (var i = 0; isGood && i < smallLength; ) + { + var code = bigString.charCodeAt(offset); + isGood = + smallString[i++] === bigString[offset++] + && ( + code === 0x000A /* \n */ + ? ( row++, col=1 ) + : ( col++, (code & 0xF800) === 0xD800 ? smallString[i++] === bigString[offset++] : 1 ) + ) + } + + return _Utils_Tuple3(isGood ? offset : -1, row, col); +}); + + + +// CHARS + + +var _Parser_isSubChar = F3(function(predicate, offset, string) +{ + return ( + string.length <= offset + ? -1 + : + (string.charCodeAt(offset) & 0xF800) === 0xD800 + ? (predicate(_Utils_chr(string.substr(offset, 2))) ? offset + 2 : -1) + : + (predicate(_Utils_chr(string[offset])) + ? ((string[offset] === '\n') ? -2 : (offset + 1)) + : -1 + ) + ); +}); + + +var _Parser_isAsciiCode = F3(function(code, offset, string) +{ + return string.charCodeAt(offset) === code; +}); + + + +// NUMBERS + + +var _Parser_chompBase10 = F2(function(offset, string) +{ + for (; offset < string.length; offset++) + { + var code = string.charCodeAt(offset); + if (code < 0x30 || 0x39 < code) + { + return offset; + } + } + return offset; +}); + + +var _Parser_consumeBase = F3(function(base, offset, string) +{ + for (var total = 0; offset < string.length; offset++) + { + var digit = string.charCodeAt(offset) - 0x30; + if (digit < 0 || base <= digit) break; + total = base * total + digit; + } + return _Utils_Tuple2(offset, total); +}); + + +var _Parser_consumeBase16 = F2(function(offset, string) +{ + for (var total = 0; offset < string.length; offset++) + { + var code = string.charCodeAt(offset); + if (0x30 <= code && code <= 0x39) + { + total = 16 * total + code - 0x30; + } + else if (0x41 <= code && code <= 0x46) + { + total = 16 * total + code - 55; + } + else if (0x61 <= code && code <= 0x66) + { + total = 16 * total + code - 87; + } + else + { + break; + } + } + return _Utils_Tuple2(offset, total); +}); + + + +// FIND STRING + + +var _Parser_findSubString = F5(function(smallString, offset, row, col, bigString) +{ + var newOffset = bigString.indexOf(smallString, offset); + var target = newOffset < 0 ? bigString.length : newOffset + smallString.length; + + while (offset < target) + { + var code = bigString.charCodeAt(offset++); + code === 0x000A /* \n */ + ? ( col=1, row++ ) + : ( col++, (code & 0xF800) === 0xD800 && offset++ ) + } + + return _Utils_Tuple3(newOffset, row, col); +}); +var $elm$core$List$cons = _List_cons; +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.$) { + 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$Dict$foldr = F3( + function (func, acc, t) { + foldr: + while (true) { + if (t.$ === -2) { + 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; + return $elm$core$Dict$keys(dict); +}; +var $elm$core$Basics$EQ = 1; +var $elm$core$Basics$GT = 2; +var $elm$core$Basics$LT = 0; +var $author$project$QCM$init = { + G: '', + M: _List_fromArray( + ['']), + L: '' +}; +var $elm$core$Result$Err = function (a) { + return {$: 1, a: a}; +}; +var $elm$json$Json$Decode$Failure = F2( + function (a, b) { + return {$: 3, a: a, b: b}; + }); +var $elm$json$Json$Decode$Field = F2( + function (a, b) { + return {$: 0, a: a, b: b}; + }); +var $elm$json$Json$Decode$Index = F2( + function (a, b) { + return {$: 1, a: a, b: b}; + }); +var $elm$core$Result$Ok = function (a) { + return {$: 0, a: a}; +}; +var $elm$json$Json$Decode$OneOf = function (a) { + return {$: 2, a: a}; +}; +var $elm$core$Basics$False = 1; +var $elm$core$Basics$add = _Basics_add; +var $elm$core$Maybe$Just = function (a) { + return {$: 0, a: a}; +}; +var $elm$core$Maybe$Nothing = {$: 1}; +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 0: + var f = error.a; + var err = error.b; + var isSimple = function () { + var _v1 = $elm$core$String$uncons(f); + if (_v1.$ === 1) { + 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 1: + 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 2: + 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 {$: 0, 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 {$: 1, 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 {$: 0, 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.g) { + return A4( + $elm$core$Array$Array_elm_builtin, + $elm$core$Elm$JsArray$length(builder.i), + $elm$core$Array$shiftStep, + $elm$core$Elm$JsArray$empty, + builder.i); + } else { + var treeLen = builder.g * $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.j) : builder.j; + var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.g); + return A4( + $elm$core$Array$Array_elm_builtin, + $elm$core$Elm$JsArray$length(builder.i) + treeLen, + A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep), + tree, + builder.i); + } + }); +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, + {j: nodeList, g: (len / $elm$core$Array$branchFactor) | 0, i: 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 = 0; +var $elm$core$Result$isOk = function (result) { + if (!result.$) { + 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 0: + return 0; + case 1: + return 1; + case 2: + return 2; + default: + return 3; + } +}; +var $elm$browser$Browser$External = function (a) { + return {$: 1, a: a}; +}; +var $elm$browser$Browser$Internal = function (a) { + return {$: 0, a: a}; +}; +var $elm$core$Basics$identity = function (x) { + return x; +}; +var $elm$browser$Browser$Dom$NotFound = $elm$core$Basics$identity; +var $elm$url$Url$Http = 0; +var $elm$url$Url$Https = 1; +var $elm$url$Url$Url = F6( + function (protocol, host, port_, path, query, fragment) { + return {X: fragment, Z: host, ab: path, ad: port_, ag: protocol, ah: 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.$ === 1) { + 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, + 0, + A2($elm$core$String$dropLeft, 7, str)) : (A2($elm$core$String$startsWith, 'https://', str) ? A2( + $elm$url$Url$chompAfterProtocol, + 1, + A2($elm$core$String$dropLeft, 8, str)) : $elm$core$Maybe$Nothing); +}; +var $elm$core$Basics$never = function (_v0) { + never: + while (true) { + var nvr = _v0; + var $temp$_v0 = nvr; + _v0 = $temp$_v0; + continue never; + } +}; +var $elm$core$Task$Perform = $elm$core$Basics$identity; +var $elm$core$Task$succeed = _Scheduler_succeed; +var $elm$core$Task$init = $elm$core$Task$succeed(0); +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; + 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 0; + }, + $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(0); + }); +var $elm$core$Task$cmdMap = F2( + function (tagger, _v0) { + var task = _v0; + return 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( + A2($elm$core$Task$map, toMessage, task)); + }); +var $elm$core$Platform$Cmd$batch = _Platform_batch; +var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil); +var $elm$core$Platform$Sub$batch = _Platform_batch; +var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil); +var $elm$browser$Browser$sandbox = function (impl) { + return _Browser_element( + { + aK: function (_v0) { + return _Utils_Tuple2(impl.aK, $elm$core$Platform$Cmd$none); + }, + aZ: function (_v1) { + return $elm$core$Platform$Sub$none; + }, + a0: F2( + function (msg, model) { + return _Utils_Tuple2( + A2(impl.a0, msg, model), + $elm$core$Platform$Cmd$none); + }), + a1: impl.a1 + }); +}; +var $elm$core$String$lines = _String_lines; +var $author$project$QCM$Aremplacer = F2( + function (_var, vals) { + return {ap: vals, aq: _var}; + }); +var $elm$parser$Parser$Optional = 1; +var $elm$core$Set$Set_elm_builtin = $elm$core$Basics$identity; +var $elm$core$Dict$RBEmpty_elm_builtin = {$: -2}; +var $elm$core$Dict$empty = $elm$core$Dict$RBEmpty_elm_builtin; +var $elm$core$Set$empty = $elm$core$Dict$empty; +var $elm$core$Dict$Black = 1; +var $elm$core$Dict$RBNode_elm_builtin = F5( + function (a, b, c, d, e) { + return {$: -1, a: a, b: b, c: c, d: d, e: e}; + }); +var $elm$core$Dict$Red = 0; +var $elm$core$Dict$balance = F5( + function (color, key, value, left, right) { + if ((right.$ === -1) && (!right.a)) { + var _v1 = right.a; + var rK = right.b; + var rV = right.c; + var rLeft = right.d; + var rRight = right.e; + if ((left.$ === -1) && (!left.a)) { + 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, + 0, + key, + value, + A5($elm$core$Dict$RBNode_elm_builtin, 1, lK, lV, lLeft, lRight), + A5($elm$core$Dict$RBNode_elm_builtin, 1, rK, rV, rLeft, rRight)); + } else { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + color, + rK, + rV, + A5($elm$core$Dict$RBNode_elm_builtin, 0, key, value, left, rLeft), + rRight); + } + } else { + if ((((left.$ === -1) && (!left.a)) && (left.d.$ === -1)) && (!left.d.a)) { + 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, + 0, + lK, + lV, + A5($elm$core$Dict$RBNode_elm_builtin, 1, llK, llV, llLeft, llRight), + A5($elm$core$Dict$RBNode_elm_builtin, 1, 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.$ === -2) { + return A5($elm$core$Dict$RBNode_elm_builtin, 0, 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 0: + return A5( + $elm$core$Dict$balance, + nColor, + nKey, + nValue, + A3($elm$core$Dict$insertHelp, key, value, nLeft), + nRight); + case 1: + 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.$ === -1) && (!_v0.a)) { + 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, 1, k, v, l, r); + } else { + var x = _v0; + return x; + } + }); +var $elm$core$Set$insert = F2( + function (key, _v0) { + var dict = _v0; + return A3($elm$core$Dict$insert, key, 0, dict); + }); +var $elm$core$Set$fromList = function (list) { + return A3($elm$core$List$foldl, $elm$core$Set$insert, $elm$core$Set$empty, list); +}; +var $elm$core$Basics$always = F2( + function (a, _v0) { + return a; + }); +var $elm$parser$Parser$Advanced$Bad = F2( + function (a, b) { + return {$: 1, a: a, b: b}; + }); +var $elm$parser$Parser$Advanced$Good = F3( + function (a, b, c) { + return {$: 0, a: a, b: b, c: c}; + }); +var $elm$parser$Parser$Advanced$Parser = $elm$core$Basics$identity; +var $elm$parser$Parser$Advanced$map2 = F3( + function (func, _v0, _v1) { + var parseA = _v0; + var parseB = _v1; + return function (s0) { + var _v2 = parseA(s0); + if (_v2.$ === 1) { + var p = _v2.a; + var x = _v2.b; + return A2($elm$parser$Parser$Advanced$Bad, p, x); + } else { + var p1 = _v2.a; + var a = _v2.b; + var s1 = _v2.c; + var _v3 = parseB(s1); + if (_v3.$ === 1) { + var p2 = _v3.a; + var x = _v3.b; + return A2($elm$parser$Parser$Advanced$Bad, p1 || p2, x); + } else { + var p2 = _v3.a; + var b = _v3.b; + var s2 = _v3.c; + return A3( + $elm$parser$Parser$Advanced$Good, + p1 || p2, + A2(func, a, b), + s2); + } + } + }; + }); +var $elm$parser$Parser$Advanced$ignorer = F2( + function (keepParser, ignoreParser) { + return A3($elm$parser$Parser$Advanced$map2, $elm$core$Basics$always, keepParser, ignoreParser); + }); +var $elm$parser$Parser$ignorer = $elm$parser$Parser$Advanced$ignorer; +var $elm$parser$Parser$Advanced$keeper = F2( + function (parseFunc, parseArg) { + return A3($elm$parser$Parser$Advanced$map2, $elm$core$Basics$apL, parseFunc, parseArg); + }); +var $elm$parser$Parser$keeper = $elm$parser$Parser$Advanced$keeper; +var $elm$core$Basics$neq = _Utils_notEqual; +var $elm$parser$Parser$Advanced$andThen = F2( + function (callback, _v0) { + var parseA = _v0; + return function (s0) { + var _v1 = parseA(s0); + if (_v1.$ === 1) { + var p = _v1.a; + var x = _v1.b; + return A2($elm$parser$Parser$Advanced$Bad, p, x); + } else { + var p1 = _v1.a; + var a = _v1.b; + var s1 = _v1.c; + var _v2 = callback(a); + var parseB = _v2; + var _v3 = parseB(s1); + if (_v3.$ === 1) { + var p2 = _v3.a; + var x = _v3.b; + return A2($elm$parser$Parser$Advanced$Bad, p1 || p2, x); + } else { + var p2 = _v3.a; + var b = _v3.b; + var s2 = _v3.c; + return A3($elm$parser$Parser$Advanced$Good, p1 || p2, b, s2); + } + } + }; + }); +var $elm$parser$Parser$Advanced$loopHelp = F4( + function (p, state, callback, s0) { + loopHelp: + while (true) { + var _v0 = callback(state); + var parse = _v0; + var _v1 = parse(s0); + if (!_v1.$) { + var p1 = _v1.a; + var step = _v1.b; + var s1 = _v1.c; + if (!step.$) { + var newState = step.a; + var $temp$p = p || p1, + $temp$state = newState, + $temp$callback = callback, + $temp$s0 = s1; + p = $temp$p; + state = $temp$state; + callback = $temp$callback; + s0 = $temp$s0; + continue loopHelp; + } else { + var result = step.a; + return A3($elm$parser$Parser$Advanced$Good, p || p1, result, s1); + } + } else { + var p1 = _v1.a; + var x = _v1.b; + return A2($elm$parser$Parser$Advanced$Bad, p || p1, x); + } + } + }); +var $elm$parser$Parser$Advanced$loop = F2( + function (state, callback) { + return function (s) { + return A4($elm$parser$Parser$Advanced$loopHelp, false, state, callback, s); + }; + }); +var $elm$parser$Parser$Advanced$map = F2( + function (func, _v0) { + var parse = _v0; + return function (s0) { + var _v1 = parse(s0); + if (!_v1.$) { + var p = _v1.a; + var a = _v1.b; + var s1 = _v1.c; + return A3( + $elm$parser$Parser$Advanced$Good, + p, + func(a), + s1); + } else { + var p = _v1.a; + var x = _v1.b; + return A2($elm$parser$Parser$Advanced$Bad, p, x); + } + }; + }); +var $elm$parser$Parser$Advanced$Empty = {$: 0}; +var $elm$parser$Parser$Advanced$Append = F2( + function (a, b) { + return {$: 2, a: a, b: b}; + }); +var $elm$parser$Parser$Advanced$oneOfHelp = F3( + function (s0, bag, parsers) { + oneOfHelp: + while (true) { + if (!parsers.b) { + return A2($elm$parser$Parser$Advanced$Bad, false, bag); + } else { + var parse = parsers.a; + var remainingParsers = parsers.b; + var _v1 = parse(s0); + if (!_v1.$) { + var step = _v1; + return step; + } else { + var step = _v1; + var p = step.a; + var x = step.b; + if (p) { + return step; + } else { + var $temp$s0 = s0, + $temp$bag = A2($elm$parser$Parser$Advanced$Append, bag, x), + $temp$parsers = remainingParsers; + s0 = $temp$s0; + bag = $temp$bag; + parsers = $temp$parsers; + continue oneOfHelp; + } + } + } + } + }); +var $elm$parser$Parser$Advanced$oneOf = function (parsers) { + return function (s) { + return A3($elm$parser$Parser$Advanced$oneOfHelp, s, $elm$parser$Parser$Advanced$Empty, parsers); + }; +}; +var $elm$parser$Parser$Advanced$Done = function (a) { + return {$: 1, a: a}; +}; +var $elm$parser$Parser$Advanced$Loop = function (a) { + return {$: 0, a: a}; +}; +var $elm$parser$Parser$Advanced$revAlways = F2( + function (_v0, b) { + return b; + }); +var $elm$parser$Parser$Advanced$skip = F2( + function (iParser, kParser) { + return A3($elm$parser$Parser$Advanced$map2, $elm$parser$Parser$Advanced$revAlways, iParser, kParser); + }); +var $elm$parser$Parser$Advanced$sequenceEndForbidden = F5( + function (ender, ws, parseItem, sep, revItems) { + var chompRest = function (item) { + return A5( + $elm$parser$Parser$Advanced$sequenceEndForbidden, + ender, + ws, + parseItem, + sep, + A2($elm$core$List$cons, item, revItems)); + }; + return A2( + $elm$parser$Parser$Advanced$skip, + ws, + $elm$parser$Parser$Advanced$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$Advanced$skip, + sep, + A2( + $elm$parser$Parser$Advanced$skip, + ws, + A2( + $elm$parser$Parser$Advanced$map, + function (item) { + return $elm$parser$Parser$Advanced$Loop( + A2($elm$core$List$cons, item, revItems)); + }, + parseItem))), + A2( + $elm$parser$Parser$Advanced$map, + function (_v0) { + return $elm$parser$Parser$Advanced$Done( + $elm$core$List$reverse(revItems)); + }, + ender) + ]))); + }); +var $elm$parser$Parser$Advanced$succeed = function (a) { + return function (s) { + return A3($elm$parser$Parser$Advanced$Good, false, a, s); + }; +}; +var $elm$parser$Parser$Advanced$sequenceEndMandatory = F4( + function (ws, parseItem, sep, revItems) { + return $elm$parser$Parser$Advanced$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$Advanced$map, + function (item) { + return $elm$parser$Parser$Advanced$Loop( + A2($elm$core$List$cons, item, revItems)); + }, + A2( + $elm$parser$Parser$Advanced$ignorer, + parseItem, + A2( + $elm$parser$Parser$Advanced$ignorer, + ws, + A2($elm$parser$Parser$Advanced$ignorer, sep, ws)))), + A2( + $elm$parser$Parser$Advanced$map, + function (_v0) { + return $elm$parser$Parser$Advanced$Done( + $elm$core$List$reverse(revItems)); + }, + $elm$parser$Parser$Advanced$succeed(0)) + ])); + }); +var $elm$parser$Parser$Advanced$sequenceEndOptional = F5( + function (ender, ws, parseItem, sep, revItems) { + var parseEnd = A2( + $elm$parser$Parser$Advanced$map, + function (_v0) { + return $elm$parser$Parser$Advanced$Done( + $elm$core$List$reverse(revItems)); + }, + ender); + return A2( + $elm$parser$Parser$Advanced$skip, + ws, + $elm$parser$Parser$Advanced$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$Advanced$skip, + sep, + A2( + $elm$parser$Parser$Advanced$skip, + ws, + $elm$parser$Parser$Advanced$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$Advanced$map, + function (item) { + return $elm$parser$Parser$Advanced$Loop( + A2($elm$core$List$cons, item, revItems)); + }, + parseItem), + parseEnd + ])))), + parseEnd + ]))); + }); +var $elm$parser$Parser$Advanced$sequenceEnd = F5( + function (ender, ws, parseItem, sep, trailing) { + var chompRest = function (item) { + switch (trailing) { + case 0: + return A2( + $elm$parser$Parser$Advanced$loop, + _List_fromArray( + [item]), + A4($elm$parser$Parser$Advanced$sequenceEndForbidden, ender, ws, parseItem, sep)); + case 1: + return A2( + $elm$parser$Parser$Advanced$loop, + _List_fromArray( + [item]), + A4($elm$parser$Parser$Advanced$sequenceEndOptional, ender, ws, parseItem, sep)); + default: + return A2( + $elm$parser$Parser$Advanced$ignorer, + A2( + $elm$parser$Parser$Advanced$skip, + ws, + A2( + $elm$parser$Parser$Advanced$skip, + sep, + A2( + $elm$parser$Parser$Advanced$skip, + ws, + A2( + $elm$parser$Parser$Advanced$loop, + _List_fromArray( + [item]), + A3($elm$parser$Parser$Advanced$sequenceEndMandatory, ws, parseItem, sep))))), + ender); + } + }; + return $elm$parser$Parser$Advanced$oneOf( + _List_fromArray( + [ + A2($elm$parser$Parser$Advanced$andThen, chompRest, parseItem), + A2( + $elm$parser$Parser$Advanced$map, + function (_v0) { + return _List_Nil; + }, + ender) + ])); + }); +var $elm$parser$Parser$Advanced$AddRight = F2( + function (a, b) { + return {$: 1, a: a, b: b}; + }); +var $elm$parser$Parser$Advanced$DeadEnd = F4( + function (row, col, problem, contextStack) { + return {aA: col, aB: contextStack, aU: problem, ak: row}; + }); +var $elm$parser$Parser$Advanced$fromState = F2( + function (s, x) { + return A2( + $elm$parser$Parser$Advanced$AddRight, + $elm$parser$Parser$Advanced$Empty, + A4($elm$parser$Parser$Advanced$DeadEnd, s.ak, s.aA, x, s.c)); + }); +var $elm$parser$Parser$Advanced$isSubString = _Parser_isSubString; +var $elm$core$Basics$negate = function (n) { + return -n; +}; +var $elm$core$Basics$not = _Basics_not; +var $elm$parser$Parser$Advanced$token = function (_v0) { + var str = _v0.a; + var expecting = _v0.b; + var progress = !$elm$core$String$isEmpty(str); + return function (s) { + var _v1 = A5($elm$parser$Parser$Advanced$isSubString, str, s.b, s.ak, s.aA, s.a); + var newOffset = _v1.a; + var newRow = _v1.b; + var newCol = _v1.c; + return _Utils_eq(newOffset, -1) ? A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : A3( + $elm$parser$Parser$Advanced$Good, + progress, + 0, + {aA: newCol, c: s.c, d: s.d, b: newOffset, ak: newRow, a: s.a}); + }; +}; +var $elm$parser$Parser$Advanced$sequence = function (i) { + return A2( + $elm$parser$Parser$Advanced$skip, + $elm$parser$Parser$Advanced$token(i.am), + A2( + $elm$parser$Parser$Advanced$skip, + i.aY, + A5( + $elm$parser$Parser$Advanced$sequenceEnd, + $elm$parser$Parser$Advanced$token(i.aE), + i.aY, + i.aO, + $elm$parser$Parser$Advanced$token(i.aX), + i.a$))); +}; +var $elm$parser$Parser$Advanced$Forbidden = 0; +var $elm$parser$Parser$Advanced$Mandatory = 2; +var $elm$parser$Parser$Advanced$Optional = 1; +var $elm$parser$Parser$toAdvancedTrailing = function (trailing) { + switch (trailing) { + case 0: + return 0; + case 1: + return 1; + default: + return 2; + } +}; +var $elm$parser$Parser$Expecting = function (a) { + return {$: 0, a: a}; +}; +var $elm$parser$Parser$Advanced$Token = F2( + function (a, b) { + return {$: 0, a: a, b: b}; + }); +var $elm$parser$Parser$toToken = function (str) { + return A2( + $elm$parser$Parser$Advanced$Token, + str, + $elm$parser$Parser$Expecting(str)); +}; +var $elm$parser$Parser$sequence = function (i) { + return $elm$parser$Parser$Advanced$sequence( + { + aE: $elm$parser$Parser$toToken(i.aE), + aO: i.aO, + aX: $elm$parser$Parser$toToken(i.aX), + aY: i.aY, + am: $elm$parser$Parser$toToken(i.am), + a$: $elm$parser$Parser$toAdvancedTrailing(i.a$) + }); +}; +var $elm$parser$Parser$Advanced$isSubChar = _Parser_isSubChar; +var $elm$parser$Parser$Advanced$chompWhileHelp = F5( + function (isGood, offset, row, col, s0) { + chompWhileHelp: + while (true) { + var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, offset, s0.a); + if (_Utils_eq(newOffset, -1)) { + return A3( + $elm$parser$Parser$Advanced$Good, + _Utils_cmp(s0.b, offset) < 0, + 0, + {aA: col, c: s0.c, d: s0.d, b: offset, ak: row, a: s0.a}); + } else { + if (_Utils_eq(newOffset, -2)) { + var $temp$isGood = isGood, + $temp$offset = offset + 1, + $temp$row = row + 1, + $temp$col = 1, + $temp$s0 = s0; + isGood = $temp$isGood; + offset = $temp$offset; + row = $temp$row; + col = $temp$col; + s0 = $temp$s0; + continue chompWhileHelp; + } else { + var $temp$isGood = isGood, + $temp$offset = newOffset, + $temp$row = row, + $temp$col = col + 1, + $temp$s0 = s0; + isGood = $temp$isGood; + offset = $temp$offset; + row = $temp$row; + col = $temp$col; + s0 = $temp$s0; + continue chompWhileHelp; + } + } + } + }); +var $elm$parser$Parser$Advanced$chompWhile = function (isGood) { + return function (s) { + return A5($elm$parser$Parser$Advanced$chompWhileHelp, isGood, s.b, s.ak, s.aA, s); + }; +}; +var $elm$parser$Parser$Advanced$spaces = $elm$parser$Parser$Advanced$chompWhile( + function (c) { + return (c === ' ') || ((c === '\n') || (c === '\r')); + }); +var $elm$parser$Parser$spaces = $elm$parser$Parser$Advanced$spaces; +var $elm$parser$Parser$succeed = $elm$parser$Parser$Advanced$succeed; +var $elm$parser$Parser$ExpectingSymbol = function (a) { + return {$: 8, a: a}; +}; +var $elm$parser$Parser$Advanced$symbol = $elm$parser$Parser$Advanced$token; +var $elm$parser$Parser$symbol = function (str) { + return $elm$parser$Parser$Advanced$symbol( + A2( + $elm$parser$Parser$Advanced$Token, + str, + $elm$parser$Parser$ExpectingSymbol(str))); +}; +var $elm$parser$Parser$ExpectingVariable = {$: 7}; +var $elm$core$Dict$get = F2( + function (targetKey, dict) { + get: + while (true) { + if (dict.$ === -2) { + 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 0: + var $temp$targetKey = targetKey, + $temp$dict = left; + targetKey = $temp$targetKey; + dict = $temp$dict; + continue get; + case 1: + return $elm$core$Maybe$Just(value); + default: + var $temp$targetKey = targetKey, + $temp$dict = right; + targetKey = $temp$targetKey; + dict = $temp$dict; + continue get; + } + } + } + }); +var $elm$core$Dict$member = F2( + function (key, dict) { + var _v0 = A2($elm$core$Dict$get, key, dict); + if (!_v0.$) { + return true; + } else { + return false; + } + }); +var $elm$core$Set$member = F2( + function (key, _v0) { + var dict = _v0; + return A2($elm$core$Dict$member, key, dict); + }); +var $elm$parser$Parser$Advanced$varHelp = F7( + function (isGood, offset, row, col, src, indent, context) { + varHelp: + while (true) { + var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, offset, src); + if (_Utils_eq(newOffset, -1)) { + return {aA: col, c: context, d: indent, b: offset, ak: row, a: src}; + } else { + if (_Utils_eq(newOffset, -2)) { + var $temp$isGood = isGood, + $temp$offset = offset + 1, + $temp$row = row + 1, + $temp$col = 1, + $temp$src = src, + $temp$indent = indent, + $temp$context = context; + isGood = $temp$isGood; + offset = $temp$offset; + row = $temp$row; + col = $temp$col; + src = $temp$src; + indent = $temp$indent; + context = $temp$context; + continue varHelp; + } else { + var $temp$isGood = isGood, + $temp$offset = newOffset, + $temp$row = row, + $temp$col = col + 1, + $temp$src = src, + $temp$indent = indent, + $temp$context = context; + isGood = $temp$isGood; + offset = $temp$offset; + row = $temp$row; + col = $temp$col; + src = $temp$src; + indent = $temp$indent; + context = $temp$context; + continue varHelp; + } + } + } + }); +var $elm$parser$Parser$Advanced$variable = function (i) { + return function (s) { + var firstOffset = A3($elm$parser$Parser$Advanced$isSubChar, i.am, s.b, s.a); + if (_Utils_eq(firstOffset, -1)) { + return A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, i.W)); + } else { + var s1 = _Utils_eq(firstOffset, -2) ? A7($elm$parser$Parser$Advanced$varHelp, i.aL, s.b + 1, s.ak + 1, 1, s.a, s.d, s.c) : A7($elm$parser$Parser$Advanced$varHelp, i.aL, firstOffset, s.ak, s.aA + 1, s.a, s.d, s.c); + var name = A3($elm$core$String$slice, s.b, s1.b, s.a); + return A2($elm$core$Set$member, name, i.aV) ? A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, i.W)) : A3($elm$parser$Parser$Advanced$Good, true, name, s1); + } + }; +}; +var $elm$parser$Parser$variable = function (i) { + return $elm$parser$Parser$Advanced$variable( + {W: $elm$parser$Parser$ExpectingVariable, aL: i.aL, aV: i.aV, am: i.am}); +}; +var $author$project$QCM$aRemplacer = A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed($author$project$QCM$Aremplacer), + $elm$parser$Parser$spaces), + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$variable( + { + aL: $elm$core$Char$isAlpha, + aV: $elm$core$Set$fromList(_List_Nil), + am: function (_v0) { + return true; + } + }), + $elm$parser$Parser$spaces), + $elm$parser$Parser$symbol(':'))), + $elm$parser$Parser$sequence( + { + aE: '', + aO: $elm$parser$Parser$variable( + { + aL: $elm$core$Basics$neq(','), + aV: $elm$core$Set$fromList(_List_Nil), + am: $elm$core$Basics$neq(',') + }), + aX: ',', + aY: $elm$parser$Parser$spaces, + am: '', + a$: 1 + })); +var $elm$parser$Parser$DeadEnd = F3( + function (row, col, problem) { + return {aA: col, aU: problem, ak: row}; + }); +var $elm$parser$Parser$problemToDeadEnd = function (p) { + return A3($elm$parser$Parser$DeadEnd, p.ak, p.aA, p.aU); +}; +var $elm$parser$Parser$Advanced$bagToList = F2( + function (bag, list) { + bagToList: + while (true) { + switch (bag.$) { + case 0: + return list; + case 1: + var bag1 = bag.a; + var x = bag.b; + var $temp$bag = bag1, + $temp$list = A2($elm$core$List$cons, x, list); + bag = $temp$bag; + list = $temp$list; + continue bagToList; + default: + var bag1 = bag.a; + var bag2 = bag.b; + var $temp$bag = bag1, + $temp$list = A2($elm$parser$Parser$Advanced$bagToList, bag2, list); + bag = $temp$bag; + list = $temp$list; + continue bagToList; + } + } + }); +var $elm$parser$Parser$Advanced$run = F2( + function (_v0, src) { + var parse = _v0; + var _v1 = parse( + {aA: 1, c: _List_Nil, d: 1, b: 0, ak: 1, a: src}); + if (!_v1.$) { + var value = _v1.b; + return $elm$core$Result$Ok(value); + } else { + var bag = _v1.b; + return $elm$core$Result$Err( + A2($elm$parser$Parser$Advanced$bagToList, bag, _List_Nil)); + } + }); +var $elm$parser$Parser$run = F2( + function (parser, source) { + var _v0 = A2($elm$parser$Parser$Advanced$run, parser, source); + if (!_v0.$) { + var a = _v0.a; + return $elm$core$Result$Ok(a); + } else { + var problems = _v0.a; + return $elm$core$Result$Err( + A2($elm$core$List$map, $elm$parser$Parser$problemToDeadEnd, problems)); + } + }); +var $author$project$QCM$parserAremplacer = function (variables) { + var _v0 = A2($elm$parser$Parser$run, $author$project$QCM$aRemplacer, variables); + if (!_v0.$) { + var ars = _v0.a; + return ars; + } else { + return A2($author$project$QCM$Aremplacer, '', _List_Nil); + } +}; +var $elm$parser$Parser$map = $elm$parser$Parser$Advanced$map; +var $elm$parser$Parser$toAdvancedStep = function (step) { + if (!step.$) { + var s = step.a; + return $elm$parser$Parser$Advanced$Loop(s); + } else { + var a = step.a; + return $elm$parser$Parser$Advanced$Done(a); + } +}; +var $elm$parser$Parser$loop = F2( + function (state, callback) { + return A2( + $elm$parser$Parser$Advanced$loop, + state, + function (s) { + return A2( + $elm$parser$Parser$map, + $elm$parser$Parser$toAdvancedStep, + callback(s)); + }); + }); +var $elm$parser$Parser$Done = function (a) { + return {$: 1, a: a}; +}; +var $elm$parser$Parser$Loop = function (a) { + return {$: 0, a: a}; +}; +var $author$project$QCM$Variable = function (a) { + return {$: 1, a: a}; +}; +var $elm$parser$Parser$Advanced$findSubString = _Parser_findSubString; +var $elm$parser$Parser$Advanced$fromInfo = F4( + function (row, col, x, context) { + return A2( + $elm$parser$Parser$Advanced$AddRight, + $elm$parser$Parser$Advanced$Empty, + A4($elm$parser$Parser$Advanced$DeadEnd, row, col, x, context)); + }); +var $elm$parser$Parser$Advanced$chompUntil = function (_v0) { + var str = _v0.a; + var expecting = _v0.b; + return function (s) { + var _v1 = A5($elm$parser$Parser$Advanced$findSubString, str, s.b, s.ak, s.aA, s.a); + var newOffset = _v1.a; + var newRow = _v1.b; + var newCol = _v1.c; + return _Utils_eq(newOffset, -1) ? A2( + $elm$parser$Parser$Advanced$Bad, + false, + A4($elm$parser$Parser$Advanced$fromInfo, newRow, newCol, expecting, s.c)) : A3( + $elm$parser$Parser$Advanced$Good, + _Utils_cmp(s.b, newOffset) < 0, + 0, + {aA: newCol, c: s.c, d: s.d, b: newOffset, ak: newRow, a: s.a}); + }; +}; +var $elm$parser$Parser$chompUntil = function (str) { + return $elm$parser$Parser$Advanced$chompUntil( + $elm$parser$Parser$toToken(str)); +}; +var $elm$parser$Parser$Advanced$mapChompedString = F2( + function (func, _v0) { + var parse = _v0; + return function (s0) { + var _v1 = parse(s0); + if (_v1.$ === 1) { + var p = _v1.a; + var x = _v1.b; + return A2($elm$parser$Parser$Advanced$Bad, p, x); + } else { + var p = _v1.a; + var a = _v1.b; + var s1 = _v1.c; + return A3( + $elm$parser$Parser$Advanced$Good, + p, + A2( + func, + A3($elm$core$String$slice, s0.b, s1.b, s0.a), + a), + s1); + } + }; + }); +var $elm$parser$Parser$Advanced$getChompedString = function (parser) { + return A2($elm$parser$Parser$Advanced$mapChompedString, $elm$core$Basics$always, parser); +}; +var $elm$parser$Parser$getChompedString = $elm$parser$Parser$Advanced$getChompedString; +var $author$project$QCM$expressionVariable = A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed($author$project$QCM$Variable), + $elm$parser$Parser$symbol('#')), + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$getChompedString( + $elm$parser$Parser$chompUntil('#')), + $elm$parser$Parser$symbol('#'))); +var $elm$parser$Parser$oneOf = $elm$parser$Parser$Advanced$oneOf; +var $author$project$QCM$Texte = function (a) { + return {$: 0, a: a}; +}; +var $elm$parser$Parser$UnexpectedChar = {$: 11}; +var $elm$parser$Parser$Advanced$chompIf = F2( + function (isGood, expecting) { + return function (s) { + var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, s.b, s.a); + return _Utils_eq(newOffset, -1) ? A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : (_Utils_eq(newOffset, -2) ? A3( + $elm$parser$Parser$Advanced$Good, + true, + 0, + {aA: 1, c: s.c, d: s.d, b: s.b + 1, ak: s.ak + 1, a: s.a}) : A3( + $elm$parser$Parser$Advanced$Good, + true, + 0, + {aA: s.aA + 1, c: s.c, d: s.d, b: newOffset, ak: s.ak, a: s.a})); + }; + }); +var $elm$parser$Parser$chompIf = function (isGood) { + return A2($elm$parser$Parser$Advanced$chompIf, isGood, $elm$parser$Parser$UnexpectedChar); +}; +var $elm$parser$Parser$chompWhile = $elm$parser$Parser$Advanced$chompWhile; +var $author$project$QCM$texteSansVariables = A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($author$project$QCM$Texte), + $elm$parser$Parser$getChompedString( + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed(0), + $elm$parser$Parser$chompIf( + $elm$core$Basics$neq('#'))), + $elm$parser$Parser$chompWhile( + $elm$core$Basics$neq('#'))))); +var $author$project$QCM$questionsBis = function (ls) { + return $elm$parser$Parser$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed( + function (l) { + return $elm$parser$Parser$Loop( + A2($elm$core$List$cons, l, ls)); + }), + $elm$parser$Parser$oneOf( + _List_fromArray( + [$author$project$QCM$expressionVariable, $author$project$QCM$texteSansVariables]))), + A2( + $elm$parser$Parser$map, + function (_v0) { + return $elm$parser$Parser$Done( + $elm$core$List$reverse(ls)); + }, + $elm$parser$Parser$succeed(0)) + ])); +}; +var $author$project$QCM$questions = A2($elm$parser$Parser$loop, _List_Nil, $author$project$QCM$questionsBis); +var $author$project$QCM$parserQuestion = function (question) { + var _v0 = A2($elm$parser$Parser$run, $author$project$QCM$questions, question); + if (!_v0.$) { + var macro = _v0.a; + return macro; + } else { + return _List_Nil; + } +}; +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 $elm$core$List$concat = function (lists) { + return A3($elm$core$List$foldr, $elm$core$List$append, _List_Nil, lists); +}; +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 $author$project$QCM$remplacerLaVariableParLaValeurDansLeTexteVariable = F3( + function (_var, val, tv) { + if (!tv.$) { + var chaine = tv.a; + return $author$project$QCM$Texte(chaine); + } else { + var chaine = tv.a; + return $author$project$QCM$Variable( + A3($elm$core$String$replace, _var, val, chaine)); + } + }); +var $author$project$QCM$remplacerLaVariableParLaValeurDansLaMacro = F3( + function (_var, val, macro) { + return A2( + $elm$core$List$map, + A2($author$project$QCM$remplacerLaVariableParLaValeurDansLeTexteVariable, _var, val), + macro); + }); +var $author$project$QCM$remplacerLaVariableDansLaMacro = F2( + function (ar, macro) { + var f = function (val) { + return A3($author$project$QCM$remplacerLaVariableParLaValeurDansLaMacro, ar.aq, val, macro); + }; + return A2($elm$core$List$map, f, ar.ap); + }); +var $author$project$QCM$remplacerLesVariablesDansLaMacroBis = F2( + function (ars, macros) { + if (!ars.b) { + return macros; + } else { + var ar = ars.a; + var arss = ars.b; + return A2( + $author$project$QCM$remplacerLesVariablesDansLaMacroBis, + arss, + $elm$core$List$concat( + A2( + $elm$core$List$map, + $author$project$QCM$remplacerLaVariableDansLaMacro(ar), + macros))); + } + }); +var $elm$core$String$concat = function (strings) { + return A2($elm$core$String$join, '', strings); +}; +var $author$project$Fractions$Frac = F2( + function (num, den) { + return {f: den, e: num}; + }); +var $elm$core$Basics$abs = function (n) { + return (n < 0) ? (-n) : n; +}; +var $elm$core$Basics$modBy = _Basics_modBy; +var $lynn$elm_arithmetic$Arithmetic$gcd = F2( + function (a, b) { + var gcd_ = F2( + function (x, y) { + gcd_: + while (true) { + if (!y) { + return x; + } else { + var $temp$x = y, + $temp$y = A2($elm$core$Basics$modBy, y, x); + x = $temp$x; + y = $temp$y; + continue gcd_; + } + } + }); + return A2( + gcd_, + $elm$core$Basics$abs(a), + $elm$core$Basics$abs(b)); + }); +var $author$project$Fractions$simplifier = function (a) { + var sgnDuDen = (a.f < 0) ? (-1) : 1; + var pgcd = A2($lynn$elm_arithmetic$Arithmetic$gcd, a.e, a.f); + return A2($author$project$Fractions$Frac, ((sgnDuDen * a.e) / pgcd) | 0, ((sgnDuDen * a.f) / pgcd) | 0); +}; +var $author$project$Fractions$add = F2( + function (a, b) { + return $author$project$Fractions$simplifier( + A2($author$project$Fractions$Frac, (a.e * b.f) + (a.f * b.e), a.f * b.f)); + }); +var $author$project$Fractions$inv = function (a) { + return $author$project$Fractions$simplifier( + A2($author$project$Fractions$Frac, a.f, a.e)); +}; +var $author$project$Fractions$mul = F2( + function (a, b) { + return $author$project$Fractions$simplifier( + A2($author$project$Fractions$Frac, a.e * b.e, a.f * b.f)); + }); +var $author$project$Fractions$div = F2( + function (a, b) { + return $author$project$Fractions$simplifier( + A2( + $author$project$Fractions$mul, + a, + $author$project$Fractions$inv(b))); + }); +var $elm$core$Basics$pow = _Basics_pow; +var $author$project$Fractions$exp = F2( + function (a, b) { + var bb = $author$project$Fractions$simplifier(b); + var sgnDeB = (bb.e < 0) ? (-1) : 1; + var aa = $author$project$Fractions$simplifier(a); + var sgnDeA = (aa.e < 0) ? (-1) : 1; + return ((bb.f === 1) && (bb.e < 0)) ? $elm$core$Maybe$Just( + A2( + $author$project$Fractions$Frac, + A2($elm$core$Basics$pow, sgnDeA * aa.f, sgnDeB * bb.e), + A2($elm$core$Basics$pow, sgnDeA * aa.e, sgnDeB * bb.e))) : ((bb.f === 1) ? $elm$core$Maybe$Just( + A2( + $author$project$Fractions$Frac, + A2($elm$core$Basics$pow, aa.e, bb.e), + A2($elm$core$Basics$pow, aa.f, bb.e))) : $elm$core$Maybe$Nothing); + }); +var $elm$core$Maybe$map = F2( + function (f, maybe) { + if (!maybe.$) { + var value = maybe.a; + return $elm$core$Maybe$Just( + f(value)); + } else { + return $elm$core$Maybe$Nothing; + } + }); +var $elm$core$Maybe$map2 = F3( + function (func, ma, mb) { + if (ma.$ === 1) { + return $elm$core$Maybe$Nothing; + } else { + var a = ma.a; + if (mb.$ === 1) { + return $elm$core$Maybe$Nothing; + } else { + var b = mb.a; + return $elm$core$Maybe$Just( + A2(func, a, b)); + } + } + }); +var $author$project$Fractions$neg = function (a) { + return $author$project$Fractions$simplifier( + A2($author$project$Fractions$Frac, -a.e, a.f)); +}; +var $author$project$Fractions$sub = F2( + function (a, b) { + return $author$project$Fractions$simplifier( + A2( + $author$project$Fractions$add, + a, + $author$project$Fractions$neg(b))); + }); +var $author$project$ParserMaths$evaluer = function (expression) { + evaluer: + while (true) { + switch (expression.$) { + case 0: + var a = expression.a; + var b = expression.b; + return A3( + $elm$core$Maybe$map2, + $author$project$Fractions$add, + $author$project$ParserMaths$evaluer(a), + $author$project$ParserMaths$evaluer(b)); + case 1: + var a = expression.a; + var b = expression.b; + return A3( + $elm$core$Maybe$map2, + $author$project$Fractions$sub, + $author$project$ParserMaths$evaluer(a), + $author$project$ParserMaths$evaluer(b)); + case 2: + var a = expression.a; + var b = expression.b; + return A3( + $elm$core$Maybe$map2, + $author$project$Fractions$mul, + $author$project$ParserMaths$evaluer(a), + $author$project$ParserMaths$evaluer(b)); + case 3: + var a = expression.a; + var b = expression.b; + return A3( + $elm$core$Maybe$map2, + $author$project$Fractions$div, + $author$project$ParserMaths$evaluer(a), + $author$project$ParserMaths$evaluer(b)); + case 4: + var a = expression.a; + var b = expression.b; + var _v1 = A3( + $elm$core$Maybe$map2, + $author$project$Fractions$exp, + $author$project$ParserMaths$evaluer(a), + $author$project$ParserMaths$evaluer(b)); + if (_v1.$ === 1) { + return $elm$core$Maybe$Nothing; + } else { + var p = _v1.a; + return p; + } + case 5: + var a = expression.a; + return A2( + $elm$core$Maybe$map, + $author$project$Fractions$neg, + $author$project$ParserMaths$evaluer(a)); + case 7: + var l = expression.a; + var $temp$expression = l; + expression = $temp$expression; + continue evaluer; + case 6: + var n = expression.a; + return $elm$core$Maybe$Just( + A2($author$project$Fractions$Frac, n, 1)); + default: + var a_i = expression.a; + var x = expression.b; + return $elm$core$Maybe$Just( + A2($author$project$Fractions$Frac, 50, 1)); + } + } +}; +var $author$project$ParserMaths$AddOp = 2; +var $author$project$ParserMaths$DivOp = 1; +var $author$project$ParserMaths$ExpOp = 4; +var $elm$parser$Parser$Forbidden = 0; +var $author$project$ParserMaths$Grouping = function (a) { + return {$: 7, a: a}; +}; +var $author$project$ParserMaths$MulOp = 0; +var $author$project$ParserMaths$Neg = function (a) { + return {$: 5, a: a}; +}; +var $author$project$ParserMaths$NoOperand = {$: 0}; +var $author$project$ParserMaths$Operand = F2( + function (a, b) { + return {$: 1, a: a, b: b}; + }); +var $author$project$ParserMaths$Poly = F2( + function (a, b) { + return {$: 8, a: a, b: b}; + }); +var $author$project$ParserMaths$SubOp = 3; +var $author$project$ParserMaths$Add = F2( + function (a, b) { + return {$: 0, a: a, b: b}; + }); +var $author$project$ParserMaths$Div = F2( + function (a, b) { + return {$: 3, a: a, b: b}; + }); +var $author$project$ParserMaths$Exp = F2( + function (a, b) { + return {$: 4, a: a, b: b}; + }); +var $author$project$ParserMaths$Mul = F2( + function (a, b) { + return {$: 2, a: a, b: b}; + }); +var $author$project$ParserMaths$Sub = F2( + function (a, b) { + return {$: 1, a: a, b: b}; + }); +var $author$project$ParserMaths$binary = F2( + function (a, b) { + if (!b.$) { + return a; + } else { + var op = b.a; + var e = b.b; + switch (op) { + case 0: + return A2($author$project$ParserMaths$Mul, a, e); + case 1: + return A2($author$project$ParserMaths$Div, a, e); + case 2: + return A2($author$project$ParserMaths$Add, a, e); + case 3: + return A2($author$project$ParserMaths$Sub, a, e); + default: + return A2($author$project$ParserMaths$Exp, a, e); + } + } + }); +var $author$project$ParserMaths$foldBinary = F2( + function (left, operands) { + return A3( + $elm$core$List$foldr, + F2( + function (operand, expression) { + return A2($author$project$ParserMaths$binary, expression, operand); + }), + left, + operands); + }); +var $elm$parser$Parser$ExpectingKeyword = function (a) { + return {$: 9, a: a}; +}; +var $elm$parser$Parser$Advanced$keyword = function (_v0) { + var kwd = _v0.a; + var expecting = _v0.b; + var progress = !$elm$core$String$isEmpty(kwd); + return function (s) { + var _v1 = A5($elm$parser$Parser$Advanced$isSubString, kwd, s.b, s.ak, s.aA, s.a); + var newOffset = _v1.a; + var newRow = _v1.b; + var newCol = _v1.c; + return (_Utils_eq(newOffset, -1) || (0 <= A3( + $elm$parser$Parser$Advanced$isSubChar, + function (c) { + return $elm$core$Char$isAlphaNum(c) || (c === '_'); + }, + newOffset, + s.a))) ? A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : A3( + $elm$parser$Parser$Advanced$Good, + progress, + 0, + {aA: newCol, c: s.c, d: s.d, b: newOffset, ak: newRow, a: s.a}); + }; +}; +var $elm$parser$Parser$keyword = function (kwd) { + return $elm$parser$Parser$Advanced$keyword( + A2( + $elm$parser$Parser$Advanced$Token, + kwd, + $elm$parser$Parser$ExpectingKeyword(kwd))); +}; +var $elm$parser$Parser$Advanced$lazy = function (thunk) { + return function (s) { + var _v0 = thunk(0); + var parse = _v0; + return parse(s); + }; +}; +var $elm$parser$Parser$lazy = $elm$parser$Parser$Advanced$lazy; +var $author$project$ParserMaths$Entier = function (a) { + return {$: 6, a: a}; +}; +var $elm$parser$Parser$ExpectingBinary = {$: 4}; +var $elm$parser$Parser$ExpectingFloat = {$: 5}; +var $elm$parser$Parser$ExpectingHex = {$: 2}; +var $elm$parser$Parser$ExpectingInt = {$: 1}; +var $elm$parser$Parser$ExpectingNumber = {$: 6}; +var $elm$parser$Parser$ExpectingOctal = {$: 3}; +var $elm$core$Result$fromMaybe = F2( + function (err, maybe) { + if (!maybe.$) { + var v = maybe.a; + return $elm$core$Result$Ok(v); + } else { + return $elm$core$Result$Err(err); + } + }); +var $elm$parser$Parser$Advanced$consumeBase = _Parser_consumeBase; +var $elm$parser$Parser$Advanced$consumeBase16 = _Parser_consumeBase16; +var $elm$parser$Parser$Advanced$bumpOffset = F2( + function (newOffset, s) { + return {aA: s.aA + (newOffset - s.b), c: s.c, d: s.d, b: newOffset, ak: s.ak, a: s.a}; + }); +var $elm$parser$Parser$Advanced$chompBase10 = _Parser_chompBase10; +var $elm$parser$Parser$Advanced$isAsciiCode = _Parser_isAsciiCode; +var $elm$parser$Parser$Advanced$consumeExp = F2( + function (offset, src) { + if (A3($elm$parser$Parser$Advanced$isAsciiCode, 101, offset, src) || A3($elm$parser$Parser$Advanced$isAsciiCode, 69, offset, src)) { + var eOffset = offset + 1; + var expOffset = (A3($elm$parser$Parser$Advanced$isAsciiCode, 43, eOffset, src) || A3($elm$parser$Parser$Advanced$isAsciiCode, 45, eOffset, src)) ? (eOffset + 1) : eOffset; + var newOffset = A2($elm$parser$Parser$Advanced$chompBase10, expOffset, src); + return _Utils_eq(expOffset, newOffset) ? (-newOffset) : newOffset; + } else { + return offset; + } + }); +var $elm$parser$Parser$Advanced$consumeDotAndExp = F2( + function (offset, src) { + return A3($elm$parser$Parser$Advanced$isAsciiCode, 46, offset, src) ? A2( + $elm$parser$Parser$Advanced$consumeExp, + A2($elm$parser$Parser$Advanced$chompBase10, offset + 1, src), + src) : A2($elm$parser$Parser$Advanced$consumeExp, offset, src); + }); +var $elm$parser$Parser$Advanced$finalizeInt = F5( + function (invalid, handler, startOffset, _v0, s) { + var endOffset = _v0.a; + var n = _v0.b; + if (handler.$ === 1) { + var x = handler.a; + return A2( + $elm$parser$Parser$Advanced$Bad, + true, + A2($elm$parser$Parser$Advanced$fromState, s, x)); + } else { + var toValue = handler.a; + return _Utils_eq(startOffset, endOffset) ? A2( + $elm$parser$Parser$Advanced$Bad, + _Utils_cmp(s.b, startOffset) < 0, + A2($elm$parser$Parser$Advanced$fromState, s, invalid)) : A3( + $elm$parser$Parser$Advanced$Good, + true, + toValue(n), + A2($elm$parser$Parser$Advanced$bumpOffset, endOffset, s)); + } + }); +var $elm$core$String$toFloat = _String_toFloat; +var $elm$parser$Parser$Advanced$finalizeFloat = F6( + function (invalid, expecting, intSettings, floatSettings, intPair, s) { + var intOffset = intPair.a; + var floatOffset = A2($elm$parser$Parser$Advanced$consumeDotAndExp, intOffset, s.a); + if (floatOffset < 0) { + return A2( + $elm$parser$Parser$Advanced$Bad, + true, + A4($elm$parser$Parser$Advanced$fromInfo, s.ak, s.aA - (floatOffset + s.b), invalid, s.c)); + } else { + if (_Utils_eq(s.b, floatOffset)) { + return A2( + $elm$parser$Parser$Advanced$Bad, + false, + A2($elm$parser$Parser$Advanced$fromState, s, expecting)); + } else { + if (_Utils_eq(intOffset, floatOffset)) { + return A5($elm$parser$Parser$Advanced$finalizeInt, invalid, intSettings, s.b, intPair, s); + } else { + if (floatSettings.$ === 1) { + var x = floatSettings.a; + return A2( + $elm$parser$Parser$Advanced$Bad, + true, + A2($elm$parser$Parser$Advanced$fromState, s, invalid)); + } else { + var toValue = floatSettings.a; + var _v1 = $elm$core$String$toFloat( + A3($elm$core$String$slice, s.b, floatOffset, s.a)); + if (_v1.$ === 1) { + return A2( + $elm$parser$Parser$Advanced$Bad, + true, + A2($elm$parser$Parser$Advanced$fromState, s, invalid)); + } else { + var n = _v1.a; + return A3( + $elm$parser$Parser$Advanced$Good, + true, + toValue(n), + A2($elm$parser$Parser$Advanced$bumpOffset, floatOffset, s)); + } + } + } + } + } + }); +var $elm$parser$Parser$Advanced$number = function (c) { + return function (s) { + if (A3($elm$parser$Parser$Advanced$isAsciiCode, 48, s.b, s.a)) { + var zeroOffset = s.b + 1; + var baseOffset = zeroOffset + 1; + return A3($elm$parser$Parser$Advanced$isAsciiCode, 120, zeroOffset, s.a) ? A5( + $elm$parser$Parser$Advanced$finalizeInt, + c.aN, + c.aH, + baseOffset, + A2($elm$parser$Parser$Advanced$consumeBase16, baseOffset, s.a), + s) : (A3($elm$parser$Parser$Advanced$isAsciiCode, 111, zeroOffset, s.a) ? A5( + $elm$parser$Parser$Advanced$finalizeInt, + c.aN, + c.aQ, + baseOffset, + A3($elm$parser$Parser$Advanced$consumeBase, 8, baseOffset, s.a), + s) : (A3($elm$parser$Parser$Advanced$isAsciiCode, 98, zeroOffset, s.a) ? A5( + $elm$parser$Parser$Advanced$finalizeInt, + c.aN, + c.ax, + baseOffset, + A3($elm$parser$Parser$Advanced$consumeBase, 2, baseOffset, s.a), + s) : A6( + $elm$parser$Parser$Advanced$finalizeFloat, + c.aN, + c.W, + c.aM, + c.aG, + _Utils_Tuple2(zeroOffset, 0), + s))); + } else { + return A6( + $elm$parser$Parser$Advanced$finalizeFloat, + c.aN, + c.W, + c.aM, + c.aG, + A3($elm$parser$Parser$Advanced$consumeBase, 10, s.b, s.a), + s); + } + }; +}; +var $elm$parser$Parser$number = function (i) { + return $elm$parser$Parser$Advanced$number( + { + ax: A2($elm$core$Result$fromMaybe, $elm$parser$Parser$ExpectingBinary, i.ax), + W: $elm$parser$Parser$ExpectingNumber, + aG: A2($elm$core$Result$fromMaybe, $elm$parser$Parser$ExpectingFloat, i.aG), + aH: A2($elm$core$Result$fromMaybe, $elm$parser$Parser$ExpectingHex, i.aH), + aM: A2($elm$core$Result$fromMaybe, $elm$parser$Parser$ExpectingInt, i.aM), + aN: $elm$parser$Parser$ExpectingNumber, + aQ: A2($elm$core$Result$fromMaybe, $elm$parser$Parser$ExpectingOctal, i.aQ) + }); +}; +var $author$project$ParserMaths$nombre = A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($author$project$ParserMaths$Entier), + $elm$parser$Parser$number( + { + ax: $elm$core$Maybe$Nothing, + aG: $elm$core$Maybe$Nothing, + aH: $elm$core$Maybe$Nothing, + aM: $elm$core$Maybe$Just($elm$core$Basics$identity), + aQ: $elm$core$Maybe$Nothing + })); +var $author$project$ParserMaths$addHelper = function (operands) { + return $elm$parser$Parser$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed( + function (right) { + return $elm$parser$Parser$Loop( + A2( + $elm$core$List$cons, + A2($author$project$ParserMaths$Operand, 2, right), + operands)); + }), + $elm$parser$Parser$symbol('+')), + $elm$parser$Parser$spaces), + $elm$parser$Parser$lazy( + function (_v9) { + return $author$project$ParserMaths$cyclic$mul(); + })), + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed( + function (right) { + return $elm$parser$Parser$Loop( + A2( + $elm$core$List$cons, + A2($author$project$ParserMaths$Operand, 3, right), + operands)); + }), + $elm$parser$Parser$symbol('-')), + $elm$parser$Parser$spaces), + $elm$parser$Parser$lazy( + function (_v10) { + return $author$project$ParserMaths$cyclic$mul(); + })), + A2( + $elm$parser$Parser$map, + function (_v11) { + return $elm$parser$Parser$Done(operands); + }, + $elm$parser$Parser$succeed(0)) + ])); +}; +var $author$project$ParserMaths$mulHelper = function (operands) { + return $elm$parser$Parser$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed( + function (right) { + return $elm$parser$Parser$Loop( + A2( + $elm$core$List$cons, + A2($author$project$ParserMaths$Operand, 0, right), + operands)); + }), + $elm$parser$Parser$symbol('*')), + $elm$parser$Parser$spaces), + $elm$parser$Parser$lazy( + function (_v3) { + return $author$project$ParserMaths$cyclic$exp(); + })), + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed( + function (right) { + return $elm$parser$Parser$Loop( + A2( + $elm$core$List$cons, + A2($author$project$ParserMaths$Operand, 1, right), + operands)); + }), + $elm$parser$Parser$symbol('/')), + $elm$parser$Parser$spaces), + $elm$parser$Parser$lazy( + function (_v4) { + return $author$project$ParserMaths$cyclic$exp(); + })), + A2( + $elm$parser$Parser$map, + function (_v5) { + return $elm$parser$Parser$Done(operands); + }, + $elm$parser$Parser$succeed(0)) + ])); +}; +function $author$project$ParserMaths$cyclic$expr() { + return $author$project$ParserMaths$cyclic$add(); +} +function $author$project$ParserMaths$cyclic$add() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($author$project$ParserMaths$foldBinary), + A2( + $elm$parser$Parser$ignorer, + $author$project$ParserMaths$cyclic$mul(), + $elm$parser$Parser$spaces)), + A2($elm$parser$Parser$loop, _List_Nil, $author$project$ParserMaths$addHelper)); +} +function $author$project$ParserMaths$cyclic$mul() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($author$project$ParserMaths$foldBinary), + A2( + $elm$parser$Parser$ignorer, + $author$project$ParserMaths$cyclic$exp(), + $elm$parser$Parser$spaces)), + A2($elm$parser$Parser$loop, _List_Nil, $author$project$ParserMaths$mulHelper)); +} +function $author$project$ParserMaths$cyclic$exp() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($author$project$ParserMaths$binary), + A2( + $elm$parser$Parser$ignorer, + $author$project$ParserMaths$cyclic$primary(), + $elm$parser$Parser$spaces)), + $elm$parser$Parser$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed( + $author$project$ParserMaths$Operand(4)), + $elm$parser$Parser$symbol('^')), + $elm$parser$Parser$spaces), + $elm$parser$Parser$lazy( + function (_v8) { + return $author$project$ParserMaths$cyclic$exp(); + })), + $elm$parser$Parser$succeed($author$project$ParserMaths$NoOperand) + ]))); +} +function $author$project$ParserMaths$cyclic$primary() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed( + F2( + function (op, literal) { + if (op.$ === 1) { + return literal; + } else { + return $author$project$ParserMaths$Neg(literal); + } + })), + $elm$parser$Parser$oneOf( + _List_fromArray( + [ + A2( + $elm$parser$Parser$keeper, + $elm$parser$Parser$succeed($elm$core$Maybe$Just), + $elm$parser$Parser$symbol('-')), + $elm$parser$Parser$succeed($elm$core$Maybe$Nothing) + ]))), + $elm$parser$Parser$oneOf( + _List_fromArray( + [ + $author$project$ParserMaths$cyclic$grouping(), + $author$project$ParserMaths$cyclic$poly(), + $author$project$ParserMaths$nombre + ]))); +} +function $author$project$ParserMaths$cyclic$grouping() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed($author$project$ParserMaths$Grouping), + $elm$parser$Parser$symbol('(')), + $elm$parser$Parser$spaces), + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$lazy( + function (_v6) { + return $author$project$ParserMaths$cyclic$expr(); + }), + $elm$parser$Parser$spaces), + $elm$parser$Parser$symbol(')'))); +} +function $author$project$ParserMaths$cyclic$poly() { + return A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$keeper, + A2( + $elm$parser$Parser$ignorer, + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$succeed($author$project$ParserMaths$Poly), + $elm$parser$Parser$keyword('Poly')), + $elm$parser$Parser$spaces), + A2( + $elm$parser$Parser$ignorer, + $elm$parser$Parser$sequence( + { + aE: ']', + aO: $elm$parser$Parser$lazy( + function (_v0) { + return $author$project$ParserMaths$cyclic$expr(); + }), + aX: ',', + aY: $elm$parser$Parser$spaces, + am: '[', + a$: 0 + }), + $elm$parser$Parser$spaces)), + $elm$parser$Parser$variable( + { + aL: function (_v1) { + return false; + }, + aV: $elm$core$Set$fromList(_List_Nil), + am: function (_v2) { + return true; + } + })); +} +var $author$project$ParserMaths$expr = $author$project$ParserMaths$cyclic$expr(); +$author$project$ParserMaths$cyclic$expr = function () { + return $author$project$ParserMaths$expr; +}; +var $author$project$ParserMaths$add = $author$project$ParserMaths$cyclic$add(); +$author$project$ParserMaths$cyclic$add = function () { + return $author$project$ParserMaths$add; +}; +var $author$project$ParserMaths$mul = $author$project$ParserMaths$cyclic$mul(); +$author$project$ParserMaths$cyclic$mul = function () { + return $author$project$ParserMaths$mul; +}; +var $author$project$ParserMaths$exp = $author$project$ParserMaths$cyclic$exp(); +$author$project$ParserMaths$cyclic$exp = function () { + return $author$project$ParserMaths$exp; +}; +var $author$project$ParserMaths$primary = $author$project$ParserMaths$cyclic$primary(); +$author$project$ParserMaths$cyclic$primary = function () { + return $author$project$ParserMaths$primary; +}; +var $author$project$ParserMaths$grouping = $author$project$ParserMaths$cyclic$grouping(); +$author$project$ParserMaths$cyclic$grouping = function () { + return $author$project$ParserMaths$grouping; +}; +var $author$project$ParserMaths$poly = $author$project$ParserMaths$cyclic$poly(); +$author$project$ParserMaths$cyclic$poly = function () { + return $author$project$ParserMaths$poly; +}; +var $author$project$ParserMaths$parseMaths = function (source) { + return A2($elm$parser$Parser$run, $author$project$ParserMaths$expr, source); +}; +var $author$project$Fractions$teX = function (a) { + var _v0 = a.f; + if (_v0 === 1) { + return $elm$core$String$fromInt(a.e); + } else { + return (a.e < 0) ? ('-\\frac{' + ($elm$core$String$fromInt(-a.e) + ('}{' + ($elm$core$String$fromInt(a.f) + '}')))) : ('\\frac{' + ($elm$core$String$fromInt(a.e) + ('}{' + ($elm$core$String$fromInt(a.f) + '}')))); + } +}; +var $author$project$QCM$voirTexteVariable = function (txtvar) { + if (!txtvar.$) { + var txt = txtvar.a; + return txt; + } else { + var _var = txtvar.a; + var expressionParseePotentielle = $author$project$ParserMaths$parseMaths(_var); + if (expressionParseePotentielle.$ === 1) { + var erreur = expressionParseePotentielle.a; + return 'L\'expression est mal formée.'; + } else { + var expressionParsee = expressionParseePotentielle.a; + var _v2 = A2( + $elm$core$Maybe$map, + $author$project$Fractions$teX, + $author$project$ParserMaths$evaluer(expressionParsee)); + if (!_v2.$) { + var a = _v2.a; + return a; + } else { + return 'Les puissances non-entières ne sont pas acceptées.'; + } + } + } +}; +var $author$project$QCM$voirMacro = function (macro) { + return $elm$core$String$concat( + A2($elm$core$List$map, $author$project$QCM$voirTexteVariable, macro)); +}; +var $author$project$QCM$remplacerLesVariablesDansLaMacro = F2( + function (ars, macro) { + return A2( + $elm$core$List$map, + $author$project$QCM$voirMacro, + A2( + $author$project$QCM$remplacerLesVariablesDansLaMacroBis, + ars, + _List_fromArray( + [macro]))); + }); +var $author$project$QCM$remplacer = F2( + function (variables, question) { + var macro = $author$project$QCM$parserQuestion(question); + var ars = A2( + $elm$core$List$map, + $author$project$QCM$parserAremplacer, + $elm$core$String$lines(variables)); + return A2($author$project$QCM$remplacerLesVariablesDansLaMacro, ars, macro); + }); +var $author$project$QCM$update = F2( + function (msg, model) { + switch (msg.$) { + case 0: + var nouvelleQuestion = msg.a; + return _Utils_update( + model, + {G: nouvelleQuestion}); + case 1: + var nouvellesVariables = msg.a; + return _Utils_update( + model, + {L: nouvellesVariables}); + default: + return _Utils_update( + model, + { + M: A2($author$project$QCM$remplacer, model.L, model.G) + }); + } + }); +var $author$project$QCM$GenererQuestion = {$: 2}; +var $author$project$QCM$Question = function (a) { + return {$: 0, a: a}; +}; +var $author$project$QCM$Variables = function (a) { + return {$: 1, a: a}; +}; +var $elm$html$Html$button = _VirtualDom_node('button'); +var $elm$html$Html$div = _VirtualDom_node('div'); +var $elm$virtual_dom$VirtualDom$Normal = function (a) { + return {$: 0, a: a}; +}; +var $elm$virtual_dom$VirtualDom$on = _VirtualDom_on; +var $elm$html$Html$Events$on = F2( + function (event, decoder) { + return A2( + $elm$virtual_dom$VirtualDom$on, + event, + $elm$virtual_dom$VirtualDom$Normal(decoder)); + }); +var $elm$html$Html$Events$onClick = function (msg) { + return A2( + $elm$html$Html$Events$on, + 'click', + $elm$json$Json$Decode$succeed(msg)); +}; +var $elm$html$Html$Events$alwaysStop = function (x) { + return _Utils_Tuple2(x, true); +}; +var $elm$virtual_dom$VirtualDom$MayStopPropagation = function (a) { + return {$: 1, a: a}; +}; +var $elm$html$Html$Events$stopPropagationOn = F2( + function (event, decoder) { + return A2( + $elm$virtual_dom$VirtualDom$on, + event, + $elm$virtual_dom$VirtualDom$MayStopPropagation(decoder)); + }); +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$string = _Json_decodeString; +var $elm$html$Html$Events$targetValue = A2( + $elm$json$Json$Decode$at, + _List_fromArray( + ['target', 'value']), + $elm$json$Json$Decode$string); +var $elm$html$Html$Events$onInput = function (tagger) { + return A2( + $elm$html$Html$Events$stopPropagationOn, + 'input', + A2( + $elm$json$Json$Decode$map, + $elm$html$Html$Events$alwaysStop, + A2($elm$json$Json$Decode$map, tagger, $elm$html$Html$Events$targetValue))); +}; +var $elm$html$Html$p = _VirtualDom_node('p'); +var $elm$json$Json$Encode$string = _Json_wrap; +var $elm$html$Html$Attributes$stringProperty = F2( + function (key, string) { + return A2( + _VirtualDom_property, + key, + $elm$json$Json$Encode$string(string)); + }); +var $elm$html$Html$Attributes$placeholder = $elm$html$Html$Attributes$stringProperty('placeholder'); +var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text; +var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text; +var $elm$html$Html$textarea = _VirtualDom_node('textarea'); +var $elm$html$Html$Attributes$value = $elm$html$Html$Attributes$stringProperty('value'); +var $author$project$QCM$view = function (model) { + return A2( + $elm$html$Html$div, + _List_Nil, + A2( + $elm$core$List$cons, + A2( + $elm$html$Html$textarea, + _List_fromArray( + [ + $elm$html$Html$Attributes$placeholder('Liste des variables'), + $elm$html$Html$Attributes$value(model.L), + $elm$html$Html$Events$onInput($author$project$QCM$Variables) + ]), + _List_Nil), + A2( + $elm$core$List$cons, + A2( + $elm$html$Html$textarea, + _List_fromArray( + [ + $elm$html$Html$Attributes$placeholder('Format de la question'), + $elm$html$Html$Attributes$value(model.G), + $elm$html$Html$Events$onInput($author$project$QCM$Question) + ]), + _List_Nil), + A2( + $elm$core$List$cons, + A2( + $elm$html$Html$button, + _List_fromArray( + [ + $elm$html$Html$Events$onClick($author$project$QCM$GenererQuestion) + ]), + _List_fromArray( + [ + $elm$html$Html$text('Générer les questions') + ])), + _List_fromArray( + [ + A2( + $elm$html$Html$p, + _List_Nil, + A2( + $elm$core$List$map, + function (q) { + return A2( + $elm$html$Html$p, + _List_Nil, + _List_fromArray( + [ + $elm$html$Html$text(q) + ])); + }, + model.M)) + ]))))); +}; +var $author$project$QCM$main = $elm$browser$Browser$sandbox( + {aK: $author$project$QCM$init, a0: $author$project$QCM$update, a1: $author$project$QCM$view}); +_Platform_export({'QCM':{'init':$author$project$QCM$main( + $elm$json$Json$Decode$succeed(0))(0)}});}(this)); \ No newline at end of file diff --git a/qcm.min.js b/qcm.min.js new file mode 100644 index 0000000..ef35496 --- /dev/null +++ b/qcm.min.js @@ -0,0 +1 @@ +(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)}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=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;isource.length){itemsToCopy=source.length}var size=destLen+itemsToCopy;var result=new Array(size);for(var i=0;i"}function _Debug_toString_UNUSED(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){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?""+string+"":string}function _Debug_numberColor(ansi,string){return ansi?""+string+"":string}function _Debug_stringColor(ansi,string){return ansi?""+string+"":string}function _Debug_charColor(ansi,string){return ansi?""+string+"":string}function _Debug_fadeColor(ansi,string){return ansi?""+string+"":string}function _Debug_internalColor(ansi,string){return ansi?""+string+"":string}function _Debug_toHexDigit(n){return String.fromCharCode(n<10?48+n:55+n)}function _Debug_crash(identifier){throw new Error("https://github.com/elm/core/blob/1.0.0/hints/"+identifier+".md")}function _Debug_crash_UNUSED(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.am.F===region.aE.F){return"on line "+region.am.F}return"on lines "+region.am.F+" through "+region.aE.F}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.$<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)});function _Utils_cmp(x,y,ord){if(typeof x!=="object"){return x===y?0:x0});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});var _Utils_Tuple0=0;var _Utils_Tuple0_UNUSED={$:"#0"};function _Utils_Tuple2(a,b){return{a:a,b:b}}function _Utils_Tuple2_UNUSED(a,b){return{$:"#2",a:a,b:b}}function _Utils_Tuple3(a,b,c){return{a:a,b:b,c:c}}function _Utils_Tuple3_UNUSED(a,b,c){return{$:"#3",a:a,b:b,c:c}}function _Utils_chr(c){return c}function _Utils_chr_UNUSED(c){return new String(c)}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}var _Utils_append=F2(_Utils_ap);function _Utils_ap(xs,ys){if(typeof xs==="string"){return xs+ys}if(!xs.b){return ys}var root=_List_Cons(xs.a,ys);xs=xs.b;for(var curr=root;xs.b;xs=xs.b){curr=curr.b=_List_Cons(xs.a,ys)}return root}var _List_Nil={$:0};var _List_Nil_UNUSED={$:"[]"};function _List_Cons(hd,tl){return{$:1,a:hd,b:tl}}function _List_Cons_UNUSED(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){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){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){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){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){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 _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});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});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);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;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(55296<=word&&word<=56319?_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-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)});function _String_fromNumber(number){return number+""}function _String_toInt(str){var total=0;var code0=str.charCodeAt(0);var start=code0==43||code0==45?1:0;for(var i=start;i=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;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=0){subs.splice(index,1)}}return{subscribe:subscribe,unsubscribe:unsubscribe}}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;var init=_Scheduler_succeed(null);_Platform_effectManagers[name].b=init;_Platform_effectManagers[name].c=F3(function(router,subList,state){subs=subList;return init});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){sendToApp(temp.a(value))}}return{send:send}}function _Platform_export(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_UNUSED(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]}}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){var node=args["node"];node.parentNode.replaceChild(_VirtualDom_render(virtualNode,function(){}),node);return{}});function _VirtualDom_text(string){return{$:0,a:string}}var _VirtualDom_nodeNS=F2(function(namespace,tag){return F2(function(factList,kidList){for(var kids=[],descendantsCount=0;kidList.b;kidList=kidList.b){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);var _VirtualDom_keyedNodeNS=F2(function(namespace,tag){return F2(function(factList,kidList){for(var kids=[],descendantsCount=0;kidList.b;kidList=kidList.b){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);function _VirtualDom_custom(factList,model,render,diff){return{$:3,d:_VirtualDom_organizeFacts(factList),g:model,h:render,i:diff}}var _VirtualDom_map=F2(function(tagger,node){return{$:4,j:tagger,k:node,b:1+(node.b||0)}});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)})});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}}});function _VirtualDom_noScript(tag){return tag=="script"?"p":tag}function _VirtualDom_noOnOrFormAction(key){return/^(on|formAction$)/i.test(key)?"data-"+key:key}function _VirtualDom_noInnerHtmlOrFormAction(key){return key=="innerHTML"||key=="formAction"?"data-"+key:key}function _VirtualDom_noJavaScriptUri(value){return/^javascript:/i.test(value.replace(/\s/g,""))?"":value}function _VirtualDom_noJavaScriptUri_UNUSED(value){return/^javascript:/i.test(value.replace(/\s/g,""))?'javascript:alert("This is an XSS vector. Please use ports or web components instead.")':value}function _VirtualDom_noJavaScriptOrHtmlUri(value){return/^\s*(javascript:|data:text\/html)/i.test(value)?"":value}function _VirtualDom_noJavaScriptOrHtmlUri_UNUSED(value){return/^\s*(javascript:|data:text\/html)/i.test(value)?'javascript:alert("This is an XSS vector. Please use ports or web components instead.")':value}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);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{u:func(record.u),R:record.R,P:record.P}});function _VirtualDom_organizeFacts(factList){for(var facts={};factList.b;factList=factList.b){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}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}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;i0&&_VirtualDom_pushPatch(patches,1,index,subPatches);return;case 4: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}if(nesting&&xTaggers.length!==yTaggers.length){_VirtualDom_pushPatch(patches,0,index,y);return}if(nesting?!_VirtualDom_pairwiseRefEqual(xTaggers,yTaggers):xTaggers!==yTaggers){_VirtualDom_pushPatch(patches,2,index,yTaggers)}_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}}function _VirtualDom_pairwiseRefEqual(as,bs){for(var i=0;iyLen){_VirtualDom_pushPatch(patches,6,index,{v:yLen,i:xLen-yLen})}else if(xLen0||inserts.length>0||endInserts){_VirtualDom_pushPatch(patches,8,rootIndex,{w:localPatches,x:inserts,y:endInserts})}}var _VirtualDom_POSTFIX="_elmW6BL";function _VirtualDom_insertNode(changes,localPatches,key,vnode,yIndex,inserts){var entry=changes[key];if(!entry){entry={c:0,z:vnode,r:yIndex,s:undefined};inserts.push({r:yIndex,A:entry});changes[key]=entry;return}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}_VirtualDom_insertNode(changes,localPatches,key+_VirtualDom_POSTFIX,vnode,yIndex,inserts)}function _VirtualDom_removeNode(changes,localPatches,key,vnode,index){var entry=changes[key];if(!entry){var patch=_VirtualDom_pushPatch(localPatches,9,index,undefined);changes[key]={c:1,z:vnode,r:index,s:patch};return}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}_VirtualDom_removeNode(changes,localPatches,key+_VirtualDom_POSTFIX,vnode,index)}function _VirtualDom_addDomNodes(domNode,vNode,patches,eventNode){_VirtualDom_addDomNodesHelp(domNode,vNode,patches,0,0,vNode.b,eventNode)}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)}var vKids=vNode.e;var childNodes=domNode.childNodes;for(var j=0;jhigh){return i}}low=nextLow}return i}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;i0?x:y});var $elm$core$Basics$mul=_Basics_mul;var $elm$core$Array$SubTree=function(a){return{$:0,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.g){return A4($elm$core$Array$Array_elm_builtin,$elm$core$Elm$JsArray$length(builder.i),$elm$core$Array$shiftStep,$elm$core$Elm$JsArray$empty,builder.i)}else{var treeLen=builder.g*$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.j):builder.j;var tree=A2($elm$core$Array$treeFromBuilder,correctNodeList,builder.g);return A4($elm$core$Array$Array_elm_builtin,$elm$core$Elm$JsArray$length(builder.i)+treeLen,A2($elm$core$Basics$max,5,depth*$elm$core$Array$shiftStep),tree,builder.i)}});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,{j:nodeList,g:len/$elm$core$Array$branchFactor|0,i: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=0;var $elm$core$Result$isOk=function(result){if(!result.$){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 0:return 0;case 1:return 1;case 2:return 2;default:return 3}};var $elm$browser$Browser$External=function(a){return{$:1,a:a}};var $elm$browser$Browser$Internal=function(a){return{$:0,a:a}};var $elm$core$Basics$identity=function(x){return x};var $elm$browser$Browser$Dom$NotFound=$elm$core$Basics$identity;var $elm$url$Url$Http=0;var $elm$url$Url$Https=1;var $elm$url$Url$Url=F6(function(protocol,host,port_,path,query,fragment){return{X:fragment,Z:host,ab:path,ad:port_,ag:protocol,ah: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.$===1){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,0,A2($elm$core$String$dropLeft,7,str)):A2($elm$core$String$startsWith,"https://",str)?A2($elm$url$Url$chompAfterProtocol,1,A2($elm$core$String$dropLeft,8,str)):$elm$core$Maybe$Nothing};var $elm$core$Basics$never=function(_v0){never:while(true){var nvr=_v0;var $temp$_v0=nvr;_v0=$temp$_v0;continue never}};var $elm$core$Task$Perform=$elm$core$Basics$identity;var $elm$core$Task$succeed=_Scheduler_succeed;var $elm$core$Task$init=$elm$core$Task$succeed(0);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;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 0},$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(0)});var $elm$core$Task$cmdMap=F2(function(tagger,_v0){var task=_v0;return 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(A2($elm$core$Task$map,toMessage,task))});var $elm$core$Platform$Cmd$batch=_Platform_batch;var $elm$core$Platform$Cmd$none=$elm$core$Platform$Cmd$batch(_List_Nil);var $elm$core$Platform$Sub$batch=_Platform_batch;var $elm$core$Platform$Sub$none=$elm$core$Platform$Sub$batch(_List_Nil);var $elm$browser$Browser$sandbox=function(impl){return _Browser_element({aK:function(_v0){return _Utils_Tuple2(impl.aK,$elm$core$Platform$Cmd$none)},aZ:function(_v1){return $elm$core$Platform$Sub$none},a0:F2(function(msg,model){return _Utils_Tuple2(A2(impl.a0,msg,model),$elm$core$Platform$Cmd$none)}),a1:impl.a1})};var $elm$core$String$lines=_String_lines;var $author$project$QCM$Aremplacer=F2(function(_var,vals){return{ap:vals,aq:_var}});var $elm$parser$Parser$Optional=1;var $elm$core$Set$Set_elm_builtin=$elm$core$Basics$identity;var $elm$core$Dict$RBEmpty_elm_builtin={$:-2};var $elm$core$Dict$empty=$elm$core$Dict$RBEmpty_elm_builtin;var $elm$core$Set$empty=$elm$core$Dict$empty;var $elm$core$Dict$Black=1;var $elm$core$Dict$RBNode_elm_builtin=F5(function(a,b,c,d,e){return{$:-1,a:a,b:b,c:c,d:d,e:e}});var $elm$core$Dict$Red=0;var $elm$core$Dict$balance=F5(function(color,key,value,left,right){if(right.$===-1&&!right.a){var _v1=right.a;var rK=right.b;var rV=right.c;var rLeft=right.d;var rRight=right.e;if(left.$===-1&&!left.a){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,0,key,value,A5($elm$core$Dict$RBNode_elm_builtin,1,lK,lV,lLeft,lRight),A5($elm$core$Dict$RBNode_elm_builtin,1,rK,rV,rLeft,rRight))}else{return A5($elm$core$Dict$RBNode_elm_builtin,color,rK,rV,A5($elm$core$Dict$RBNode_elm_builtin,0,key,value,left,rLeft),rRight)}}else{if(left.$===-1&&!left.a&&left.d.$===-1&&!left.d.a){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,0,lK,lV,A5($elm$core$Dict$RBNode_elm_builtin,1,llK,llV,llLeft,llRight),A5($elm$core$Dict$RBNode_elm_builtin,1,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.$===-2){return A5($elm$core$Dict$RBNode_elm_builtin,0,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 0:return A5($elm$core$Dict$balance,nColor,nKey,nValue,A3($elm$core$Dict$insertHelp,key,value,nLeft),nRight);case 1: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.$===-1&&!_v0.a){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,1,k,v,l,r)}else{var x=_v0;return x}});var $elm$core$Set$insert=F2(function(key,_v0){var dict=_v0;return A3($elm$core$Dict$insert,key,0,dict)});var $elm$core$Set$fromList=function(list){return A3($elm$core$List$foldl,$elm$core$Set$insert,$elm$core$Set$empty,list)};var $elm$core$Basics$always=F2(function(a,_v0){return a});var $elm$parser$Parser$Advanced$Bad=F2(function(a,b){return{$:1,a:a,b:b}});var $elm$parser$Parser$Advanced$Good=F3(function(a,b,c){return{$:0,a:a,b:b,c:c}});var $elm$parser$Parser$Advanced$Parser=$elm$core$Basics$identity;var $elm$parser$Parser$Advanced$map2=F3(function(func,_v0,_v1){var parseA=_v0;var parseB=_v1;return function(s0){var _v2=parseA(s0);if(_v2.$===1){var p=_v2.a;var x=_v2.b;return A2($elm$parser$Parser$Advanced$Bad,p,x)}else{var p1=_v2.a;var a=_v2.b;var s1=_v2.c;var _v3=parseB(s1);if(_v3.$===1){var p2=_v3.a;var x=_v3.b;return A2($elm$parser$Parser$Advanced$Bad,p1||p2,x)}else{var p2=_v3.a;var b=_v3.b;var s2=_v3.c;return A3($elm$parser$Parser$Advanced$Good,p1||p2,A2(func,a,b),s2)}}}});var $elm$parser$Parser$Advanced$ignorer=F2(function(keepParser,ignoreParser){return A3($elm$parser$Parser$Advanced$map2,$elm$core$Basics$always,keepParser,ignoreParser)});var $elm$parser$Parser$ignorer=$elm$parser$Parser$Advanced$ignorer;var $elm$parser$Parser$Advanced$keeper=F2(function(parseFunc,parseArg){return A3($elm$parser$Parser$Advanced$map2,$elm$core$Basics$apL,parseFunc,parseArg)});var $elm$parser$Parser$keeper=$elm$parser$Parser$Advanced$keeper;var $elm$core$Basics$neq=_Utils_notEqual;var $elm$parser$Parser$Advanced$andThen=F2(function(callback,_v0){var parseA=_v0;return function(s0){var _v1=parseA(s0);if(_v1.$===1){var p=_v1.a;var x=_v1.b;return A2($elm$parser$Parser$Advanced$Bad,p,x)}else{var p1=_v1.a;var a=_v1.b;var s1=_v1.c;var _v2=callback(a);var parseB=_v2;var _v3=parseB(s1);if(_v3.$===1){var p2=_v3.a;var x=_v3.b;return A2($elm$parser$Parser$Advanced$Bad,p1||p2,x)}else{var p2=_v3.a;var b=_v3.b;var s2=_v3.c;return A3($elm$parser$Parser$Advanced$Good,p1||p2,b,s2)}}}});var $elm$parser$Parser$Advanced$loopHelp=F4(function(p,state,callback,s0){loopHelp:while(true){var _v0=callback(state);var parse=_v0;var _v1=parse(s0);if(!_v1.$){var p1=_v1.a;var step=_v1.b;var s1=_v1.c;if(!step.$){var newState=step.a;var $temp$p=p||p1,$temp$state=newState,$temp$callback=callback,$temp$s0=s1;p=$temp$p;state=$temp$state;callback=$temp$callback;s0=$temp$s0;continue loopHelp}else{var result=step.a;return A3($elm$parser$Parser$Advanced$Good,p||p1,result,s1)}}else{var p1=_v1.a;var x=_v1.b;return A2($elm$parser$Parser$Advanced$Bad,p||p1,x)}}});var $elm$parser$Parser$Advanced$loop=F2(function(state,callback){return function(s){return A4($elm$parser$Parser$Advanced$loopHelp,false,state,callback,s)}});var $elm$parser$Parser$Advanced$map=F2(function(func,_v0){var parse=_v0;return function(s0){var _v1=parse(s0);if(!_v1.$){var p=_v1.a;var a=_v1.b;var s1=_v1.c;return A3($elm$parser$Parser$Advanced$Good,p,func(a),s1)}else{var p=_v1.a;var x=_v1.b;return A2($elm$parser$Parser$Advanced$Bad,p,x)}}});var $elm$parser$Parser$Advanced$Empty={$:0};var $elm$parser$Parser$Advanced$Append=F2(function(a,b){return{$:2,a:a,b:b}});var $elm$parser$Parser$Advanced$oneOfHelp=F3(function(s0,bag,parsers){oneOfHelp:while(true){if(!parsers.b){return A2($elm$parser$Parser$Advanced$Bad,false,bag)}else{var parse=parsers.a;var remainingParsers=parsers.b;var _v1=parse(s0);if(!_v1.$){var step=_v1;return step}else{var step=_v1;var p=step.a;var x=step.b;if(p){return step}else{var $temp$s0=s0,$temp$bag=A2($elm$parser$Parser$Advanced$Append,bag,x),$temp$parsers=remainingParsers;s0=$temp$s0;bag=$temp$bag;parsers=$temp$parsers;continue oneOfHelp}}}}});var $elm$parser$Parser$Advanced$oneOf=function(parsers){return function(s){return A3($elm$parser$Parser$Advanced$oneOfHelp,s,$elm$parser$Parser$Advanced$Empty,parsers)}};var $elm$parser$Parser$Advanced$Done=function(a){return{$:1,a:a}};var $elm$parser$Parser$Advanced$Loop=function(a){return{$:0,a:a}};var $elm$parser$Parser$Advanced$revAlways=F2(function(_v0,b){return b});var $elm$parser$Parser$Advanced$skip=F2(function(iParser,kParser){return A3($elm$parser$Parser$Advanced$map2,$elm$parser$Parser$Advanced$revAlways,iParser,kParser)});var $elm$parser$Parser$Advanced$sequenceEndForbidden=F5(function(ender,ws,parseItem,sep,revItems){var chompRest=function(item){return A5($elm$parser$Parser$Advanced$sequenceEndForbidden,ender,ws,parseItem,sep,A2($elm$core$List$cons,item,revItems))};return A2($elm$parser$Parser$Advanced$skip,ws,$elm$parser$Parser$Advanced$oneOf(_List_fromArray([A2($elm$parser$Parser$Advanced$skip,sep,A2($elm$parser$Parser$Advanced$skip,ws,A2($elm$parser$Parser$Advanced$map,function(item){return $elm$parser$Parser$Advanced$Loop(A2($elm$core$List$cons,item,revItems))},parseItem))),A2($elm$parser$Parser$Advanced$map,function(_v0){return $elm$parser$Parser$Advanced$Done($elm$core$List$reverse(revItems))},ender)])))});var $elm$parser$Parser$Advanced$succeed=function(a){return function(s){return A3($elm$parser$Parser$Advanced$Good,false,a,s)}};var $elm$parser$Parser$Advanced$sequenceEndMandatory=F4(function(ws,parseItem,sep,revItems){return $elm$parser$Parser$Advanced$oneOf(_List_fromArray([A2($elm$parser$Parser$Advanced$map,function(item){return $elm$parser$Parser$Advanced$Loop(A2($elm$core$List$cons,item,revItems))},A2($elm$parser$Parser$Advanced$ignorer,parseItem,A2($elm$parser$Parser$Advanced$ignorer,ws,A2($elm$parser$Parser$Advanced$ignorer,sep,ws)))),A2($elm$parser$Parser$Advanced$map,function(_v0){return $elm$parser$Parser$Advanced$Done($elm$core$List$reverse(revItems))},$elm$parser$Parser$Advanced$succeed(0))]))});var $elm$parser$Parser$Advanced$sequenceEndOptional=F5(function(ender,ws,parseItem,sep,revItems){var parseEnd=A2($elm$parser$Parser$Advanced$map,function(_v0){return $elm$parser$Parser$Advanced$Done($elm$core$List$reverse(revItems))},ender);return A2($elm$parser$Parser$Advanced$skip,ws,$elm$parser$Parser$Advanced$oneOf(_List_fromArray([A2($elm$parser$Parser$Advanced$skip,sep,A2($elm$parser$Parser$Advanced$skip,ws,$elm$parser$Parser$Advanced$oneOf(_List_fromArray([A2($elm$parser$Parser$Advanced$map,function(item){return $elm$parser$Parser$Advanced$Loop(A2($elm$core$List$cons,item,revItems))},parseItem),parseEnd])))),parseEnd])))});var $elm$parser$Parser$Advanced$sequenceEnd=F5(function(ender,ws,parseItem,sep,trailing){var chompRest=function(item){switch(trailing){case 0:return A2($elm$parser$Parser$Advanced$loop,_List_fromArray([item]),A4($elm$parser$Parser$Advanced$sequenceEndForbidden,ender,ws,parseItem,sep));case 1:return A2($elm$parser$Parser$Advanced$loop,_List_fromArray([item]),A4($elm$parser$Parser$Advanced$sequenceEndOptional,ender,ws,parseItem,sep));default:return A2($elm$parser$Parser$Advanced$ignorer,A2($elm$parser$Parser$Advanced$skip,ws,A2($elm$parser$Parser$Advanced$skip,sep,A2($elm$parser$Parser$Advanced$skip,ws,A2($elm$parser$Parser$Advanced$loop,_List_fromArray([item]),A3($elm$parser$Parser$Advanced$sequenceEndMandatory,ws,parseItem,sep))))),ender)}};return $elm$parser$Parser$Advanced$oneOf(_List_fromArray([A2($elm$parser$Parser$Advanced$andThen,chompRest,parseItem),A2($elm$parser$Parser$Advanced$map,function(_v0){return _List_Nil},ender)]))});var $elm$parser$Parser$Advanced$AddRight=F2(function(a,b){return{$:1,a:a,b:b}});var $elm$parser$Parser$Advanced$DeadEnd=F4(function(row,col,problem,contextStack){return{aA:col,aB:contextStack,aU:problem,ak:row}});var $elm$parser$Parser$Advanced$fromState=F2(function(s,x){return A2($elm$parser$Parser$Advanced$AddRight,$elm$parser$Parser$Advanced$Empty,A4($elm$parser$Parser$Advanced$DeadEnd,s.ak,s.aA,x,s.c))});var $elm$parser$Parser$Advanced$isSubString=_Parser_isSubString;var $elm$core$Basics$negate=function(n){return-n};var $elm$core$Basics$not=_Basics_not;var $elm$parser$Parser$Advanced$token=function(_v0){var str=_v0.a;var expecting=_v0.b;var progress=!$elm$core$String$isEmpty(str);return function(s){var _v1=A5($elm$parser$Parser$Advanced$isSubString,str,s.b,s.ak,s.aA,s.a);var newOffset=_v1.a;var newRow=_v1.b;var newCol=_v1.c;return _Utils_eq(newOffset,-1)?A2($elm$parser$Parser$Advanced$Bad,false,A2($elm$parser$Parser$Advanced$fromState,s,expecting)):A3($elm$parser$Parser$Advanced$Good,progress,0,{aA:newCol,c:s.c,d:s.d,b:newOffset,ak:newRow,a:s.a})}};var $elm$parser$Parser$Advanced$sequence=function(i){return A2($elm$parser$Parser$Advanced$skip,$elm$parser$Parser$Advanced$token(i.am),A2($elm$parser$Parser$Advanced$skip,i.aY,A5($elm$parser$Parser$Advanced$sequenceEnd,$elm$parser$Parser$Advanced$token(i.aE),i.aY,i.aO,$elm$parser$Parser$Advanced$token(i.aX),i.a$)))};var $elm$parser$Parser$Advanced$Forbidden=0;var $elm$parser$Parser$Advanced$Mandatory=2;var $elm$parser$Parser$Advanced$Optional=1;var $elm$parser$Parser$toAdvancedTrailing=function(trailing){switch(trailing){case 0:return 0;case 1:return 1;default:return 2}};var $elm$parser$Parser$Expecting=function(a){return{$:0,a:a}};var $elm$parser$Parser$Advanced$Token=F2(function(a,b){return{$:0,a:a,b:b}});var $elm$parser$Parser$toToken=function(str){return A2($elm$parser$Parser$Advanced$Token,str,$elm$parser$Parser$Expecting(str))};var $elm$parser$Parser$sequence=function(i){return $elm$parser$Parser$Advanced$sequence({aE:$elm$parser$Parser$toToken(i.aE),aO:i.aO,aX:$elm$parser$Parser$toToken(i.aX),aY:i.aY,am:$elm$parser$Parser$toToken(i.am),a$:$elm$parser$Parser$toAdvancedTrailing(i.a$)})};var $elm$parser$Parser$Advanced$isSubChar=_Parser_isSubChar;var $elm$parser$Parser$Advanced$chompWhileHelp=F5(function(isGood,offset,row,col,s0){chompWhileHelp:while(true){var newOffset=A3($elm$parser$Parser$Advanced$isSubChar,isGood,offset,s0.a);if(_Utils_eq(newOffset,-1)){return A3($elm$parser$Parser$Advanced$Good,_Utils_cmp(s0.b,offset)<0,0,{aA:col,c:s0.c,d:s0.d,b:offset,ak:row,a:s0.a})}else{if(_Utils_eq(newOffset,-2)){var $temp$isGood=isGood,$temp$offset=offset+1,$temp$row=row+1,$temp$col=1,$temp$s0=s0;isGood=$temp$isGood;offset=$temp$offset;row=$temp$row;col=$temp$col;s0=$temp$s0;continue chompWhileHelp}else{var $temp$isGood=isGood,$temp$offset=newOffset,$temp$row=row,$temp$col=col+1,$temp$s0=s0;isGood=$temp$isGood;offset=$temp$offset;row=$temp$row;col=$temp$col;s0=$temp$s0;continue chompWhileHelp}}}});var $elm$parser$Parser$Advanced$chompWhile=function(isGood){return function(s){return A5($elm$parser$Parser$Advanced$chompWhileHelp,isGood,s.b,s.ak,s.aA,s)}};var $elm$parser$Parser$Advanced$spaces=$elm$parser$Parser$Advanced$chompWhile(function(c){return c===" "||(c==="\n"||c==="\r")});var $elm$parser$Parser$spaces=$elm$parser$Parser$Advanced$spaces;var $elm$parser$Parser$succeed=$elm$parser$Parser$Advanced$succeed;var $elm$parser$Parser$ExpectingSymbol=function(a){return{$:8,a:a}};var $elm$parser$Parser$Advanced$symbol=$elm$parser$Parser$Advanced$token;var $elm$parser$Parser$symbol=function(str){return $elm$parser$Parser$Advanced$symbol(A2($elm$parser$Parser$Advanced$Token,str,$elm$parser$Parser$ExpectingSymbol(str)))};var $elm$parser$Parser$ExpectingVariable={$:7};var $elm$core$Dict$get=F2(function(targetKey,dict){get:while(true){if(dict.$===-2){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 0:var $temp$targetKey=targetKey,$temp$dict=left;targetKey=$temp$targetKey;dict=$temp$dict;continue get;case 1:return $elm$core$Maybe$Just(value);default:var $temp$targetKey=targetKey,$temp$dict=right;targetKey=$temp$targetKey;dict=$temp$dict;continue get}}}});var $elm$core$Dict$member=F2(function(key,dict){var _v0=A2($elm$core$Dict$get,key,dict);if(!_v0.$){return true}else{return false}});var $elm$core$Set$member=F2(function(key,_v0){var dict=_v0;return A2($elm$core$Dict$member,key,dict)});var $elm$parser$Parser$Advanced$varHelp=F7(function(isGood,offset,row,col,src,indent,context){varHelp:while(true){var newOffset=A3($elm$parser$Parser$Advanced$isSubChar,isGood,offset,src);if(_Utils_eq(newOffset,-1)){return{aA:col,c:context,d:indent,b:offset,ak:row,a:src}}else{if(_Utils_eq(newOffset,-2)){var $temp$isGood=isGood,$temp$offset=offset+1,$temp$row=row+1,$temp$col=1,$temp$src=src,$temp$indent=indent,$temp$context=context;isGood=$temp$isGood;offset=$temp$offset;row=$temp$row;col=$temp$col;src=$temp$src;indent=$temp$indent;context=$temp$context;continue varHelp}else{var $temp$isGood=isGood,$temp$offset=newOffset,$temp$row=row,$temp$col=col+1,$temp$src=src,$temp$indent=indent,$temp$context=context;isGood=$temp$isGood;offset=$temp$offset;row=$temp$row;col=$temp$col;src=$temp$src;indent=$temp$indent;context=$temp$context;continue varHelp}}}});var $elm$parser$Parser$Advanced$variable=function(i){return function(s){var firstOffset=A3($elm$parser$Parser$Advanced$isSubChar,i.am,s.b,s.a);if(_Utils_eq(firstOffset,-1)){return A2($elm$parser$Parser$Advanced$Bad,false,A2($elm$parser$Parser$Advanced$fromState,s,i.W))}else{var s1=_Utils_eq(firstOffset,-2)?A7($elm$parser$Parser$Advanced$varHelp,i.aL,s.b+1,s.ak+1,1,s.a,s.d,s.c):A7($elm$parser$Parser$Advanced$varHelp,i.aL,firstOffset,s.ak,s.aA+1,s.a,s.d,s.c);var name=A3($elm$core$String$slice,s.b,s1.b,s.a);return A2($elm$core$Set$member,name,i.aV)?A2($elm$parser$Parser$Advanced$Bad,false,A2($elm$parser$Parser$Advanced$fromState,s,i.W)):A3($elm$parser$Parser$Advanced$Good,true,name,s1)}}};var $elm$parser$Parser$variable=function(i){return $elm$parser$Parser$Advanced$variable({W:$elm$parser$Parser$ExpectingVariable,aL:i.aL,aV:i.aV,am:i.am})};var $author$project$QCM$aRemplacer=A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$succeed($author$project$QCM$Aremplacer),$elm$parser$Parser$spaces),A2($elm$parser$Parser$ignorer,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$variable({aL:$elm$core$Char$isAlpha,aV:$elm$core$Set$fromList(_List_Nil),am:function(_v0){return true}}),$elm$parser$Parser$spaces),$elm$parser$Parser$symbol(":"))),$elm$parser$Parser$sequence({aE:"",aO:$elm$parser$Parser$variable({aL:$elm$core$Basics$neq(","),aV:$elm$core$Set$fromList(_List_Nil),am:$elm$core$Basics$neq(",")}),aX:",",aY:$elm$parser$Parser$spaces,am:"",a$:1}));var $elm$parser$Parser$DeadEnd=F3(function(row,col,problem){return{aA:col,aU:problem,ak:row}});var $elm$parser$Parser$problemToDeadEnd=function(p){return A3($elm$parser$Parser$DeadEnd,p.ak,p.aA,p.aU)};var $elm$parser$Parser$Advanced$bagToList=F2(function(bag,list){bagToList:while(true){switch(bag.$){case 0:return list;case 1:var bag1=bag.a;var x=bag.b;var $temp$bag=bag1,$temp$list=A2($elm$core$List$cons,x,list);bag=$temp$bag;list=$temp$list;continue bagToList;default:var bag1=bag.a;var bag2=bag.b;var $temp$bag=bag1,$temp$list=A2($elm$parser$Parser$Advanced$bagToList,bag2,list);bag=$temp$bag;list=$temp$list;continue bagToList}}});var $elm$parser$Parser$Advanced$run=F2(function(_v0,src){var parse=_v0;var _v1=parse({aA:1,c:_List_Nil,d:1,b:0,ak:1,a:src});if(!_v1.$){var value=_v1.b;return $elm$core$Result$Ok(value)}else{var bag=_v1.b;return $elm$core$Result$Err(A2($elm$parser$Parser$Advanced$bagToList,bag,_List_Nil))}});var $elm$parser$Parser$run=F2(function(parser,source){var _v0=A2($elm$parser$Parser$Advanced$run,parser,source);if(!_v0.$){var a=_v0.a;return $elm$core$Result$Ok(a)}else{var problems=_v0.a;return $elm$core$Result$Err(A2($elm$core$List$map,$elm$parser$Parser$problemToDeadEnd,problems))}});var $author$project$QCM$parserAremplacer=function(variables){var _v0=A2($elm$parser$Parser$run,$author$project$QCM$aRemplacer,variables);if(!_v0.$){var ars=_v0.a;return ars}else{return A2($author$project$QCM$Aremplacer,"",_List_Nil)}};var $elm$parser$Parser$map=$elm$parser$Parser$Advanced$map;var $elm$parser$Parser$toAdvancedStep=function(step){if(!step.$){var s=step.a;return $elm$parser$Parser$Advanced$Loop(s)}else{var a=step.a;return $elm$parser$Parser$Advanced$Done(a)}};var $elm$parser$Parser$loop=F2(function(state,callback){return A2($elm$parser$Parser$Advanced$loop,state,function(s){return A2($elm$parser$Parser$map,$elm$parser$Parser$toAdvancedStep,callback(s))})});var $elm$parser$Parser$Done=function(a){return{$:1,a:a}};var $elm$parser$Parser$Loop=function(a){return{$:0,a:a}};var $author$project$QCM$Variable=function(a){return{$:1,a:a}};var $elm$parser$Parser$Advanced$findSubString=_Parser_findSubString;var $elm$parser$Parser$Advanced$fromInfo=F4(function(row,col,x,context){return A2($elm$parser$Parser$Advanced$AddRight,$elm$parser$Parser$Advanced$Empty,A4($elm$parser$Parser$Advanced$DeadEnd,row,col,x,context))});var $elm$parser$Parser$Advanced$chompUntil=function(_v0){var str=_v0.a;var expecting=_v0.b;return function(s){var _v1=A5($elm$parser$Parser$Advanced$findSubString,str,s.b,s.ak,s.aA,s.a);var newOffset=_v1.a;var newRow=_v1.b;var newCol=_v1.c;return _Utils_eq(newOffset,-1)?A2($elm$parser$Parser$Advanced$Bad,false,A4($elm$parser$Parser$Advanced$fromInfo,newRow,newCol,expecting,s.c)):A3($elm$parser$Parser$Advanced$Good,_Utils_cmp(s.b,newOffset)<0,0,{aA:newCol,c:s.c,d:s.d,b:newOffset,ak:newRow,a:s.a})}};var $elm$parser$Parser$chompUntil=function(str){return $elm$parser$Parser$Advanced$chompUntil($elm$parser$Parser$toToken(str))};var $elm$parser$Parser$Advanced$mapChompedString=F2(function(func,_v0){var parse=_v0;return function(s0){var _v1=parse(s0);if(_v1.$===1){var p=_v1.a;var x=_v1.b;return A2($elm$parser$Parser$Advanced$Bad,p,x)}else{var p=_v1.a;var a=_v1.b;var s1=_v1.c;return A3($elm$parser$Parser$Advanced$Good,p,A2(func,A3($elm$core$String$slice,s0.b,s1.b,s0.a),a),s1)}}});var $elm$parser$Parser$Advanced$getChompedString=function(parser){return A2($elm$parser$Parser$Advanced$mapChompedString,$elm$core$Basics$always,parser)};var $elm$parser$Parser$getChompedString=$elm$parser$Parser$Advanced$getChompedString;var $author$project$QCM$expressionVariable=A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$succeed($author$project$QCM$Variable),$elm$parser$Parser$symbol("#")),A2($elm$parser$Parser$ignorer,$elm$parser$Parser$getChompedString($elm$parser$Parser$chompUntil("#")),$elm$parser$Parser$symbol("#")));var $elm$parser$Parser$oneOf=$elm$parser$Parser$Advanced$oneOf;var $author$project$QCM$Texte=function(a){return{$:0,a:a}};var $elm$parser$Parser$UnexpectedChar={$:11};var $elm$parser$Parser$Advanced$chompIf=F2(function(isGood,expecting){return function(s){var newOffset=A3($elm$parser$Parser$Advanced$isSubChar,isGood,s.b,s.a);return _Utils_eq(newOffset,-1)?A2($elm$parser$Parser$Advanced$Bad,false,A2($elm$parser$Parser$Advanced$fromState,s,expecting)):_Utils_eq(newOffset,-2)?A3($elm$parser$Parser$Advanced$Good,true,0,{aA:1,c:s.c,d:s.d,b:s.b+1,ak:s.ak+1,a:s.a}):A3($elm$parser$Parser$Advanced$Good,true,0,{aA:s.aA+1,c:s.c,d:s.d,b:newOffset,ak:s.ak,a:s.a})}});var $elm$parser$Parser$chompIf=function(isGood){return A2($elm$parser$Parser$Advanced$chompIf,isGood,$elm$parser$Parser$UnexpectedChar)};var $elm$parser$Parser$chompWhile=$elm$parser$Parser$Advanced$chompWhile;var $author$project$QCM$texteSansVariables=A2($elm$parser$Parser$keeper,$elm$parser$Parser$succeed($author$project$QCM$Texte),$elm$parser$Parser$getChompedString(A2($elm$parser$Parser$ignorer,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$succeed(0),$elm$parser$Parser$chompIf($elm$core$Basics$neq("#"))),$elm$parser$Parser$chompWhile($elm$core$Basics$neq("#")))));var $author$project$QCM$questionsBis=function(ls){return $elm$parser$Parser$oneOf(_List_fromArray([A2($elm$parser$Parser$keeper,$elm$parser$Parser$succeed(function(l){return $elm$parser$Parser$Loop(A2($elm$core$List$cons,l,ls))}),$elm$parser$Parser$oneOf(_List_fromArray([$author$project$QCM$expressionVariable,$author$project$QCM$texteSansVariables]))),A2($elm$parser$Parser$map,function(_v0){return $elm$parser$Parser$Done($elm$core$List$reverse(ls))},$elm$parser$Parser$succeed(0))]))};var $author$project$QCM$questions=A2($elm$parser$Parser$loop,_List_Nil,$author$project$QCM$questionsBis);var $author$project$QCM$parserQuestion=function(question){var _v0=A2($elm$parser$Parser$run,$author$project$QCM$questions,question);if(!_v0.$){var macro=_v0.a;return macro}else{return _List_Nil}};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 $elm$core$List$concat=function(lists){return A3($elm$core$List$foldr,$elm$core$List$append,_List_Nil,lists)};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 $author$project$QCM$remplacerLaVariableParLaValeurDansLeTexteVariable=F3(function(_var,val,tv){if(!tv.$){var chaine=tv.a;return $author$project$QCM$Texte(chaine)}else{var chaine=tv.a;return $author$project$QCM$Variable(A3($elm$core$String$replace,_var,val,chaine))}});var $author$project$QCM$remplacerLaVariableParLaValeurDansLaMacro=F3(function(_var,val,macro){return A2($elm$core$List$map,A2($author$project$QCM$remplacerLaVariableParLaValeurDansLeTexteVariable,_var,val),macro)});var $author$project$QCM$remplacerLaVariableDansLaMacro=F2(function(ar,macro){var f=function(val){return A3($author$project$QCM$remplacerLaVariableParLaValeurDansLaMacro,ar.aq,val,macro)};return A2($elm$core$List$map,f,ar.ap)});var $author$project$QCM$remplacerLesVariablesDansLaMacroBis=F2(function(ars,macros){if(!ars.b){return macros}else{var ar=ars.a;var arss=ars.b;return A2($author$project$QCM$remplacerLesVariablesDansLaMacroBis,arss,$elm$core$List$concat(A2($elm$core$List$map,$author$project$QCM$remplacerLaVariableDansLaMacro(ar),macros)))}});var $elm$core$String$concat=function(strings){return A2($elm$core$String$join,"",strings)};var $author$project$Fractions$Frac=F2(function(num,den){return{f:den,e:num}});var $elm$core$Basics$abs=function(n){return n<0?-n:n};var $elm$core$Basics$modBy=_Basics_modBy;var $lynn$elm_arithmetic$Arithmetic$gcd=F2(function(a,b){var gcd_=F2(function(x,y){gcd_:while(true){if(!y){return x}else{var $temp$x=y,$temp$y=A2($elm$core$Basics$modBy,y,x);x=$temp$x;y=$temp$y;continue gcd_}}});return A2(gcd_,$elm$core$Basics$abs(a),$elm$core$Basics$abs(b))});var $author$project$Fractions$simplifier=function(a){var sgnDuDen=a.f<0?-1:1;var pgcd=A2($lynn$elm_arithmetic$Arithmetic$gcd,a.e,a.f);return A2($author$project$Fractions$Frac,sgnDuDen*a.e/pgcd|0,sgnDuDen*a.f/pgcd|0)};var $author$project$Fractions$add=F2(function(a,b){return $author$project$Fractions$simplifier(A2($author$project$Fractions$Frac,a.e*b.f+a.f*b.e,a.f*b.f))});var $author$project$Fractions$inv=function(a){return $author$project$Fractions$simplifier(A2($author$project$Fractions$Frac,a.f,a.e))};var $author$project$Fractions$mul=F2(function(a,b){return $author$project$Fractions$simplifier(A2($author$project$Fractions$Frac,a.e*b.e,a.f*b.f))});var $author$project$Fractions$div=F2(function(a,b){return $author$project$Fractions$simplifier(A2($author$project$Fractions$mul,a,$author$project$Fractions$inv(b)))});var $elm$core$Basics$pow=_Basics_pow;var $author$project$Fractions$exp=F2(function(a,b){var bb=$author$project$Fractions$simplifier(b);var sgnDeB=bb.e<0?-1:1;var aa=$author$project$Fractions$simplifier(a);var sgnDeA=aa.e<0?-1:1;return bb.f===1&&bb.e<0?$elm$core$Maybe$Just(A2($author$project$Fractions$Frac,A2($elm$core$Basics$pow,sgnDeA*aa.f,sgnDeB*bb.e),A2($elm$core$Basics$pow,sgnDeA*aa.e,sgnDeB*bb.e))):bb.f===1?$elm$core$Maybe$Just(A2($author$project$Fractions$Frac,A2($elm$core$Basics$pow,aa.e,bb.e),A2($elm$core$Basics$pow,aa.f,bb.e))):$elm$core$Maybe$Nothing});var $elm$core$Maybe$map=F2(function(f,maybe){if(!maybe.$){var value=maybe.a;return $elm$core$Maybe$Just(f(value))}else{return $elm$core$Maybe$Nothing}});var $elm$core$Maybe$map2=F3(function(func,ma,mb){if(ma.$===1){return $elm$core$Maybe$Nothing}else{var a=ma.a;if(mb.$===1){return $elm$core$Maybe$Nothing}else{var b=mb.a;return $elm$core$Maybe$Just(A2(func,a,b))}}});var $author$project$Fractions$neg=function(a){return $author$project$Fractions$simplifier(A2($author$project$Fractions$Frac,-a.e,a.f))};var $author$project$Fractions$sub=F2(function(a,b){return $author$project$Fractions$simplifier(A2($author$project$Fractions$add,a,$author$project$Fractions$neg(b)))});var $author$project$ParserMaths$evaluer=function(expression){evaluer:while(true){switch(expression.$){case 0:var a=expression.a;var b=expression.b;return A3($elm$core$Maybe$map2,$author$project$Fractions$add,$author$project$ParserMaths$evaluer(a),$author$project$ParserMaths$evaluer(b));case 1:var a=expression.a;var b=expression.b;return A3($elm$core$Maybe$map2,$author$project$Fractions$sub,$author$project$ParserMaths$evaluer(a),$author$project$ParserMaths$evaluer(b));case 2:var a=expression.a;var b=expression.b;return A3($elm$core$Maybe$map2,$author$project$Fractions$mul,$author$project$ParserMaths$evaluer(a),$author$project$ParserMaths$evaluer(b));case 3:var a=expression.a;var b=expression.b;return A3($elm$core$Maybe$map2,$author$project$Fractions$div,$author$project$ParserMaths$evaluer(a),$author$project$ParserMaths$evaluer(b));case 4:var a=expression.a;var b=expression.b;var _v1=A3($elm$core$Maybe$map2,$author$project$Fractions$exp,$author$project$ParserMaths$evaluer(a),$author$project$ParserMaths$evaluer(b));if(_v1.$===1){return $elm$core$Maybe$Nothing}else{var p=_v1.a;return p}case 5:var a=expression.a;return A2($elm$core$Maybe$map,$author$project$Fractions$neg,$author$project$ParserMaths$evaluer(a));case 7:var l=expression.a;var $temp$expression=l;expression=$temp$expression;continue evaluer;case 6:var n=expression.a;return $elm$core$Maybe$Just(A2($author$project$Fractions$Frac,n,1));default:var a_i=expression.a;var x=expression.b;return $elm$core$Maybe$Just(A2($author$project$Fractions$Frac,50,1))}}};var $author$project$ParserMaths$AddOp=2;var $author$project$ParserMaths$DivOp=1;var $author$project$ParserMaths$ExpOp=4;var $elm$parser$Parser$Forbidden=0;var $author$project$ParserMaths$Grouping=function(a){return{$:7,a:a}};var $author$project$ParserMaths$MulOp=0;var $author$project$ParserMaths$Neg=function(a){return{$:5,a:a}};var $author$project$ParserMaths$NoOperand={$:0};var $author$project$ParserMaths$Operand=F2(function(a,b){return{$:1,a:a,b:b}});var $author$project$ParserMaths$Poly=F2(function(a,b){return{$:8,a:a,b:b}});var $author$project$ParserMaths$SubOp=3;var $author$project$ParserMaths$Add=F2(function(a,b){return{$:0,a:a,b:b}});var $author$project$ParserMaths$Div=F2(function(a,b){return{$:3,a:a,b:b}});var $author$project$ParserMaths$Exp=F2(function(a,b){return{$:4,a:a,b:b}});var $author$project$ParserMaths$Mul=F2(function(a,b){return{$:2,a:a,b:b}});var $author$project$ParserMaths$Sub=F2(function(a,b){return{$:1,a:a,b:b}});var $author$project$ParserMaths$binary=F2(function(a,b){if(!b.$){return a}else{var op=b.a;var e=b.b;switch(op){case 0:return A2($author$project$ParserMaths$Mul,a,e);case 1:return A2($author$project$ParserMaths$Div,a,e);case 2:return A2($author$project$ParserMaths$Add,a,e);case 3:return A2($author$project$ParserMaths$Sub,a,e);default:return A2($author$project$ParserMaths$Exp,a,e)}}});var $author$project$ParserMaths$foldBinary=F2(function(left,operands){return A3($elm$core$List$foldr,F2(function(operand,expression){return A2($author$project$ParserMaths$binary,expression,operand)}),left,operands)});var $elm$parser$Parser$ExpectingKeyword=function(a){return{$:9,a:a}};var $elm$parser$Parser$Advanced$keyword=function(_v0){var kwd=_v0.a;var expecting=_v0.b;var progress=!$elm$core$String$isEmpty(kwd);return function(s){var _v1=A5($elm$parser$Parser$Advanced$isSubString,kwd,s.b,s.ak,s.aA,s.a);var newOffset=_v1.a;var newRow=_v1.b;var newCol=_v1.c;return _Utils_eq(newOffset,-1)||0<=A3($elm$parser$Parser$Advanced$isSubChar,function(c){return $elm$core$Char$isAlphaNum(c)||c==="_"},newOffset,s.a)?A2($elm$parser$Parser$Advanced$Bad,false,A2($elm$parser$Parser$Advanced$fromState,s,expecting)):A3($elm$parser$Parser$Advanced$Good,progress,0,{aA:newCol,c:s.c,d:s.d,b:newOffset,ak:newRow,a:s.a})}};var $elm$parser$Parser$keyword=function(kwd){return $elm$parser$Parser$Advanced$keyword(A2($elm$parser$Parser$Advanced$Token,kwd,$elm$parser$Parser$ExpectingKeyword(kwd)))};var $elm$parser$Parser$Advanced$lazy=function(thunk){return function(s){var _v0=thunk(0);var parse=_v0;return parse(s)}};var $elm$parser$Parser$lazy=$elm$parser$Parser$Advanced$lazy;var $author$project$ParserMaths$Entier=function(a){return{$:6,a:a}};var $elm$parser$Parser$ExpectingBinary={$:4};var $elm$parser$Parser$ExpectingFloat={$:5};var $elm$parser$Parser$ExpectingHex={$:2};var $elm$parser$Parser$ExpectingInt={$:1};var $elm$parser$Parser$ExpectingNumber={$:6};var $elm$parser$Parser$ExpectingOctal={$:3};var $elm$core$Result$fromMaybe=F2(function(err,maybe){if(!maybe.$){var v=maybe.a;return $elm$core$Result$Ok(v)}else{return $elm$core$Result$Err(err)}});var $elm$parser$Parser$Advanced$consumeBase=_Parser_consumeBase;var $elm$parser$Parser$Advanced$consumeBase16=_Parser_consumeBase16;var $elm$parser$Parser$Advanced$bumpOffset=F2(function(newOffset,s){return{aA:s.aA+(newOffset-s.b),c:s.c,d:s.d,b:newOffset,ak:s.ak,a:s.a}});var $elm$parser$Parser$Advanced$chompBase10=_Parser_chompBase10;var $elm$parser$Parser$Advanced$isAsciiCode=_Parser_isAsciiCode;var $elm$parser$Parser$Advanced$consumeExp=F2(function(offset,src){if(A3($elm$parser$Parser$Advanced$isAsciiCode,101,offset,src)||A3($elm$parser$Parser$Advanced$isAsciiCode,69,offset,src)){var eOffset=offset+1;var expOffset=A3($elm$parser$Parser$Advanced$isAsciiCode,43,eOffset,src)||A3($elm$parser$Parser$Advanced$isAsciiCode,45,eOffset,src)?eOffset+1:eOffset;var newOffset=A2($elm$parser$Parser$Advanced$chompBase10,expOffset,src);return _Utils_eq(expOffset,newOffset)?-newOffset:newOffset}else{return offset}});var $elm$parser$Parser$Advanced$consumeDotAndExp=F2(function(offset,src){return A3($elm$parser$Parser$Advanced$isAsciiCode,46,offset,src)?A2($elm$parser$Parser$Advanced$consumeExp,A2($elm$parser$Parser$Advanced$chompBase10,offset+1,src),src):A2($elm$parser$Parser$Advanced$consumeExp,offset,src)});var $elm$parser$Parser$Advanced$finalizeInt=F5(function(invalid,handler,startOffset,_v0,s){var endOffset=_v0.a;var n=_v0.b;if(handler.$===1){var x=handler.a;return A2($elm$parser$Parser$Advanced$Bad,true,A2($elm$parser$Parser$Advanced$fromState,s,x))}else{var toValue=handler.a;return _Utils_eq(startOffset,endOffset)?A2($elm$parser$Parser$Advanced$Bad,_Utils_cmp(s.b,startOffset)<0,A2($elm$parser$Parser$Advanced$fromState,s,invalid)):A3($elm$parser$Parser$Advanced$Good,true,toValue(n),A2($elm$parser$Parser$Advanced$bumpOffset,endOffset,s))}});var $elm$core$String$toFloat=_String_toFloat;var $elm$parser$Parser$Advanced$finalizeFloat=F6(function(invalid,expecting,intSettings,floatSettings,intPair,s){var intOffset=intPair.a;var floatOffset=A2($elm$parser$Parser$Advanced$consumeDotAndExp,intOffset,s.a);if(floatOffset<0){return A2($elm$parser$Parser$Advanced$Bad,true,A4($elm$parser$Parser$Advanced$fromInfo,s.ak,s.aA-(floatOffset+s.b),invalid,s.c))}else{if(_Utils_eq(s.b,floatOffset)){return A2($elm$parser$Parser$Advanced$Bad,false,A2($elm$parser$Parser$Advanced$fromState,s,expecting))}else{if(_Utils_eq(intOffset,floatOffset)){return A5($elm$parser$Parser$Advanced$finalizeInt,invalid,intSettings,s.b,intPair,s)}else{if(floatSettings.$===1){var x=floatSettings.a;return A2($elm$parser$Parser$Advanced$Bad,true,A2($elm$parser$Parser$Advanced$fromState,s,invalid))}else{var toValue=floatSettings.a;var _v1=$elm$core$String$toFloat(A3($elm$core$String$slice,s.b,floatOffset,s.a));if(_v1.$===1){return A2($elm$parser$Parser$Advanced$Bad,true,A2($elm$parser$Parser$Advanced$fromState,s,invalid))}else{var n=_v1.a;return A3($elm$parser$Parser$Advanced$Good,true,toValue(n),A2($elm$parser$Parser$Advanced$bumpOffset,floatOffset,s))}}}}}});var $elm$parser$Parser$Advanced$number=function(c){return function(s){if(A3($elm$parser$Parser$Advanced$isAsciiCode,48,s.b,s.a)){var zeroOffset=s.b+1;var baseOffset=zeroOffset+1;return A3($elm$parser$Parser$Advanced$isAsciiCode,120,zeroOffset,s.a)?A5($elm$parser$Parser$Advanced$finalizeInt,c.aN,c.aH,baseOffset,A2($elm$parser$Parser$Advanced$consumeBase16,baseOffset,s.a),s):A3($elm$parser$Parser$Advanced$isAsciiCode,111,zeroOffset,s.a)?A5($elm$parser$Parser$Advanced$finalizeInt,c.aN,c.aQ,baseOffset,A3($elm$parser$Parser$Advanced$consumeBase,8,baseOffset,s.a),s):A3($elm$parser$Parser$Advanced$isAsciiCode,98,zeroOffset,s.a)?A5($elm$parser$Parser$Advanced$finalizeInt,c.aN,c.ax,baseOffset,A3($elm$parser$Parser$Advanced$consumeBase,2,baseOffset,s.a),s):A6($elm$parser$Parser$Advanced$finalizeFloat,c.aN,c.W,c.aM,c.aG,_Utils_Tuple2(zeroOffset,0),s)}else{return A6($elm$parser$Parser$Advanced$finalizeFloat,c.aN,c.W,c.aM,c.aG,A3($elm$parser$Parser$Advanced$consumeBase,10,s.b,s.a),s)}}};var $elm$parser$Parser$number=function(i){return $elm$parser$Parser$Advanced$number({ax:A2($elm$core$Result$fromMaybe,$elm$parser$Parser$ExpectingBinary,i.ax),W:$elm$parser$Parser$ExpectingNumber,aG:A2($elm$core$Result$fromMaybe,$elm$parser$Parser$ExpectingFloat,i.aG),aH:A2($elm$core$Result$fromMaybe,$elm$parser$Parser$ExpectingHex,i.aH),aM:A2($elm$core$Result$fromMaybe,$elm$parser$Parser$ExpectingInt,i.aM),aN:$elm$parser$Parser$ExpectingNumber,aQ:A2($elm$core$Result$fromMaybe,$elm$parser$Parser$ExpectingOctal,i.aQ)})};var $author$project$ParserMaths$nombre=A2($elm$parser$Parser$keeper,$elm$parser$Parser$succeed($author$project$ParserMaths$Entier),$elm$parser$Parser$number({ax:$elm$core$Maybe$Nothing,aG:$elm$core$Maybe$Nothing,aH:$elm$core$Maybe$Nothing,aM:$elm$core$Maybe$Just($elm$core$Basics$identity),aQ:$elm$core$Maybe$Nothing}));var $author$project$ParserMaths$addHelper=function(operands){return $elm$parser$Parser$oneOf(_List_fromArray([A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$ignorer,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$succeed(function(right){return $elm$parser$Parser$Loop(A2($elm$core$List$cons,A2($author$project$ParserMaths$Operand,2,right),operands))}),$elm$parser$Parser$symbol("+")),$elm$parser$Parser$spaces),$elm$parser$Parser$lazy(function(_v9){return $author$project$ParserMaths$cyclic$mul()})),A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$ignorer,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$succeed(function(right){return $elm$parser$Parser$Loop(A2($elm$core$List$cons,A2($author$project$ParserMaths$Operand,3,right),operands))}),$elm$parser$Parser$symbol("-")),$elm$parser$Parser$spaces),$elm$parser$Parser$lazy(function(_v10){return $author$project$ParserMaths$cyclic$mul()})),A2($elm$parser$Parser$map,function(_v11){return $elm$parser$Parser$Done(operands)},$elm$parser$Parser$succeed(0))]))};var $author$project$ParserMaths$mulHelper=function(operands){return $elm$parser$Parser$oneOf(_List_fromArray([A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$ignorer,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$succeed(function(right){return $elm$parser$Parser$Loop(A2($elm$core$List$cons,A2($author$project$ParserMaths$Operand,0,right),operands))}),$elm$parser$Parser$symbol("*")),$elm$parser$Parser$spaces),$elm$parser$Parser$lazy(function(_v3){return $author$project$ParserMaths$cyclic$exp()})),A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$ignorer,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$succeed(function(right){return $elm$parser$Parser$Loop(A2($elm$core$List$cons,A2($author$project$ParserMaths$Operand,1,right),operands))}),$elm$parser$Parser$symbol("/")),$elm$parser$Parser$spaces),$elm$parser$Parser$lazy(function(_v4){return $author$project$ParserMaths$cyclic$exp()})),A2($elm$parser$Parser$map,function(_v5){return $elm$parser$Parser$Done(operands)},$elm$parser$Parser$succeed(0))]))};function $author$project$ParserMaths$cyclic$expr(){return $author$project$ParserMaths$cyclic$add()}function $author$project$ParserMaths$cyclic$add(){return A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$keeper,$elm$parser$Parser$succeed($author$project$ParserMaths$foldBinary),A2($elm$parser$Parser$ignorer,$author$project$ParserMaths$cyclic$mul(),$elm$parser$Parser$spaces)),A2($elm$parser$Parser$loop,_List_Nil,$author$project$ParserMaths$addHelper))}function $author$project$ParserMaths$cyclic$mul(){return A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$keeper,$elm$parser$Parser$succeed($author$project$ParserMaths$foldBinary),A2($elm$parser$Parser$ignorer,$author$project$ParserMaths$cyclic$exp(),$elm$parser$Parser$spaces)),A2($elm$parser$Parser$loop,_List_Nil,$author$project$ParserMaths$mulHelper))}function $author$project$ParserMaths$cyclic$exp(){return A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$keeper,$elm$parser$Parser$succeed($author$project$ParserMaths$binary),A2($elm$parser$Parser$ignorer,$author$project$ParserMaths$cyclic$primary(),$elm$parser$Parser$spaces)),$elm$parser$Parser$oneOf(_List_fromArray([A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$ignorer,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$succeed($author$project$ParserMaths$Operand(4)),$elm$parser$Parser$symbol("^")),$elm$parser$Parser$spaces),$elm$parser$Parser$lazy(function(_v8){return $author$project$ParserMaths$cyclic$exp()})),$elm$parser$Parser$succeed($author$project$ParserMaths$NoOperand)])))}function $author$project$ParserMaths$cyclic$primary(){return A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$keeper,$elm$parser$Parser$succeed(F2(function(op,literal){if(op.$===1){return literal}else{return $author$project$ParserMaths$Neg(literal)}})),$elm$parser$Parser$oneOf(_List_fromArray([A2($elm$parser$Parser$keeper,$elm$parser$Parser$succeed($elm$core$Maybe$Just),$elm$parser$Parser$symbol("-")),$elm$parser$Parser$succeed($elm$core$Maybe$Nothing)]))),$elm$parser$Parser$oneOf(_List_fromArray([$author$project$ParserMaths$cyclic$grouping(),$author$project$ParserMaths$cyclic$poly(),$author$project$ParserMaths$nombre])))}function $author$project$ParserMaths$cyclic$grouping(){return A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$ignorer,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$succeed($author$project$ParserMaths$Grouping),$elm$parser$Parser$symbol("(")),$elm$parser$Parser$spaces),A2($elm$parser$Parser$ignorer,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$lazy(function(_v6){return $author$project$ParserMaths$cyclic$expr()}),$elm$parser$Parser$spaces),$elm$parser$Parser$symbol(")")))}function $author$project$ParserMaths$cyclic$poly(){return A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$keeper,A2($elm$parser$Parser$ignorer,A2($elm$parser$Parser$ignorer,$elm$parser$Parser$succeed($author$project$ParserMaths$Poly),$elm$parser$Parser$keyword("Poly")),$elm$parser$Parser$spaces),A2($elm$parser$Parser$ignorer,$elm$parser$Parser$sequence({aE:"]",aO:$elm$parser$Parser$lazy(function(_v0){return $author$project$ParserMaths$cyclic$expr()}),aX:",",aY:$elm$parser$Parser$spaces,am:"[",a$:0}),$elm$parser$Parser$spaces)),$elm$parser$Parser$variable({aL:function(_v1){return false},aV:$elm$core$Set$fromList(_List_Nil),am:function(_v2){return true}}))}var $author$project$ParserMaths$expr=$author$project$ParserMaths$cyclic$expr();$author$project$ParserMaths$cyclic$expr=function(){return $author$project$ParserMaths$expr};var $author$project$ParserMaths$add=$author$project$ParserMaths$cyclic$add();$author$project$ParserMaths$cyclic$add=function(){return $author$project$ParserMaths$add};var $author$project$ParserMaths$mul=$author$project$ParserMaths$cyclic$mul();$author$project$ParserMaths$cyclic$mul=function(){return $author$project$ParserMaths$mul};var $author$project$ParserMaths$exp=$author$project$ParserMaths$cyclic$exp();$author$project$ParserMaths$cyclic$exp=function(){return $author$project$ParserMaths$exp};var $author$project$ParserMaths$primary=$author$project$ParserMaths$cyclic$primary();$author$project$ParserMaths$cyclic$primary=function(){return $author$project$ParserMaths$primary};var $author$project$ParserMaths$grouping=$author$project$ParserMaths$cyclic$grouping();$author$project$ParserMaths$cyclic$grouping=function(){return $author$project$ParserMaths$grouping};var $author$project$ParserMaths$poly=$author$project$ParserMaths$cyclic$poly();$author$project$ParserMaths$cyclic$poly=function(){return $author$project$ParserMaths$poly};var $author$project$ParserMaths$parseMaths=function(source){return A2($elm$parser$Parser$run,$author$project$ParserMaths$expr,source)};var $author$project$Fractions$teX=function(a){var _v0=a.f;if(_v0===1){return $elm$core$String$fromInt(a.e)}else{return a.e<0?"-\\frac{"+($elm$core$String$fromInt(-a.e)+("}{"+($elm$core$String$fromInt(a.f)+"}"))):"\\frac{"+($elm$core$String$fromInt(a.e)+("}{"+($elm$core$String$fromInt(a.f)+"}")))}};var $author$project$QCM$voirTexteVariable=function(txtvar){if(!txtvar.$){var txt=txtvar.a;return txt}else{var _var=txtvar.a;var expressionParseePotentielle=$author$project$ParserMaths$parseMaths(_var);if(expressionParseePotentielle.$===1){var erreur=expressionParseePotentielle.a;return"L'expression est mal formée."}else{var expressionParsee=expressionParseePotentielle.a;var _v2=A2($elm$core$Maybe$map,$author$project$Fractions$teX,$author$project$ParserMaths$evaluer(expressionParsee));if(!_v2.$){var a=_v2.a;return a}else{return"Les puissances non-entières ne sont pas acceptées."}}}};var $author$project$QCM$voirMacro=function(macro){return $elm$core$String$concat(A2($elm$core$List$map,$author$project$QCM$voirTexteVariable,macro))};var $author$project$QCM$remplacerLesVariablesDansLaMacro=F2(function(ars,macro){return A2($elm$core$List$map,$author$project$QCM$voirMacro,A2($author$project$QCM$remplacerLesVariablesDansLaMacroBis,ars,_List_fromArray([macro])))});var $author$project$QCM$remplacer=F2(function(variables,question){var macro=$author$project$QCM$parserQuestion(question);var ars=A2($elm$core$List$map,$author$project$QCM$parserAremplacer,$elm$core$String$lines(variables));return A2($author$project$QCM$remplacerLesVariablesDansLaMacro,ars,macro)});var $author$project$QCM$update=F2(function(msg,model){switch(msg.$){case 0:var nouvelleQuestion=msg.a;return _Utils_update(model,{G:nouvelleQuestion});case 1:var nouvellesVariables=msg.a;return _Utils_update(model,{L:nouvellesVariables});default:return _Utils_update(model,{M:A2($author$project$QCM$remplacer,model.L,model.G)})}});var $author$project$QCM$GenererQuestion={$:2};var $author$project$QCM$Question=function(a){return{$:0,a:a}};var $author$project$QCM$Variables=function(a){return{$:1,a:a}};var $elm$html$Html$button=_VirtualDom_node("button");var $elm$html$Html$div=_VirtualDom_node("div");var $elm$virtual_dom$VirtualDom$Normal=function(a){return{$:0,a:a}};var $elm$virtual_dom$VirtualDom$on=_VirtualDom_on;var $elm$html$Html$Events$on=F2(function(event,decoder){return A2($elm$virtual_dom$VirtualDom$on,event,$elm$virtual_dom$VirtualDom$Normal(decoder))});var $elm$html$Html$Events$onClick=function(msg){return A2($elm$html$Html$Events$on,"click",$elm$json$Json$Decode$succeed(msg))};var $elm$html$Html$Events$alwaysStop=function(x){return _Utils_Tuple2(x,true)};var $elm$virtual_dom$VirtualDom$MayStopPropagation=function(a){return{$:1,a:a}};var $elm$html$Html$Events$stopPropagationOn=F2(function(event,decoder){return A2($elm$virtual_dom$VirtualDom$on,event,$elm$virtual_dom$VirtualDom$MayStopPropagation(decoder))});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$string=_Json_decodeString;var $elm$html$Html$Events$targetValue=A2($elm$json$Json$Decode$at,_List_fromArray(["target","value"]),$elm$json$Json$Decode$string);var $elm$html$Html$Events$onInput=function(tagger){return A2($elm$html$Html$Events$stopPropagationOn,"input",A2($elm$json$Json$Decode$map,$elm$html$Html$Events$alwaysStop,A2($elm$json$Json$Decode$map,tagger,$elm$html$Html$Events$targetValue)))};var $elm$html$Html$p=_VirtualDom_node("p");var $elm$json$Json$Encode$string=_Json_wrap;var $elm$html$Html$Attributes$stringProperty=F2(function(key,string){return A2(_VirtualDom_property,key,$elm$json$Json$Encode$string(string))});var $elm$html$Html$Attributes$placeholder=$elm$html$Html$Attributes$stringProperty("placeholder");var $elm$virtual_dom$VirtualDom$text=_VirtualDom_text;var $elm$html$Html$text=$elm$virtual_dom$VirtualDom$text;var $elm$html$Html$textarea=_VirtualDom_node("textarea");var $elm$html$Html$Attributes$value=$elm$html$Html$Attributes$stringProperty("value");var $author$project$QCM$view=function(model){return A2($elm$html$Html$div,_List_Nil,A2($elm$core$List$cons,A2($elm$html$Html$textarea,_List_fromArray([$elm$html$Html$Attributes$placeholder("Liste des variables"),$elm$html$Html$Attributes$value(model.L),$elm$html$Html$Events$onInput($author$project$QCM$Variables)]),_List_Nil),A2($elm$core$List$cons,A2($elm$html$Html$textarea,_List_fromArray([$elm$html$Html$Attributes$placeholder("Format de la question"),$elm$html$Html$Attributes$value(model.G),$elm$html$Html$Events$onInput($author$project$QCM$Question)]),_List_Nil),A2($elm$core$List$cons,A2($elm$html$Html$button,_List_fromArray([$elm$html$Html$Events$onClick($author$project$QCM$GenererQuestion)]),_List_fromArray([$elm$html$Html$text("Générer les questions")])),_List_fromArray([A2($elm$html$Html$p,_List_Nil,A2($elm$core$List$map,function(q){return A2($elm$html$Html$p,_List_Nil,_List_fromArray([$elm$html$Html$text(q)]))},model.M))])))))};var $author$project$QCM$main=$elm$browser$Browser$sandbox({aK:$author$project$QCM$init,a0:$author$project$QCM$update,a1:$author$project$QCM$view});_Platform_export({QCM:{init:$author$project$QCM$main($elm$json$Json$Decode$succeed(0))(0)}})})(this); \ No newline at end of file diff --git a/qcmUgly.js b/qcmUgly.js new file mode 100644 index 0000000..569dc81 --- /dev/null +++ b/qcmUgly.js @@ -0,0 +1 @@ +!function(n){"use strict";function r(n,r,t){return t.a=n,t.f=r,t}function t(n){return r(2,n,function(r){return function(t){return n(r,t)}})}function u(n){return r(3,n,function(r){return function(t){return function(u){return n(r,t,u)}}})}function e(n){return r(4,n,function(r){return function(t){return function(u){return function(e){return n(r,t,u,e)}}}})}function a(n){return r(5,n,function(r){return function(t){return function(u){return function(e){return function(a){return n(r,t,u,e,a)}}}}})}function f(n){return r(6,n,function(r){return function(t){return function(u){return function(e){return function(a){return function(f){return n(r,t,u,e,a,f)}}}}}})}function i(n){return r(7,n,function(r){return function(t){return function(u){return function(e){return function(a){return function(f){return function(i){return n(r,t,u,e,a,f,i)}}}}}}})}function o(n){return r(8,n,function(r){return function(t){return function(u){return function(e){return function(a){return function(f){return function(i){return function(o){return n(r,t,u,e,a,f,i,o)}}}}}}}})}function c(n){return r(9,n,function(r){return function(t){return function(u){return function(e){return function(a){return function(f){return function(i){return function(o){return function(c){return n(r,t,u,e,a,f,i,o,c)}}}}}}}}})}function v(n,r,t){return 2===n.a?n.f(r,t):n(r)(t)}function b(n,r,t,u){return 3===n.a?n.f(r,t,u):n(r)(t)(u)}function s(n,r,t,u,e){return 4===n.a?n.f(r,t,u,e):n(r)(t)(u)(e)}function l(n,r,t,u,e,a){return 5===n.a?n.f(r,t,u,e,a):n(r)(t)(u)(e)(a)}function d(n,r,t,u,e,a,f){return 6===n.a?n.f(r,t,u,e,a,f):n(r)(t)(u)(e)(a)(f)}function h(n,r,t,u,e,a,f,i){return 7===n.a?n.f(r,t,u,e,a,f,i):n(r)(t)(u)(e)(a)(f)(i)}var $=u(function(n,r,t){for(var u=new Array(n),e=0;e=0;u--)r=v(n,t[u],r);return r}));t(function(n,r){for(var t=r.length,u=new Array(t),e=0;et.length&&(e=t.length);for(var a=new Array(u+e),f=0;f"),r});function m(n){throw new Error("https://github.com/elm/core/blob/1.0.0/hints/"+n+".md")}function A(n,r){for(var t,u=[],e=y(n,r,0,u);e&&(t=u.pop());e=y(t.a,t.b,0,u));return e}function y(n,r,t,u){if(n===r)return!0;if("object"!=typeof n||null===n||null===r)return"function"==typeof n&&m(5),!1;if(t>100)return u.push(L(n,r)),!0;for(var e in n.$<0&&(n=qr(n),r=qr(r)),n)if(!y(n[e],r[e],t+1,u))return!1;return!0}t(A);var k=t(function(n,r){return!A(n,r)});function w(n,r,t){if("object"!=typeof n)return n===r?0:n0}),t(function(n,r){return w(n,r)>=0});var j=t(function(n,r){var t=w(n,r);return t<0?Sr:t?Gr:Fr}),N=0;function L(n,r){return{a:n,b:r}}function C(n,r,t){return{a:n,b:r,c:t}}function _(n){return n}function E(n,r){var t={};for(var u in n)t[u]=n[u];for(var u in r)t[u]=r[u];return t}t(function(n,r){if("string"==typeof n)return n+r;if(!n.b)return r;var t=O(n.a,r);n=n.b;for(var u=t;n.b;n=n.b)u=u.b=O(n.a,r);return t});var M={$:0};function O(n,r){return{$:1,a:n,b:r}}var x=t(O);function T(n){for(var r=M,t=n.length;t--;)r=O(n[t],r);return r}function q(n){for(var r=[];n.b;n=n.b)r.push(n.a);return r}var F=u(function(n,r,t){for(var u=[];r.b&&t.b;r=r.b,t=t.b)u.push(v(n,r.a,t.a));return T(u)}),G=(e(function(n,r,t,u){for(var e=[];r.b&&t.b&&u.b;r=r.b,t=t.b,u=u.b)e.push(b(n,r.a,t.a,u.a));return T(e)}),a(function(n,r,t,u,e){for(var a=[];r.b&&t.b&&u.b&&e.b;r=r.b,t=t.b,u=u.b,e=e.b)a.push(s(n,r.a,t.a,u.a,e.a));return T(a)}),f(function(n,r,t,u,e,a){for(var f=[];r.b&&t.b&&u.b&&e.b&&a.b;r=r.b,t=t.b,u=u.b,e=e.b,a=a.b)f.push(l(n,r.a,t.a,u.a,e.a,a.a));return T(f)}),t(function(n,r){return T(q(r).sort(function(r,t){return w(n(r),n(t))}))}),t(function(n,r){return T(q(r).sort(function(r,t){var u=v(n,r,t);return u===Fr?0:u===Sr?-1:1}))}),t(function(n,r){return n+r}),t(function(n,r){return n-r}),t(function(n,r){return n*r}),t(function(n,r){return n/r}),t(function(n,r){return n/r|0}),t(Math.pow)),S=(t(function(n,r){return r%n}),t(function(n,r){var t=r%n;return 0===n?m(11):t>0&&n<0||t<0&&n>0?t+n:t}));Math.PI,Math.E,Math.cos,Math.sin,Math.tan,Math.acos,Math.asin,Math.atan,t(Math.atan2);var P=Math.ceil,R=Math.floor,B=(Math.round,Math.sqrt,Math.log);isNaN;t(function(n,r){return n&&r}),t(function(n,r){return n||r}),t(function(n,r){return n!==r}),t(function(n,r){return n+r});t(function(n,r){return n+r});t(function(n,r){for(var t=r.length,u=new Array(t),e=0;e-1}),z=(t(function(n,r){return 0===r.indexOf(n)}),t(function(n,r){return r.length>=n.length&&r.lastIndexOf(n)===r.length-n.length}),t(function(n,r){var t=n.length;if(t<1)return M;for(var u=0,e=[];(u=r.indexOf(n,u))>-1;)e.push(u),u+=t;return T(e)}));function D(n){return{$:2,b:n}}D(function(n){return"number"!=typeof n?en("an INT",n):-2147483647=r.length)return en("a LONGER array. Need index "+e+" but only see "+r.length+" entries",r);u=nn(n.b,r[e]);return xt(u)?u:Rr(v(Yr,e,u.a));case 8:if("object"!=typeof r||null===r||tn(r))return en("an OBJECT",r);var a=M;for(var f in r)if(r.hasOwnProperty(f)){u=nn(n.b,r[f]);if(!xt(u))return Rr(v(Jr,f,u.a));a=O(L(f,u.a),a)}return Ir(vt(a));case 9:for(var i=n.f,o=n.g,c=0;c0&&ur(t,1,u,v));case 4:for(var b=n.j,s=r.j,l=!1,d=n.k;4===d.$;)l=!0,"object"!=typeof b?b=[b,d.j]:b.push(d.j),d=d.k;for(var h=r.k;4===h.$;)l=!0,"object"!=typeof s?s=[s,h.j]:s.push(h.j),h=h.k;return l&&b.length!==s.length?void ur(t,0,u,r):((l?function(n,r){for(var t=0;ti?ur(t,6,u,{v:i,i:f-i}):f0||f.length>0||_)&&ur(t,8,u,{w:e,x:f,y:_})}var cr="_elmW6BL";function vr(n,r,t,u,e,a){var f=n[t];if(!f)return f={c:0,z:u,r:e,s:void 0},a.push({r:e,A:f}),void(n[t]=f);if(1===f.c){a.push({r:e,A:f}),f.c=2;var i=[];return er(f.z,u,i,f.r),f.r=e,void(f.s.s={w:i,A:f})}vr(n,r,t+cr,u,e,a)}function br(n,r,t,u,e){var a=n[t];if(a){if(0===a.c){a.c=2;var f=[];return er(u,a.z,f,e),void ur(r,9,e,{w:f,A:a})}br(n,r,t+cr,u,e)}else{var i=ur(r,9,e,void 0);n[t]={c:1,z:u,r:e,s:i}}}function sr(n,r,t,u){!function n(r,t,u,e,a,f,i){var o=u[e];var c=o.r;for(;c===a;){var v=o.$;if(1===v)sr(r,t.k,o.s,i);else if(8===v){o.t=r,o.u=i;var b=o.s.w;b.length>0&&n(r,t,b,0,a,f,i)}else if(9===v){o.t=r,o.u=i;var s=o.s;if(s){s.A.s=r;var b=s.w;b.length>0&&n(r,t,b,0,a,f,i)}}else o.t=r,o.u=i;if(!(o=u[++e])||(c=o.r)>f)return e}var l=t.$;if(4===l){for(var d=t.k;4===d.$;)d=d.k;return n(r,d,u,e,a+1,f,r.elm_event_node_ref)}var h=t.e;var $=r.childNodes;for(var g=0;gf))return e;a=m}return e}(n,r,t,0,0,r.b,u)}function lr(n,r,t,u){return 0===t.length?n:(sr(n,r,t,u),dr(n,t))}function dr(n,r){for(var t=0;t0?n:r}),Lt=g,Ct=t(function(n,r){for(;;){var t=v(Lt,32,n),u=t.a,e=t.b,a=v(Or,{$:0,a:u},r);if(!e.b)return vt(a);n=e,r=a}}),_t=t(function(n,r){for(;;){var t=gt(r/32);if(1===t)return v(Lt,32,n).a;n=v(Ct,n,M),r=t}}),Et=t(function(n,r){if(r.g){var t=32*r.g,u=wt(v(pt,32,t-1)),e=n?vt(r.j):r.j,a=v(_t,e,r.g);return s(ht,jt(r.i)+t,v(Nt,5,u*mt),a,r.i)}return s(ht,jt(r.i),mt,$t,r.i)}),Mt=a(function(n,r,t,u,e){for(;;){if(r<0)return v(Et,!1,{j:u,g:t/32|0,i:e});var a={$:1,a:b(yt,32,r,n)};n=n,r=r-32,t=t,u=v(Or,a,u),e=e}}),Ot=t(function(n,r){if(n<=0)return At;var t=n%32,u=b(yt,t,n-t,r);return l(Mt,r,n-t-32,n,M,u)}),xt=function(n){return!n.$},Tt=Z,qt=H,Ft=function(n){return{$:0,a:n}},Gt=function(n){switch(n.$){case 0:return 0;case 1:return 1;case 2:return 2;default:return 3}},St=function(n){return n},Pt=St,Rt=f(function(n,r,t,u,e,a){return{X:a,Z:r,ab:u,ad:t,ag:n,ah:e}}),Bt=W,Jt=function(n){return n.length},Yt=I,It=t(function(n,r){return n<1?r:b(Yt,n,Jt(r),r)}),Qt=z,Wt=function(n){return""===n},zt=t(function(n,r){return n<1?"":b(Yt,0,n,r)}),Dt=function(n){for(var r=0,t=n.charCodeAt(0),u=43==t||45==t?1:0,e=u;e500?b(Ur,n,r,vt(d)):s(nu,n,r,t+1,d)))))}return v(n,e,v(n,f,v(n,o,r)))}return v(n,e,v(n,f,r))}return v(n,e,r)}return r}),ru=u(function(n,r,t){return s(nu,n,r,0,t)}),tu=t(function(n,r){return b(ru,t(function(r,t){return v(Or,n(r),t)}),M,r)}),uu=ln,eu=t(function(n,r){return v(uu,function(r){return Ht(n(r))},r)}),au=u(function(n,r,t){return v(uu,function(r){return v(uu,function(t){return Ht(v(n,r,t))},t)},r)}),fu=Ln,iu=t(function(n,r){var t=r;return $n(v(uu,fu(n),t))}),ou=u(function(n,r,t){return v(eu,function(n){return 0},(u=v(tu,iu(n),r),b(ru,au(Or),Ht(M),u)));var u}),cu=u(function(n,r,t){return Ht(0)}),vu=t(function(n,r){return v(eu,n,r)});jn.Task={b:Ut,c:ou,d:cu,e:vu,f:wr};var bu,su,lu,du=Cn("Task"),hu=t(function(n,r){return du(v(eu,n,r))}),$u=_n(M),gu=_n(M),pu=function(n){return T(n.split(/\r\n|\r|\n/g))},mu=t(function(n,r){return{ap:r,aq:n}}),Au={$:-2},yu=Au,ku=a(function(n,r,t,u,e){return{$:-1,a:n,b:r,c:t,d:u,e:e}}),wu=a(function(n,r,t,u,e){if(-1!==e.$||e.a){if(-1!==u.$||u.a||-1!==u.d.$||u.d.a)return l(ku,n,r,t,u,e);u.a,h=u.b,$=u.c;var a=u.d,f=(a.a,a.b),i=a.c,o=a.d,c=a.e;p=u.e;return l(ku,0,h,$,l(ku,1,f,i,o,c),l(ku,1,r,t,p,e))}e.a;var v=e.b,b=e.c,s=e.d,d=e.e;if(-1!==u.$||u.a)return l(ku,n,v,b,l(ku,0,r,t,u,s),d);u.a;var h=u.b,$=u.c,g=u.d,p=u.e;return l(ku,0,r,t,l(ku,1,h,$,g,p),l(ku,1,v,b,s,d))}),ju=j,Nu=u(function(n,r,t){if(-2===t.$)return l(ku,0,n,r,Au,Au);var u=t.a,e=t.b,a=t.c,f=t.d,i=t.e;switch(v(ju,n,e)){case 0:return l(wu,u,e,a,b(Nu,n,r,f),i);case 1:return l(ku,u,e,r,f,i);default:return l(wu,u,e,a,f,b(Nu,n,r,i))}}),Lu=u(function(n,r,t){var u=b(Nu,n,r,t);if(-1!==u.$||u.a)return u;u.a;var e=u.b,a=u.c,f=u.d,i=u.e;return l(ku,1,e,a,f,i)}),Cu=t(function(n,r){return b(Lu,n,0,r)}),_u=function(n){return b(Ur,Cu,yu,n)},Eu=t(function(n,r){return n}),Mu=t(function(n,r){return{$:1,a:n,b:r}}),Ou=u(function(n,r,t){return{$:0,a:n,b:r,c:t}}),xu=u(function(n,r,t){var u=r,e=t;return function(r){var t=u(r);if(1===t.$){var a=t.a,f=t.b;return v(Mu,a,f)}var i=t.a,o=t.b,c=t.c,s=e(c);if(1===s.$){var l=s.a;f=s.b;return v(Mu,i||l,f)}l=s.a;var d=s.b,h=s.c;return b(Ou,i||l,v(n,o,d),h)}}),Tu=t(function(n,r){return b(xu,Eu,n,r)}),qu=Tu,Fu=t(function(n,r){return b(xu,kt,n,r)}),Gu=k,Su=t(function(n,r){var t=r;return function(r){var u=t(r);if(1===u.$){var e=u.a,a=u.b;return v(Mu,e,a)}var f=u.a,i=u.b,o=u.c,c=n(i)(o);if(1===c.$){var s=c.a;a=c.b;return v(Mu,f||s,a)}s=c.a;var l=c.b,d=c.c;return b(Ou,f||s,l,d)}}),Pu=e(function(n,r,t,u){for(;;){var e=t(r)(u);if(e.$){f=e.a;var a=e.b;return v(Mu,n||f,a)}var f=e.a,i=e.b,o=e.c;if(i.$){var c=i.a;return b(Ou,n||f,c,o)}n=n||f,r=i.a,t=t,u=o}}),Ru=t(function(n,r){return function(t){return s(Pu,!1,n,r,t)}}),Bu=t(function(n,r){var t=r;return function(r){var u=t(r);if(u.$){a=u.a;var e=u.b;return v(Mu,a,e)}var a=u.a,f=u.b,i=u.c;return b(Ou,a,n(f),i)}}),Ju={$:0},Yu=t(function(n,r){return{$:2,a:n,b:r}}),Iu=u(function(n,r,t){n:for(;;){if(t.b){var u=t.a,e=t.b,a=u(n);if(a.$){var f,i=(f=a).a,o=f.b;if(i)return f;n=n,r=v(Yu,r,o),t=e;continue n}return f=a}return v(Mu,!1,r)}}),Qu=function(n){return function(r){return b(Iu,r,Ju,n)}},Wu=function(n){return{$:1,a:n}},zu=function(n){return{$:0,a:n}},Du=t(function(n,r){return r}),Ku=t(function(n,r){return b(xu,Du,n,r)}),Vu=a(function(n,r,t,u,e){return v(Ku,r,Qu(T([v(Ku,u,v(Ku,r,v(Bu,function(n){return zu(v(Or,n,e))},t))),v(Bu,function(n){return Wu(vt(e))},n)])))}),Xu=function(n){return function(r){return b(Ou,!1,n,r)}},Zu=e(function(n,r,t,u){return Qu(T([v(Bu,function(n){return zu(v(Or,n,u))},v(Tu,r,v(Tu,n,v(Tu,t,n)))),v(Bu,function(n){return Wu(vt(u))},Xu(0))]))}),Hu=a(function(n,r,t,u,e){var a=v(Bu,function(n){return Wu(vt(e))},n);return v(Ku,r,Qu(T([v(Ku,u,v(Ku,r,Qu(T([v(Bu,function(n){return zu(v(Or,n,e))},t),a])))),a])))}),Uu=a(function(n,r,t,u,e){return Qu(T([v(Su,function(a){switch(e){case 0:return v(Ru,T([a]),s(Vu,n,r,t,u));case 1:return v(Ru,T([a]),s(Hu,n,r,t,u));default:return v(Tu,v(Ku,r,v(Ku,u,v(Ku,r,v(Ru,T([a]),b(Zu,r,t,u))))),n)}},t),v(Bu,function(n){return M},n)]))}),ne=t(function(n,r){return{$:1,a:n,b:r}}),re=e(function(n,r,t,u){return{aA:r,aB:u,aU:t,ak:n}}),te=t(function(n,r){return v(ne,Ju,s(re,n.ak,n.aA,r,n.c))}),ue=jr,ee=function(n){var r=n.a,t=n.b,u=!Wt(r);return function(n){var e=l(ue,r,n.b,n.ak,n.aA,n.a),a=e.a,f=e.b,i=e.c;return A(a,-1)?v(Mu,!1,v(te,n,t)):b(Ou,u,0,{aA:i,c:n.c,d:n.d,b:a,ak:f,a:n.a})}},ae=t(function(n,r){return{$:0,a:n,b:r}}),fe=function(n){return v(ae,n,{$:0,a:n})},ie=function(n){return function(n){return v(Ku,ee(n.am),v(Ku,n.aY,l(Uu,ee(n.aE),n.aY,n.aO,ee(n.aX),n.a$)))}({aE:fe(n.aE),aO:n.aO,aX:fe(n.aX),aY:n.aY,am:fe(n.am),a$:function(n){switch(n){case 0:return 0;case 1:return 1;default:return 2}}(n.a$)})},oe=Nr,ce=a(function(n,r,t,u,e){for(;;){var a=b(oe,n,r,e.a);if(A(a,-1))return b(Ou,w(e.b,r)<0,0,{aA:u,c:e.c,d:e.d,b:r,ak:t,a:e.a});if(A(a,-2))n=n,r=r+1,t=t+1,u=1,e=e;else n=n,r=a,t=t,u=u+1,e=e}}),ve=function(n){return function(r){return l(ce,n,r.b,r.ak,r.aA,r)}},be=ve(function(n){return" "===n||"\n"===n||"\r"===n}),se=Xu,le=ee,de=function(n){return le(v(ae,n,{$:8,a:n}))},he={$:7},$e=t(function(n,r){n:for(;;){if(-2===r.$)return zr;var t=r.b,u=r.c,e=r.d,a=r.e;switch(v(ju,n,t)){case 0:n=n,r=e;continue n;case 1:return Wr(u);default:n=n,r=a;continue n}}}),ge=t(function(n,r){return!v($e,n,r).$}),pe=t(function(n,r){return v(ge,n,r)}),me=i(function(n,r,t,u,e,a,f){for(;;){var i=b(oe,n,r,e);if(A(i,-1))return{aA:u,c:f,d:a,b:r,ak:t,a:e};if(A(i,-2))n=n,r=r+1,t=t+1,u=1,e=e,a=a,f=f;else n=n,r=i,t=t,u=u+1,e=e,a=a,f=f}}),Ae=function(n){return function(n){return function(r){var t=b(oe,n.am,r.b,r.a);if(A(t,-1))return v(Mu,!1,v(te,r,n.W));var u=A(t,-2)?h(me,n.aL,r.b+1,r.ak+1,1,r.a,r.d,r.c):h(me,n.aL,t,r.ak,r.aA+1,r.a,r.d,r.c),e=b(Yt,r.b,u.b,r.a);return v(pe,e,n.aV)?v(Mu,!1,v(te,r,n.W)):b(Ou,!0,e,u)}}({W:he,aL:n.aL,aV:n.aV,am:n.am})},ye=v(Fu,v(Fu,v(qu,se(mu),be),v(qu,v(qu,Ae({aL:ot,aV:_u(M),am:function(n){return!0}}),be),de(":"))),ie({aE:"",aO:Ae({aL:Gu(","),aV:_u(M),am:Gu(",")}),aX:",",aY:be,am:"",a$:1})),ke=u(function(n,r,t){return{aA:r,aU:t,ak:n}}),we=function(n){return b(ke,n.ak,n.aA,n.aU)},je=t(function(n,r){n:for(;;)switch(n.$){case 0:return r;case 1:var t=n.a,u=n.b;n=t,r=v(Or,u,r);continue n;default:t=n.a;var e=n.b;n=t,r=v(je,e,r);continue n}}),Ne=t(function(n,r){var t=n({aA:1,c:M,d:1,b:0,ak:1,a:r});if(t.$){var u=t.b;return Rr(v(je,u,M))}var e=t.b;return Ir(e)}),Le=t(function(n,r){var t=v(Ne,n,r);if(t.$){var u=t.a;return Rr(v(tu,we,u))}var e=t.a;return Ir(e)}),Ce=function(n){var r=v(Le,ye,n);return r.$?v(mu,"",M):r.a},_e=Bu,Ee=function(n){if(n.$){var r=n.a;return Wu(r)}var t=n.a;return zu(t)},Me=t(function(n,r){return v(Ru,n,function(n){return v(_e,Ee,r(n))})}),Oe=function(n){return{$:1,a:n}},xe=function(n){return{$:0,a:n}},Te=function(n){return{$:1,a:n}},qe=Mr,Fe=e(function(n,r,t,u){return v(ne,Ju,s(re,n,r,t,u))}),Ge=t(function(n,r){var t=r;return function(r){var u=t(r);if(1===u.$){var e=u.a,a=u.b;return v(Mu,e,a)}e=u.a;var f=u.b,i=u.c;return b(Ou,e,v(n,b(Yt,r.b,i.b,r.a),f),i)}}),Se=function(n){return v(Ge,Eu,n)},Pe=v(Fu,v(qu,se(Te),de("#")),v(qu,Se(function(n){var r=n.a,t=n.b;return function(n){var u=l(qe,r,n.b,n.ak,n.aA,n.a),e=u.a,a=u.b,f=u.c;return A(e,-1)?v(Mu,!1,s(Fe,a,f,t,n.c)):b(Ou,w(n.b,e)<0,0,{aA:f,c:n.c,d:n.d,b:e,ak:a,a:n.a})}}(fe("#"))),de("#"))),Re=Qu,Be=function(n){return{$:0,a:n}},Je={$:11},Ye=t(function(n,r){return function(t){var u=b(oe,n,t.b,t.a);return A(u,-1)?v(Mu,!1,v(te,t,r)):A(u,-2)?b(Ou,!0,0,{aA:1,c:t.c,d:t.d,b:t.b+1,ak:t.ak+1,a:t.a}):b(Ou,!0,0,{aA:t.aA+1,c:t.c,d:t.d,b:u,ak:t.ak,a:t.a})}}),Ie=ve,Qe=v(Fu,se(Be),Se(v(qu,v(qu,se(0),(bu=Gu("#"),v(Ye,bu,Je))),Ie(Gu("#"))))),We=v(Me,M,function(n){return Re(T([v(Fu,se(function(r){return xe(v(Or,r,n))}),Re(T([Pe,Qe]))),v(_e,function(r){return Oe(vt(n))},se(0))]))}),ze=t(function(n,r){return r.b?b(ru,Or,r,n):n}),De=u(function(n,r,t){return v(Xr,r,v(Zr,n,t))}),Ke=u(function(n,r,t){if(t.$){u=t.a;return Te(b(De,n,r,u))}var u=t.a;return Be(u)}),Ve=u(function(n,r,t){return v(tu,v(Ke,n,r),t)}),Xe=t(function(n,r){return v(tu,function(t){return b(Ve,n.aq,t,r)},n.ap)}),Ze=t(function(n,r){if(n.b){var t=n.a,u=n.b;return v(Ze,u,(e=v(tu,Xe(t),r),b(ru,ze,M,e)))}return r;var e}),He=t(function(n,r){return{f:r,e:n}}),Ue=function(n){return n<0?-n:n},na=S,ra=t(function(n,r){return v(t(function(n,r){for(;;){if(!r)return n;var t=r,u=v(na,r,n);n=t,r=u}}),Ue(n),Ue(r))}),ta=function(n){var r=n.f<0?-1:1,t=v(ra,n.e,n.f);return v(He,r*n.e/t|0,r*n.f/t|0)},ua=t(function(n,r){return ta(v(He,n.e*r.f+n.f*r.e,n.f*r.f))}),ea=t(function(n,r){return ta(v(He,n.e*r.e,n.f*r.f))}),aa=t(function(n,r){return ta(v(ea,n,function(n){return ta(v(He,n.f,n.e))}(r)))}),fa=G,ia=t(function(n,r){var t=ta(r),u=t.e<0?-1:1,e=ta(n),a=e.e<0?-1:1;return 1===t.f&&t.e<0?Wr(v(He,v(fa,a*e.f,u*t.e),v(fa,a*e.e,u*t.e))):1===t.f?Wr(v(He,v(fa,e.e,t.e),v(fa,e.f,t.e))):zr}),oa=t(function(n,r){if(r.$)return zr;var t=r.a;return Wr(n(t))}),ca=u(function(n,r,t){if(1===r.$)return zr;var u=r.a;if(1===t.$)return zr;var e=t.a;return Wr(v(n,u,e))}),va=function(n){return ta(v(He,-n.e,n.f))},ba=t(function(n,r){return ta(v(ua,n,va(r)))}),sa=function(n){n:for(;;)switch(n.$){case 0:var r=n.a,t=n.b;return b(ca,ua,sa(r),sa(t));case 1:r=n.a,t=n.b;return b(ca,ba,sa(r),sa(t));case 2:r=n.a,t=n.b;return b(ca,ea,sa(r),sa(t));case 3:r=n.a,t=n.b;return b(ca,aa,sa(r),sa(t));case 4:r=n.a,t=n.b;var u=b(ca,ia,sa(r),sa(t));return 1===u.$?zr:u.a;case 5:r=n.a;return v(oa,va,sa(r));case 7:n=n.a;continue n;case 6:var e=n.a;return Wr(v(He,e,1));default:n.a,n.b;return Wr(v(He,50,1))}},la=function(n){return{$:7,a:n}},da=function(n){return{$:5,a:n}},ha={$:0},$a=t(function(n,r){return{$:1,a:n,b:r}}),ga=t(function(n,r){return{$:8,a:n,b:r}}),pa=t(function(n,r){return{$:0,a:n,b:r}}),ma=t(function(n,r){return{$:3,a:n,b:r}}),Aa=t(function(n,r){return{$:4,a:n,b:r}}),ya=t(function(n,r){return{$:2,a:n,b:r}}),ka=t(function(n,r){return{$:1,a:n,b:r}}),wa=t(function(n,r){if(!r.$)return n;var t=r.a,u=r.b;switch(t){case 0:return v(ya,n,u);case 1:return v(ma,n,u);case 2:return v(pa,n,u);case 3:return v(ka,n,u);default:return v(Aa,n,u)}}),ja=t(function(n,r){return b(ru,t(function(n,r){return v(wa,r,n)}),n,r)}),Na=function(n){return function(n){var r=n.a,t=n.b,u=!Wt(r);return function(n){var e=l(ue,r,n.b,n.ak,n.aA,n.a),a=e.a,f=e.b,i=e.c;return A(a,-1)||0<=b(oe,function(n){return ct(n)||"_"===n},a,n.a)?v(Mu,!1,v(te,n,t)):b(Ou,u,0,{aA:i,c:n.c,d:n.d,b:a,ak:f,a:n.a})}}(v(ae,n,{$:9,a:n}))},La=function(n){return function(r){return n(0)(r)}},Ca={$:4},_a={$:5},Ea={$:2},Ma={$:1},Oa={$:6},xa={$:3},Ta=t(function(n,r){if(r.$)return Rr(n);var t=r.a;return Ir(t)}),qa=_r,Fa=Er,Ga=t(function(n,r){return{aA:r.aA+(n-r.b),c:r.c,d:r.d,b:n,ak:r.ak,a:r.a}}),Sa=Cr,Pa=Lr,Ra=t(function(n,r){if(b(Pa,101,n,r)||b(Pa,69,n,r)){var t=n+1,u=b(Pa,43,t,r)||b(Pa,45,t,r)?t+1:t,e=v(Sa,u,r);return A(u,e)?-e:e}return n}),Ba=t(function(n,r){return b(Pa,46,n,r)?v(Ra,v(Sa,n+1,r),r):v(Ra,n,r)}),Ja=a(function(n,r,t,u,e){var a=u.a,f=u.b;if(1===r.$){var i=r.a;return v(Mu,!0,v(te,e,i))}var o=r.a;return A(t,a)?v(Mu,w(e.b,t)<0,v(te,e,n)):b(Ou,!0,o(f),v(Ga,a,e))}),Ya=function(n){if(0===n.length||/[\sxbo]/.test(n))return zr;var r=+n;return r==r?Wr(r):zr},Ia=f(function(n,r,t,u,e,a){var f=e.a,i=v(Ba,f,a.a);if(i<0)return v(Mu,!0,s(Fe,a.ak,a.aA-(i+a.b),n,a.c));if(A(a.b,i))return v(Mu,!1,v(te,a,r));if(A(f,i))return l(Ja,n,t,a.b,e,a);if(1===u.$){u.a;return v(Mu,!0,v(te,a,n))}var o=u.a,c=Ya(b(Yt,a.b,i,a.a));if(1===c.$)return v(Mu,!0,v(te,a,n));var d=c.a;return b(Ou,!0,o(d),v(Ga,i,a))}),Qa=v(Fu,se(function(n){return{$:6,a:n}}),(su={ax:zr,aG:zr,aH:zr,aM:Wr(St),aQ:zr},lu={ax:v(Ta,Ca,su.ax),W:Oa,aG:v(Ta,_a,su.aG),aH:v(Ta,Ea,su.aH),aM:v(Ta,Ma,su.aM),aN:Oa,aQ:v(Ta,xa,su.aQ)},function(n){if(b(Pa,48,n.b,n.a)){var r=n.b+1,t=r+1;return b(Pa,120,r,n.a)?l(Ja,lu.aN,lu.aH,t,v(Fa,t,n.a),n):b(Pa,111,r,n.a)?l(Ja,lu.aN,lu.aQ,t,b(qa,8,t,n.a),n):b(Pa,98,r,n.a)?l(Ja,lu.aN,lu.ax,t,b(qa,2,t,n.a),n):d(Ia,lu.aN,lu.W,lu.aM,lu.aG,L(r,0),n)}return d(Ia,lu.aN,lu.W,lu.aM,lu.aG,b(qa,10,n.b,n.a),n)})),Wa=function(n){return Re(T([v(Fu,v(qu,v(qu,se(function(r){return xe(v(Or,v($a,2,r),n))}),de("+")),be),La(function(n){return Va()})),v(Fu,v(qu,v(qu,se(function(r){return xe(v(Or,v($a,3,r),n))}),de("-")),be),La(function(n){return Va()})),v(_e,function(r){return Oe(n)},se(0))]))},za=function(n){return Re(T([v(Fu,v(qu,v(qu,se(function(r){return xe(v(Or,v($a,0,r),n))}),de("*")),be),La(function(n){return Xa()})),v(Fu,v(qu,v(qu,se(function(r){return xe(v(Or,v($a,1,r),n))}),de("/")),be),La(function(n){return Xa()})),v(_e,function(r){return Oe(n)},se(0))]))};function Da(){return Ka()}function Ka(){return v(Fu,v(Fu,se(ja),v(qu,Va(),be)),v(Me,M,Wa))}function Va(){return v(Fu,v(Fu,se(ja),v(qu,Xa(),be)),v(Me,M,za))}function Xa(){return v(Fu,v(Fu,se(wa),v(qu,Za(),be)),Re(T([v(Fu,v(qu,v(qu,se($a(4)),de("^")),be),La(function(n){return Xa()})),se(ha)])))}function Za(){return v(Fu,v(Fu,se(t(function(n,r){return 1===n.$?r:da(r)})),Re(T([v(Fu,se(Wr),de("-")),se(zr)]))),Re(T([Ha(),Ua(),Qa])))}function Ha(){return v(Fu,v(qu,v(qu,se(la),de("(")),be),v(qu,v(qu,La(function(n){return Da()}),be),de(")")))}function Ua(){return v(Fu,v(Fu,v(qu,v(qu,se(ga),Na("Poly")),be),v(qu,ie({aE:"]",aO:La(function(n){return Da()}),aX:",",aY:be,am:"[",a$:0}),be)),Ae({aL:function(n){return!1},aV:_u(M),am:function(n){return!0}}))}var nf=Da();Da=function(){return nf};var rf=Ka();Ka=function(){return rf};var tf=Va();Va=function(){return tf};var uf=Xa();Xa=function(){return uf};var ef=Za();Za=function(){return ef};var af=Ha();Ha=function(){return af};var ff=Ua();Ua=function(){return ff};var of,cf,vf=function(n){return 1===n.f?Vr(n.e):n.e<0?"-\\frac{"+Vr(-n.e)+"}{"+Vr(n.f)+"}":"\\frac{"+Vr(n.e)+"}{"+Vr(n.f)+"}"},bf=function(n){if(n.$){var r=n.a,t=v(Le,nf,r);if(1===t.$){t.a;return"L'expression est mal formée."}var u=t.a,e=v(oa,vf,sa(u));return e.$?"Les puissances non-entières ne sont pas acceptées.":e.a}return n.a},sf=function(n){return r=v(tu,bf,n),v(Xr,"",r);var r},lf=t(function(n,r){return v(tu,sf,v(Ze,n,T([r])))}),df=t(function(n,r){var t=function(n){var r=v(Le,We,n);return r.$?M:r.a}(r),u=v(tu,Ce,pu(n));return v(lf,u,t)}),hf=t(function(n,r){switch(n.$){case 0:return E(r,{G:n.a});case 1:return E(r,{L:n.a});default:return E(r,{M:v(df,r.L,r.G)})}}),$f={$:2},gf=function(n){return{$:0,a:n}},pf=function(n){return{$:1,a:n}},mf=Pn("button"),Af=Pn("div"),yf=Bn,kf=t(function(n,r){return v(yf,n,{$:0,a:r})}),wf=function(n){return L(n,!0)},jf=t(function(n,r){return v(yf,n,{$:1,a:r})}),Nf=V,Lf=K,Cf=v(t(function(n,r){return b(ru,Nf,r,n)}),T(["target","value"]),Lf),_f=function(n){return v(jf,"input",v(Tt,wf,v(Tt,n,Cf)))},Ef=Pn("p"),Mf=cn,Of=t(function(n,r){return v(Jn,n,Mf(r))}),xf=Of("placeholder"),Tf=Sn,qf=Pn("textarea"),Ff=Of("value"),Gf=(of={aK:Pr,a0:hf,a1:function(n){return v(Af,M,v(Or,v(qf,T([xf("Liste des variables"),Ff(n.L),_f(pf)]),M),v(Or,v(qf,T([xf("Format de la question"),Ff(n.G),_f(gf)]),M),v(Or,v(mf,T([(r=$f,v(kf,"click",Ft(r)))]),T([Tf("Générer les questions")])),T([v(Ef,M,v(tu,function(n){return v(Ef,M,T([Tf(n)]))},n.M))])))));var r}},gr({aK:function(n){return L(of.aK,$u)},aZ:function(n){return gu},a0:t(function(n,r){return L(v(of.a0,n,r),$u)}),a1:of.a1}));cf={QCM:{init:Gf(Ft(0))(0)}},n.Elm?function n(r,t){for(var u in t)u in r?"init"==u?m(6):n(r[u],t[u]):r[u]=t[u]}(n.Elm,cf):n.Elm=cf}(this); \ No newline at end of file diff --git a/src/ParserMaths.elm b/src/ParserMaths.elm index c8d6d4a..823d155 100644 --- a/src/ParserMaths.elm +++ b/src/ParserMaths.elm @@ -2,6 +2,7 @@ module ParserMaths exposing (parseMaths, evaluer, montrerErreurs) import Fractions as F import Maybe as M +import Set import Parser exposing (..) montrerErreurs : String -> List DeadEnd -> String @@ -61,6 +62,9 @@ evaluer expression = Entier n -> Just <| F.Frac n 1 + Poly a_i x -> + Just <| F.Frac 50 1 + type Expr = Add Expr Expr @@ -71,6 +75,7 @@ type Expr | Neg Expr | Entier Int | Grouping Expr + | Poly (List Expr) String parseMaths : String -> Result (List DeadEnd) Expr @@ -96,6 +101,10 @@ type Operand | Operand Operator Expr +{- + En quelque sorte, décurryfie une expression binaire + binary e_1 (Operand MulOp e_2) == Mul e_1 e_2 +-} binary : Expr -> Operand -> Expr binary a b = case b of @@ -129,6 +138,7 @@ add = |= loop [] addHelper +-- foldBinary : Expr -> List Operand -> Expr foldBinary left operands = List.foldr @@ -210,6 +220,7 @@ primary = ] |= oneOf [ grouping + , poly , nombre ] @@ -225,6 +236,26 @@ nombre = , float = Nothing } +poly : Parser Expr +poly = + succeed Poly + |. keyword "Poly" + |. spaces + |= sequence + { start = "[" + , separator = "," + , end = "]" + , spaces = spaces + , item = lazy (\_ -> expr) + , trailing = Forbidden + } + |. spaces + |= variable + { start = \_ -> True + , inner = \_ -> False + , reserved = Set.fromList [] + } + grouping : Parser Expr grouping = diff --git a/src/QCM.elm b/src/QCM.elm index 4377e45..2b28487 100644 --- a/src/QCM.elm +++ b/src/QCM.elm @@ -7,7 +7,7 @@ import Set import ParserMaths as PM import String as S import Fractions as F exposing (Frac) -import Html exposing (Html, Attribute, button, div, textarea, input, text, p) +import Html exposing (Html, Attribute, button, div, textarea, input, text, p, iframe) import Html.Attributes exposing (..) import Html.Events exposing (onInput, onClick) @@ -244,8 +244,8 @@ aRemplacer = , end = "" , spaces = spaces , item = P.variable - { start = \x -> Char.isDigit x || x == '-' - , inner = Char.isDigit + { start = (/=) ',' + , inner = (/=) ',' , reserved = Set.fromList [] } , trailing = P.Optional @@ -312,6 +312,9 @@ remplacerLaVariableParLaValeurDansLeTexteVariable var val tv = -} +type Nombre + = + type Expr num = Const num | Var String