diff options
Diffstat (limited to 'public/client.js')
| -rw-r--r-- | public/client.js | 11041 |
1 files changed, 11041 insertions, 0 deletions
diff --git a/public/client.js b/public/client.js new file mode 100644 index 0000000..20e57c8 --- /dev/null +++ b/public/client.js @@ -0,0 +1,11041 @@ + +(function() { +'use strict'; + +function F2(fun) +{ + function wrapper(a) { return function(b) { return fun(a,b); }; } + wrapper.arity = 2; + wrapper.func = fun; + return wrapper; +} + +function F3(fun) +{ + function wrapper(a) { + return function(b) { return function(c) { return fun(a, b, c); }; }; + } + wrapper.arity = 3; + wrapper.func = fun; + return wrapper; +} + +function F4(fun) +{ + function wrapper(a) { return function(b) { return function(c) { + return function(d) { return fun(a, b, c, d); }; }; }; + } + wrapper.arity = 4; + wrapper.func = fun; + return wrapper; +} + +function F5(fun) +{ + function wrapper(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; }; + } + wrapper.arity = 5; + wrapper.func = fun; + return wrapper; +} + +function F6(fun) +{ + function wrapper(a) { return function(b) { return function(c) { + return function(d) { return function(e) { return function(f) { + return fun(a, b, c, d, e, f); }; }; }; }; }; + } + wrapper.arity = 6; + wrapper.func = fun; + return wrapper; +} + +function F7(fun) +{ + function wrapper(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); }; }; }; }; }; }; + } + wrapper.arity = 7; + wrapper.func = fun; + return wrapper; +} + +function F8(fun) +{ + function wrapper(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); }; }; }; }; }; }; }; + } + wrapper.arity = 8; + wrapper.func = fun; + return wrapper; +} + +function F9(fun) +{ + function wrapper(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); }; }; }; }; }; }; }; }; + } + wrapper.arity = 9; + wrapper.func = fun; + return wrapper; +} + +function A2(fun, a, b) +{ + return fun.arity === 2 + ? fun.func(a, b) + : fun(a)(b); +} +function A3(fun, a, b, c) +{ + return fun.arity === 3 + ? fun.func(a, b, c) + : fun(a)(b)(c); +} +function A4(fun, a, b, c, d) +{ + return fun.arity === 4 + ? fun.func(a, b, c, d) + : fun(a)(b)(c)(d); +} +function A5(fun, a, b, c, d, e) +{ + return fun.arity === 5 + ? fun.func(a, b, c, d, e) + : fun(a)(b)(c)(d)(e); +} +function A6(fun, a, b, c, d, e, f) +{ + return fun.arity === 6 + ? fun.func(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.arity === 7 + ? fun.func(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.arity === 8 + ? fun.func(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.arity === 9 + ? fun.func(a, b, c, d, e, f, g, h, i) + : fun(a)(b)(c)(d)(e)(f)(g)(h)(i); +} + +//import Native.List // + +var _elm_lang$core$Native_Array = function() { + +// A RRB-Tree has two distinct data types. +// Leaf -> "height" is always 0 +// "table" is an array of elements +// Node -> "height" is always greater than 0 +// "table" is an array of child nodes +// "lengths" is an array of accumulated lengths of the child nodes + +// M is the maximal table size. 32 seems fast. E is the allowed increase +// of search steps when concatting to find an index. Lower values will +// decrease balancing, but will increase search steps. +var M = 32; +var E = 2; + +// An empty array. +var empty = { + ctor: '_Array', + height: 0, + table: [] +}; + + +function get(i, array) +{ + if (i < 0 || i >= length(array)) + { + throw new Error( + 'Index ' + i + ' is out of range. Check the length of ' + + 'your array first or use getMaybe or getWithDefault.'); + } + return unsafeGet(i, array); +} + + +function unsafeGet(i, array) +{ + for (var x = array.height; x > 0; x--) + { + var slot = i >> (x * 5); + while (array.lengths[slot] <= i) + { + slot++; + } + if (slot > 0) + { + i -= array.lengths[slot - 1]; + } + array = array.table[slot]; + } + return array.table[i]; +} + + +// Sets the value at the index i. Only the nodes leading to i will get +// copied and updated. +function set(i, item, array) +{ + if (i < 0 || length(array) <= i) + { + return array; + } + return unsafeSet(i, item, array); +} + + +function unsafeSet(i, item, array) +{ + array = nodeCopy(array); + + if (array.height === 0) + { + array.table[i] = item; + } + else + { + var slot = getSlot(i, array); + if (slot > 0) + { + i -= array.lengths[slot - 1]; + } + array.table[slot] = unsafeSet(i, item, array.table[slot]); + } + return array; +} + + +function initialize(len, f) +{ + if (len <= 0) + { + return empty; + } + var h = Math.floor( Math.log(len) / Math.log(M) ); + return initialize_(f, h, 0, len); +} + +function initialize_(f, h, from, to) +{ + if (h === 0) + { + var table = new Array((to - from) % (M + 1)); + for (var i = 0; i < table.length; i++) + { + table[i] = f(from + i); + } + return { + ctor: '_Array', + height: 0, + table: table + }; + } + + var step = Math.pow(M, h); + var table = new Array(Math.ceil((to - from) / step)); + var lengths = new Array(table.length); + for (var i = 0; i < table.length; i++) + { + table[i] = initialize_(f, h - 1, from + (i * step), Math.min(from + ((i + 1) * step), to)); + lengths[i] = length(table[i]) + (i > 0 ? lengths[i-1] : 0); + } + return { + ctor: '_Array', + height: h, + table: table, + lengths: lengths + }; +} + +function fromList(list) +{ + if (list.ctor === '[]') + { + return empty; + } + + // Allocate M sized blocks (table) and write list elements to it. + var table = new Array(M); + var nodes = []; + var i = 0; + + while (list.ctor !== '[]') + { + table[i] = list._0; + list = list._1; + i++; + + // table is full, so we can push a leaf containing it into the + // next node. + if (i === M) + { + var leaf = { + ctor: '_Array', + height: 0, + table: table + }; + fromListPush(leaf, nodes); + table = new Array(M); + i = 0; + } + } + + // Maybe there is something left on the table. + if (i > 0) + { + var leaf = { + ctor: '_Array', + height: 0, + table: table.splice(0, i) + }; + fromListPush(leaf, nodes); + } + + // Go through all of the nodes and eventually push them into higher nodes. + for (var h = 0; h < nodes.length - 1; h++) + { + if (nodes[h].table.length > 0) + { + fromListPush(nodes[h], nodes); + } + } + + var head = nodes[nodes.length - 1]; + if (head.height > 0 && head.table.length === 1) + { + return head.table[0]; + } + else + { + return head; + } +} + +// Push a node into a higher node as a child. +function fromListPush(toPush, nodes) +{ + var h = toPush.height; + + // Maybe the node on this height does not exist. + if (nodes.length === h) + { + var node = { + ctor: '_Array', + height: h + 1, + table: [], + lengths: [] + }; + nodes.push(node); + } + + nodes[h].table.push(toPush); + var len = length(toPush); + if (nodes[h].lengths.length > 0) + { + len += nodes[h].lengths[nodes[h].lengths.length - 1]; + } + nodes[h].lengths.push(len); + + if (nodes[h].table.length === M) + { + fromListPush(nodes[h], nodes); + nodes[h] = { + ctor: '_Array', + height: h + 1, + table: [], + lengths: [] + }; + } +} + +// Pushes an item via push_ to the bottom right of a tree. +function push(item, a) +{ + var pushed = push_(item, a); + if (pushed !== null) + { + return pushed; + } + + var newTree = create(item, a.height); + return siblise(a, newTree); +} + +// Recursively tries to push an item to the bottom-right most +// tree possible. If there is no space left for the item, +// null will be returned. +function push_(item, a) +{ + // Handle resursion stop at leaf level. + if (a.height === 0) + { + if (a.table.length < M) + { + var newA = { + ctor: '_Array', + height: 0, + table: a.table.slice() + }; + newA.table.push(item); + return newA; + } + else + { + return null; + } + } + + // Recursively push + var pushed = push_(item, botRight(a)); + + // There was space in the bottom right tree, so the slot will + // be updated. + if (pushed !== null) + { + var newA = nodeCopy(a); + newA.table[newA.table.length - 1] = pushed; + newA.lengths[newA.lengths.length - 1]++; + return newA; + } + + // When there was no space left, check if there is space left + // for a new slot with a tree which contains only the item + // at the bottom. + if (a.table.length < M) + { + var newSlot = create(item, a.height - 1); + var newA = nodeCopy(a); + newA.table.push(newSlot); + newA.lengths.push(newA.lengths[newA.lengths.length - 1] + length(newSlot)); + return newA; + } + else + { + return null; + } +} + +// Converts an array into a list of elements. +function toList(a) +{ + return toList_(_elm_lang$core$Native_List.Nil, a); +} + +function toList_(list, a) +{ + for (var i = a.table.length - 1; i >= 0; i--) + { + list = + a.height === 0 + ? _elm_lang$core$Native_List.Cons(a.table[i], list) + : toList_(list, a.table[i]); + } + return list; +} + +// Maps a function over the elements of an array. +function map(f, a) +{ + var newA = { + ctor: '_Array', + height: a.height, + table: new Array(a.table.length) + }; + if (a.height > 0) + { + newA.lengths = a.lengths; + } + for (var i = 0; i < a.table.length; i++) + { + newA.table[i] = + a.height === 0 + ? f(a.table[i]) + : map(f, a.table[i]); + } + return newA; +} + +// Maps a function over the elements with their index as first argument. +function indexedMap(f, a) +{ + return indexedMap_(f, a, 0); +} + +function indexedMap_(f, a, from) +{ + var newA = { + ctor: '_Array', + height: a.height, + table: new Array(a.table.length) + }; + if (a.height > 0) + { + newA.lengths = a.lengths; + } + for (var i = 0; i < a.table.length; i++) + { + newA.table[i] = + a.height === 0 + ? A2(f, from + i, a.table[i]) + : indexedMap_(f, a.table[i], i == 0 ? from : from + a.lengths[i - 1]); + } + return newA; +} + +function foldl(f, b, a) +{ + if (a.height === 0) + { + for (var i = 0; i < a.table.length; i++) + { + b = A2(f, a.table[i], b); + } + } + else + { + for (var i = 0; i < a.table.length; i++) + { + b = foldl(f, b, a.table[i]); + } + } + return b; +} + +function foldr(f, b, a) +{ + if (a.height === 0) + { + for (var i = a.table.length; i--; ) + { + b = A2(f, a.table[i], b); + } + } + else + { + for (var i = a.table.length; i--; ) + { + b = foldr(f, b, a.table[i]); + } + } + return b; +} + +// TODO: currently, it slices the right, then the left. This can be +// optimized. +function slice(from, to, a) +{ + if (from < 0) + { + from += length(a); + } + if (to < 0) + { + to += length(a); + } + return sliceLeft(from, sliceRight(to, a)); +} + +function sliceRight(to, a) +{ + if (to === length(a)) + { + return a; + } + + // Handle leaf level. + if (a.height === 0) + { + var newA = { ctor:'_Array', height:0 }; + newA.table = a.table.slice(0, to); + return newA; + } + + // Slice the right recursively. + var right = getSlot(to, a); + var sliced = sliceRight(to - (right > 0 ? a.lengths[right - 1] : 0), a.table[right]); + + // Maybe the a node is not even needed, as sliced contains the whole slice. + if (right === 0) + { + return sliced; + } + + // Create new node. + var newA = { + ctor: '_Array', + height: a.height, + table: a.table.slice(0, right), + lengths: a.lengths.slice(0, right) + }; + if (sliced.table.length > 0) + { + newA.table[right] = sliced; + newA.lengths[right] = length(sliced) + (right > 0 ? newA.lengths[right - 1] : 0); + } + return newA; +} + +function sliceLeft(from, a) +{ + if (from === 0) + { + return a; + } + + // Handle leaf level. + if (a.height === 0) + { + var newA = { ctor:'_Array', height:0 }; + newA.table = a.table.slice(from, a.table.length + 1); + return newA; + } + + // Slice the left recursively. + var left = getSlot(from, a); + var sliced = sliceLeft(from - (left > 0 ? a.lengths[left - 1] : 0), a.table[left]); + + // Maybe the a node is not even needed, as sliced contains the whole slice. + if (left === a.table.length - 1) + { + return sliced; + } + + // Create new node. + var newA = { + ctor: '_Array', + height: a.height, + table: a.table.slice(left, a.table.length + 1), + lengths: new Array(a.table.length - left) + }; + newA.table[0] = sliced; + var len = 0; + for (var i = 0; i < newA.table.length; i++) + { + len += length(newA.table[i]); + newA.lengths[i] = len; + } + + return newA; +} + +// Appends two trees. +function append(a,b) +{ + if (a.table.length === 0) + { + return b; + } + if (b.table.length === 0) + { + return a; + } + + var c = append_(a, b); + + // Check if both nodes can be crunshed together. + if (c[0].table.length + c[1].table.length <= M) + { + if (c[0].table.length === 0) + { + return c[1]; + } + if (c[1].table.length === 0) + { + return c[0]; + } + + // Adjust .table and .lengths + c[0].table = c[0].table.concat(c[1].table); + if (c[0].height > 0) + { + var len = length(c[0]); + for (var i = 0; i < c[1].lengths.length; i++) + { + c[1].lengths[i] += len; + } + c[0].lengths = c[0].lengths.concat(c[1].lengths); + } + + return c[0]; + } + + if (c[0].height > 0) + { + var toRemove = calcToRemove(a, b); + if (toRemove > E) + { + c = shuffle(c[0], c[1], toRemove); + } + } + + return siblise(c[0], c[1]); +} + +// Returns an array of two nodes; right and left. One node _may_ be empty. +function append_(a, b) +{ + if (a.height === 0 && b.height === 0) + { + return [a, b]; + } + + if (a.height !== 1 || b.height !== 1) + { + if (a.height === b.height) + { + a = nodeCopy(a); + b = nodeCopy(b); + var appended = append_(botRight(a), botLeft(b)); + + insertRight(a, appended[1]); + insertLeft(b, appended[0]); + } + else if (a.height > b.height) + { + a = nodeCopy(a); + var appended = append_(botRight(a), b); + + insertRight(a, appended[0]); + b = parentise(appended[1], appended[1].height + 1); + } + else + { + b = nodeCopy(b); + var appended = append_(a, botLeft(b)); + + var left = appended[0].table.length === 0 ? 0 : 1; + var right = left === 0 ? 1 : 0; + insertLeft(b, appended[left]); + a = parentise(appended[right], appended[right].height + 1); + } + } + + // Check if balancing is needed and return based on that. + if (a.table.length === 0 || b.table.length === 0) + { + return [a, b]; + } + + var toRemove = calcToRemove(a, b); + if (toRemove <= E) + { + return [a, b]; + } + return shuffle(a, b, toRemove); +} + +// Helperfunctions for append_. Replaces a child node at the side of the parent. +function insertRight(parent, node) +{ + var index = parent.table.length - 1; + parent.table[index] = node; + parent.lengths[index] = length(node); + parent.lengths[index] += index > 0 ? parent.lengths[index - 1] : 0; +} + +function insertLeft(parent, node) +{ + if (node.table.length > 0) + { + parent.table[0] = node; + parent.lengths[0] = length(node); + + var len = length(parent.table[0]); + for (var i = 1; i < parent.lengths.length; i++) + { + len += length(parent.table[i]); + parent.lengths[i] = len; + } + } + else + { + parent.table.shift(); + for (var i = 1; i < parent.lengths.length; i++) + { + parent.lengths[i] = parent.lengths[i] - parent.lengths[0]; + } + parent.lengths.shift(); + } +} + +// Returns the extra search steps for E. Refer to the paper. +function calcToRemove(a, b) +{ + var subLengths = 0; + for (var i = 0; i < a.table.length; i++) + { + subLengths += a.table[i].table.length; + } + for (var i = 0; i < b.table.length; i++) + { + subLengths += b.table[i].table.length; + } + + var toRemove = a.table.length + b.table.length; + return toRemove - (Math.floor((subLengths - 1) / M) + 1); +} + +// get2, set2 and saveSlot are helpers for accessing elements over two arrays. +function get2(a, b, index) +{ + return index < a.length + ? a[index] + : b[index - a.length]; +} + +function set2(a, b, index, value) +{ + if (index < a.length) + { + a[index] = value; + } + else + { + b[index - a.length] = value; + } +} + +function saveSlot(a, b, index, slot) +{ + set2(a.table, b.table, index, slot); + + var l = (index === 0 || index === a.lengths.length) + ? 0 + : get2(a.lengths, a.lengths, index - 1); + + set2(a.lengths, b.lengths, index, l + length(slot)); +} + +// Creates a node or leaf with a given length at their arrays for perfomance. +// Is only used by shuffle. +function createNode(h, length) +{ + if (length < 0) + { + length = 0; + } + var a = { + ctor: '_Array', + height: h, + table: new Array(length) + }; + if (h > 0) + { + a.lengths = new Array(length); + } + return a; +} + +// Returns an array of two balanced nodes. +function shuffle(a, b, toRemove) +{ + var newA = createNode(a.height, Math.min(M, a.table.length + b.table.length - toRemove)); + var newB = createNode(a.height, newA.table.length - (a.table.length + b.table.length - toRemove)); + + // Skip the slots with size M. More precise: copy the slot references + // to the new node + var read = 0; + while (get2(a.table, b.table, read).table.length % M === 0) + { + set2(newA.table, newB.table, read, get2(a.table, b.table, read)); + set2(newA.lengths, newB.lengths, read, get2(a.lengths, b.lengths, read)); + read++; + } + + // Pulling items from left to right, caching in a slot before writing + // it into the new nodes. + var write = read; + var slot = new createNode(a.height - 1, 0); + var from = 0; + + // If the current slot is still containing data, then there will be at + // least one more write, so we do not break this loop yet. + while (read - write - (slot.table.length > 0 ? 1 : 0) < toRemove) + { + // Find out the max possible items for copying. + var source = get2(a.table, b.table, read); + var to = Math.min(M - slot.table.length, source.table.length); + + // Copy and adjust size table. + slot.table = slot.table.concat(source.table.slice(from, to)); + if (slot.height > 0) + { + var len = slot.lengths.length; + for (var i = len; i < len + to - from; i++) + { + slot.lengths[i] = length(slot.table[i]); + slot.lengths[i] += (i > 0 ? slot.lengths[i - 1] : 0); + } + } + + from += to; + + // Only proceed to next slots[i] if the current one was + // fully copied. + if (source.table.length <= to) + { + read++; from = 0; + } + + // Only create a new slot if the current one is filled up. + if (slot.table.length === M) + { + saveSlot(newA, newB, write, slot); + slot = createNode(a.height - 1, 0); + write++; + } + } + + // Cleanup after the loop. Copy the last slot into the new nodes. + if (slot.table.length > 0) + { + saveSlot(newA, newB, write, slot); + write++; + } + + // Shift the untouched slots to the left + while (read < a.table.length + b.table.length ) + { + saveSlot(newA, newB, write, get2(a.table, b.table, read)); + read++; + write++; + } + + return [newA, newB]; +} + +// Navigation functions +function botRight(a) +{ + return a.table[a.table.length - 1]; +} +function botLeft(a) +{ + return a.table[0]; +} + +// Copies a node for updating. Note that you should not use this if +// only updating only one of "table" or "lengths" for performance reasons. +function nodeCopy(a) +{ + var newA = { + ctor: '_Array', + height: a.height, + table: a.table.slice() + }; + if (a.height > 0) + { + newA.lengths = a.lengths.slice(); + } + return newA; +} + +// Returns how many items are in the tree. +function length(array) +{ + if (array.height === 0) + { + return array.table.length; + } + else + { + return array.lengths[array.lengths.length - 1]; + } +} + +// Calculates in which slot of "table" the item probably is, then +// find the exact slot via forward searching in "lengths". Returns the index. +function getSlot(i, a) +{ + var slot = i >> (5 * a.height); + while (a.lengths[slot] <= i) + { + slot++; + } + return slot; +} + +// Recursively creates a tree with a given height containing +// only the given item. +function create(item, h) +{ + if (h === 0) + { + return { + ctor: '_Array', + height: 0, + table: [item] + }; + } + return { + ctor: '_Array', + height: h, + table: [create(item, h - 1)], + lengths: [1] + }; +} + +// Recursively creates a tree that contains the given tree. +function parentise(tree, h) +{ + if (h === tree.height) + { + return tree; + } + + return { + ctor: '_Array', + height: h, + table: [parentise(tree, h - 1)], + lengths: [length(tree)] + }; +} + +// Emphasizes blood brotherhood beneath two trees. +function siblise(a, b) +{ + return { + ctor: '_Array', + height: a.height + 1, + table: [a, b], + lengths: [length(a), length(a) + length(b)] + }; +} + +function toJSArray(a) +{ + var jsArray = new Array(length(a)); + toJSArray_(jsArray, 0, a); + return jsArray; +} + +function toJSArray_(jsArray, i, a) +{ + for (var t = 0; t < a.table.length; t++) + { + if (a.height === 0) + { + jsArray[i + t] = a.table[t]; + } + else + { + var inc = t === 0 ? 0 : a.lengths[t - 1]; + toJSArray_(jsArray, i + inc, a.table[t]); + } + } +} + +function fromJSArray(jsArray) +{ + if (jsArray.length === 0) + { + return empty; + } + var h = Math.floor(Math.log(jsArray.length) / Math.log(M)); + return fromJSArray_(jsArray, h, 0, jsArray.length); +} + +function fromJSArray_(jsArray, h, from, to) +{ + if (h === 0) + { + return { + ctor: '_Array', + height: 0, + table: jsArray.slice(from, to) + }; + } + + var step = Math.pow(M, h); + var table = new Array(Math.ceil((to - from) / step)); + var lengths = new Array(table.length); + for (var i = 0; i < table.length; i++) + { + table[i] = fromJSArray_(jsArray, h - 1, from + (i * step), Math.min(from + ((i + 1) * step), to)); + lengths[i] = length(table[i]) + (i > 0 ? lengths[i - 1] : 0); + } + return { + ctor: '_Array', + height: h, + table: table, + lengths: lengths + }; +} + +return { + empty: empty, + fromList: fromList, + toList: toList, + initialize: F2(initialize), + append: F2(append), + push: F2(push), + slice: F3(slice), + get: F2(get), + set: F3(set), + map: F2(map), + indexedMap: F2(indexedMap), + foldl: F3(foldl), + foldr: F3(foldr), + length: length, + + toJSArray: toJSArray, + fromJSArray: fromJSArray +}; + +}(); +//import Native.Utils // + +var _elm_lang$core$Native_Basics = function() { + +function div(a, b) +{ + return (a / b) | 0; +} +function rem(a, b) +{ + return a % b; +} +function mod(a, b) +{ + if (b === 0) + { + throw new Error('Cannot perform mod 0. Division by zero error.'); + } + var r = a % b; + var m = a === 0 ? 0 : (b > 0 ? (a >= 0 ? r : r + b) : -mod(-a, -b)); + + return m === b ? 0 : m; +} +function logBase(base, n) +{ + return Math.log(n) / Math.log(base); +} +function negate(n) +{ + return -n; +} +function abs(n) +{ + return n < 0 ? -n : n; +} + +function min(a, b) +{ + return _elm_lang$core$Native_Utils.cmp(a, b) < 0 ? a : b; +} +function max(a, b) +{ + return _elm_lang$core$Native_Utils.cmp(a, b) > 0 ? a : b; +} +function clamp(lo, hi, n) +{ + return _elm_lang$core$Native_Utils.cmp(n, lo) < 0 + ? lo + : _elm_lang$core$Native_Utils.cmp(n, hi) > 0 + ? hi + : n; +} + +var ord = ['LT', 'EQ', 'GT']; + +function compare(x, y) +{ + return { ctor: ord[_elm_lang$core$Native_Utils.cmp(x, y) + 1] }; +} + +function xor(a, b) +{ + return a !== b; +} +function not(b) +{ + return !b; +} +function isInfinite(n) +{ + return n === Infinity || n === -Infinity; +} + +function truncate(n) +{ + return n | 0; +} + +function degrees(d) +{ + return d * Math.PI / 180; +} +function turns(t) +{ + return 2 * Math.PI * t; +} +function fromPolar(point) +{ + var r = point._0; + var t = point._1; + return _elm_lang$core$Native_Utils.Tuple2(r * Math.cos(t), r * Math.sin(t)); +} +function toPolar(point) +{ + var x = point._0; + var y = point._1; + return _elm_lang$core$Native_Utils.Tuple2(Math.sqrt(x * x + y * y), Math.atan2(y, x)); +} + +return { + div: F2(div), + rem: F2(rem), + mod: F2(mod), + + pi: Math.PI, + e: Math.E, + cos: Math.cos, + sin: Math.sin, + tan: Math.tan, + acos: Math.acos, + asin: Math.asin, + atan: Math.atan, + atan2: F2(Math.atan2), + + degrees: degrees, + turns: turns, + fromPolar: fromPolar, + toPolar: toPolar, + + sqrt: Math.sqrt, + logBase: F2(logBase), + negate: negate, + abs: abs, + min: F2(min), + max: F2(max), + clamp: F3(clamp), + compare: F2(compare), + + xor: F2(xor), + not: not, + + truncate: truncate, + ceiling: Math.ceil, + floor: Math.floor, + round: Math.round, + toFloat: function(x) { return x; }, + isNaN: isNaN, + isInfinite: isInfinite +}; + +}(); +//import // + +var _elm_lang$core$Native_Utils = function() { + +// COMPARISONS + +function eq(x, y) +{ + var stack = []; + var isEqual = eqHelp(x, y, 0, stack); + var pair; + while (isEqual && (pair = stack.pop())) + { + isEqual = eqHelp(pair.x, pair.y, 0, stack); + } + return isEqual; +} + + +function eqHelp(x, y, depth, stack) +{ + if (depth > 100) + { + stack.push({ x: x, y: y }); + return true; + } + + if (x === y) + { + return true; + } + + if (typeof x !== 'object') + { + if (typeof x === 'function') + { + throw new Error( + 'Trying to use `(==)` on functions. There is no way to know if functions are "the same" in the Elm sense.' + + ' Read more about this at http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#==' + + ' which describes why it is this way and what the better version will look like.' + ); + } + return false; + } + + if (x === null || y === null) + { + return false + } + + if (x instanceof Date) + { + return x.getTime() === y.getTime(); + } + + if (!('ctor' in x)) + { + for (var key in x) + { + if (!eqHelp(x[key], y[key], depth + 1, stack)) + { + return false; + } + } + return true; + } + + // convert Dicts and Sets to lists + if (x.ctor === 'RBNode_elm_builtin' || x.ctor === 'RBEmpty_elm_builtin') + { + x = _elm_lang$core$Dict$toList(x); + y = _elm_lang$core$Dict$toList(y); + } + if (x.ctor === 'Set_elm_builtin') + { + x = _elm_lang$core$Set$toList(x); + y = _elm_lang$core$Set$toList(y); + } + + // check if lists are equal without recursion + if (x.ctor === '::') + { + var a = x; + var b = y; + while (a.ctor === '::' && b.ctor === '::') + { + if (!eqHelp(a._0, b._0, depth + 1, stack)) + { + return false; + } + a = a._1; + b = b._1; + } + return a.ctor === b.ctor; + } + + // check if Arrays are equal + if (x.ctor === '_Array') + { + var xs = _elm_lang$core$Native_Array.toJSArray(x); + var ys = _elm_lang$core$Native_Array.toJSArray(y); + if (xs.length !== ys.length) + { + return false; + } + for (var i = 0; i < xs.length; i++) + { + if (!eqHelp(xs[i], ys[i], depth + 1, stack)) + { + return false; + } + } + return true; + } + + if (!eqHelp(x.ctor, y.ctor, depth + 1, stack)) + { + return false; + } + + for (var key in x) + { + if (!eqHelp(x[key], y[key], depth + 1, stack)) + { + return false; + } + } + return true; +} + +// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on +// the particular integer values assigned to LT, EQ, and GT. + +var LT = -1, EQ = 0, GT = 1; + +function cmp(x, y) +{ + if (typeof x !== 'object') + { + return x === y ? EQ : x < y ? LT : GT; + } + + if (x instanceof String) + { + var a = x.valueOf(); + var b = y.valueOf(); + return a === b ? EQ : a < b ? LT : GT; + } + + if (x.ctor === '::' || x.ctor === '[]') + { + while (x.ctor === '::' && y.ctor === '::') + { + var ord = cmp(x._0, y._0); + if (ord !== EQ) + { + return ord; + } + x = x._1; + y = y._1; + } + return x.ctor === y.ctor ? EQ : x.ctor === '[]' ? LT : GT; + } + + if (x.ctor.slice(0, 6) === '_Tuple') + { + var ord; + var n = x.ctor.slice(6) - 0; + var err = 'cannot compare tuples with more than 6 elements.'; + if (n === 0) return EQ; + if (n >= 1) { ord = cmp(x._0, y._0); if (ord !== EQ) return ord; + if (n >= 2) { ord = cmp(x._1, y._1); if (ord !== EQ) return ord; + if (n >= 3) { ord = cmp(x._2, y._2); if (ord !== EQ) return ord; + if (n >= 4) { ord = cmp(x._3, y._3); if (ord !== EQ) return ord; + if (n >= 5) { ord = cmp(x._4, y._4); if (ord !== EQ) return ord; + if (n >= 6) { ord = cmp(x._5, y._5); if (ord !== EQ) return ord; + if (n >= 7) throw new Error('Comparison error: ' + err); } } } } } } + return EQ; + } + + throw new Error( + 'Comparison error: comparison is only defined on ints, ' + + 'floats, times, chars, strings, lists of comparable values, ' + + 'and tuples of comparable values.' + ); +} + + +// COMMON VALUES + +var Tuple0 = { + ctor: '_Tuple0' +}; + +function Tuple2(x, y) +{ + return { + ctor: '_Tuple2', + _0: x, + _1: y + }; +} + +function chr(c) +{ + return new String(c); +} + + +// GUID + +var count = 0; +function guid(_) +{ + return count++; +} + + +// RECORDS + +function update(oldRecord, updatedFields) +{ + var newRecord = {}; + for (var key in oldRecord) + { + var value = (key in updatedFields) ? updatedFields[key] : oldRecord[key]; + newRecord[key] = value; + } + return newRecord; +} + + +//// LIST STUFF //// + +var Nil = { ctor: '[]' }; + +function Cons(hd, tl) +{ + return { + ctor: '::', + _0: hd, + _1: tl + }; +} + +function append(xs, ys) +{ + // append Strings + if (typeof xs === 'string') + { + return xs + ys; + } + + // append Lists + if (xs.ctor === '[]') + { + return ys; + } + var root = Cons(xs._0, Nil); + var curr = root; + xs = xs._1; + while (xs.ctor !== '[]') + { + curr._1 = Cons(xs._0, Nil); + xs = xs._1; + curr = curr._1; + } + curr._1 = ys; + return root; +} + + +// CRASHES + +function crash(moduleName, region) +{ + return function(message) { + throw new Error( + 'Ran into a `Debug.crash` in module `' + moduleName + '` ' + regionToString(region) + '\n' + + 'The message provided by the code author is:\n\n ' + + message + ); + }; +} + +function crashCase(moduleName, region, value) +{ + return function(message) { + throw new Error( + 'Ran into a `Debug.crash` in module `' + moduleName + '`\n\n' + + 'This was caused by the `case` expression ' + regionToString(region) + '.\n' + + 'One of the branches ended with a crash and the following value got through:\n\n ' + toString(value) + '\n\n' + + 'The message provided by the code author is:\n\n ' + + message + ); + }; +} + +function regionToString(region) +{ + if (region.start.line == region.end.line) + { + return 'on line ' + region.start.line; + } + return 'between lines ' + region.start.line + ' and ' + region.end.line; +} + + +// TO STRING + +function toString(v) +{ + var type = typeof v; + if (type === 'function') + { + var name = v.func ? v.func.name : v.name; + return '<function' + (name === '' ? '' : ':') + name + '>'; + } + + if (type === 'boolean') + { + return v ? 'True' : 'False'; + } + + if (type === 'number') + { + return v + ''; + } + + if (v instanceof String) + { + return '\'' + addSlashes(v, true) + '\''; + } + + if (type === 'string') + { + return '"' + addSlashes(v, false) + '"'; + } + + if (v === null) + { + return 'null'; + } + + if (type === 'object' && 'ctor' in v) + { + var ctorStarter = v.ctor.substring(0, 5); + + if (ctorStarter === '_Tupl') + { + var output = []; + for (var k in v) + { + if (k === 'ctor') continue; + output.push(toString(v[k])); + } + return '(' + output.join(',') + ')'; + } + + if (ctorStarter === '_Task') + { + return '<task>' + } + + if (v.ctor === '_Array') + { + var list = _elm_lang$core$Array$toList(v); + return 'Array.fromList ' + toString(list); + } + + if (v.ctor === '<decoder>') + { + return '<decoder>'; + } + + if (v.ctor === '_Process') + { + return '<process:' + v.id + '>'; + } + + if (v.ctor === '::') + { + var output = '[' + toString(v._0); + v = v._1; + while (v.ctor === '::') + { + output += ',' + toString(v._0); + v = v._1; + } + return output + ']'; + } + + if (v.ctor === '[]') + { + return '[]'; + } + + if (v.ctor === 'Set_elm_builtin') + { + return 'Set.fromList ' + toString(_elm_lang$core$Set$toList(v)); + } + + if (v.ctor === 'RBNode_elm_builtin' || v.ctor === 'RBEmpty_elm_builtin') + { + return 'Dict.fromList ' + toString(_elm_lang$core$Dict$toList(v)); + } + + var output = ''; + for (var i in v) + { + if (i === 'ctor') continue; + var str = toString(v[i]); + var c0 = str[0]; + var parenless = c0 === '{' || c0 === '(' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0; + output += ' ' + (parenless ? str : '(' + str + ')'); + } + return v.ctor + output; + } + + if (type === 'object') + { + if (v instanceof Date) + { + return '<' + v.toString() + '>'; + } + + if (v.elm_web_socket) + { + return '<websocket>'; + } + + var output = []; + for (var k in v) + { + output.push(k + ' = ' + toString(v[k])); + } + if (output.length === 0) + { + return '{}'; + } + return '{ ' + output.join(', ') + ' }'; + } + + return '<internal structure>'; +} + +function 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, '\\"'); + } +} + + +return { + eq: eq, + cmp: cmp, + Tuple0: Tuple0, + Tuple2: Tuple2, + chr: chr, + update: update, + guid: guid, + + append: F2(append), + + crash: crash, + crashCase: crashCase, + + toString: toString +}; + +}(); +var _elm_lang$core$Basics$uncurry = F2( + function (f, _p0) { + var _p1 = _p0; + return A2(f, _p1._0, _p1._1); + }); +var _elm_lang$core$Basics$curry = F3( + function (f, a, b) { + return f( + {ctor: '_Tuple2', _0: a, _1: b}); + }); +var _elm_lang$core$Basics$flip = F3( + function (f, b, a) { + return A2(f, a, b); + }); +var _elm_lang$core$Basics$snd = function (_p2) { + var _p3 = _p2; + return _p3._1; +}; +var _elm_lang$core$Basics$fst = function (_p4) { + var _p5 = _p4; + return _p5._0; +}; +var _elm_lang$core$Basics$always = F2( + function (a, _p6) { + return a; + }); +var _elm_lang$core$Basics$identity = function (x) { + return x; +}; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['<|'] = F2( + function (f, x) { + return f(x); + }); +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['|>'] = F2( + function (x, f) { + return f(x); + }); +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['>>'] = F3( + function (f, g, x) { + return g( + f(x)); + }); +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['<<'] = F3( + function (g, f, x) { + return g( + f(x)); + }); +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['++'] = _elm_lang$core$Native_Utils.append; +var _elm_lang$core$Basics$toString = _elm_lang$core$Native_Utils.toString; +var _elm_lang$core$Basics$isInfinite = _elm_lang$core$Native_Basics.isInfinite; +var _elm_lang$core$Basics$isNaN = _elm_lang$core$Native_Basics.isNaN; +var _elm_lang$core$Basics$toFloat = _elm_lang$core$Native_Basics.toFloat; +var _elm_lang$core$Basics$ceiling = _elm_lang$core$Native_Basics.ceiling; +var _elm_lang$core$Basics$floor = _elm_lang$core$Native_Basics.floor; +var _elm_lang$core$Basics$truncate = _elm_lang$core$Native_Basics.truncate; +var _elm_lang$core$Basics$round = _elm_lang$core$Native_Basics.round; +var _elm_lang$core$Basics$not = _elm_lang$core$Native_Basics.not; +var _elm_lang$core$Basics$xor = _elm_lang$core$Native_Basics.xor; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['||'] = _elm_lang$core$Native_Basics.or; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['&&'] = _elm_lang$core$Native_Basics.and; +var _elm_lang$core$Basics$max = _elm_lang$core$Native_Basics.max; +var _elm_lang$core$Basics$min = _elm_lang$core$Native_Basics.min; +var _elm_lang$core$Basics$compare = _elm_lang$core$Native_Basics.compare; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['>='] = _elm_lang$core$Native_Basics.ge; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['<='] = _elm_lang$core$Native_Basics.le; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['>'] = _elm_lang$core$Native_Basics.gt; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['<'] = _elm_lang$core$Native_Basics.lt; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['/='] = _elm_lang$core$Native_Basics.neq; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['=='] = _elm_lang$core$Native_Basics.eq; +var _elm_lang$core$Basics$e = _elm_lang$core$Native_Basics.e; +var _elm_lang$core$Basics$pi = _elm_lang$core$Native_Basics.pi; +var _elm_lang$core$Basics$clamp = _elm_lang$core$Native_Basics.clamp; +var _elm_lang$core$Basics$logBase = _elm_lang$core$Native_Basics.logBase; +var _elm_lang$core$Basics$abs = _elm_lang$core$Native_Basics.abs; +var _elm_lang$core$Basics$negate = _elm_lang$core$Native_Basics.negate; +var _elm_lang$core$Basics$sqrt = _elm_lang$core$Native_Basics.sqrt; +var _elm_lang$core$Basics$atan2 = _elm_lang$core$Native_Basics.atan2; +var _elm_lang$core$Basics$atan = _elm_lang$core$Native_Basics.atan; +var _elm_lang$core$Basics$asin = _elm_lang$core$Native_Basics.asin; +var _elm_lang$core$Basics$acos = _elm_lang$core$Native_Basics.acos; +var _elm_lang$core$Basics$tan = _elm_lang$core$Native_Basics.tan; +var _elm_lang$core$Basics$sin = _elm_lang$core$Native_Basics.sin; +var _elm_lang$core$Basics$cos = _elm_lang$core$Native_Basics.cos; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['^'] = _elm_lang$core$Native_Basics.exp; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['%'] = _elm_lang$core$Native_Basics.mod; +var _elm_lang$core$Basics$rem = _elm_lang$core$Native_Basics.rem; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['//'] = _elm_lang$core$Native_Basics.div; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['/'] = _elm_lang$core$Native_Basics.floatDiv; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['*'] = _elm_lang$core$Native_Basics.mul; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['-'] = _elm_lang$core$Native_Basics.sub; +var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; +_elm_lang$core$Basics_ops['+'] = _elm_lang$core$Native_Basics.add; +var _elm_lang$core$Basics$toPolar = _elm_lang$core$Native_Basics.toPolar; +var _elm_lang$core$Basics$fromPolar = _elm_lang$core$Native_Basics.fromPolar; +var _elm_lang$core$Basics$turns = _elm_lang$core$Native_Basics.turns; +var _elm_lang$core$Basics$degrees = _elm_lang$core$Native_Basics.degrees; +var _elm_lang$core$Basics$radians = function (t) { + return t; +}; +var _elm_lang$core$Basics$GT = {ctor: 'GT'}; +var _elm_lang$core$Basics$EQ = {ctor: 'EQ'}; +var _elm_lang$core$Basics$LT = {ctor: 'LT'}; +var _elm_lang$core$Basics$Never = function (a) { + return {ctor: 'Never', _0: a}; +}; + +var _elm_lang$core$Maybe$withDefault = F2( + function ($default, maybe) { + var _p0 = maybe; + if (_p0.ctor === 'Just') { + return _p0._0; + } else { + return $default; + } + }); +var _elm_lang$core$Maybe$Nothing = {ctor: 'Nothing'}; +var _elm_lang$core$Maybe$oneOf = function (maybes) { + oneOf: + while (true) { + var _p1 = maybes; + if (_p1.ctor === '[]') { + return _elm_lang$core$Maybe$Nothing; + } else { + var _p3 = _p1._0; + var _p2 = _p3; + if (_p2.ctor === 'Nothing') { + var _v3 = _p1._1; + maybes = _v3; + continue oneOf; + } else { + return _p3; + } + } + } +}; +var _elm_lang$core$Maybe$andThen = F2( + function (maybeValue, callback) { + var _p4 = maybeValue; + if (_p4.ctor === 'Just') { + return callback(_p4._0); + } else { + return _elm_lang$core$Maybe$Nothing; + } + }); +var _elm_lang$core$Maybe$Just = function (a) { + return {ctor: 'Just', _0: a}; +}; +var _elm_lang$core$Maybe$map = F2( + function (f, maybe) { + var _p5 = maybe; + if (_p5.ctor === 'Just') { + return _elm_lang$core$Maybe$Just( + f(_p5._0)); + } else { + return _elm_lang$core$Maybe$Nothing; + } + }); +var _elm_lang$core$Maybe$map2 = F3( + function (func, ma, mb) { + var _p6 = {ctor: '_Tuple2', _0: ma, _1: mb}; + if (((_p6.ctor === '_Tuple2') && (_p6._0.ctor === 'Just')) && (_p6._1.ctor === 'Just')) { + return _elm_lang$core$Maybe$Just( + A2(func, _p6._0._0, _p6._1._0)); + } else { + return _elm_lang$core$Maybe$Nothing; + } + }); +var _elm_lang$core$Maybe$map3 = F4( + function (func, ma, mb, mc) { + var _p7 = {ctor: '_Tuple3', _0: ma, _1: mb, _2: mc}; + if ((((_p7.ctor === '_Tuple3') && (_p7._0.ctor === 'Just')) && (_p7._1.ctor === 'Just')) && (_p7._2.ctor === 'Just')) { + return _elm_lang$core$Maybe$Just( + A3(func, _p7._0._0, _p7._1._0, _p7._2._0)); + } else { + return _elm_lang$core$Maybe$Nothing; + } + }); +var _elm_lang$core$Maybe$map4 = F5( + function (func, ma, mb, mc, md) { + var _p8 = {ctor: '_Tuple4', _0: ma, _1: mb, _2: mc, _3: md}; + if (((((_p8.ctor === '_Tuple4') && (_p8._0.ctor === 'Just')) && (_p8._1.ctor === 'Just')) && (_p8._2.ctor === 'Just')) && (_p8._3.ctor === 'Just')) { + return _elm_lang$core$Maybe$Just( + A4(func, _p8._0._0, _p8._1._0, _p8._2._0, _p8._3._0)); + } else { + return _elm_lang$core$Maybe$Nothing; + } + }); +var _elm_lang$core$Maybe$map5 = F6( + function (func, ma, mb, mc, md, me) { + var _p9 = {ctor: '_Tuple5', _0: ma, _1: mb, _2: mc, _3: md, _4: me}; + if ((((((_p9.ctor === '_Tuple5') && (_p9._0.ctor === 'Just')) && (_p9._1.ctor === 'Just')) && (_p9._2.ctor === 'Just')) && (_p9._3.ctor === 'Just')) && (_p9._4.ctor === 'Just')) { + return _elm_lang$core$Maybe$Just( + A5(func, _p9._0._0, _p9._1._0, _p9._2._0, _p9._3._0, _p9._4._0)); + } else { + return _elm_lang$core$Maybe$Nothing; + } + }); + +//import Native.Utils // + +var _elm_lang$core$Native_List = function() { + +var Nil = { ctor: '[]' }; + +function Cons(hd, tl) +{ + return { ctor: '::', _0: hd, _1: tl }; +} + +function fromArray(arr) +{ + var out = Nil; + for (var i = arr.length; i--; ) + { + out = Cons(arr[i], out); + } + return out; +} + +function toArray(xs) +{ + var out = []; + while (xs.ctor !== '[]') + { + out.push(xs._0); + xs = xs._1; + } + return out; +} + + +function range(lo, hi) +{ + var list = Nil; + if (lo <= hi) + { + do + { + list = Cons(hi, list); + } + while (hi-- > lo); + } + return list; +} + +function foldr(f, b, xs) +{ + var arr = toArray(xs); + var acc = b; + for (var i = arr.length; i--; ) + { + acc = A2(f, arr[i], acc); + } + return acc; +} + +function map2(f, xs, ys) +{ + var arr = []; + while (xs.ctor !== '[]' && ys.ctor !== '[]') + { + arr.push(A2(f, xs._0, ys._0)); + xs = xs._1; + ys = ys._1; + } + return fromArray(arr); +} + +function map3(f, xs, ys, zs) +{ + var arr = []; + while (xs.ctor !== '[]' && ys.ctor !== '[]' && zs.ctor !== '[]') + { + arr.push(A3(f, xs._0, ys._0, zs._0)); + xs = xs._1; + ys = ys._1; + zs = zs._1; + } + return fromArray(arr); +} + +function map4(f, ws, xs, ys, zs) +{ + var arr = []; + while ( ws.ctor !== '[]' + && xs.ctor !== '[]' + && ys.ctor !== '[]' + && zs.ctor !== '[]') + { + arr.push(A4(f, ws._0, xs._0, ys._0, zs._0)); + ws = ws._1; + xs = xs._1; + ys = ys._1; + zs = zs._1; + } + return fromArray(arr); +} + +function map5(f, vs, ws, xs, ys, zs) +{ + var arr = []; + while ( vs.ctor !== '[]' + && ws.ctor !== '[]' + && xs.ctor !== '[]' + && ys.ctor !== '[]' + && zs.ctor !== '[]') + { + arr.push(A5(f, vs._0, ws._0, xs._0, ys._0, zs._0)); + vs = vs._1; + ws = ws._1; + xs = xs._1; + ys = ys._1; + zs = zs._1; + } + return fromArray(arr); +} + +function sortBy(f, xs) +{ + return fromArray(toArray(xs).sort(function(a, b) { + return _elm_lang$core$Native_Utils.cmp(f(a), f(b)); + })); +} + +function sortWith(f, xs) +{ + return fromArray(toArray(xs).sort(function(a, b) { + var ord = f(a)(b).ctor; + return ord === 'EQ' ? 0 : ord === 'LT' ? -1 : 1; + })); +} + +return { + Nil: Nil, + Cons: Cons, + cons: F2(Cons), + toArray: toArray, + fromArray: fromArray, + range: range, + + foldr: F3(foldr), + + map2: F3(map2), + map3: F4(map3), + map4: F5(map4), + map5: F6(map5), + sortBy: F2(sortBy), + sortWith: F2(sortWith) +}; + +}(); +var _elm_lang$core$List$sortWith = _elm_lang$core$Native_List.sortWith; +var _elm_lang$core$List$sortBy = _elm_lang$core$Native_List.sortBy; +var _elm_lang$core$List$sort = function (xs) { + return A2(_elm_lang$core$List$sortBy, _elm_lang$core$Basics$identity, xs); +}; +var _elm_lang$core$List$drop = F2( + function (n, list) { + drop: + while (true) { + if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) { + return list; + } else { + var _p0 = list; + if (_p0.ctor === '[]') { + return list; + } else { + var _v1 = n - 1, + _v2 = _p0._1; + n = _v1; + list = _v2; + continue drop; + } + } + } + }); +var _elm_lang$core$List$map5 = _elm_lang$core$Native_List.map5; +var _elm_lang$core$List$map4 = _elm_lang$core$Native_List.map4; +var _elm_lang$core$List$map3 = _elm_lang$core$Native_List.map3; +var _elm_lang$core$List$map2 = _elm_lang$core$Native_List.map2; +var _elm_lang$core$List$any = F2( + function (isOkay, list) { + any: + while (true) { + var _p1 = list; + if (_p1.ctor === '[]') { + return false; + } else { + if (isOkay(_p1._0)) { + return true; + } else { + var _v4 = isOkay, + _v5 = _p1._1; + isOkay = _v4; + list = _v5; + continue any; + } + } + } + }); +var _elm_lang$core$List$all = F2( + function (isOkay, list) { + return _elm_lang$core$Basics$not( + A2( + _elm_lang$core$List$any, + function (_p2) { + return _elm_lang$core$Basics$not( + isOkay(_p2)); + }, + list)); + }); +var _elm_lang$core$List$foldr = _elm_lang$core$Native_List.foldr; +var _elm_lang$core$List$foldl = F3( + function (func, acc, list) { + foldl: + while (true) { + var _p3 = list; + if (_p3.ctor === '[]') { + return acc; + } else { + var _v7 = func, + _v8 = A2(func, _p3._0, acc), + _v9 = _p3._1; + func = _v7; + acc = _v8; + list = _v9; + continue foldl; + } + } + }); +var _elm_lang$core$List$length = function (xs) { + return A3( + _elm_lang$core$List$foldl, + F2( + function (_p4, i) { + return i + 1; + }), + 0, + xs); +}; +var _elm_lang$core$List$sum = function (numbers) { + return A3( + _elm_lang$core$List$foldl, + F2( + function (x, y) { + return x + y; + }), + 0, + numbers); +}; +var _elm_lang$core$List$product = function (numbers) { + return A3( + _elm_lang$core$List$foldl, + F2( + function (x, y) { + return x * y; + }), + 1, + numbers); +}; +var _elm_lang$core$List$maximum = function (list) { + var _p5 = list; + if (_p5.ctor === '::') { + return _elm_lang$core$Maybe$Just( + A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$max, _p5._0, _p5._1)); + } else { + return _elm_lang$core$Maybe$Nothing; + } +}; +var _elm_lang$core$List$minimum = function (list) { + var _p6 = list; + if (_p6.ctor === '::') { + return _elm_lang$core$Maybe$Just( + A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$min, _p6._0, _p6._1)); + } else { + return _elm_lang$core$Maybe$Nothing; + } +}; +var _elm_lang$core$List$indexedMap = F2( + function (f, xs) { + return A3( + _elm_lang$core$List$map2, + f, + _elm_lang$core$Native_List.range( + 0, + _elm_lang$core$List$length(xs) - 1), + xs); + }); +var _elm_lang$core$List$member = F2( + function (x, xs) { + return A2( + _elm_lang$core$List$any, + function (a) { + return _elm_lang$core$Native_Utils.eq(a, x); + }, + xs); + }); +var _elm_lang$core$List$isEmpty = function (xs) { + var _p7 = xs; + if (_p7.ctor === '[]') { + return true; + } else { + return false; + } +}; +var _elm_lang$core$List$tail = function (list) { + var _p8 = list; + if (_p8.ctor === '::') { + return _elm_lang$core$Maybe$Just(_p8._1); + } else { + return _elm_lang$core$Maybe$Nothing; + } +}; +var _elm_lang$core$List$head = function (list) { + var _p9 = list; + if (_p9.ctor === '::') { + return _elm_lang$core$Maybe$Just(_p9._0); + } else { + return _elm_lang$core$Maybe$Nothing; + } +}; +var _elm_lang$core$List_ops = _elm_lang$core$List_ops || {}; +_elm_lang$core$List_ops['::'] = _elm_lang$core$Native_List.cons; +var _elm_lang$core$List$map = F2( + function (f, xs) { + return A3( + _elm_lang$core$List$foldr, + F2( + function (x, acc) { + return A2( + _elm_lang$core$List_ops['::'], + f(x), + acc); + }), + _elm_lang$core$Native_List.fromArray( + []), + xs); + }); +var _elm_lang$core$List$filter = F2( + function (pred, xs) { + var conditionalCons = F2( + function (x, xs$) { + return pred(x) ? A2(_elm_lang$core$List_ops['::'], x, xs$) : xs$; + }); + return A3( + _elm_lang$core$List$foldr, + conditionalCons, + _elm_lang$core$Native_List.fromArray( + []), + xs); + }); +var _elm_lang$core$List$maybeCons = F3( + function (f, mx, xs) { + var _p10 = f(mx); + if (_p10.ctor === 'Just') { + return A2(_elm_lang$core$List_ops['::'], _p10._0, xs); + } else { + return xs; + } + }); +var _elm_lang$core$List$filterMap = F2( + function (f, xs) { + return A3( + _elm_lang$core$List$foldr, + _elm_lang$core$List$maybeCons(f), + _elm_lang$core$Native_List.fromArray( + []), + xs); + }); +var _elm_lang$core$List$reverse = function (list) { + return A3( + _elm_lang$core$List$foldl, + F2( + function (x, y) { + return A2(_elm_lang$core$List_ops['::'], x, y); + }), + _elm_lang$core$Native_List.fromArray( + []), + list); +}; +var _elm_lang$core$List$scanl = F3( + function (f, b, xs) { + var scan1 = F2( + function (x, accAcc) { + var _p11 = accAcc; + if (_p11.ctor === '::') { + return A2( + _elm_lang$core$List_ops['::'], + A2(f, x, _p11._0), + accAcc); + } else { + return _elm_lang$core$Native_List.fromArray( + []); + } + }); + return _elm_lang$core$List$reverse( + A3( + _elm_lang$core$List$foldl, + scan1, + _elm_lang$core$Native_List.fromArray( + [b]), + xs)); + }); +var _elm_lang$core$List$append = F2( + function (xs, ys) { + var _p12 = ys; + if (_p12.ctor === '[]') { + return xs; + } else { + return A3( + _elm_lang$core$List$foldr, + F2( + function (x, y) { + return A2(_elm_lang$core$List_ops['::'], x, y); + }), + ys, + xs); + } + }); +var _elm_lang$core$List$concat = function (lists) { + return A3( + _elm_lang$core$List$foldr, + _elm_lang$core$List$append, + _elm_lang$core$Native_List.fromArray( + []), + lists); +}; +var _elm_lang$core$List$concatMap = F2( + function (f, list) { + return _elm_lang$core$List$concat( + A2(_elm_lang$core$List$map, f, list)); + }); +var _elm_lang$core$List$partition = F2( + function (pred, list) { + var step = F2( + function (x, _p13) { + var _p14 = _p13; + var _p16 = _p14._0; + var _p15 = _p14._1; + return pred(x) ? { + ctor: '_Tuple2', + _0: A2(_elm_lang$core$List_ops['::'], x, _p16), + _1: _p15 + } : { + ctor: '_Tuple2', + _0: _p16, + _1: A2(_elm_lang$core$List_ops['::'], x, _p15) + }; + }); + return A3( + _elm_lang$core$List$foldr, + step, + { + ctor: '_Tuple2', + _0: _elm_lang$core$Native_List.fromArray( + []), + _1: _elm_lang$core$Native_List.fromArray( + []) + }, + list); + }); +var _elm_lang$core$List$unzip = function (pairs) { + var step = F2( + function (_p18, _p17) { + var _p19 = _p18; + var _p20 = _p17; + return { + ctor: '_Tuple2', + _0: A2(_elm_lang$core$List_ops['::'], _p19._0, _p20._0), + _1: A2(_elm_lang$core$List_ops['::'], _p19._1, _p20._1) + }; + }); + return A3( + _elm_lang$core$List$foldr, + step, + { + ctor: '_Tuple2', + _0: _elm_lang$core$Native_List.fromArray( + []), + _1: _elm_lang$core$Native_List.fromArray( + []) + }, + pairs); +}; +var _elm_lang$core$List$intersperse = F2( + function (sep, xs) { + var _p21 = xs; + if (_p21.ctor === '[]') { + return _elm_lang$core$Native_List.fromArray( + []); + } else { + var step = F2( + function (x, rest) { + return A2( + _elm_lang$core$List_ops['::'], + sep, + A2(_elm_lang$core$List_ops['::'], x, rest)); + }); + var spersed = A3( + _elm_lang$core$List$foldr, + step, + _elm_lang$core$Native_List.fromArray( + []), + _p21._1); + return A2(_elm_lang$core$List_ops['::'], _p21._0, spersed); + } + }); +var _elm_lang$core$List$takeReverse = F3( + function (n, list, taken) { + takeReverse: + while (true) { + if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) { + return taken; + } else { + var _p22 = list; + if (_p22.ctor === '[]') { + return taken; + } else { + var _v23 = n - 1, + _v24 = _p22._1, + _v25 = A2(_elm_lang$core$List_ops['::'], _p22._0, taken); + n = _v23; + list = _v24; + taken = _v25; + continue takeReverse; + } + } + } + }); +var _elm_lang$core$List$takeTailRec = F2( + function (n, list) { + return _elm_lang$core$List$reverse( + A3( + _elm_lang$core$List$takeReverse, + n, + list, + _elm_lang$core$Native_List.fromArray( + []))); + }); +var _elm_lang$core$List$takeFast = F3( + function (ctr, n, list) { + if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) { + return _elm_lang$core$Native_List.fromArray( + []); + } else { + var _p23 = {ctor: '_Tuple2', _0: n, _1: list}; + _v26_5: + do { + _v26_1: + do { + if (_p23.ctor === '_Tuple2') { + if (_p23._1.ctor === '[]') { + return list; + } else { + if (_p23._1._1.ctor === '::') { + switch (_p23._0) { + case 1: + break _v26_1; + case 2: + return _elm_lang$core$Native_List.fromArray( + [_p23._1._0, _p23._1._1._0]); + case 3: + if (_p23._1._1._1.ctor === '::') { + return _elm_lang$core$Native_List.fromArray( + [_p23._1._0, _p23._1._1._0, _p23._1._1._1._0]); + } else { + break _v26_5; + } + default: + if ((_p23._1._1._1.ctor === '::') && (_p23._1._1._1._1.ctor === '::')) { + var _p28 = _p23._1._1._1._0; + var _p27 = _p23._1._1._0; + var _p26 = _p23._1._0; + var _p25 = _p23._1._1._1._1._0; + var _p24 = _p23._1._1._1._1._1; + return (_elm_lang$core$Native_Utils.cmp(ctr, 1000) > 0) ? A2( + _elm_lang$core$List_ops['::'], + _p26, + A2( + _elm_lang$core$List_ops['::'], + _p27, + A2( + _elm_lang$core$List_ops['::'], + _p28, + A2( + _elm_lang$core$List_ops['::'], + _p25, + A2(_elm_lang$core$List$takeTailRec, n - 4, _p24))))) : A2( + _elm_lang$core$List_ops['::'], + _p26, + A2( + _elm_lang$core$List_ops['::'], + _p27, + A2( + _elm_lang$core$List_ops['::'], + _p28, + A2( + _elm_lang$core$List_ops['::'], + _p25, + A3(_elm_lang$core$List$takeFast, ctr + 1, n - 4, _p24))))); + } else { + break _v26_5; + } + } + } else { + if (_p23._0 === 1) { + break _v26_1; + } else { + break _v26_5; + } + } + } + } else { + break _v26_5; + } + } while(false); + return _elm_lang$core$Native_List.fromArray( + [_p23._1._0]); + } while(false); + return list; + } + }); +var _elm_lang$core$List$take = F2( + function (n, list) { + return A3(_elm_lang$core$List$takeFast, 0, n, list); + }); +var _elm_lang$core$List$repeatHelp = F3( + function (result, n, value) { + repeatHelp: + while (true) { + if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) { + return result; + } else { + var _v27 = A2(_elm_lang$core$List_ops['::'], value, result), + _v28 = n - 1, + _v29 = value; + result = _v27; + n = _v28; + value = _v29; + continue repeatHelp; + } + } + }); +var _elm_lang$core$List$repeat = F2( + function (n, value) { + return A3( + _elm_lang$core$List$repeatHelp, + _elm_lang$core$Native_List.fromArray( + []), + n, + value); + }); + +var _elm_lang$core$Array$append = _elm_lang$core$Native_Array.append; +var _elm_lang$core$Array$length = _elm_lang$core$Native_Array.length; +var _elm_lang$core$Array$isEmpty = function (array) { + return _elm_lang$core$Native_Utils.eq( + _elm_lang$core$Array$length(array), + 0); +}; +var _elm_lang$core$Array$slice = _elm_lang$core$Native_Array.slice; +var _elm_lang$core$Array$set = _elm_lang$core$Native_Array.set; +var _elm_lang$core$Array$get = F2( + function (i, array) { + return ((_elm_lang$core$Native_Utils.cmp(0, i) < 1) && (_elm_lang$core$Native_Utils.cmp( + i, + _elm_lang$core$Native_Array.length(array)) < 0)) ? _elm_lang$core$Maybe$Just( + A2(_elm_lang$core$Native_Array.get, i, array)) : _elm_lang$core$Maybe$Nothing; + }); +var _elm_lang$core$Array$push = _elm_lang$core$Native_Array.push; +var _elm_lang$core$Array$empty = _elm_lang$core$Native_Array.empty; +var _elm_lang$core$Array$filter = F2( + function (isOkay, arr) { + var update = F2( + function (x, xs) { + return isOkay(x) ? A2(_elm_lang$core$Native_Array.push, x, xs) : xs; + }); + return A3(_elm_lang$core$Native_Array.foldl, update, _elm_lang$core$Native_Array.empty, arr); + }); +var _elm_lang$core$Array$foldr = _elm_lang$core$Native_Array.foldr; +var _elm_lang$core$Array$foldl = _elm_lang$core$Native_Array.foldl; +var _elm_lang$core$Array$indexedMap = _elm_lang$core$Native_Array.indexedMap; +var _elm_lang$core$Array$map = _elm_lang$core$Native_Array.map; +var _elm_lang$core$Array$toIndexedList = function (array) { + return A3( + _elm_lang$core$List$map2, + F2( + function (v0, v1) { + return {ctor: '_Tuple2', _0: v0, _1: v1}; + }), + _elm_lang$core$Native_List.range( + 0, + _elm_lang$core$Native_Array.length(array) - 1), + _elm_lang$core$Native_Array.toList(array)); +}; +var _elm_lang$core$Array$toList = _elm_lang$core$Native_Array.toList; +var _elm_lang$core$Array$fromList = _elm_lang$core$Native_Array.fromList; +var _elm_lang$core$Array$initialize = _elm_lang$core$Native_Array.initialize; +var _elm_lang$core$Array$repeat = F2( + function (n, e) { + return A2( + _elm_lang$core$Array$initialize, + n, + _elm_lang$core$Basics$always(e)); + }); +var _elm_lang$core$Array$Array = {ctor: 'Array'}; + +var _elm_lang$core$Native_Bitwise = function() { + +return { + and: F2(function and(a, b) { return a & b; }), + or: F2(function or(a, b) { return a | b; }), + xor: F2(function xor(a, b) { return a ^ b; }), + complement: function complement(a) { return ~a; }, + shiftLeft: F2(function sll(a, offset) { return a << offset; }), + shiftRightArithmatic: F2(function sra(a, offset) { return a >> offset; }), + shiftRightLogical: F2(function srl(a, offset) { return a >>> offset; }) +}; + +}(); + +var _elm_lang$core$Bitwise$shiftRightLogical = _elm_lang$core$Native_Bitwise.shiftRightLogical; +var _elm_lang$core$Bitwise$shiftRight = _elm_lang$core$Native_Bitwise.shiftRightArithmatic; +var _elm_lang$core$Bitwise$shiftLeft = _elm_lang$core$Native_Bitwise.shiftLeft; +var _elm_lang$core$Bitwise$complement = _elm_lang$core$Native_Bitwise.complement; +var _elm_lang$core$Bitwise$xor = _elm_lang$core$Native_Bitwise.xor; +var _elm_lang$core$Bitwise$or = _elm_lang$core$Native_Bitwise.or; +var _elm_lang$core$Bitwise$and = _elm_lang$core$Native_Bitwise.and; + +//import Native.Utils // + +var _elm_lang$core$Native_Char = function() { + +return { + fromCode: function(c) { return _elm_lang$core$Native_Utils.chr(String.fromCharCode(c)); }, + toCode: function(c) { return c.charCodeAt(0); }, + toUpper: function(c) { return _elm_lang$core$Native_Utils.chr(c.toUpperCase()); }, + toLower: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLowerCase()); }, + toLocaleUpper: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLocaleUpperCase()); }, + toLocaleLower: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLocaleLowerCase()); } +}; + +}(); +var _elm_lang$core$Char$fromCode = _elm_lang$core$Native_Char.fromCode; +var _elm_lang$core$Char$toCode = _elm_lang$core$Native_Char.toCode; +var _elm_lang$core$Char$toLocaleLower = _elm_lang$core$Native_Char.toLocaleLower; +var _elm_lang$core$Char$toLocaleUpper = _elm_lang$core$Native_Char.toLocaleUpper; +var _elm_lang$core$Char$toLower = _elm_lang$core$Native_Char.toLower; +var _elm_lang$core$Char$toUpper = _elm_lang$core$Native_Char.toUpper; +var _elm_lang$core$Char$isBetween = F3( + function (low, high, $char) { + var code = _elm_lang$core$Char$toCode($char); + return (_elm_lang$core$Native_Utils.cmp( + code, + _elm_lang$core$Char$toCode(low)) > -1) && (_elm_lang$core$Native_Utils.cmp( + code, + _elm_lang$core$Char$toCode(high)) < 1); + }); +var _elm_lang$core$Char$isUpper = A2( + _elm_lang$core$Char$isBetween, + _elm_lang$core$Native_Utils.chr('A'), + _elm_lang$core$Native_Utils.chr('Z')); +var _elm_lang$core$Char$isLower = A2( + _elm_lang$core$Char$isBetween, + _elm_lang$core$Native_Utils.chr('a'), + _elm_lang$core$Native_Utils.chr('z')); +var _elm_lang$core$Char$isDigit = A2( + _elm_lang$core$Char$isBetween, + _elm_lang$core$Native_Utils.chr('0'), + _elm_lang$core$Native_Utils.chr('9')); +var _elm_lang$core$Char$isOctDigit = A2( + _elm_lang$core$Char$isBetween, + _elm_lang$core$Native_Utils.chr('0'), + _elm_lang$core$Native_Utils.chr('7')); +var _elm_lang$core$Char$isHexDigit = function ($char) { + return _elm_lang$core$Char$isDigit($char) || (A3( + _elm_lang$core$Char$isBetween, + _elm_lang$core$Native_Utils.chr('a'), + _elm_lang$core$Native_Utils.chr('f'), + $char) || A3( + _elm_lang$core$Char$isBetween, + _elm_lang$core$Native_Utils.chr('A'), + _elm_lang$core$Native_Utils.chr('F'), + $char)); +}; + +//import Native.Utils // + +var _elm_lang$core$Native_Scheduler = function() { + +var MAX_STEPS = 10000; + + +// TASKS + +function succeed(value) +{ + return { + ctor: '_Task_succeed', + value: value + }; +} + +function fail(error) +{ + return { + ctor: '_Task_fail', + value: error + }; +} + +function nativeBinding(callback) +{ + return { + ctor: '_Task_nativeBinding', + callback: callback, + cancel: null + }; +} + +function andThen(task, callback) +{ + return { + ctor: '_Task_andThen', + task: task, + callback: callback + }; +} + +function onError(task, callback) +{ + return { + ctor: '_Task_onError', + task: task, + callback: callback + }; +} + +function receive(callback) +{ + return { + ctor: '_Task_receive', + callback: callback + }; +} + + +// PROCESSES + +function rawSpawn(task) +{ + var process = { + ctor: '_Process', + id: _elm_lang$core$Native_Utils.guid(), + root: task, + stack: null, + mailbox: [] + }; + + enqueue(process); + + return process; +} + +function spawn(task) +{ + return nativeBinding(function(callback) { + var process = rawSpawn(task); + callback(succeed(process)); + }); +} + +function rawSend(process, msg) +{ + process.mailbox.push(msg); + enqueue(process); +} + +function send(process, msg) +{ + return nativeBinding(function(callback) { + rawSend(process, msg); + callback(succeed(_elm_lang$core$Native_Utils.Tuple0)); + }); +} + +function kill(process) +{ + return nativeBinding(function(callback) { + var root = process.root; + if (root.ctor === '_Task_nativeBinding' && root.cancel) + { + root.cancel(); + } + + process.root = null; + + callback(succeed(_elm_lang$core$Native_Utils.Tuple0)); + }); +} + +function sleep(time) +{ + return nativeBinding(function(callback) { + var id = setTimeout(function() { + callback(succeed(_elm_lang$core$Native_Utils.Tuple0)); + }, time); + + return function() { clearTimeout(id); }; + }); +} + + +// STEP PROCESSES + +function step(numSteps, process) +{ + while (numSteps < MAX_STEPS) + { + var ctor = process.root.ctor; + + if (ctor === '_Task_succeed') + { + while (process.stack && process.stack.ctor === '_Task_onError') + { + process.stack = process.stack.rest; + } + if (process.stack === null) + { + break; + } + process.root = process.stack.callback(process.root.value); + process.stack = process.stack.rest; + ++numSteps; + continue; + } + + if (ctor === '_Task_fail') + { + while (process.stack && process.stack.ctor === '_Task_andThen') + { + process.stack = process.stack.rest; + } + if (process.stack === null) + { + break; + } + process.root = process.stack.callback(process.root.value); + process.stack = process.stack.rest; + ++numSteps; + continue; + } + + if (ctor === '_Task_andThen') + { + process.stack = { + ctor: '_Task_andThen', + callback: process.root.callback, + rest: process.stack + }; + process.root = process.root.task; + ++numSteps; + continue; + } + + if (ctor === '_Task_onError') + { + process.stack = { + ctor: '_Task_onError', + callback: process.root.callback, + rest: process.stack + }; + process.root = process.root.task; + ++numSteps; + continue; + } + + if (ctor === '_Task_nativeBinding') + { + process.root.cancel = process.root.callback(function(newRoot) { + process.root = newRoot; + enqueue(process); + }); + + break; + } + + if (ctor === '_Task_receive') + { + var mailbox = process.mailbox; + if (mailbox.length === 0) + { + break; + } + + process.root = process.root.callback(mailbox.shift()); + ++numSteps; + continue; + } + + throw new Error(ctor); + } + + if (numSteps < MAX_STEPS) + { + return numSteps + 1; + } + enqueue(process); + + return numSteps; +} + + +// WORK QUEUE + +var working = false; +var workQueue = []; + +function enqueue(process) +{ + workQueue.push(process); + + if (!working) + { + setTimeout(work, 0); + working = true; + } +} + +function work() +{ + var numSteps = 0; + var process; + while (numSteps < MAX_STEPS && (process = workQueue.shift())) + { + if (process.root) + { + numSteps = step(numSteps, process); + } + } + if (!process) + { + working = false; + return; + } + setTimeout(work, 0); +} + + +return { + succeed: succeed, + fail: fail, + nativeBinding: nativeBinding, + andThen: F2(andThen), + onError: F2(onError), + receive: receive, + + spawn: spawn, + kill: kill, + sleep: sleep, + send: F2(send), + + rawSpawn: rawSpawn, + rawSend: rawSend +}; + +}(); +//import // + +var _elm_lang$core$Native_Platform = function() { + + +// PROGRAMS + +function addPublicModule(object, name, main) +{ + var init = main ? makeEmbed(name, main) : mainIsUndefined(name); + + object['worker'] = function worker(flags) + { + return init(undefined, flags, false); + } + + object['embed'] = function embed(domNode, flags) + { + return init(domNode, flags, true); + } + + object['fullscreen'] = function fullscreen(flags) + { + return init(document.body, flags, true); + }; +} + + +// PROGRAM FAIL + +function mainIsUndefined(name) +{ + return function(domNode) + { + var message = 'Cannot initialize module `' + name + + '` because it has no `main` value!\nWhat should I show on screen?'; + domNode.innerHTML = errorHtml(message); + throw new Error(message); + }; +} + +function errorHtml(message) +{ + return '<div style="padding-left:1em;">' + + '<h2 style="font-weight:normal;"><b>Oops!</b> Something went wrong when starting your Elm program.</h2>' + + '<pre style="padding-left:1em;">' + message + '</pre>' + + '</div>'; +} + + +// PROGRAM SUCCESS + +function makeEmbed(moduleName, main) +{ + return function embed(rootDomNode, flags, withRenderer) + { + try + { + var program = mainToProgram(moduleName, main); + if (!withRenderer) + { + program.renderer = dummyRenderer; + } + return makeEmbedHelp(moduleName, program, rootDomNode, flags); + } + catch (e) + { + rootDomNode.innerHTML = errorHtml(e.message); + throw e; + } + }; +} + +function dummyRenderer() +{ + return { update: function() {} }; +} + + +// MAIN TO PROGRAM + +function mainToProgram(moduleName, wrappedMain) +{ + var main = wrappedMain.main; + + if (typeof main.init === 'undefined') + { + var emptyBag = batch(_elm_lang$core$Native_List.Nil); + var noChange = _elm_lang$core$Native_Utils.Tuple2( + _elm_lang$core$Native_Utils.Tuple0, + emptyBag + ); + + return _elm_lang$virtual_dom$VirtualDom$programWithFlags({ + init: function() { return noChange; }, + view: function() { return main; }, + update: F2(function() { return noChange; }), + subscriptions: function () { return emptyBag; } + }); + } + + var flags = wrappedMain.flags; + var init = flags + ? initWithFlags(moduleName, main.init, flags) + : initWithoutFlags(moduleName, main.init); + + return _elm_lang$virtual_dom$VirtualDom$programWithFlags({ + init: init, + view: main.view, + update: main.update, + subscriptions: main.subscriptions, + }); +} + +function initWithoutFlags(moduleName, realInit) +{ + return function init(flags) + { + if (typeof flags !== 'undefined') + { + throw new Error( + 'You are giving module `' + moduleName + '` an argument in JavaScript.\n' + + 'This module does not take arguments though! You probably need to change the\n' + + 'initialization code to something like `Elm.' + moduleName + '.fullscreen()`' + ); + } + return realInit(); + }; +} + +function initWithFlags(moduleName, realInit, flagDecoder) +{ + return function init(flags) + { + var result = A2(_elm_lang$core$Native_Json.run, flagDecoder, flags); + if (result.ctor === 'Err') + { + throw new Error( + 'You are trying to initialize module `' + moduleName + '` with an unexpected argument.\n' + + 'When trying to convert it to a usable Elm value, I run into this problem:\n\n' + + result._0 + ); + } + return realInit(result._0); + }; +} + + +// SETUP RUNTIME SYSTEM + +function makeEmbedHelp(moduleName, program, rootDomNode, flags) +{ + var init = program.init; + var update = program.update; + var subscriptions = program.subscriptions; + var view = program.view; + var makeRenderer = program.renderer; + + // ambient state + var managers = {}; + var renderer; + + // init and update state in main process + var initApp = _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { + var results = init(flags); + var model = results._0; + renderer = makeRenderer(rootDomNode, enqueue, view(model)); + var cmds = results._1; + var subs = subscriptions(model); + dispatchEffects(managers, cmds, subs); + callback(_elm_lang$core$Native_Scheduler.succeed(model)); + }); + + function onMessage(msg, model) + { + return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { + var results = A2(update, msg, model); + model = results._0; + renderer.update(view(model)); + var cmds = results._1; + var subs = subscriptions(model); + dispatchEffects(managers, cmds, subs); + callback(_elm_lang$core$Native_Scheduler.succeed(model)); + }); + } + + var mainProcess = spawnLoop(initApp, onMessage); + + function enqueue(msg) + { + _elm_lang$core$Native_Scheduler.rawSend(mainProcess, msg); + } + + var ports = setupEffects(managers, enqueue); + + return ports ? { ports: ports } : {}; +} + + +// EFFECT MANAGERS + +var effectManagers = {}; + +function setupEffects(managers, callback) +{ + var ports; + + // setup all necessary effect managers + for (var key in effectManagers) + { + var manager = effectManagers[key]; + + if (manager.isForeign) + { + ports = ports || {}; + ports[key] = manager.tag === 'cmd' + ? setupOutgoingPort(key) + : setupIncomingPort(key, callback); + } + + managers[key] = makeManager(manager, callback); + } + + return ports; +} + +function makeManager(info, callback) +{ + var router = { + main: callback, + self: undefined + }; + + var tag = info.tag; + var onEffects = info.onEffects; + var onSelfMsg = info.onSelfMsg; + + function onMessage(msg, state) + { + if (msg.ctor === 'self') + { + return A3(onSelfMsg, router, msg._0, state); + } + + var fx = msg._0; + switch (tag) + { + case 'cmd': + return A3(onEffects, router, fx.cmds, state); + + case 'sub': + return A3(onEffects, router, fx.subs, state); + + case 'fx': + return A4(onEffects, router, fx.cmds, fx.subs, state); + } + } + + var process = spawnLoop(info.init, onMessage); + router.self = process; + return process; +} + +function sendToApp(router, msg) +{ + return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) + { + router.main(msg); + callback(_elm_lang$core$Native_Scheduler.succeed(_elm_lang$core$Native_Utils.Tuple0)); + }); +} + +function sendToSelf(router, msg) +{ + return A2(_elm_lang$core$Native_Scheduler.send, router.self, { + ctor: 'self', + _0: msg + }); +} + + +// HELPER for STATEFUL LOOPS + +function spawnLoop(init, onMessage) +{ + var andThen = _elm_lang$core$Native_Scheduler.andThen; + + function loop(state) + { + var handleMsg = _elm_lang$core$Native_Scheduler.receive(function(msg) { + return onMessage(msg, state); + }); + return A2(andThen, handleMsg, loop); + } + + var task = A2(andThen, init, loop); + + return _elm_lang$core$Native_Scheduler.rawSpawn(task); +} + + +// BAGS + +function leaf(home) +{ + return function(value) + { + return { + type: 'leaf', + home: home, + value: value + }; + }; +} + +function batch(list) +{ + return { + type: 'node', + branches: list + }; +} + +function map(tagger, bag) +{ + return { + type: 'map', + tagger: tagger, + tree: bag + } +} + + +// PIPE BAGS INTO EFFECT MANAGERS + +function dispatchEffects(managers, cmdBag, subBag) +{ + var effectsDict = {}; + gatherEffects(true, cmdBag, effectsDict, null); + gatherEffects(false, subBag, effectsDict, null); + + for (var home in managers) + { + var fx = home in effectsDict + ? effectsDict[home] + : { + cmds: _elm_lang$core$Native_List.Nil, + subs: _elm_lang$core$Native_List.Nil + }; + + _elm_lang$core$Native_Scheduler.rawSend(managers[home], { ctor: 'fx', _0: fx }); + } +} + +function gatherEffects(isCmd, bag, effectsDict, taggers) +{ + switch (bag.type) + { + case 'leaf': + var home = bag.home; + var effect = toEffect(isCmd, home, taggers, bag.value); + effectsDict[home] = insert(isCmd, effect, effectsDict[home]); + return; + + case 'node': + var list = bag.branches; + while (list.ctor !== '[]') + { + gatherEffects(isCmd, list._0, effectsDict, taggers); + list = list._1; + } + return; + + case 'map': + gatherEffects(isCmd, bag.tree, effectsDict, { + tagger: bag.tagger, + rest: taggers + }); + return; + } +} + +function toEffect(isCmd, home, taggers, value) +{ + function applyTaggers(x) + { + var temp = taggers; + while (temp) + { + x = temp.tagger(x); + temp = temp.rest; + } + return x; + } + + var map = isCmd + ? effectManagers[home].cmdMap + : effectManagers[home].subMap; + + return A2(map, applyTaggers, value) +} + +function insert(isCmd, newEffect, effects) +{ + effects = effects || { + cmds: _elm_lang$core$Native_List.Nil, + subs: _elm_lang$core$Native_List.Nil + }; + if (isCmd) + { + effects.cmds = _elm_lang$core$Native_List.Cons(newEffect, effects.cmds); + return effects; + } + effects.subs = _elm_lang$core$Native_List.Cons(newEffect, effects.subs); + return effects; +} + + +// PORTS + +function checkPortName(name) +{ + if (name in effectManagers) + { + throw new Error('There can only be one port named `' + name + '`, but your program has multiple.'); + } +} + + +// OUTGOING PORTS + +function outgoingPort(name, converter) +{ + checkPortName(name); + effectManagers[name] = { + tag: 'cmd', + cmdMap: outgoingPortMap, + converter: converter, + isForeign: true + }; + return leaf(name); +} + +var outgoingPortMap = F2(function cmdMap(tagger, value) { + return value; +}); + +function setupOutgoingPort(name) +{ + var subs = []; + var converter = effectManagers[name].converter; + + // CREATE MANAGER + + var init = _elm_lang$core$Native_Scheduler.succeed(null); + + function onEffects(router, cmdList, state) + { + while (cmdList.ctor !== '[]') + { + var value = converter(cmdList._0); + for (var i = 0; i < subs.length; i++) + { + subs[i](value); + } + cmdList = cmdList._1; + } + return init; + } + + effectManagers[name].init = init; + effectManagers[name].onEffects = F3(onEffects); + + // PUBLIC API + + function subscribe(callback) + { + subs.push(callback); + } + + function unsubscribe(callback) + { + var index = subs.indexOf(callback); + if (index >= 0) + { + subs.splice(index, 1); + } + } + + return { + subscribe: subscribe, + unsubscribe: unsubscribe + }; +} + + +// INCOMING PORTS + +function incomingPort(name, converter) +{ + checkPortName(name); + effectManagers[name] = { + tag: 'sub', + subMap: incomingPortMap, + converter: converter, + isForeign: true + }; + return leaf(name); +} + +var incomingPortMap = F2(function subMap(tagger, finalTagger) +{ + return function(value) + { + return tagger(finalTagger(value)); + }; +}); + +function setupIncomingPort(name, callback) +{ + var sentBeforeInit = []; + var subs = _elm_lang$core$Native_List.Nil; + var converter = effectManagers[name].converter; + var currentOnEffects = preInitOnEffects; + var currentSend = preInitSend; + + // CREATE MANAGER + + var init = _elm_lang$core$Native_Scheduler.succeed(null); + + function preInitOnEffects(router, subList, state) + { + var postInitResult = postInitOnEffects(router, subList, state); + + for(var i = 0; i < sentBeforeInit.length; i++) + { + postInitSend(sentBeforeInit[i]); + } + + sentBeforeInit = null; // to release objects held in queue + currentSend = postInitSend; + currentOnEffects = postInitOnEffects; + return postInitResult; + } + + function postInitOnEffects(router, subList, state) + { + subs = subList; + return init; + } + + function onEffects(router, subList, state) + { + return currentOnEffects(router, subList, state); + } + + effectManagers[name].init = init; + effectManagers[name].onEffects = F3(onEffects); + + // PUBLIC API + + function preInitSend(value) + { + sentBeforeInit.push(value); + } + + function postInitSend(incomingValue) + { + var result = A2(_elm_lang$core$Json_Decode$decodeValue, converter, incomingValue); + if (result.ctor === 'Err') + { + throw new Error('Trying to send an unexpected type of value through port `' + name + '`:\n' + result._0); + } + + var value = result._0; + var temp = subs; + while (temp.ctor !== '[]') + { + callback(temp._0(value)); + temp = temp._1; + } + } + + function send(incomingValue) + { + currentSend(incomingValue); + } + + return { send: send }; +} + +return { + // routers + sendToApp: F2(sendToApp), + sendToSelf: F2(sendToSelf), + + // global setup + mainToProgram: mainToProgram, + effectManagers: effectManagers, + outgoingPort: outgoingPort, + incomingPort: incomingPort, + addPublicModule: addPublicModule, + + // effect bags + leaf: leaf, + batch: batch, + map: F2(map) +}; + +}(); + +var _elm_lang$core$Platform$hack = _elm_lang$core$Native_Scheduler.succeed; +var _elm_lang$core$Platform$sendToSelf = _elm_lang$core$Native_Platform.sendToSelf; +var _elm_lang$core$Platform$sendToApp = _elm_lang$core$Native_Platform.sendToApp; +var _elm_lang$core$Platform$Program = {ctor: 'Program'}; +var _elm_lang$core$Platform$Task = {ctor: 'Task'}; +var _elm_lang$core$Platform$ProcessId = {ctor: 'ProcessId'}; +var _elm_lang$core$Platform$Router = {ctor: 'Router'}; + +var _elm_lang$core$Platform_Cmd$batch = _elm_lang$core$Native_Platform.batch; +var _elm_lang$core$Platform_Cmd$none = _elm_lang$core$Platform_Cmd$batch( + _elm_lang$core$Native_List.fromArray( + [])); +var _elm_lang$core$Platform_Cmd_ops = _elm_lang$core$Platform_Cmd_ops || {}; +_elm_lang$core$Platform_Cmd_ops['!'] = F2( + function (model, commands) { + return { + ctor: '_Tuple2', + _0: model, + _1: _elm_lang$core$Platform_Cmd$batch(commands) + }; + }); +var _elm_lang$core$Platform_Cmd$map = _elm_lang$core$Native_Platform.map; +var _elm_lang$core$Platform_Cmd$Cmd = {ctor: 'Cmd'}; + +var _elm_lang$core$Result$toMaybe = function (result) { + var _p0 = result; + if (_p0.ctor === 'Ok') { + return _elm_lang$core$Maybe$Just(_p0._0); + } else { + return _elm_lang$core$Maybe$Nothing; + } +}; +var _elm_lang$core$Result$withDefault = F2( + function (def, result) { + var _p1 = result; + if (_p1.ctor === 'Ok') { + return _p1._0; + } else { + return def; + } + }); +var _elm_lang$core$Result$Err = function (a) { + return {ctor: 'Err', _0: a}; +}; +var _elm_lang$core$Result$andThen = F2( + function (result, callback) { + var _p2 = result; + if (_p2.ctor === 'Ok') { + return callback(_p2._0); + } else { + return _elm_lang$core$Result$Err(_p2._0); + } + }); +var _elm_lang$core$Result$Ok = function (a) { + return {ctor: 'Ok', _0: a}; +}; +var _elm_lang$core$Result$map = F2( + function (func, ra) { + var _p3 = ra; + if (_p3.ctor === 'Ok') { + return _elm_lang$core$Result$Ok( + func(_p3._0)); + } else { + return _elm_lang$core$Result$Err(_p3._0); + } + }); +var _elm_lang$core$Result$map2 = F3( + function (func, ra, rb) { + var _p4 = {ctor: '_Tuple2', _0: ra, _1: rb}; + if (_p4._0.ctor === 'Ok') { + if (_p4._1.ctor === 'Ok') { + return _elm_lang$core$Result$Ok( + A2(func, _p4._0._0, _p4._1._0)); + } else { + return _elm_lang$core$Result$Err(_p4._1._0); + } + } else { + return _elm_lang$core$Result$Err(_p4._0._0); + } + }); +var _elm_lang$core$Result$map3 = F4( + function (func, ra, rb, rc) { + var _p5 = {ctor: '_Tuple3', _0: ra, _1: rb, _2: rc}; + if (_p5._0.ctor === 'Ok') { + if (_p5._1.ctor === 'Ok') { + if (_p5._2.ctor === 'Ok') { + return _elm_lang$core$Result$Ok( + A3(func, _p5._0._0, _p5._1._0, _p5._2._0)); + } else { + return _elm_lang$core$Result$Err(_p5._2._0); + } + } else { + return _elm_lang$core$Result$Err(_p5._1._0); + } + } else { + return _elm_lang$core$Result$Err(_p5._0._0); + } + }); +var _elm_lang$core$Result$map4 = F5( + function (func, ra, rb, rc, rd) { + var _p6 = {ctor: '_Tuple4', _0: ra, _1: rb, _2: rc, _3: rd}; + if (_p6._0.ctor === 'Ok') { + if (_p6._1.ctor === 'Ok') { + if (_p6._2.ctor === 'Ok') { + if (_p6._3.ctor === 'Ok') { + return _elm_lang$core$Result$Ok( + A4(func, _p6._0._0, _p6._1._0, _p6._2._0, _p6._3._0)); + } else { + return _elm_lang$core$Result$Err(_p6._3._0); + } + } else { + return _elm_lang$core$Result$Err(_p6._2._0); + } + } else { + return _elm_lang$core$Result$Err(_p6._1._0); + } + } else { + return _elm_lang$core$Result$Err(_p6._0._0); + } + }); +var _elm_lang$core$Result$map5 = F6( + function (func, ra, rb, rc, rd, re) { + var _p7 = {ctor: '_Tuple5', _0: ra, _1: rb, _2: rc, _3: rd, _4: re}; + if (_p7._0.ctor === 'Ok') { + if (_p7._1.ctor === 'Ok') { + if (_p7._2.ctor === 'Ok') { + if (_p7._3.ctor === 'Ok') { + if (_p7._4.ctor === 'Ok') { + return _elm_lang$core$Result$Ok( + A5(func, _p7._0._0, _p7._1._0, _p7._2._0, _p7._3._0, _p7._4._0)); + } else { + return _elm_lang$core$Result$Err(_p7._4._0); + } + } else { + return _elm_lang$core$Result$Err(_p7._3._0); + } + } else { + return _elm_lang$core$Result$Err(_p7._2._0); + } + } else { + return _elm_lang$core$Result$Err(_p7._1._0); + } + } else { + return _elm_lang$core$Result$Err(_p7._0._0); + } + }); +var _elm_lang$core$Result$formatError = F2( + function (f, result) { + var _p8 = result; + if (_p8.ctor === 'Ok') { + return _elm_lang$core$Result$Ok(_p8._0); + } else { + return _elm_lang$core$Result$Err( + f(_p8._0)); + } + }); +var _elm_lang$core$Result$fromMaybe = F2( + function (err, maybe) { + var _p9 = maybe; + if (_p9.ctor === 'Just') { + return _elm_lang$core$Result$Ok(_p9._0); + } else { + return _elm_lang$core$Result$Err(err); + } + }); + +var _elm_lang$core$Task$onError = _elm_lang$core$Native_Scheduler.onError; +var _elm_lang$core$Task$andThen = _elm_lang$core$Native_Scheduler.andThen; +var _elm_lang$core$Task$spawnCmd = F2( + function (router, _p0) { + var _p1 = _p0; + return _elm_lang$core$Native_Scheduler.spawn( + A2( + _elm_lang$core$Task$andThen, + _p1._0, + _elm_lang$core$Platform$sendToApp(router))); + }); +var _elm_lang$core$Task$fail = _elm_lang$core$Native_Scheduler.fail; +var _elm_lang$core$Task$mapError = F2( + function (f, task) { + return A2( + _elm_lang$core$Task$onError, + task, + function (err) { + return _elm_lang$core$Task$fail( + f(err)); + }); + }); +var _elm_lang$core$Task$succeed = _elm_lang$core$Native_Scheduler.succeed; +var _elm_lang$core$Task$map = F2( + function (func, taskA) { + return A2( + _elm_lang$core$Task$andThen, + taskA, + function (a) { + return _elm_lang$core$Task$succeed( + func(a)); + }); + }); +var _elm_lang$core$Task$map2 = F3( + function (func, taskA, taskB) { + return A2( + _elm_lang$core$Task$andThen, + taskA, + function (a) { + return A2( + _elm_lang$core$Task$andThen, + taskB, + function (b) { + return _elm_lang$core$Task$succeed( + A2(func, a, b)); + }); + }); + }); +var _elm_lang$core$Task$map3 = F4( + function (func, taskA, taskB, taskC) { + return A2( + _elm_lang$core$Task$andThen, + taskA, + function (a) { + return A2( + _elm_lang$core$Task$andThen, + taskB, + function (b) { + return A2( + _elm_lang$core$Task$andThen, + taskC, + function (c) { + return _elm_lang$core$Task$succeed( + A3(func, a, b, c)); + }); + }); + }); + }); +var _elm_lang$core$Task$map4 = F5( + function (func, taskA, taskB, taskC, taskD) { + return A2( + _elm_lang$core$Task$andThen, + taskA, + function (a) { + return A2( + _elm_lang$core$Task$andThen, + taskB, + function (b) { + return A2( + _elm_lang$core$Task$andThen, + taskC, + function (c) { + return A2( + _elm_lang$core$Task$andThen, + taskD, + function (d) { + return _elm_lang$core$Task$succeed( + A4(func, a, b, c, d)); + }); + }); + }); + }); + }); +var _elm_lang$core$Task$map5 = F6( + function (func, taskA, taskB, taskC, taskD, taskE) { + return A2( + _elm_lang$core$Task$andThen, + taskA, + function (a) { + return A2( + _elm_lang$core$Task$andThen, + taskB, + function (b) { + return A2( + _elm_lang$core$Task$andThen, + taskC, + function (c) { + return A2( + _elm_lang$core$Task$andThen, + taskD, + function (d) { + return A2( + _elm_lang$core$Task$andThen, + taskE, + function (e) { + return _elm_lang$core$Task$succeed( + A5(func, a, b, c, d, e)); + }); + }); + }); + }); + }); + }); +var _elm_lang$core$Task$andMap = F2( + function (taskFunc, taskValue) { + return A2( + _elm_lang$core$Task$andThen, + taskFunc, + function (func) { + return A2( + _elm_lang$core$Task$andThen, + taskValue, + function (value) { + return _elm_lang$core$Task$succeed( + func(value)); + }); + }); + }); +var _elm_lang$core$Task$sequence = function (tasks) { + var _p2 = tasks; + if (_p2.ctor === '[]') { + return _elm_lang$core$Task$succeed( + _elm_lang$core$Native_List.fromArray( + [])); + } else { + return A3( + _elm_lang$core$Task$map2, + F2( + function (x, y) { + return A2(_elm_lang$core$List_ops['::'], x, y); + }), + _p2._0, + _elm_lang$core$Task$sequence(_p2._1)); + } +}; +var _elm_lang$core$Task$onEffects = F3( + function (router, commands, state) { + return A2( + _elm_lang$core$Task$map, + function (_p3) { + return {ctor: '_Tuple0'}; + }, + _elm_lang$core$Task$sequence( + A2( + _elm_lang$core$List$map, + _elm_lang$core$Task$spawnCmd(router), + commands))); + }); +var _elm_lang$core$Task$toMaybe = function (task) { + return A2( + _elm_lang$core$Task$onError, + A2(_elm_lang$core$Task$map, _elm_lang$core$Maybe$Just, task), + function (_p4) { + return _elm_lang$core$Task$succeed(_elm_lang$core$Maybe$Nothing); + }); +}; +var _elm_lang$core$Task$fromMaybe = F2( + function ($default, maybe) { + var _p5 = maybe; + if (_p5.ctor === 'Just') { + return _elm_lang$core$Task$succeed(_p5._0); + } else { + return _elm_lang$core$Task$fail($default); + } + }); +var _elm_lang$core$Task$toResult = function (task) { + return A2( + _elm_lang$core$Task$onError, + A2(_elm_lang$core$Task$map, _elm_lang$core$Result$Ok, task), + function (msg) { + return _elm_lang$core$Task$succeed( + _elm_lang$core$Result$Err(msg)); + }); +}; +var _elm_lang$core$Task$fromResult = function (result) { + var _p6 = result; + if (_p6.ctor === 'Ok') { + return _elm_lang$core$Task$succeed(_p6._0); + } else { + return _elm_lang$core$Task$fail(_p6._0); + } +}; +var _elm_lang$core$Task$init = _elm_lang$core$Task$succeed( + {ctor: '_Tuple0'}); +var _elm_lang$core$Task$onSelfMsg = F3( + function (_p9, _p8, _p7) { + return _elm_lang$core$Task$succeed( + {ctor: '_Tuple0'}); + }); +var _elm_lang$core$Task$command = _elm_lang$core$Native_Platform.leaf('Task'); +var _elm_lang$core$Task$T = function (a) { + return {ctor: 'T', _0: a}; +}; +var _elm_lang$core$Task$perform = F3( + function (onFail, onSuccess, task) { + return _elm_lang$core$Task$command( + _elm_lang$core$Task$T( + A2( + _elm_lang$core$Task$onError, + A2(_elm_lang$core$Task$map, onSuccess, task), + function (x) { + return _elm_lang$core$Task$succeed( + onFail(x)); + }))); + }); +var _elm_lang$core$Task$cmdMap = F2( + function (tagger, _p10) { + var _p11 = _p10; + return _elm_lang$core$Task$T( + A2(_elm_lang$core$Task$map, tagger, _p11._0)); + }); +_elm_lang$core$Native_Platform.effectManagers['Task'] = {pkg: 'elm-lang/core', init: _elm_lang$core$Task$init, onEffects: _elm_lang$core$Task$onEffects, onSelfMsg: _elm_lang$core$Task$onSelfMsg, tag: 'cmd', cmdMap: _elm_lang$core$Task$cmdMap}; + +//import Native.Utils // + +var _elm_lang$core$Native_Debug = function() { + +function log(tag, value) +{ + var msg = tag + ': ' + _elm_lang$core$Native_Utils.toString(value); + var process = process || {}; + if (process.stdout) + { + process.stdout.write(msg); + } + else + { + console.log(msg); + } + return value; +} + +function crash(message) +{ + throw new Error(message); +} + +return { + crash: crash, + log: F2(log) +}; + +}(); +//import Maybe, Native.List, Native.Utils, Result // + +var _elm_lang$core$Native_String = function() { + +function isEmpty(str) +{ + return str.length === 0; +} +function cons(chr, str) +{ + return chr + str; +} +function uncons(str) +{ + var hd = str[0]; + if (hd) + { + return _elm_lang$core$Maybe$Just(_elm_lang$core$Native_Utils.Tuple2(_elm_lang$core$Native_Utils.chr(hd), str.slice(1))); + } + return _elm_lang$core$Maybe$Nothing; +} +function append(a, b) +{ + return a + b; +} +function concat(strs) +{ + return _elm_lang$core$Native_List.toArray(strs).join(''); +} +function length(str) +{ + return str.length; +} +function map(f, str) +{ + var out = str.split(''); + for (var i = out.length; i--; ) + { + out[i] = f(_elm_lang$core$Native_Utils.chr(out[i])); + } + return out.join(''); +} +function filter(pred, str) +{ + return str.split('').map(_elm_lang$core$Native_Utils.chr).filter(pred).join(''); +} +function reverse(str) +{ + return str.split('').reverse().join(''); +} +function foldl(f, b, str) +{ + var len = str.length; + for (var i = 0; i < len; ++i) + { + b = A2(f, _elm_lang$core$Native_Utils.chr(str[i]), b); + } + return b; +} +function foldr(f, b, str) +{ + for (var i = str.length; i--; ) + { + b = A2(f, _elm_lang$core$Native_Utils.chr(str[i]), b); + } + return b; +} +function split(sep, str) +{ + return _elm_lang$core$Native_List.fromArray(str.split(sep)); +} +function join(sep, strs) +{ + return _elm_lang$core$Native_List.toArray(strs).join(sep); +} +function repeat(n, str) +{ + var result = ''; + while (n > 0) + { + if (n & 1) + { + result += str; + } + n >>= 1, str += str; + } + return result; +} +function slice(start, end, str) +{ + return str.slice(start, end); +} +function left(n, str) +{ + return n < 1 ? '' : str.slice(0, n); +} +function right(n, str) +{ + return n < 1 ? '' : str.slice(-n); +} +function dropLeft(n, str) +{ + return n < 1 ? str : str.slice(n); +} +function dropRight(n, str) +{ + return n < 1 ? str : str.slice(0, -n); +} +function pad(n, chr, str) +{ + var half = (n - str.length) / 2; + return repeat(Math.ceil(half), chr) + str + repeat(half | 0, chr); +} +function padRight(n, chr, str) +{ + return str + repeat(n - str.length, chr); +} +function padLeft(n, chr, str) +{ + return repeat(n - str.length, chr) + str; +} + +function trim(str) +{ + return str.trim(); +} +function trimLeft(str) +{ + return str.replace(/^\s+/, ''); +} +function trimRight(str) +{ + return str.replace(/\s+$/, ''); +} + +function words(str) +{ + return _elm_lang$core$Native_List.fromArray(str.trim().split(/\s+/g)); +} +function lines(str) +{ + return _elm_lang$core$Native_List.fromArray(str.split(/\r\n|\r|\n/g)); +} + +function toUpper(str) +{ + return str.toUpperCase(); +} +function toLower(str) +{ + return str.toLowerCase(); +} + +function any(pred, str) +{ + for (var i = str.length; i--; ) + { + if (pred(_elm_lang$core$Native_Utils.chr(str[i]))) + { + return true; + } + } + return false; +} +function all(pred, str) +{ + for (var i = str.length; i--; ) + { + if (!pred(_elm_lang$core$Native_Utils.chr(str[i]))) + { + return false; + } + } + return true; +} + +function contains(sub, str) +{ + return str.indexOf(sub) > -1; +} +function startsWith(sub, str) +{ + return str.indexOf(sub) === 0; +} +function endsWith(sub, str) +{ + return str.length >= sub.length && + str.lastIndexOf(sub) === str.length - sub.length; +} +function indexes(sub, str) +{ + var subLen = sub.length; + + if (subLen < 1) + { + return _elm_lang$core$Native_List.Nil; + } + + var i = 0; + var is = []; + + while ((i = str.indexOf(sub, i)) > -1) + { + is.push(i); + i = i + subLen; + } + + return _elm_lang$core$Native_List.fromArray(is); +} + +function toInt(s) +{ + var len = s.length; + if (len === 0) + { + return _elm_lang$core$Result$Err("could not convert string '" + s + "' to an Int" ); + } + var start = 0; + if (s[0] === '-') + { + if (len === 1) + { + return _elm_lang$core$Result$Err("could not convert string '" + s + "' to an Int" ); + } + start = 1; + } + for (var i = start; i < len; ++i) + { + var c = s[i]; + if (c < '0' || '9' < c) + { + return _elm_lang$core$Result$Err("could not convert string '" + s + "' to an Int" ); + } + } + return _elm_lang$core$Result$Ok(parseInt(s, 10)); +} + +function toFloat(s) +{ + var len = s.length; + if (len === 0) + { + return _elm_lang$core$Result$Err("could not convert string '" + s + "' to a Float" ); + } + var start = 0; + if (s[0] === '-') + { + if (len === 1) + { + return _elm_lang$core$Result$Err("could not convert string '" + s + "' to a Float" ); + } + start = 1; + } + var dotCount = 0; + for (var i = start; i < len; ++i) + { + var c = s[i]; + if ('0' <= c && c <= '9') + { + continue; + } + if (c === '.') + { + dotCount += 1; + if (dotCount <= 1) + { + continue; + } + } + return _elm_lang$core$Result$Err("could not convert string '" + s + "' to a Float" ); + } + return _elm_lang$core$Result$Ok(parseFloat(s)); +} + +function toList(str) +{ + return _elm_lang$core$Native_List.fromArray(str.split('').map(_elm_lang$core$Native_Utils.chr)); +} +function fromList(chars) +{ + return _elm_lang$core$Native_List.toArray(chars).join(''); +} + +return { + isEmpty: isEmpty, + cons: F2(cons), + uncons: uncons, + append: F2(append), + concat: concat, + length: length, + map: F2(map), + filter: F2(filter), + reverse: reverse, + foldl: F3(foldl), + foldr: F3(foldr), + + split: F2(split), + join: F2(join), + repeat: F2(repeat), + + slice: F3(slice), + left: F2(left), + right: F2(right), + dropLeft: F2(dropLeft), + dropRight: F2(dropRight), + + pad: F3(pad), + padLeft: F3(padLeft), + padRight: F3(padRight), + + trim: trim, + trimLeft: trimLeft, + trimRight: trimRight, + + words: words, + lines: lines, + + toUpper: toUpper, + toLower: toLower, + + any: F2(any), + all: F2(all), + + contains: F2(contains), + startsWith: F2(startsWith), + endsWith: F2(endsWith), + indexes: F2(indexes), + + toInt: toInt, + toFloat: toFloat, + toList: toList, + fromList: fromList +}; + +}(); + +var _elm_lang$core$String$fromList = _elm_lang$core$Native_String.fromList; +var _elm_lang$core$String$toList = _elm_lang$core$Native_String.toList; +var _elm_lang$core$String$toFloat = _elm_lang$core$Native_String.toFloat; +var _elm_lang$core$String$toInt = _elm_lang$core$Native_String.toInt; +var _elm_lang$core$String$indices = _elm_lang$core$Native_String.indexes; +var _elm_lang$core$String$indexes = _elm_lang$core$Native_String.indexes; +var _elm_lang$core$String$endsWith = _elm_lang$core$Native_String.endsWith; +var _elm_lang$core$String$startsWith = _elm_lang$core$Native_String.startsWith; +var _elm_lang$core$String$contains = _elm_lang$core$Native_String.contains; +var _elm_lang$core$String$all = _elm_lang$core$Native_String.all; +var _elm_lang$core$String$any = _elm_lang$core$Native_String.any; +var _elm_lang$core$String$toLower = _elm_lang$core$Native_String.toLower; +var _elm_lang$core$String$toUpper = _elm_lang$core$Native_String.toUpper; +var _elm_lang$core$String$lines = _elm_lang$core$Native_String.lines; +var _elm_lang$core$String$words = _elm_lang$core$Native_String.words; +var _elm_lang$core$String$trimRight = _elm_lang$core$Native_String.trimRight; +var _elm_lang$core$String$trimLeft = _elm_lang$core$Native_String.trimLeft; +var _elm_lang$core$String$trim = _elm_lang$core$Native_String.trim; +var _elm_lang$core$String$padRight = _elm_lang$core$Native_String.padRight; +var _elm_lang$core$String$padLeft = _elm_lang$core$Native_String.padLeft; +var _elm_lang$core$String$pad = _elm_lang$core$Native_String.pad; +var _elm_lang$core$String$dropRight = _elm_lang$core$Native_String.dropRight; +var _elm_lang$core$String$dropLeft = _elm_lang$core$Native_String.dropLeft; +var _elm_lang$core$String$right = _elm_lang$core$Native_String.right; +var _elm_lang$core$String$left = _elm_lang$core$Native_String.left; +var _elm_lang$core$String$slice = _elm_lang$core$Native_String.slice; +var _elm_lang$core$String$repeat = _elm_lang$core$Native_String.repeat; +var _elm_lang$core$String$join = _elm_lang$core$Native_String.join; +var _elm_lang$core$String$split = _elm_lang$core$Native_String.split; +var _elm_lang$core$String$foldr = _elm_lang$core$Native_String.foldr; +var _elm_lang$core$String$foldl = _elm_lang$core$Native_String.foldl; +var _elm_lang$core$String$reverse = _elm_lang$core$Native_String.reverse; +var _elm_lang$core$String$filter = _elm_lang$core$Native_String.filter; +var _elm_lang$core$String$map = _elm_lang$core$Native_String.map; +var _elm_lang$core$String$length = _elm_lang$core$Native_String.length; +var _elm_lang$core$String$concat = _elm_lang$core$Native_String.concat; +var _elm_lang$core$String$append = _elm_lang$core$Native_String.append; +var _elm_lang$core$String$uncons = _elm_lang$core$Native_String.uncons; +var _elm_lang$core$String$cons = _elm_lang$core$Native_String.cons; +var _elm_lang$core$String$fromChar = function ($char) { + return A2(_elm_lang$core$String$cons, $char, ''); +}; +var _elm_lang$core$String$isEmpty = _elm_lang$core$Native_String.isEmpty; + +var _elm_lang$core$Dict$foldr = F3( + function (f, acc, t) { + foldr: + while (true) { + var _p0 = t; + if (_p0.ctor === 'RBEmpty_elm_builtin') { + return acc; + } else { + var _v1 = f, + _v2 = A3( + f, + _p0._1, + _p0._2, + A3(_elm_lang$core$Dict$foldr, f, acc, _p0._4)), + _v3 = _p0._3; + f = _v1; + acc = _v2; + t = _v3; + continue foldr; + } + } + }); +var _elm_lang$core$Dict$keys = function (dict) { + return A3( + _elm_lang$core$Dict$foldr, + F3( + function (key, value, keyList) { + return A2(_elm_lang$core$List_ops['::'], key, keyList); + }), + _elm_lang$core$Native_List.fromArray( + []), + dict); +}; +var _elm_lang$core$Dict$values = function (dict) { + return A3( + _elm_lang$core$Dict$foldr, + F3( + function (key, value, valueList) { + return A2(_elm_lang$core$List_ops['::'], value, valueList); + }), + _elm_lang$core$Native_List.fromArray( + []), + dict); +}; +var _elm_lang$core$Dict$toList = function (dict) { + return A3( + _elm_lang$core$Dict$foldr, + F3( + function (key, value, list) { + return A2( + _elm_lang$core$List_ops['::'], + {ctor: '_Tuple2', _0: key, _1: value}, + list); + }), + _elm_lang$core$Native_List.fromArray( + []), + dict); +}; +var _elm_lang$core$Dict$foldl = F3( + function (f, acc, dict) { + foldl: + while (true) { + var _p1 = dict; + if (_p1.ctor === 'RBEmpty_elm_builtin') { + return acc; + } else { + var _v5 = f, + _v6 = A3( + f, + _p1._1, + _p1._2, + A3(_elm_lang$core$Dict$foldl, f, acc, _p1._3)), + _v7 = _p1._4; + f = _v5; + acc = _v6; + dict = _v7; + continue foldl; + } + } + }); +var _elm_lang$core$Dict$merge = F6( + function (leftStep, bothStep, rightStep, leftDict, rightDict, initialResult) { + var stepState = F3( + function (rKey, rValue, _p2) { + stepState: + while (true) { + var _p3 = _p2; + var _p9 = _p3._1; + var _p8 = _p3._0; + var _p4 = _p8; + if (_p4.ctor === '[]') { + return { + ctor: '_Tuple2', + _0: _p8, + _1: A3(rightStep, rKey, rValue, _p9) + }; + } else { + var _p7 = _p4._1; + var _p6 = _p4._0._1; + var _p5 = _p4._0._0; + if (_elm_lang$core$Native_Utils.cmp(_p5, rKey) < 0) { + var _v10 = rKey, + _v11 = rValue, + _v12 = { + ctor: '_Tuple2', + _0: _p7, + _1: A3(leftStep, _p5, _p6, _p9) + }; + rKey = _v10; + rValue = _v11; + _p2 = _v12; + continue stepState; + } else { + if (_elm_lang$core$Native_Utils.cmp(_p5, rKey) > 0) { + return { + ctor: '_Tuple2', + _0: _p8, + _1: A3(rightStep, rKey, rValue, _p9) + }; + } else { + return { + ctor: '_Tuple2', + _0: _p7, + _1: A4(bothStep, _p5, _p6, rValue, _p9) + }; + } + } + } + } + }); + var _p10 = A3( + _elm_lang$core$Dict$foldl, + stepState, + { + ctor: '_Tuple2', + _0: _elm_lang$core$Dict$toList(leftDict), + _1: initialResult + }, + rightDict); + var leftovers = _p10._0; + var intermediateResult = _p10._1; + return A3( + _elm_lang$core$List$foldl, + F2( + function (_p11, result) { + var _p12 = _p11; + return A3(leftStep, _p12._0, _p12._1, result); + }), + intermediateResult, + leftovers); + }); +var _elm_lang$core$Dict$reportRemBug = F4( + function (msg, c, lgot, rgot) { + return _elm_lang$core$Native_Debug.crash( + _elm_lang$core$String$concat( + _elm_lang$core$Native_List.fromArray( + [ + 'Internal red-black tree invariant violated, expected ', + msg, + ' and got ', + _elm_lang$core$Basics$toString(c), + '/', + lgot, + '/', + rgot, + '\nPlease report this bug to <https://github.com/elm-lang/core/issues>' + ]))); + }); +var _elm_lang$core$Dict$isBBlack = function (dict) { + var _p13 = dict; + _v14_2: + do { + if (_p13.ctor === 'RBNode_elm_builtin') { + if (_p13._0.ctor === 'BBlack') { + return true; + } else { + break _v14_2; + } + } else { + if (_p13._0.ctor === 'LBBlack') { + return true; + } else { + break _v14_2; + } + } + } while(false); + return false; +}; +var _elm_lang$core$Dict$sizeHelp = F2( + function (n, dict) { + sizeHelp: + while (true) { + var _p14 = dict; + if (_p14.ctor === 'RBEmpty_elm_builtin') { + return n; + } else { + var _v16 = A2(_elm_lang$core$Dict$sizeHelp, n + 1, _p14._4), + _v17 = _p14._3; + n = _v16; + dict = _v17; + continue sizeHelp; + } + } + }); +var _elm_lang$core$Dict$size = function (dict) { + return A2(_elm_lang$core$Dict$sizeHelp, 0, dict); +}; +var _elm_lang$core$Dict$get = F2( + function (targetKey, dict) { + get: + while (true) { + var _p15 = dict; + if (_p15.ctor === 'RBEmpty_elm_builtin') { + return _elm_lang$core$Maybe$Nothing; + } else { + var _p16 = A2(_elm_lang$core$Basics$compare, targetKey, _p15._1); + switch (_p16.ctor) { + case 'LT': + var _v20 = targetKey, + _v21 = _p15._3; + targetKey = _v20; + dict = _v21; + continue get; + case 'EQ': + return _elm_lang$core$Maybe$Just(_p15._2); + default: + var _v22 = targetKey, + _v23 = _p15._4; + targetKey = _v22; + dict = _v23; + continue get; + } + } + } + }); +var _elm_lang$core$Dict$member = F2( + function (key, dict) { + var _p17 = A2(_elm_lang$core$Dict$get, key, dict); + if (_p17.ctor === 'Just') { + return true; + } else { + return false; + } + }); +var _elm_lang$core$Dict$maxWithDefault = F3( + function (k, v, r) { + maxWithDefault: + while (true) { + var _p18 = r; + if (_p18.ctor === 'RBEmpty_elm_builtin') { + return {ctor: '_Tuple2', _0: k, _1: v}; + } else { + var _v26 = _p18._1, + _v27 = _p18._2, + _v28 = _p18._4; + k = _v26; + v = _v27; + r = _v28; + continue maxWithDefault; + } + } + }); +var _elm_lang$core$Dict$NBlack = {ctor: 'NBlack'}; +var _elm_lang$core$Dict$BBlack = {ctor: 'BBlack'}; +var _elm_lang$core$Dict$Black = {ctor: 'Black'}; +var _elm_lang$core$Dict$blackish = function (t) { + var _p19 = t; + if (_p19.ctor === 'RBNode_elm_builtin') { + var _p20 = _p19._0; + return _elm_lang$core$Native_Utils.eq(_p20, _elm_lang$core$Dict$Black) || _elm_lang$core$Native_Utils.eq(_p20, _elm_lang$core$Dict$BBlack); + } else { + return true; + } +}; +var _elm_lang$core$Dict$Red = {ctor: 'Red'}; +var _elm_lang$core$Dict$moreBlack = function (color) { + var _p21 = color; + switch (_p21.ctor) { + case 'Black': + return _elm_lang$core$Dict$BBlack; + case 'Red': + return _elm_lang$core$Dict$Black; + case 'NBlack': + return _elm_lang$core$Dict$Red; + default: + return _elm_lang$core$Native_Debug.crash('Can\'t make a double black node more black!'); + } +}; +var _elm_lang$core$Dict$lessBlack = function (color) { + var _p22 = color; + switch (_p22.ctor) { + case 'BBlack': + return _elm_lang$core$Dict$Black; + case 'Black': + return _elm_lang$core$Dict$Red; + case 'Red': + return _elm_lang$core$Dict$NBlack; + default: + return _elm_lang$core$Native_Debug.crash('Can\'t make a negative black node less black!'); + } +}; +var _elm_lang$core$Dict$LBBlack = {ctor: 'LBBlack'}; +var _elm_lang$core$Dict$LBlack = {ctor: 'LBlack'}; +var _elm_lang$core$Dict$RBEmpty_elm_builtin = function (a) { + return {ctor: 'RBEmpty_elm_builtin', _0: a}; +}; +var _elm_lang$core$Dict$empty = _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack); +var _elm_lang$core$Dict$isEmpty = function (dict) { + return _elm_lang$core$Native_Utils.eq(dict, _elm_lang$core$Dict$empty); +}; +var _elm_lang$core$Dict$RBNode_elm_builtin = F5( + function (a, b, c, d, e) { + return {ctor: 'RBNode_elm_builtin', _0: a, _1: b, _2: c, _3: d, _4: e}; + }); +var _elm_lang$core$Dict$ensureBlackRoot = function (dict) { + var _p23 = dict; + if ((_p23.ctor === 'RBNode_elm_builtin') && (_p23._0.ctor === 'Red')) { + return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p23._1, _p23._2, _p23._3, _p23._4); + } else { + return dict; + } +}; +var _elm_lang$core$Dict$lessBlackTree = function (dict) { + var _p24 = dict; + if (_p24.ctor === 'RBNode_elm_builtin') { + return A5( + _elm_lang$core$Dict$RBNode_elm_builtin, + _elm_lang$core$Dict$lessBlack(_p24._0), + _p24._1, + _p24._2, + _p24._3, + _p24._4); + } else { + return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack); + } +}; +var _elm_lang$core$Dict$balancedTree = function (col) { + return function (xk) { + return function (xv) { + return function (yk) { + return function (yv) { + return function (zk) { + return function (zv) { + return function (a) { + return function (b) { + return function (c) { + return function (d) { + return A5( + _elm_lang$core$Dict$RBNode_elm_builtin, + _elm_lang$core$Dict$lessBlack(col), + yk, + yv, + A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, xk, xv, a, b), + A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, zk, zv, c, d)); + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; +}; +var _elm_lang$core$Dict$blacken = function (t) { + var _p25 = t; + if (_p25.ctor === 'RBEmpty_elm_builtin') { + return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack); + } else { + return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p25._1, _p25._2, _p25._3, _p25._4); + } +}; +var _elm_lang$core$Dict$redden = function (t) { + var _p26 = t; + if (_p26.ctor === 'RBEmpty_elm_builtin') { + return _elm_lang$core$Native_Debug.crash('can\'t make a Leaf red'); + } else { + return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Red, _p26._1, _p26._2, _p26._3, _p26._4); + } +}; +var _elm_lang$core$Dict$balanceHelp = function (tree) { + var _p27 = tree; + _v36_6: + do { + _v36_5: + do { + _v36_4: + do { + _v36_3: + do { + _v36_2: + do { + _v36_1: + do { + _v36_0: + do { + if (_p27.ctor === 'RBNode_elm_builtin') { + if (_p27._3.ctor === 'RBNode_elm_builtin') { + if (_p27._4.ctor === 'RBNode_elm_builtin') { + switch (_p27._3._0.ctor) { + case 'Red': + switch (_p27._4._0.ctor) { + case 'Red': + if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) { + break _v36_0; + } else { + if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) { + break _v36_1; + } else { + if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) { + break _v36_2; + } else { + if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) { + break _v36_3; + } else { + break _v36_6; + } + } + } + } + case 'NBlack': + if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) { + break _v36_0; + } else { + if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) { + break _v36_1; + } else { + if (((((_p27._0.ctor === 'BBlack') && (_p27._4._3.ctor === 'RBNode_elm_builtin')) && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) { + break _v36_4; + } else { + break _v36_6; + } + } + } + default: + if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) { + break _v36_0; + } else { + if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) { + break _v36_1; + } else { + break _v36_6; + } + } + } + case 'NBlack': + switch (_p27._4._0.ctor) { + case 'Red': + if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) { + break _v36_2; + } else { + if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) { + break _v36_3; + } else { + if (((((_p27._0.ctor === 'BBlack') && (_p27._3._3.ctor === 'RBNode_elm_builtin')) && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) { + break _v36_5; + } else { + break _v36_6; + } + } + } + case 'NBlack': + if (_p27._0.ctor === 'BBlack') { + if ((((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) { + break _v36_4; + } else { + if ((((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) { + break _v36_5; + } else { + break _v36_6; + } + } + } else { + break _v36_6; + } + default: + if (((((_p27._0.ctor === 'BBlack') && (_p27._3._3.ctor === 'RBNode_elm_builtin')) && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) { + break _v36_5; + } else { + break _v36_6; + } + } + default: + switch (_p27._4._0.ctor) { + case 'Red': + if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) { + break _v36_2; + } else { + if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) { + break _v36_3; + } else { + break _v36_6; + } + } + case 'NBlack': + if (((((_p27._0.ctor === 'BBlack') && (_p27._4._3.ctor === 'RBNode_elm_builtin')) && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) { + break _v36_4; + } else { + break _v36_6; + } + default: + break _v36_6; + } + } + } else { + switch (_p27._3._0.ctor) { + case 'Red': + if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) { + break _v36_0; + } else { + if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) { + break _v36_1; + } else { + break _v36_6; + } + } + case 'NBlack': + if (((((_p27._0.ctor === 'BBlack') && (_p27._3._3.ctor === 'RBNode_elm_builtin')) && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) { + break _v36_5; + } else { + break _v36_6; + } + default: + break _v36_6; + } + } + } else { + if (_p27._4.ctor === 'RBNode_elm_builtin') { + switch (_p27._4._0.ctor) { + case 'Red': + if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) { + break _v36_2; + } else { + if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) { + break _v36_3; + } else { + break _v36_6; + } + } + case 'NBlack': + if (((((_p27._0.ctor === 'BBlack') && (_p27._4._3.ctor === 'RBNode_elm_builtin')) && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) { + break _v36_4; + } else { + break _v36_6; + } + default: + break _v36_6; + } + } else { + break _v36_6; + } + } + } else { + break _v36_6; + } + } while(false); + return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._3._3._1)(_p27._3._3._2)(_p27._3._1)(_p27._3._2)(_p27._1)(_p27._2)(_p27._3._3._3)(_p27._3._3._4)(_p27._3._4)(_p27._4); + } while(false); + return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._3._1)(_p27._3._2)(_p27._3._4._1)(_p27._3._4._2)(_p27._1)(_p27._2)(_p27._3._3)(_p27._3._4._3)(_p27._3._4._4)(_p27._4); + } while(false); + return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._1)(_p27._2)(_p27._4._3._1)(_p27._4._3._2)(_p27._4._1)(_p27._4._2)(_p27._3)(_p27._4._3._3)(_p27._4._3._4)(_p27._4._4); + } while(false); + return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._1)(_p27._2)(_p27._4._1)(_p27._4._2)(_p27._4._4._1)(_p27._4._4._2)(_p27._3)(_p27._4._3)(_p27._4._4._3)(_p27._4._4._4); + } while(false); + return A5( + _elm_lang$core$Dict$RBNode_elm_builtin, + _elm_lang$core$Dict$Black, + _p27._4._3._1, + _p27._4._3._2, + A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p27._1, _p27._2, _p27._3, _p27._4._3._3), + A5( + _elm_lang$core$Dict$balance, + _elm_lang$core$Dict$Black, + _p27._4._1, + _p27._4._2, + _p27._4._3._4, + _elm_lang$core$Dict$redden(_p27._4._4))); + } while(false); + return A5( + _elm_lang$core$Dict$RBNode_elm_builtin, + _elm_lang$core$Dict$Black, + _p27._3._4._1, + _p27._3._4._2, + A5( + _elm_lang$core$Dict$balance, + _elm_lang$core$Dict$Black, + _p27._3._1, + _p27._3._2, + _elm_lang$core$Dict$redden(_p27._3._3), + _p27._3._4._3), + A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p27._1, _p27._2, _p27._3._4._4, _p27._4)); + } while(false); + return tree; +}; +var _elm_lang$core$Dict$balance = F5( + function (c, k, v, l, r) { + var tree = A5(_elm_lang$core$Dict$RBNode_elm_builtin, c, k, v, l, r); + return _elm_lang$core$Dict$blackish(tree) ? _elm_lang$core$Dict$balanceHelp(tree) : tree; + }); +var _elm_lang$core$Dict$bubble = F5( + function (c, k, v, l, r) { + return (_elm_lang$core$Dict$isBBlack(l) || _elm_lang$core$Dict$isBBlack(r)) ? A5( + _elm_lang$core$Dict$balance, + _elm_lang$core$Dict$moreBlack(c), + k, + v, + _elm_lang$core$Dict$lessBlackTree(l), + _elm_lang$core$Dict$lessBlackTree(r)) : A5(_elm_lang$core$Dict$RBNode_elm_builtin, c, k, v, l, r); + }); +var _elm_lang$core$Dict$removeMax = F5( + function (c, k, v, l, r) { + var _p28 = r; + if (_p28.ctor === 'RBEmpty_elm_builtin') { + return A3(_elm_lang$core$Dict$rem, c, l, r); + } else { + return A5( + _elm_lang$core$Dict$bubble, + c, + k, + v, + l, + A5(_elm_lang$core$Dict$removeMax, _p28._0, _p28._1, _p28._2, _p28._3, _p28._4)); + } + }); +var _elm_lang$core$Dict$rem = F3( + function (c, l, r) { + var _p29 = {ctor: '_Tuple2', _0: l, _1: r}; + if (_p29._0.ctor === 'RBEmpty_elm_builtin') { + if (_p29._1.ctor === 'RBEmpty_elm_builtin') { + var _p30 = c; + switch (_p30.ctor) { + case 'Red': + return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack); + case 'Black': + return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBBlack); + default: + return _elm_lang$core$Native_Debug.crash('cannot have bblack or nblack nodes at this point'); + } + } else { + var _p33 = _p29._1._0; + var _p32 = _p29._0._0; + var _p31 = {ctor: '_Tuple3', _0: c, _1: _p32, _2: _p33}; + if ((((_p31.ctor === '_Tuple3') && (_p31._0.ctor === 'Black')) && (_p31._1.ctor === 'LBlack')) && (_p31._2.ctor === 'Red')) { + return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p29._1._1, _p29._1._2, _p29._1._3, _p29._1._4); + } else { + return A4( + _elm_lang$core$Dict$reportRemBug, + 'Black/LBlack/Red', + c, + _elm_lang$core$Basics$toString(_p32), + _elm_lang$core$Basics$toString(_p33)); + } + } + } else { + if (_p29._1.ctor === 'RBEmpty_elm_builtin') { + var _p36 = _p29._1._0; + var _p35 = _p29._0._0; + var _p34 = {ctor: '_Tuple3', _0: c, _1: _p35, _2: _p36}; + if ((((_p34.ctor === '_Tuple3') && (_p34._0.ctor === 'Black')) && (_p34._1.ctor === 'Red')) && (_p34._2.ctor === 'LBlack')) { + return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p29._0._1, _p29._0._2, _p29._0._3, _p29._0._4); + } else { + return A4( + _elm_lang$core$Dict$reportRemBug, + 'Black/Red/LBlack', + c, + _elm_lang$core$Basics$toString(_p35), + _elm_lang$core$Basics$toString(_p36)); + } + } else { + var _p40 = _p29._0._2; + var _p39 = _p29._0._4; + var _p38 = _p29._0._1; + var l$ = A5(_elm_lang$core$Dict$removeMax, _p29._0._0, _p38, _p40, _p29._0._3, _p39); + var _p37 = A3(_elm_lang$core$Dict$maxWithDefault, _p38, _p40, _p39); + var k = _p37._0; + var v = _p37._1; + return A5(_elm_lang$core$Dict$bubble, c, k, v, l$, r); + } + } + }); +var _elm_lang$core$Dict$map = F2( + function (f, dict) { + var _p41 = dict; + if (_p41.ctor === 'RBEmpty_elm_builtin') { + return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack); + } else { + var _p42 = _p41._1; + return A5( + _elm_lang$core$Dict$RBNode_elm_builtin, + _p41._0, + _p42, + A2(f, _p42, _p41._2), + A2(_elm_lang$core$Dict$map, f, _p41._3), + A2(_elm_lang$core$Dict$map, f, _p41._4)); + } + }); +var _elm_lang$core$Dict$Same = {ctor: 'Same'}; +var _elm_lang$core$Dict$Remove = {ctor: 'Remove'}; +var _elm_lang$core$Dict$Insert = {ctor: 'Insert'}; +var _elm_lang$core$Dict$update = F3( + function (k, alter, dict) { + var up = function (dict) { + var _p43 = dict; + if (_p43.ctor === 'RBEmpty_elm_builtin') { + var _p44 = alter(_elm_lang$core$Maybe$Nothing); + if (_p44.ctor === 'Nothing') { + return {ctor: '_Tuple2', _0: _elm_lang$core$Dict$Same, _1: _elm_lang$core$Dict$empty}; + } else { + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Dict$Insert, + _1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Red, k, _p44._0, _elm_lang$core$Dict$empty, _elm_lang$core$Dict$empty) + }; + } + } else { + var _p55 = _p43._2; + var _p54 = _p43._4; + var _p53 = _p43._3; + var _p52 = _p43._1; + var _p51 = _p43._0; + var _p45 = A2(_elm_lang$core$Basics$compare, k, _p52); + switch (_p45.ctor) { + case 'EQ': + var _p46 = alter( + _elm_lang$core$Maybe$Just(_p55)); + if (_p46.ctor === 'Nothing') { + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Dict$Remove, + _1: A3(_elm_lang$core$Dict$rem, _p51, _p53, _p54) + }; + } else { + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Dict$Same, + _1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p46._0, _p53, _p54) + }; + } + case 'LT': + var _p47 = up(_p53); + var flag = _p47._0; + var newLeft = _p47._1; + var _p48 = flag; + switch (_p48.ctor) { + case 'Same': + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Dict$Same, + _1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p55, newLeft, _p54) + }; + case 'Insert': + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Dict$Insert, + _1: A5(_elm_lang$core$Dict$balance, _p51, _p52, _p55, newLeft, _p54) + }; + default: + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Dict$Remove, + _1: A5(_elm_lang$core$Dict$bubble, _p51, _p52, _p55, newLeft, _p54) + }; + } + default: + var _p49 = up(_p54); + var flag = _p49._0; + var newRight = _p49._1; + var _p50 = flag; + switch (_p50.ctor) { + case 'Same': + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Dict$Same, + _1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p55, _p53, newRight) + }; + case 'Insert': + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Dict$Insert, + _1: A5(_elm_lang$core$Dict$balance, _p51, _p52, _p55, _p53, newRight) + }; + default: + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Dict$Remove, + _1: A5(_elm_lang$core$Dict$bubble, _p51, _p52, _p55, _p53, newRight) + }; + } + } + } + }; + var _p56 = up(dict); + var flag = _p56._0; + var updatedDict = _p56._1; + var _p57 = flag; + switch (_p57.ctor) { + case 'Same': + return updatedDict; + case 'Insert': + return _elm_lang$core$Dict$ensureBlackRoot(updatedDict); + default: + return _elm_lang$core$Dict$blacken(updatedDict); + } + }); +var _elm_lang$core$Dict$insert = F3( + function (key, value, dict) { + return A3( + _elm_lang$core$Dict$update, + key, + _elm_lang$core$Basics$always( + _elm_lang$core$Maybe$Just(value)), + dict); + }); +var _elm_lang$core$Dict$singleton = F2( + function (key, value) { + return A3(_elm_lang$core$Dict$insert, key, value, _elm_lang$core$Dict$empty); + }); +var _elm_lang$core$Dict$union = F2( + function (t1, t2) { + return A3(_elm_lang$core$Dict$foldl, _elm_lang$core$Dict$insert, t2, t1); + }); +var _elm_lang$core$Dict$filter = F2( + function (predicate, dictionary) { + var add = F3( + function (key, value, dict) { + return A2(predicate, key, value) ? A3(_elm_lang$core$Dict$insert, key, value, dict) : dict; + }); + return A3(_elm_lang$core$Dict$foldl, add, _elm_lang$core$Dict$empty, dictionary); + }); +var _elm_lang$core$Dict$intersect = F2( + function (t1, t2) { + return A2( + _elm_lang$core$Dict$filter, + F2( + function (k, _p58) { + return A2(_elm_lang$core$Dict$member, k, t2); + }), + t1); + }); +var _elm_lang$core$Dict$partition = F2( + function (predicate, dict) { + var add = F3( + function (key, value, _p59) { + var _p60 = _p59; + var _p62 = _p60._1; + var _p61 = _p60._0; + return A2(predicate, key, value) ? { + ctor: '_Tuple2', + _0: A3(_elm_lang$core$Dict$insert, key, value, _p61), + _1: _p62 + } : { + ctor: '_Tuple2', + _0: _p61, + _1: A3(_elm_lang$core$Dict$insert, key, value, _p62) + }; + }); + return A3( + _elm_lang$core$Dict$foldl, + add, + {ctor: '_Tuple2', _0: _elm_lang$core$Dict$empty, _1: _elm_lang$core$Dict$empty}, + dict); + }); +var _elm_lang$core$Dict$fromList = function (assocs) { + return A3( + _elm_lang$core$List$foldl, + F2( + function (_p63, dict) { + var _p64 = _p63; + return A3(_elm_lang$core$Dict$insert, _p64._0, _p64._1, dict); + }), + _elm_lang$core$Dict$empty, + assocs); +}; +var _elm_lang$core$Dict$remove = F2( + function (key, dict) { + return A3( + _elm_lang$core$Dict$update, + key, + _elm_lang$core$Basics$always(_elm_lang$core$Maybe$Nothing), + dict); + }); +var _elm_lang$core$Dict$diff = F2( + function (t1, t2) { + return A3( + _elm_lang$core$Dict$foldl, + F3( + function (k, v, t) { + return A2(_elm_lang$core$Dict$remove, k, t); + }), + t1, + t2); + }); + +//import Native.Scheduler // + +var _elm_lang$core$Native_Time = function() { + +var now = _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) +{ + callback(_elm_lang$core$Native_Scheduler.succeed(Date.now())); +}); + +function setInterval_(interval, task) +{ + return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) + { + var id = setInterval(function() { + _elm_lang$core$Native_Scheduler.rawSpawn(task); + }, interval); + + return function() { clearInterval(id); }; + }); +} + +return { + now: now, + setInterval_: F2(setInterval_) +}; + +}(); +var _elm_lang$core$Platform_Sub$batch = _elm_lang$core$Native_Platform.batch; +var _elm_lang$core$Platform_Sub$none = _elm_lang$core$Platform_Sub$batch( + _elm_lang$core$Native_List.fromArray( + [])); +var _elm_lang$core$Platform_Sub$map = _elm_lang$core$Native_Platform.map; +var _elm_lang$core$Platform_Sub$Sub = {ctor: 'Sub'}; + +var _elm_lang$core$Time$setInterval = _elm_lang$core$Native_Time.setInterval_; +var _elm_lang$core$Time$spawnHelp = F3( + function (router, intervals, processes) { + var _p0 = intervals; + if (_p0.ctor === '[]') { + return _elm_lang$core$Task$succeed(processes); + } else { + var _p1 = _p0._0; + return A2( + _elm_lang$core$Task$andThen, + _elm_lang$core$Native_Scheduler.spawn( + A2( + _elm_lang$core$Time$setInterval, + _p1, + A2(_elm_lang$core$Platform$sendToSelf, router, _p1))), + function (id) { + return A3( + _elm_lang$core$Time$spawnHelp, + router, + _p0._1, + A3(_elm_lang$core$Dict$insert, _p1, id, processes)); + }); + } + }); +var _elm_lang$core$Time$addMySub = F2( + function (_p2, state) { + var _p3 = _p2; + var _p6 = _p3._1; + var _p5 = _p3._0; + var _p4 = A2(_elm_lang$core$Dict$get, _p5, state); + if (_p4.ctor === 'Nothing') { + return A3( + _elm_lang$core$Dict$insert, + _p5, + _elm_lang$core$Native_List.fromArray( + [_p6]), + state); + } else { + return A3( + _elm_lang$core$Dict$insert, + _p5, + A2(_elm_lang$core$List_ops['::'], _p6, _p4._0), + state); + } + }); +var _elm_lang$core$Time$inMilliseconds = function (t) { + return t; +}; +var _elm_lang$core$Time$millisecond = 1; +var _elm_lang$core$Time$second = 1000 * _elm_lang$core$Time$millisecond; +var _elm_lang$core$Time$minute = 60 * _elm_lang$core$Time$second; +var _elm_lang$core$Time$hour = 60 * _elm_lang$core$Time$minute; +var _elm_lang$core$Time$inHours = function (t) { + return t / _elm_lang$core$Time$hour; +}; +var _elm_lang$core$Time$inMinutes = function (t) { + return t / _elm_lang$core$Time$minute; +}; +var _elm_lang$core$Time$inSeconds = function (t) { + return t / _elm_lang$core$Time$second; +}; +var _elm_lang$core$Time$now = _elm_lang$core$Native_Time.now; +var _elm_lang$core$Time$onSelfMsg = F3( + function (router, interval, state) { + var _p7 = A2(_elm_lang$core$Dict$get, interval, state.taggers); + if (_p7.ctor === 'Nothing') { + return _elm_lang$core$Task$succeed(state); + } else { + return A2( + _elm_lang$core$Task$andThen, + _elm_lang$core$Time$now, + function (time) { + return A2( + _elm_lang$core$Task$andThen, + _elm_lang$core$Task$sequence( + A2( + _elm_lang$core$List$map, + function (tagger) { + return A2( + _elm_lang$core$Platform$sendToApp, + router, + tagger(time)); + }, + _p7._0)), + function (_p8) { + return _elm_lang$core$Task$succeed(state); + }); + }); + } + }); +var _elm_lang$core$Time$subscription = _elm_lang$core$Native_Platform.leaf('Time'); +var _elm_lang$core$Time$State = F2( + function (a, b) { + return {taggers: a, processes: b}; + }); +var _elm_lang$core$Time$init = _elm_lang$core$Task$succeed( + A2(_elm_lang$core$Time$State, _elm_lang$core$Dict$empty, _elm_lang$core$Dict$empty)); +var _elm_lang$core$Time$onEffects = F3( + function (router, subs, _p9) { + var _p10 = _p9; + var rightStep = F3( + function (_p12, id, _p11) { + var _p13 = _p11; + return { + ctor: '_Tuple3', + _0: _p13._0, + _1: _p13._1, + _2: A2( + _elm_lang$core$Task$andThen, + _elm_lang$core$Native_Scheduler.kill(id), + function (_p14) { + return _p13._2; + }) + }; + }); + var bothStep = F4( + function (interval, taggers, id, _p15) { + var _p16 = _p15; + return { + ctor: '_Tuple3', + _0: _p16._0, + _1: A3(_elm_lang$core$Dict$insert, interval, id, _p16._1), + _2: _p16._2 + }; + }); + var leftStep = F3( + function (interval, taggers, _p17) { + var _p18 = _p17; + return { + ctor: '_Tuple3', + _0: A2(_elm_lang$core$List_ops['::'], interval, _p18._0), + _1: _p18._1, + _2: _p18._2 + }; + }); + var newTaggers = A3(_elm_lang$core$List$foldl, _elm_lang$core$Time$addMySub, _elm_lang$core$Dict$empty, subs); + var _p19 = A6( + _elm_lang$core$Dict$merge, + leftStep, + bothStep, + rightStep, + newTaggers, + _p10.processes, + { + ctor: '_Tuple3', + _0: _elm_lang$core$Native_List.fromArray( + []), + _1: _elm_lang$core$Dict$empty, + _2: _elm_lang$core$Task$succeed( + {ctor: '_Tuple0'}) + }); + var spawnList = _p19._0; + var existingDict = _p19._1; + var killTask = _p19._2; + return A2( + _elm_lang$core$Task$andThen, + killTask, + function (_p20) { + return A2( + _elm_lang$core$Task$andThen, + A3(_elm_lang$core$Time$spawnHelp, router, spawnList, existingDict), + function (newProcesses) { + return _elm_lang$core$Task$succeed( + A2(_elm_lang$core$Time$State, newTaggers, newProcesses)); + }); + }); + }); +var _elm_lang$core$Time$Every = F2( + function (a, b) { + return {ctor: 'Every', _0: a, _1: b}; + }); +var _elm_lang$core$Time$every = F2( + function (interval, tagger) { + return _elm_lang$core$Time$subscription( + A2(_elm_lang$core$Time$Every, interval, tagger)); + }); +var _elm_lang$core$Time$subMap = F2( + function (f, _p21) { + var _p22 = _p21; + return A2( + _elm_lang$core$Time$Every, + _p22._0, + function (_p23) { + return f( + _p22._1(_p23)); + }); + }); +_elm_lang$core$Native_Platform.effectManagers['Time'] = {pkg: 'elm-lang/core', init: _elm_lang$core$Time$init, onEffects: _elm_lang$core$Time$onEffects, onSelfMsg: _elm_lang$core$Time$onSelfMsg, tag: 'sub', subMap: _elm_lang$core$Time$subMap}; + +var _elm_lang$core$Debug$crash = _elm_lang$core$Native_Debug.crash; +var _elm_lang$core$Debug$log = _elm_lang$core$Native_Debug.log; + +//import Maybe, Native.Array, Native.List, Native.Utils, Result // + +var _elm_lang$core$Native_Json = function() { + + +// CORE DECODERS + +function succeed(msg) +{ + return { + ctor: '<decoder>', + tag: 'succeed', + msg: msg + }; +} + +function fail(msg) +{ + return { + ctor: '<decoder>', + tag: 'fail', + msg: msg + }; +} + +function decodePrimitive(tag) +{ + return { + ctor: '<decoder>', + tag: tag + }; +} + +function decodeContainer(tag, decoder) +{ + return { + ctor: '<decoder>', + tag: tag, + decoder: decoder + }; +} + +function decodeNull(value) +{ + return { + ctor: '<decoder>', + tag: 'null', + value: value + }; +} + +function decodeField(field, decoder) +{ + return { + ctor: '<decoder>', + tag: 'field', + field: field, + decoder: decoder + }; +} + +function decodeKeyValuePairs(decoder) +{ + return { + ctor: '<decoder>', + tag: 'key-value', + decoder: decoder + }; +} + +function decodeObject(f, decoders) +{ + return { + ctor: '<decoder>', + tag: 'map-many', + func: f, + decoders: decoders + }; +} + +function decodeTuple(f, decoders) +{ + return { + ctor: '<decoder>', + tag: 'tuple', + func: f, + decoders: decoders + }; +} + +function andThen(decoder, callback) +{ + return { + ctor: '<decoder>', + tag: 'andThen', + decoder: decoder, + callback: callback + }; +} + +function customAndThen(decoder, callback) +{ + return { + ctor: '<decoder>', + tag: 'customAndThen', + decoder: decoder, + callback: callback + }; +} + +function oneOf(decoders) +{ + return { + ctor: '<decoder>', + tag: 'oneOf', + decoders: decoders + }; +} + + +// DECODING OBJECTS + +function decodeObject1(f, d1) +{ + return decodeObject(f, [d1]); +} + +function decodeObject2(f, d1, d2) +{ + return decodeObject(f, [d1, d2]); +} + +function decodeObject3(f, d1, d2, d3) +{ + return decodeObject(f, [d1, d2, d3]); +} + +function decodeObject4(f, d1, d2, d3, d4) +{ + return decodeObject(f, [d1, d2, d3, d4]); +} + +function decodeObject5(f, d1, d2, d3, d4, d5) +{ + return decodeObject(f, [d1, d2, d3, d4, d5]); +} + +function decodeObject6(f, d1, d2, d3, d4, d5, d6) +{ + return decodeObject(f, [d1, d2, d3, d4, d5, d6]); +} + +function decodeObject7(f, d1, d2, d3, d4, d5, d6, d7) +{ + return decodeObject(f, [d1, d2, d3, d4, d5, d6, d7]); +} + +function decodeObject8(f, d1, d2, d3, d4, d5, d6, d7, d8) +{ + return decodeObject(f, [d1, d2, d3, d4, d5, d6, d7, d8]); +} + + +// DECODING TUPLES + +function decodeTuple1(f, d1) +{ + return decodeTuple(f, [d1]); +} + +function decodeTuple2(f, d1, d2) +{ + return decodeTuple(f, [d1, d2]); +} + +function decodeTuple3(f, d1, d2, d3) +{ + return decodeTuple(f, [d1, d2, d3]); +} + +function decodeTuple4(f, d1, d2, d3, d4) +{ + return decodeTuple(f, [d1, d2, d3, d4]); +} + +function decodeTuple5(f, d1, d2, d3, d4, d5) +{ + return decodeTuple(f, [d1, d2, d3, d4, d5]); +} + +function decodeTuple6(f, d1, d2, d3, d4, d5, d6) +{ + return decodeTuple(f, [d1, d2, d3, d4, d5, d6]); +} + +function decodeTuple7(f, d1, d2, d3, d4, d5, d6, d7) +{ + return decodeTuple(f, [d1, d2, d3, d4, d5, d6, d7]); +} + +function decodeTuple8(f, d1, d2, d3, d4, d5, d6, d7, d8) +{ + return decodeTuple(f, [d1, d2, d3, d4, d5, d6, d7, d8]); +} + + +// DECODE HELPERS + +function ok(value) +{ + return { tag: 'ok', value: value }; +} + +function badPrimitive(type, value) +{ + return { tag: 'primitive', type: type, value: value }; +} + +function badIndex(index, nestedProblems) +{ + return { tag: 'index', index: index, rest: nestedProblems }; +} + +function badField(field, nestedProblems) +{ + return { tag: 'field', field: field, rest: nestedProblems }; +} + +function badOneOf(problems) +{ + return { tag: 'oneOf', problems: problems }; +} + +function badCustom(msg) +{ + return { tag: 'custom', msg: msg }; +} + +function bad(msg) +{ + return { tag: 'fail', msg: msg }; +} + +function badToString(problem) +{ + var context = '_'; + while (problem) + { + switch (problem.tag) + { + case 'primitive': + return 'Expecting ' + problem.type + + (context === '_' ? '' : ' at ' + context) + + ' but instead got: ' + jsToString(problem.value); + + case 'index': + context += '[' + problem.index + ']'; + problem = problem.rest; + break; + + case 'field': + context += '.' + problem.field; + problem = problem.rest; + break; + + case 'oneOf': + var problems = problem.problems; + for (var i = 0; i < problems.length; i++) + { + problems[i] = badToString(problems[i]); + } + return 'I ran into the following problems' + + (context === '_' ? '' : ' at ' + context) + + ':\n\n' + problems.join('\n'); + + case 'custom': + return 'A `customDecoder` failed' + + (context === '_' ? '' : ' at ' + context) + + ' with the message: ' + problem.msg; + + case 'fail': + return 'I ran into a `fail` decoder' + + (context === '_' ? '' : ' at ' + context) + + ': ' + problem.msg; + } + } +} + +function jsToString(value) +{ + return value === undefined + ? 'undefined' + : JSON.stringify(value); +} + + +// DECODE + +function runOnString(decoder, string) +{ + var json; + try + { + json = JSON.parse(string); + } + catch (e) + { + return _elm_lang$core$Result$Err('Given an invalid JSON: ' + e.message); + } + return run(decoder, json); +} + +function run(decoder, value) +{ + var result = runHelp(decoder, value); + return (result.tag === 'ok') + ? _elm_lang$core$Result$Ok(result.value) + : _elm_lang$core$Result$Err(badToString(result)); +} + +function runHelp(decoder, value) +{ + switch (decoder.tag) + { + case 'bool': + return (typeof value === 'boolean') + ? ok(value) + : badPrimitive('a Bool', value); + + case 'int': + if (typeof value !== 'number') { + return badPrimitive('an Int', value); + } + + if (-2147483647 < value && value < 2147483647 && (value | 0) === value) { + return ok(value); + } + + if (isFinite(value) && !(value % 1)) { + return ok(value); + } + + return badPrimitive('an Int', value); + + case 'float': + return (typeof value === 'number') + ? ok(value) + : badPrimitive('a Float', value); + + case 'string': + return (typeof value === 'string') + ? ok(value) + : (value instanceof String) + ? ok(value + '') + : badPrimitive('a String', value); + + case 'null': + return (value === null) + ? ok(decoder.value) + : badPrimitive('null', value); + + case 'value': + return ok(value); + + case 'list': + if (!(value instanceof Array)) + { + return badPrimitive('a List', value); + } + + var list = _elm_lang$core$Native_List.Nil; + for (var i = value.length; i--; ) + { + var result = runHelp(decoder.decoder, value[i]); + if (result.tag !== 'ok') + { + return badIndex(i, result) + } + list = _elm_lang$core$Native_List.Cons(result.value, list); + } + return ok(list); + + case 'array': + if (!(value instanceof Array)) + { + return badPrimitive('an Array', value); + } + + var len = value.length; + var array = new Array(len); + for (var i = len; i--; ) + { + var result = runHelp(decoder.decoder, value[i]); + if (result.tag !== 'ok') + { + return badIndex(i, result); + } + array[i] = result.value; + } + return ok(_elm_lang$core$Native_Array.fromJSArray(array)); + + case 'maybe': + var result = runHelp(decoder.decoder, value); + return (result.tag === 'ok') + ? ok(_elm_lang$core$Maybe$Just(result.value)) + : ok(_elm_lang$core$Maybe$Nothing); + + case 'field': + var field = decoder.field; + if (typeof value !== 'object' || value === null || !(field in value)) + { + return badPrimitive('an object with a field named `' + field + '`', value); + } + + var result = runHelp(decoder.decoder, value[field]); + return (result.tag === 'ok') + ? result + : badField(field, result); + + case 'key-value': + if (typeof value !== 'object' || value === null || value instanceof Array) + { + return badPrimitive('an object', value); + } + + var keyValuePairs = _elm_lang$core$Native_List.Nil; + for (var key in value) + { + var result = runHelp(decoder.decoder, value[key]); + if (result.tag !== 'ok') + { + return badField(key, result); + } + var pair = _elm_lang$core$Native_Utils.Tuple2(key, result.value); + keyValuePairs = _elm_lang$core$Native_List.Cons(pair, keyValuePairs); + } + return ok(keyValuePairs); + + case 'map-many': + var answer = decoder.func; + var decoders = decoder.decoders; + for (var i = 0; i < decoders.length; i++) + { + var result = runHelp(decoders[i], value); + if (result.tag !== 'ok') + { + return result; + } + answer = answer(result.value); + } + return ok(answer); + + case 'tuple': + var decoders = decoder.decoders; + var len = decoders.length; + + if ( !(value instanceof Array) || value.length !== len ) + { + return badPrimitive('a Tuple with ' + len + ' entries', value); + } + + var answer = decoder.func; + for (var i = 0; i < len; i++) + { + var result = runHelp(decoders[i], value[i]); + if (result.tag !== 'ok') + { + return badIndex(i, result); + } + answer = answer(result.value); + } + return ok(answer); + + case 'customAndThen': + var result = runHelp(decoder.decoder, value); + if (result.tag !== 'ok') + { + return result; + } + var realResult = decoder.callback(result.value); + if (realResult.ctor === 'Err') + { + return badCustom(realResult._0); + } + return ok(realResult._0); + + case 'andThen': + var result = runHelp(decoder.decoder, value); + return (result.tag !== 'ok') + ? result + : runHelp(decoder.callback(result.value), value); + + case 'oneOf': + var errors = []; + var temp = decoder.decoders; + while (temp.ctor !== '[]') + { + var result = runHelp(temp._0, value); + + if (result.tag === 'ok') + { + return result; + } + + errors.push(result); + + temp = temp._1; + } + return badOneOf(errors); + + case 'fail': + return bad(decoder.msg); + + case 'succeed': + return ok(decoder.msg); + } +} + + +// EQUALITY + +function equality(a, b) +{ + if (a === b) + { + return true; + } + + if (a.tag !== b.tag) + { + return false; + } + + switch (a.tag) + { + case 'succeed': + case 'fail': + return a.msg === b.msg; + + case 'bool': + case 'int': + case 'float': + case 'string': + case 'value': + return true; + + case 'null': + return a.value === b.value; + + case 'list': + case 'array': + case 'maybe': + case 'key-value': + return equality(a.decoder, b.decoder); + + case 'field': + return a.field === b.field && equality(a.decoder, b.decoder); + + case 'map-many': + case 'tuple': + if (a.func !== b.func) + { + return false; + } + return listEquality(a.decoders, b.decoders); + + case 'andThen': + case 'customAndThen': + return a.callback === b.callback && equality(a.decoder, b.decoder); + + case 'oneOf': + return listEquality(a.decoders, b.decoders); + } +} + +function listEquality(aDecoders, bDecoders) +{ + var len = aDecoders.length; + if (len !== bDecoders.length) + { + return false; + } + for (var i = 0; i < len; i++) + { + if (!equality(aDecoders[i], bDecoders[i])) + { + return false; + } + } + return true; +} + + +// ENCODE + +function encode(indentLevel, value) +{ + return JSON.stringify(value, null, indentLevel); +} + +function identity(value) +{ + return value; +} + +function encodeObject(keyValuePairs) +{ + var obj = {}; + while (keyValuePairs.ctor !== '[]') + { + var pair = keyValuePairs._0; + obj[pair._0] = pair._1; + keyValuePairs = keyValuePairs._1; + } + return obj; +} + +return { + encode: F2(encode), + runOnString: F2(runOnString), + run: F2(run), + + decodeNull: decodeNull, + decodePrimitive: decodePrimitive, + decodeContainer: F2(decodeContainer), + + decodeField: F2(decodeField), + + decodeObject1: F2(decodeObject1), + decodeObject2: F3(decodeObject2), + decodeObject3: F4(decodeObject3), + decodeObject4: F5(decodeObject4), + decodeObject5: F6(decodeObject5), + decodeObject6: F7(decodeObject6), + decodeObject7: F8(decodeObject7), + decodeObject8: F9(decodeObject8), + decodeKeyValuePairs: decodeKeyValuePairs, + + decodeTuple1: F2(decodeTuple1), + decodeTuple2: F3(decodeTuple2), + decodeTuple3: F4(decodeTuple3), + decodeTuple4: F5(decodeTuple4), + decodeTuple5: F6(decodeTuple5), + decodeTuple6: F7(decodeTuple6), + decodeTuple7: F8(decodeTuple7), + decodeTuple8: F9(decodeTuple8), + + andThen: F2(andThen), + customAndThen: F2(customAndThen), + fail: fail, + succeed: succeed, + oneOf: oneOf, + + identity: identity, + encodeNull: null, + encodeArray: _elm_lang$core$Native_Array.toJSArray, + encodeList: _elm_lang$core$Native_List.toArray, + encodeObject: encodeObject, + + equality: equality +}; + +}(); + +var _elm_lang$core$Json_Encode$list = _elm_lang$core$Native_Json.encodeList; +var _elm_lang$core$Json_Encode$array = _elm_lang$core$Native_Json.encodeArray; +var _elm_lang$core$Json_Encode$object = _elm_lang$core$Native_Json.encodeObject; +var _elm_lang$core$Json_Encode$null = _elm_lang$core$Native_Json.encodeNull; +var _elm_lang$core$Json_Encode$bool = _elm_lang$core$Native_Json.identity; +var _elm_lang$core$Json_Encode$float = _elm_lang$core$Native_Json.identity; +var _elm_lang$core$Json_Encode$int = _elm_lang$core$Native_Json.identity; +var _elm_lang$core$Json_Encode$string = _elm_lang$core$Native_Json.identity; +var _elm_lang$core$Json_Encode$encode = _elm_lang$core$Native_Json.encode; +var _elm_lang$core$Json_Encode$Value = {ctor: 'Value'}; + +var _elm_lang$core$Json_Decode$tuple8 = _elm_lang$core$Native_Json.decodeTuple8; +var _elm_lang$core$Json_Decode$tuple7 = _elm_lang$core$Native_Json.decodeTuple7; +var _elm_lang$core$Json_Decode$tuple6 = _elm_lang$core$Native_Json.decodeTuple6; +var _elm_lang$core$Json_Decode$tuple5 = _elm_lang$core$Native_Json.decodeTuple5; +var _elm_lang$core$Json_Decode$tuple4 = _elm_lang$core$Native_Json.decodeTuple4; +var _elm_lang$core$Json_Decode$tuple3 = _elm_lang$core$Native_Json.decodeTuple3; +var _elm_lang$core$Json_Decode$tuple2 = _elm_lang$core$Native_Json.decodeTuple2; +var _elm_lang$core$Json_Decode$tuple1 = _elm_lang$core$Native_Json.decodeTuple1; +var _elm_lang$core$Json_Decode$succeed = _elm_lang$core$Native_Json.succeed; +var _elm_lang$core$Json_Decode$fail = _elm_lang$core$Native_Json.fail; +var _elm_lang$core$Json_Decode$andThen = _elm_lang$core$Native_Json.andThen; +var _elm_lang$core$Json_Decode$customDecoder = _elm_lang$core$Native_Json.customAndThen; +var _elm_lang$core$Json_Decode$decodeValue = _elm_lang$core$Native_Json.run; +var _elm_lang$core$Json_Decode$value = _elm_lang$core$Native_Json.decodePrimitive('value'); +var _elm_lang$core$Json_Decode$maybe = function (decoder) { + return A2(_elm_lang$core$Native_Json.decodeContainer, 'maybe', decoder); +}; +var _elm_lang$core$Json_Decode$null = _elm_lang$core$Native_Json.decodeNull; +var _elm_lang$core$Json_Decode$array = function (decoder) { + return A2(_elm_lang$core$Native_Json.decodeContainer, 'array', decoder); +}; +var _elm_lang$core$Json_Decode$list = function (decoder) { + return A2(_elm_lang$core$Native_Json.decodeContainer, 'list', decoder); +}; +var _elm_lang$core$Json_Decode$bool = _elm_lang$core$Native_Json.decodePrimitive('bool'); +var _elm_lang$core$Json_Decode$int = _elm_lang$core$Native_Json.decodePrimitive('int'); +var _elm_lang$core$Json_Decode$float = _elm_lang$core$Native_Json.decodePrimitive('float'); +var _elm_lang$core$Json_Decode$string = _elm_lang$core$Native_Json.decodePrimitive('string'); +var _elm_lang$core$Json_Decode$oneOf = _elm_lang$core$Native_Json.oneOf; +var _elm_lang$core$Json_Decode$keyValuePairs = _elm_lang$core$Native_Json.decodeKeyValuePairs; +var _elm_lang$core$Json_Decode$object8 = _elm_lang$core$Native_Json.decodeObject8; +var _elm_lang$core$Json_Decode$object7 = _elm_lang$core$Native_Json.decodeObject7; +var _elm_lang$core$Json_Decode$object6 = _elm_lang$core$Native_Json.decodeObject6; +var _elm_lang$core$Json_Decode$object5 = _elm_lang$core$Native_Json.decodeObject5; +var _elm_lang$core$Json_Decode$object4 = _elm_lang$core$Native_Json.decodeObject4; +var _elm_lang$core$Json_Decode$object3 = _elm_lang$core$Native_Json.decodeObject3; +var _elm_lang$core$Json_Decode$object2 = _elm_lang$core$Native_Json.decodeObject2; +var _elm_lang$core$Json_Decode$object1 = _elm_lang$core$Native_Json.decodeObject1; +var _elm_lang$core$Json_Decode_ops = _elm_lang$core$Json_Decode_ops || {}; +_elm_lang$core$Json_Decode_ops[':='] = _elm_lang$core$Native_Json.decodeField; +var _elm_lang$core$Json_Decode$at = F2( + function (fields, decoder) { + return A3( + _elm_lang$core$List$foldr, + F2( + function (x, y) { + return A2(_elm_lang$core$Json_Decode_ops[':='], x, y); + }), + decoder, + fields); + }); +var _elm_lang$core$Json_Decode$decodeString = _elm_lang$core$Native_Json.runOnString; +var _elm_lang$core$Json_Decode$map = _elm_lang$core$Native_Json.decodeObject1; +var _elm_lang$core$Json_Decode$dict = function (decoder) { + return A2( + _elm_lang$core$Json_Decode$map, + _elm_lang$core$Dict$fromList, + _elm_lang$core$Json_Decode$keyValuePairs(decoder)); +}; +var _elm_lang$core$Json_Decode$Decoder = {ctor: 'Decoder'}; + +var _elm_lang$core$Process$kill = _elm_lang$core$Native_Scheduler.kill; +var _elm_lang$core$Process$sleep = _elm_lang$core$Native_Scheduler.sleep; +var _elm_lang$core$Process$spawn = _elm_lang$core$Native_Scheduler.spawn; + +var _elm_lang$core$Set$foldr = F3( + function (f, b, _p0) { + var _p1 = _p0; + return A3( + _elm_lang$core$Dict$foldr, + F3( + function (k, _p2, b) { + return A2(f, k, b); + }), + b, + _p1._0); + }); +var _elm_lang$core$Set$foldl = F3( + function (f, b, _p3) { + var _p4 = _p3; + return A3( + _elm_lang$core$Dict$foldl, + F3( + function (k, _p5, b) { + return A2(f, k, b); + }), + b, + _p4._0); + }); +var _elm_lang$core$Set$toList = function (_p6) { + var _p7 = _p6; + return _elm_lang$core$Dict$keys(_p7._0); +}; +var _elm_lang$core$Set$size = function (_p8) { + var _p9 = _p8; + return _elm_lang$core$Dict$size(_p9._0); +}; +var _elm_lang$core$Set$member = F2( + function (k, _p10) { + var _p11 = _p10; + return A2(_elm_lang$core$Dict$member, k, _p11._0); + }); +var _elm_lang$core$Set$isEmpty = function (_p12) { + var _p13 = _p12; + return _elm_lang$core$Dict$isEmpty(_p13._0); +}; +var _elm_lang$core$Set$Set_elm_builtin = function (a) { + return {ctor: 'Set_elm_builtin', _0: a}; +}; +var _elm_lang$core$Set$empty = _elm_lang$core$Set$Set_elm_builtin(_elm_lang$core$Dict$empty); +var _elm_lang$core$Set$singleton = function (k) { + return _elm_lang$core$Set$Set_elm_builtin( + A2( + _elm_lang$core$Dict$singleton, + k, + {ctor: '_Tuple0'})); +}; +var _elm_lang$core$Set$insert = F2( + function (k, _p14) { + var _p15 = _p14; + return _elm_lang$core$Set$Set_elm_builtin( + A3( + _elm_lang$core$Dict$insert, + k, + {ctor: '_Tuple0'}, + _p15._0)); + }); +var _elm_lang$core$Set$fromList = function (xs) { + return A3(_elm_lang$core$List$foldl, _elm_lang$core$Set$insert, _elm_lang$core$Set$empty, xs); +}; +var _elm_lang$core$Set$map = F2( + function (f, s) { + return _elm_lang$core$Set$fromList( + A2( + _elm_lang$core$List$map, + f, + _elm_lang$core$Set$toList(s))); + }); +var _elm_lang$core$Set$remove = F2( + function (k, _p16) { + var _p17 = _p16; + return _elm_lang$core$Set$Set_elm_builtin( + A2(_elm_lang$core$Dict$remove, k, _p17._0)); + }); +var _elm_lang$core$Set$union = F2( + function (_p19, _p18) { + var _p20 = _p19; + var _p21 = _p18; + return _elm_lang$core$Set$Set_elm_builtin( + A2(_elm_lang$core$Dict$union, _p20._0, _p21._0)); + }); +var _elm_lang$core$Set$intersect = F2( + function (_p23, _p22) { + var _p24 = _p23; + var _p25 = _p22; + return _elm_lang$core$Set$Set_elm_builtin( + A2(_elm_lang$core$Dict$intersect, _p24._0, _p25._0)); + }); +var _elm_lang$core$Set$diff = F2( + function (_p27, _p26) { + var _p28 = _p27; + var _p29 = _p26; + return _elm_lang$core$Set$Set_elm_builtin( + A2(_elm_lang$core$Dict$diff, _p28._0, _p29._0)); + }); +var _elm_lang$core$Set$filter = F2( + function (p, _p30) { + var _p31 = _p30; + return _elm_lang$core$Set$Set_elm_builtin( + A2( + _elm_lang$core$Dict$filter, + F2( + function (k, _p32) { + return p(k); + }), + _p31._0)); + }); +var _elm_lang$core$Set$partition = F2( + function (p, _p33) { + var _p34 = _p33; + var _p35 = A2( + _elm_lang$core$Dict$partition, + F2( + function (k, _p36) { + return p(k); + }), + _p34._0); + var p1 = _p35._0; + var p2 = _p35._1; + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Set$Set_elm_builtin(p1), + _1: _elm_lang$core$Set$Set_elm_builtin(p2) + }; + }); + +var _elm_lang$dom$Native_Dom = function() { + +function on(node) +{ + return function(eventName, decoder, toTask) + { + return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { + + function performTask(event) + { + var result = A2(_elm_lang$core$Json_Decode$decodeValue, decoder, event); + if (result.ctor === 'Ok') + { + _elm_lang$core$Native_Scheduler.rawSpawn(toTask(result._0)); + } + } + + node.addEventListener(eventName, performTask); + + return function() + { + node.removeEventListener(eventName, performTask); + }; + }); + }; +} + +var rAF = typeof requestAnimationFrame !== 'undefined' + ? requestAnimationFrame + : function(callback) { callback(); }; + +function withNode(id, doStuff) +{ + return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) + { + rAF(function() + { + var node = document.getElementById(id); + if (node === null) + { + callback(_elm_lang$core$Native_Scheduler.fail({ ctor: 'NotFound', _0: id })); + return; + } + callback(_elm_lang$core$Native_Scheduler.succeed(doStuff(node))); + }); + }); +} + + +// FOCUS + +function focus(id) +{ + return withNode(id, function(node) { + node.focus(); + return _elm_lang$core$Native_Utils.Tuple0; + }); +} + +function blur(id) +{ + return withNode(id, function(node) { + node.blur(); + return _elm_lang$core$Native_Utils.Tuple0; + }); +} + + +// SCROLLING + +function getScrollTop(id) +{ + return withNode(id, function(node) { + return node.scrollTop; + }); +} + +function setScrollTop(id, desiredScrollTop) +{ + return withNode(id, function(node) { + node.scrollTop = desiredScrollTop; + return _elm_lang$core$Native_Utils.Tuple0; + }); +} + +function toBottom(id) +{ + return withNode(id, function(node) { + node.scrollTop = node.scrollHeight; + return _elm_lang$core$Native_Utils.Tuple0; + }); +} + +function getScrollLeft(id) +{ + return withNode(id, function(node) { + return node.scrollLeft; + }); +} + +function setScrollLeft(id, desiredScrollLeft) +{ + return withNode(id, function(node) { + node.scrollLeft = desiredScrollLeft; + return _elm_lang$core$Native_Utils.Tuple0; + }); +} + +function toRight(id) +{ + return withNode(id, function(node) { + node.scrollLeft = node.scrollWidth; + return _elm_lang$core$Native_Utils.Tuple0; + }); +} + + +// SIZE + +function width(options, id) +{ + return withNode(id, function(node) { + switch (options.ctor) + { + case 'Content': + return node.scrollWidth; + case 'VisibleContent': + return node.clientWidth; + case 'VisibleContentWithBorders': + return node.offsetWidth; + case 'VisibleContentWithBordersAndMargins': + var rect = node.getBoundingClientRect(); + return rect.right - rect.left; + } + }); +} + +function height(options, id) +{ + return withNode(id, function(node) { + switch (options.ctor) + { + case 'Content': + return node.scrollHeight; + case 'VisibleContent': + return node.clientHeight; + case 'VisibleContentWithBorders': + return node.offsetHeight; + case 'VisibleContentWithBordersAndMargins': + var rect = node.getBoundingClientRect(); + return rect.bottom - rect.top; + } + }); +} + +return { + onDocument: F3(on(document)), + onWindow: F3(on(window)), + + focus: focus, + blur: blur, + + getScrollTop: getScrollTop, + setScrollTop: F2(setScrollTop), + getScrollLeft: getScrollLeft, + setScrollLeft: F2(setScrollLeft), + toBottom: toBottom, + toRight: toRight, + + height: F2(height), + width: F2(width) +}; + +}(); + +var _elm_lang$dom$Dom_LowLevel$onWindow = _elm_lang$dom$Native_Dom.onWindow; +var _elm_lang$dom$Dom_LowLevel$onDocument = _elm_lang$dom$Native_Dom.onDocument; + +//import Native.Json // + +var _elm_lang$virtual_dom$Native_VirtualDom = function() { + +var STYLE_KEY = 'STYLE'; +var EVENT_KEY = 'EVENT'; +var ATTR_KEY = 'ATTR'; +var ATTR_NS_KEY = 'ATTR_NS'; + + + +//////////// VIRTUAL DOM NODES //////////// + + +function text(string) +{ + return { + type: 'text', + text: string + }; +} + + +function node(tag) +{ + return F2(function(factList, kidList) { + return nodeHelp(tag, factList, kidList); + }); +} + + +function nodeHelp(tag, factList, kidList) +{ + var organized = organizeFacts(factList); + var namespace = organized.namespace; + var facts = organized.facts; + + var children = []; + var descendantsCount = 0; + while (kidList.ctor !== '[]') + { + var kid = kidList._0; + descendantsCount += (kid.descendantsCount || 0); + children.push(kid); + kidList = kidList._1; + } + descendantsCount += children.length; + + return { + type: 'node', + tag: tag, + facts: facts, + children: children, + namespace: namespace, + descendantsCount: descendantsCount + }; +} + + +function keyedNode(tag, factList, kidList) +{ + var organized = organizeFacts(factList); + var namespace = organized.namespace; + var facts = organized.facts; + + var children = []; + var descendantsCount = 0; + while (kidList.ctor !== '[]') + { + var kid = kidList._0; + descendantsCount += (kid._1.descendantsCount || 0); + children.push(kid); + kidList = kidList._1; + } + descendantsCount += children.length; + + return { + type: 'keyed-node', + tag: tag, + facts: facts, + children: children, + namespace: namespace, + descendantsCount: descendantsCount + }; +} + + +function custom(factList, model, impl) +{ + var facts = organizeFacts(factList).facts; + + return { + type: 'custom', + facts: facts, + model: model, + impl: impl + }; +} + + +function map(tagger, node) +{ + return { + type: 'tagger', + tagger: tagger, + node: node, + descendantsCount: 1 + (node.descendantsCount || 0) + }; +} + + +function thunk(func, args, thunk) +{ + return { + type: 'thunk', + func: func, + args: args, + thunk: thunk, + node: undefined + }; +} + +function lazy(fn, a) +{ + return thunk(fn, [a], function() { + return fn(a); + }); +} + +function lazy2(fn, a, b) +{ + return thunk(fn, [a,b], function() { + return A2(fn, a, b); + }); +} + +function lazy3(fn, a, b, c) +{ + return thunk(fn, [a,b,c], function() { + return A3(fn, a, b, c); + }); +} + + + +// FACTS + + +function organizeFacts(factList) +{ + var namespace, facts = {}; + + while (factList.ctor !== '[]') + { + var entry = factList._0; + var key = entry.key; + + if (key === ATTR_KEY || key === ATTR_NS_KEY || key === EVENT_KEY) + { + var subFacts = facts[key] || {}; + subFacts[entry.realKey] = entry.value; + facts[key] = subFacts; + } + else if (key === STYLE_KEY) + { + var styles = facts[key] || {}; + var styleList = entry.value; + while (styleList.ctor !== '[]') + { + var style = styleList._0; + styles[style._0] = style._1; + styleList = styleList._1; + } + facts[key] = styles; + } + else if (key === 'namespace') + { + namespace = entry.value; + } + else + { + facts[key] = entry.value; + } + factList = factList._1; + } + + return { + facts: facts, + namespace: namespace + }; +} + + + +//////////// PROPERTIES AND ATTRIBUTES //////////// + + +function style(value) +{ + return { + key: STYLE_KEY, + value: value + }; +} + + +function property(key, value) +{ + return { + key: key, + value: value + }; +} + + +function attribute(key, value) +{ + return { + key: ATTR_KEY, + realKey: key, + value: value + }; +} + + +function attributeNS(namespace, key, value) +{ + return { + key: ATTR_NS_KEY, + realKey: key, + value: { + value: value, + namespace: namespace + } + }; +} + + +function on(name, options, decoder) +{ + return { + key: EVENT_KEY, + realKey: name, + value: { + options: options, + decoder: decoder + } + }; +} + + +function equalEvents(a, b) +{ + if (!a.options === b.options) + { + if (a.stopPropagation !== b.stopPropagation || a.preventDefault !== b.preventDefault) + { + return false; + } + } + return _elm_lang$core$Native_Json.equality(a.decoder, b.decoder); +} + + + +//////////// RENDERER //////////// + + +function renderer(parent, tagger, initialVirtualNode) +{ + var eventNode = { tagger: tagger, parent: undefined }; + + var domNode = render(initialVirtualNode, eventNode); + parent.appendChild(domNode); + + var state = 'NO_REQUEST'; + var currentVirtualNode = initialVirtualNode; + var nextVirtualNode = initialVirtualNode; + + function registerVirtualNode(vNode) + { + if (state === 'NO_REQUEST') + { + rAF(updateIfNeeded); + } + state = 'PENDING_REQUEST'; + nextVirtualNode = vNode; + } + + function updateIfNeeded() + { + switch (state) + { + case 'NO_REQUEST': + throw new Error( + 'Unexpected draw callback.\n' + + 'Please report this to <https://github.com/elm-lang/core/issues>.' + ); + + case 'PENDING_REQUEST': + rAF(updateIfNeeded); + state = 'EXTRA_REQUEST'; + + var patches = diff(currentVirtualNode, nextVirtualNode); + domNode = applyPatches(domNode, currentVirtualNode, patches, eventNode); + currentVirtualNode = nextVirtualNode; + + return; + + case 'EXTRA_REQUEST': + state = 'NO_REQUEST'; + return; + } + } + + return { update: registerVirtualNode }; +} + + +var rAF = + typeof requestAnimationFrame !== 'undefined' + ? requestAnimationFrame + : function(cb) { setTimeout(cb, 1000 / 60); }; + + + +//////////// RENDER //////////// + + +function render(vNode, eventNode) +{ + switch (vNode.type) + { + case 'thunk': + if (!vNode.node) + { + vNode.node = vNode.thunk(); + } + return render(vNode.node, eventNode); + + case 'tagger': + var subNode = vNode.node; + var tagger = vNode.tagger; + + while (subNode.type === 'tagger') + { + typeof tagger !== 'object' + ? tagger = [tagger, subNode.tagger] + : tagger.push(subNode.tagger); + + subNode = subNode.node; + } + + var subEventRoot = { + tagger: tagger, + parent: eventNode + }; + + var domNode = render(subNode, subEventRoot); + domNode.elm_event_node_ref = subEventRoot; + return domNode; + + case 'text': + return document.createTextNode(vNode.text); + + case 'node': + var domNode = vNode.namespace + ? document.createElementNS(vNode.namespace, vNode.tag) + : document.createElement(vNode.tag); + + applyFacts(domNode, eventNode, vNode.facts); + + var children = vNode.children; + + for (var i = 0; i < children.length; i++) + { + domNode.appendChild(render(children[i], eventNode)); + } + + return domNode; + + case 'keyed-node': + var domNode = vNode.namespace + ? document.createElementNS(vNode.namespace, vNode.tag) + : document.createElement(vNode.tag); + + applyFacts(domNode, eventNode, vNode.facts); + + var children = vNode.children; + + for (var i = 0; i < children.length; i++) + { + domNode.appendChild(render(children[i]._1, eventNode)); + } + + return domNode; + + case 'custom': + var domNode = vNode.impl.render(vNode.model); + applyFacts(domNode, eventNode, vNode.facts); + return domNode; + } +} + + + +//////////// APPLY FACTS //////////// + + +function applyFacts(domNode, eventNode, facts) +{ + for (var key in facts) + { + var value = facts[key]; + + switch (key) + { + case STYLE_KEY: + applyStyles(domNode, value); + break; + + case EVENT_KEY: + applyEvents(domNode, eventNode, value); + break; + + case ATTR_KEY: + applyAttrs(domNode, value); + break; + + case ATTR_NS_KEY: + applyAttrsNS(domNode, value); + break; + + case 'value': + if (domNode[key] !== value) + { + domNode[key] = value; + } + break; + + default: + domNode[key] = value; + break; + } + } +} + +function applyStyles(domNode, styles) +{ + var domNodeStyle = domNode.style; + + for (var key in styles) + { + domNodeStyle[key] = styles[key]; + } +} + +function applyEvents(domNode, eventNode, events) +{ + var allHandlers = domNode.elm_handlers || {}; + + for (var key in events) + { + var handler = allHandlers[key]; + var value = events[key]; + + if (typeof value === 'undefined') + { + domNode.removeEventListener(key, handler); + allHandlers[key] = undefined; + } + else if (typeof handler === 'undefined') + { + var handler = makeEventHandler(eventNode, value); + domNode.addEventListener(key, handler); + allHandlers[key] = handler; + } + else + { + handler.info = value; + } + } + + domNode.elm_handlers = allHandlers; +} + +function makeEventHandler(eventNode, info) +{ + function eventHandler(event) + { + var info = eventHandler.info; + + var value = A2(_elm_lang$core$Native_Json.run, info.decoder, event); + + if (value.ctor === 'Ok') + { + var options = info.options; + if (options.stopPropagation) + { + event.stopPropagation(); + } + if (options.preventDefault) + { + event.preventDefault(); + } + + var message = value._0; + + var currentEventNode = eventNode; + while (currentEventNode) + { + var tagger = currentEventNode.tagger; + if (typeof tagger === 'function') + { + message = tagger(message); + } + else + { + for (var i = tagger.length; i--; ) + { + message = tagger[i](message); + } + } + currentEventNode = currentEventNode.parent; + } + } + }; + + eventHandler.info = info; + + return eventHandler; +} + +function applyAttrs(domNode, attrs) +{ + for (var key in attrs) + { + var value = attrs[key]; + if (typeof value === 'undefined') + { + domNode.removeAttribute(key); + } + else + { + domNode.setAttribute(key, value); + } + } +} + +function applyAttrsNS(domNode, nsAttrs) +{ + for (var key in nsAttrs) + { + var pair = nsAttrs[key]; + var namespace = pair.namespace; + var value = pair.value; + + if (typeof value === 'undefined') + { + domNode.removeAttributeNS(namespace, key); + } + else + { + domNode.setAttributeNS(namespace, key, value); + } + } +} + + + +//////////// DIFF //////////// + + +function diff(a, b) +{ + var patches = []; + diffHelp(a, b, patches, 0); + return patches; +} + + +function makePatch(type, index, data) +{ + return { + index: index, + type: type, + data: data, + domNode: undefined, + eventNode: undefined + }; +} + + +function diffHelp(a, b, patches, index) +{ + if (a === b) + { + return; + } + + var aType = a.type; + var bType = b.type; + + // Bail if you run into different types of nodes. Implies that the + // structure has changed significantly and it's not worth a diff. + if (aType !== bType) + { + patches.push(makePatch('p-redraw', index, b)); + return; + } + + // Now we know that both nodes are the same type. + switch (bType) + { + case 'thunk': + var aArgs = a.args; + var bArgs = b.args; + var i = aArgs.length; + var same = a.func === b.func && i === bArgs.length; + while (same && i--) + { + same = aArgs[i] === bArgs[i]; + } + if (same) + { + b.node = a.node; + return; + } + b.node = b.thunk(); + var subPatches = []; + diffHelp(a.node, b.node, subPatches, 0); + if (subPatches.length > 0) + { + patches.push(makePatch('p-thunk', index, subPatches)); + } + return; + + case 'tagger': + // gather nested taggers + var aTaggers = a.tagger; + var bTaggers = b.tagger; + var nesting = false; + + var aSubNode = a.node; + while (aSubNode.type === 'tagger') + { + nesting = true; + + typeof aTaggers !== 'object' + ? aTaggers = [aTaggers, aSubNode.tagger] + : aTaggers.push(aSubNode.tagger); + + aSubNode = aSubNode.node; + } + + var bSubNode = b.node; + while (bSubNode.type === 'tagger') + { + nesting = true; + + typeof bTaggers !== 'object' + ? bTaggers = [bTaggers, bSubNode.tagger] + : bTaggers.push(bSubNode.tagger); + + bSubNode = bSubNode.node; + } + + // Just bail if different numbers of taggers. This implies the + // structure of the virtual DOM has changed. + if (nesting && aTaggers.length !== bTaggers.length) + { + patches.push(makePatch('p-redraw', index, b)); + return; + } + + // check if taggers are "the same" + if (nesting ? !pairwiseRefEqual(aTaggers, bTaggers) : aTaggers !== bTaggers) + { + patches.push(makePatch('p-tagger', index, bTaggers)); + } + + // diff everything below the taggers + diffHelp(aSubNode, bSubNode, patches, index + 1); + return; + + case 'text': + if (a.text !== b.text) + { + patches.push(makePatch('p-text', index, b.text)); + return; + } + + return; + + case 'node': + // Bail if obvious indicators have changed. Implies more serious + // structural changes such that it's not worth it to diff. + if (a.tag !== b.tag || a.namespace !== b.namespace) + { + patches.push(makePatch('p-redraw', index, b)); + return; + } + + var factsDiff = diffFacts(a.facts, b.facts); + + if (typeof factsDiff !== 'undefined') + { + patches.push(makePatch('p-facts', index, factsDiff)); + } + + diffChildren(a, b, patches, index); + return; + + case 'keyed-node': + // Bail if obvious indicators have changed. Implies more serious + // structural changes such that it's not worth it to diff. + if (a.tag !== b.tag || a.namespace !== b.namespace) + { + patches.push(makePatch('p-redraw', index, b)); + return; + } + + var factsDiff = diffFacts(a.facts, b.facts); + + if (typeof factsDiff !== 'undefined') + { + patches.push(makePatch('p-facts', index, factsDiff)); + } + + diffKeyedChildren(a, b, patches, index); + return; + + case 'custom': + if (a.impl !== b.impl) + { + patches.push(makePatch('p-redraw', index, b)); + return; + } + + var factsDiff = diffFacts(a.facts, b.facts); + if (typeof factsDiff !== 'undefined') + { + patches.push(makePatch('p-facts', index, factsDiff)); + } + + var patch = b.impl.diff(a,b); + if (patch) + { + patches.push(makePatch('p-custom', index, patch)); + return; + } + + return; + } +} + + +// assumes the incoming arrays are the same length +function pairwiseRefEqual(as, bs) +{ + for (var i = 0; i < as.length; i++) + { + if (as[i] !== bs[i]) + { + return false; + } + } + + return true; +} + + +// 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 diffFacts(a, b, category) +{ + var diff; + + // look for changes and removals + for (var aKey in a) + { + if (aKey === STYLE_KEY || aKey === EVENT_KEY || aKey === ATTR_KEY || aKey === ATTR_NS_KEY) + { + var subDiff = diffFacts(a[aKey], b[aKey] || {}, aKey); + if (subDiff) + { + diff = diff || {}; + diff[aKey] = subDiff; + } + continue; + } + + // remove if not in the new facts + if (!(aKey in b)) + { + diff = diff || {}; + diff[aKey] = + (typeof category === 'undefined') + ? (typeof a[aKey] === 'string' ? '' : null) + : + (category === STYLE_KEY) + ? '' + : + (category === EVENT_KEY || category === ATTR_KEY) + ? undefined + : + { namespace: a[aKey].namespace, value: undefined }; + + continue; + } + + var aValue = a[aKey]; + var bValue = b[aKey]; + + // reference equal, so don't worry about it + if (aValue === bValue && aKey !== 'value' + || category === EVENT_KEY && equalEvents(aValue, bValue)) + { + continue; + } + + diff = diff || {}; + diff[aKey] = bValue; + } + + // add new stuff + for (var bKey in b) + { + if (!(bKey in a)) + { + diff = diff || {}; + diff[bKey] = b[bKey]; + } + } + + return diff; +} + + +function diffChildren(aParent, bParent, patches, rootIndex) +{ + var aChildren = aParent.children; + var bChildren = bParent.children; + + var aLen = aChildren.length; + var bLen = bChildren.length; + + // FIGURE OUT IF THERE ARE INSERTS OR REMOVALS + + if (aLen > bLen) + { + patches.push(makePatch('p-remove-last', rootIndex, aLen - bLen)); + } + else if (aLen < bLen) + { + patches.push(makePatch('p-append', rootIndex, bChildren.slice(aLen))); + } + + // PAIRWISE DIFF EVERYTHING ELSE + + var index = rootIndex; + var minLen = aLen < bLen ? aLen : bLen; + for (var i = 0; i < minLen; i++) + { + index++; + var aChild = aChildren[i]; + diffHelp(aChild, bChildren[i], patches, index); + index += aChild.descendantsCount || 0; + } +} + + + +//////////// KEYED DIFF //////////// + + +function diffKeyedChildren(aParent, bParent, 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 aChildren = aParent.children; + var bChildren = bParent.children; + var aLen = aChildren.length; + var bLen = bChildren.length; + var aIndex = 0; + var bIndex = 0; + + var index = rootIndex; + + while (aIndex < aLen && bIndex < bLen) + { + var a = aChildren[aIndex]; + var b = bChildren[bIndex]; + + var aKey = a._0; + var bKey = b._0; + var aNode = a._1; + var bNode = b._1; + + // check if keys match + + if (aKey === bKey) + { + index++; + diffHelp(aNode, bNode, localPatches, index); + index += aNode.descendantsCount || 0; + + aIndex++; + bIndex++; + continue; + } + + // look ahead 1 to detect insertions and removals. + + var aLookAhead = aIndex + 1 < aLen; + var bLookAhead = bIndex + 1 < bLen; + + if (aLookAhead) + { + var aNext = aChildren[aIndex + 1]; + var aNextKey = aNext._0; + var aNextNode = aNext._1; + var oldMatch = bKey === aNextKey; + } + + if (bLookAhead) + { + var bNext = bChildren[bIndex + 1]; + var bNextKey = bNext._0; + var bNextNode = bNext._1; + var newMatch = aKey === bNextKey; + } + + + // swap a and b + if (aLookAhead && bLookAhead && newMatch && oldMatch) + { + index++; + diffHelp(aNode, bNextNode, localPatches, index); + insertNode(changes, localPatches, aKey, bNode, bIndex, inserts); + index += aNode.descendantsCount || 0; + + index++; + removeNode(changes, localPatches, aKey, aNextNode, index); + index += aNextNode.descendantsCount || 0; + + aIndex += 2; + bIndex += 2; + continue; + } + + // insert b + if (bLookAhead && newMatch) + { + index++; + insertNode(changes, localPatches, bKey, bNode, bIndex, inserts); + diffHelp(aNode, bNextNode, localPatches, index); + index += aNode.descendantsCount || 0; + + aIndex += 1; + bIndex += 2; + continue; + } + + // remove a + if (aLookAhead && oldMatch) + { + index++; + removeNode(changes, localPatches, aKey, aNode, index); + index += aNode.descendantsCount || 0; + + index++; + diffHelp(aNextNode, bNode, localPatches, index); + index += aNextNode.descendantsCount || 0; + + aIndex += 2; + bIndex += 1; + continue; + } + + // remove a, insert b + if (aLookAhead && bLookAhead && aNextKey === bNextKey) + { + index++; + removeNode(changes, localPatches, aKey, aNode, index); + insertNode(changes, localPatches, bKey, bNode, bIndex, inserts); + index += aNode.descendantsCount || 0; + + index++; + diffHelp(aNextNode, bNextNode, localPatches, index); + index += aNextNode.descendantsCount || 0; + + aIndex += 2; + bIndex += 2; + continue; + } + + break; + } + + // eat up any remaining nodes with removeNode and insertNode + + while (aIndex < aLen) + { + index++; + var a = aChildren[aIndex]; + var aNode = a._1; + removeNode(changes, localPatches, a._0, aNode, index); + index += aNode.descendantsCount || 0; + aIndex++; + } + + var endInserts; + while (bIndex < bLen) + { + endInserts = endInserts || []; + var b = bChildren[bIndex]; + insertNode(changes, localPatches, b._0, b._1, undefined, endInserts); + bIndex++; + } + + if (localPatches.length > 0 || inserts.length > 0 || typeof endInserts !== 'undefined') + { + patches.push(makePatch('p-reorder', rootIndex, { + patches: localPatches, + inserts: inserts, + endInserts: endInserts + })); + } +} + + + +//////////// CHANGES FROM KEYED DIFF //////////// + + +var POSTFIX = '_elmW6BL'; + + +function insertNode(changes, localPatches, key, vnode, bIndex, inserts) +{ + var entry = changes[key]; + + // never seen this key before + if (typeof entry === 'undefined') + { + entry = { + tag: 'insert', + vnode: vnode, + index: bIndex, + data: undefined + }; + + inserts.push({ index: bIndex, entry: entry }); + changes[key] = entry; + + return; + } + + // this key was removed earlier, a match! + if (entry.tag === 'remove') + { + inserts.push({ index: bIndex, entry: entry }); + + entry.tag = 'move'; + var subPatches = []; + diffHelp(entry.vnode, vnode, subPatches, entry.index); + entry.index = bIndex; + entry.data.data = { + patches: subPatches, + entry: entry + }; + + return; + } + + // this key has already been inserted or moved, a duplicate! + insertNode(changes, localPatches, key + POSTFIX, vnode, bIndex, inserts); +} + + +function removeNode(changes, localPatches, key, vnode, index) +{ + var entry = changes[key]; + + // never seen this key before + if (typeof entry === 'undefined') + { + var patch = makePatch('p-remove', index, undefined); + localPatches.push(patch); + + changes[key] = { + tag: 'remove', + vnode: vnode, + index: index, + data: patch + }; + + return; + } + + // this key was inserted earlier, a match! + if (entry.tag === 'insert') + { + entry.tag = 'move'; + var subPatches = []; + diffHelp(vnode, entry.vnode, subPatches, index); + + var patch = makePatch('p-remove', index, { + patches: subPatches, + entry: entry + }); + localPatches.push(patch); + + return; + } + + // this key has already been removed or moved, a duplicate! + removeNode(changes, localPatches, key + 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 addDomNodes(domNode, vNode, patches, eventNode) +{ + addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.descendantsCount, eventNode); +} + + +// assumes `patches` is non-empty and indexes increase monotonically. +function addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode) +{ + var patch = patches[i]; + var index = patch.index; + + while (index === low) + { + var patchType = patch.type; + + if (patchType === 'p-thunk') + { + addDomNodes(domNode, vNode.node, patch.data, eventNode); + } + else if (patchType === 'p-reorder') + { + patch.domNode = domNode; + patch.eventNode = eventNode; + + var subPatches = patch.data.patches; + if (subPatches.length > 0) + { + addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode); + } + } + else if (patchType === 'p-remove') + { + patch.domNode = domNode; + patch.eventNode = eventNode; + + var data = patch.data; + if (typeof data !== 'undefined') + { + data.entry.data = domNode; + var subPatches = data.patches; + if (subPatches.length > 0) + { + addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode); + } + } + } + else + { + patch.domNode = domNode; + patch.eventNode = eventNode; + } + + i++; + + if (!(patch = patches[i]) || (index = patch.index) > high) + { + return i; + } + } + + switch (vNode.type) + { + case 'tagger': + var subNode = vNode.node; + + while (subNode.type === "tagger") + { + subNode = subNode.node; + } + + return addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref); + + case 'node': + var vChildren = vNode.children; + var childNodes = domNode.childNodes; + for (var j = 0; j < vChildren.length; j++) + { + low++; + var vChild = vChildren[j]; + var nextLow = low + (vChild.descendantsCount || 0); + if (low <= index && index <= nextLow) + { + i = addDomNodesHelp(childNodes[j], vChild, patches, i, low, nextLow, eventNode); + if (!(patch = patches[i]) || (index = patch.index) > high) + { + return i; + } + } + low = nextLow; + } + return i; + + case 'keyed-node': + var vChildren = vNode.children; + var childNodes = domNode.childNodes; + for (var j = 0; j < vChildren.length; j++) + { + low++; + var vChild = vChildren[j]._1; + var nextLow = low + (vChild.descendantsCount || 0); + if (low <= index && index <= nextLow) + { + i = addDomNodesHelp(childNodes[j], vChild, patches, i, low, nextLow, eventNode); + if (!(patch = patches[i]) || (index = patch.index) > high) + { + return i; + } + } + low = nextLow; + } + return i; + + case 'text': + case 'thunk': + throw new Error('should never traverse `text` or `thunk` nodes like this'); + } +} + + + +//////////// APPLY PATCHES //////////// + + +function applyPatches(rootDomNode, oldVirtualNode, patches, eventNode) +{ + if (patches.length === 0) + { + return rootDomNode; + } + + addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode); + return applyPatchesHelp(rootDomNode, patches); +} + +function applyPatchesHelp(rootDomNode, patches) +{ + for (var i = 0; i < patches.length; i++) + { + var patch = patches[i]; + var localDomNode = patch.domNode + var newNode = applyPatch(localDomNode, patch); + if (localDomNode === rootDomNode) + { + rootDomNode = newNode; + } + } + return rootDomNode; +} + +function applyPatch(domNode, patch) +{ + switch (patch.type) + { + case 'p-redraw': + return applyPatchRedraw(domNode, patch.data, patch.eventNode); + + case 'p-facts': + applyFacts(domNode, patch.eventNode, patch.data); + return domNode; + + case 'p-text': + domNode.replaceData(0, domNode.length, patch.data); + return domNode; + + case 'p-thunk': + return applyPatchesHelp(domNode, patch.data); + + case 'p-tagger': + domNode.elm_event_node_ref.tagger = patch.data; + return domNode; + + case 'p-remove-last': + var i = patch.data; + while (i--) + { + domNode.removeChild(domNode.lastChild); + } + return domNode; + + case 'p-append': + var newNodes = patch.data; + for (var i = 0; i < newNodes.length; i++) + { + domNode.appendChild(render(newNodes[i], patch.eventNode)); + } + return domNode; + + case 'p-remove': + var data = patch.data; + if (typeof data === 'undefined') + { + domNode.parentNode.removeChild(domNode); + return domNode; + } + var entry = data.entry; + if (typeof entry.index !== 'undefined') + { + domNode.parentNode.removeChild(domNode); + } + entry.data = applyPatchesHelp(domNode, data.patches); + return domNode; + + case 'p-reorder': + return applyPatchReorder(domNode, patch); + + case 'p-custom': + var impl = patch.data; + return impl.applyPatch(domNode, impl.data); + + default: + throw new Error('Ran into an unknown patch!'); + } +} + + +function applyPatchRedraw(domNode, vNode, eventNode) +{ + var parentNode = domNode.parentNode; + var newNode = render(vNode, eventNode); + + if (typeof newNode.elm_event_node_ref === 'undefined') + { + newNode.elm_event_node_ref = domNode.elm_event_node_ref; + } + + if (parentNode && newNode !== domNode) + { + parentNode.replaceChild(newNode, domNode); + } + return newNode; +} + + +function applyPatchReorder(domNode, patch) +{ + var data = patch.data; + + // remove end inserts + var frag = applyPatchReorderEndInsertsHelp(data.endInserts, patch); + + // removals + domNode = applyPatchesHelp(domNode, data.patches); + + // inserts + var inserts = data.inserts; + for (var i = 0; i < inserts.length; i++) + { + var insert = inserts[i]; + var entry = insert.entry; + var node = entry.tag === 'move' + ? entry.data + : render(entry.vnode, patch.eventNode); + domNode.insertBefore(node, domNode.childNodes[insert.index]); + } + + // add end inserts + if (typeof frag !== 'undefined') + { + domNode.appendChild(frag); + } + + return domNode; +} + + +function applyPatchReorderEndInsertsHelp(endInserts, patch) +{ + if (typeof endInserts === 'undefined') + { + return; + } + + var frag = document.createDocumentFragment(); + for (var i = 0; i < endInserts.length; i++) + { + var insert = endInserts[i]; + var entry = insert.entry; + frag.appendChild(entry.tag === 'move' + ? entry.data + : render(entry.vnode, patch.eventNode) + ); + } + return frag; +} + + + +//////////// PROGRAMS //////////// + + +function programWithFlags(details) +{ + return { + init: details.init, + update: details.update, + subscriptions: details.subscriptions, + view: details.view, + renderer: renderer + }; +} + + +return { + node: node, + text: text, + + custom: custom, + + map: F2(map), + + on: F3(on), + style: style, + property: F2(property), + attribute: F2(attribute), + attributeNS: F3(attributeNS), + + lazy: F2(lazy), + lazy2: F3(lazy2), + lazy3: F4(lazy3), + keyedNode: F3(keyedNode), + + programWithFlags: programWithFlags +}; + +}(); +var _elm_lang$virtual_dom$VirtualDom$programWithFlags = _elm_lang$virtual_dom$Native_VirtualDom.programWithFlags; +var _elm_lang$virtual_dom$VirtualDom$keyedNode = _elm_lang$virtual_dom$Native_VirtualDom.keyedNode; +var _elm_lang$virtual_dom$VirtualDom$lazy3 = _elm_lang$virtual_dom$Native_VirtualDom.lazy3; +var _elm_lang$virtual_dom$VirtualDom$lazy2 = _elm_lang$virtual_dom$Native_VirtualDom.lazy2; +var _elm_lang$virtual_dom$VirtualDom$lazy = _elm_lang$virtual_dom$Native_VirtualDom.lazy; +var _elm_lang$virtual_dom$VirtualDom$defaultOptions = {stopPropagation: false, preventDefault: false}; +var _elm_lang$virtual_dom$VirtualDom$onWithOptions = _elm_lang$virtual_dom$Native_VirtualDom.on; +var _elm_lang$virtual_dom$VirtualDom$on = F2( + function (eventName, decoder) { + return A3(_elm_lang$virtual_dom$VirtualDom$onWithOptions, eventName, _elm_lang$virtual_dom$VirtualDom$defaultOptions, decoder); + }); +var _elm_lang$virtual_dom$VirtualDom$style = _elm_lang$virtual_dom$Native_VirtualDom.style; +var _elm_lang$virtual_dom$VirtualDom$attributeNS = _elm_lang$virtual_dom$Native_VirtualDom.attributeNS; +var _elm_lang$virtual_dom$VirtualDom$attribute = _elm_lang$virtual_dom$Native_VirtualDom.attribute; +var _elm_lang$virtual_dom$VirtualDom$property = _elm_lang$virtual_dom$Native_VirtualDom.property; +var _elm_lang$virtual_dom$VirtualDom$map = _elm_lang$virtual_dom$Native_VirtualDom.map; +var _elm_lang$virtual_dom$VirtualDom$text = _elm_lang$virtual_dom$Native_VirtualDom.text; +var _elm_lang$virtual_dom$VirtualDom$node = _elm_lang$virtual_dom$Native_VirtualDom.node; +var _elm_lang$virtual_dom$VirtualDom$Options = F2( + function (a, b) { + return {stopPropagation: a, preventDefault: b}; + }); +var _elm_lang$virtual_dom$VirtualDom$Node = {ctor: 'Node'}; +var _elm_lang$virtual_dom$VirtualDom$Property = {ctor: 'Property'}; + +var _elm_lang$html$Html$text = _elm_lang$virtual_dom$VirtualDom$text; +var _elm_lang$html$Html$node = _elm_lang$virtual_dom$VirtualDom$node; +var _elm_lang$html$Html$body = _elm_lang$html$Html$node('body'); +var _elm_lang$html$Html$section = _elm_lang$html$Html$node('section'); +var _elm_lang$html$Html$nav = _elm_lang$html$Html$node('nav'); +var _elm_lang$html$Html$article = _elm_lang$html$Html$node('article'); +var _elm_lang$html$Html$aside = _elm_lang$html$Html$node('aside'); +var _elm_lang$html$Html$h1 = _elm_lang$html$Html$node('h1'); +var _elm_lang$html$Html$h2 = _elm_lang$html$Html$node('h2'); +var _elm_lang$html$Html$h3 = _elm_lang$html$Html$node('h3'); +var _elm_lang$html$Html$h4 = _elm_lang$html$Html$node('h4'); +var _elm_lang$html$Html$h5 = _elm_lang$html$Html$node('h5'); +var _elm_lang$html$Html$h6 = _elm_lang$html$Html$node('h6'); +var _elm_lang$html$Html$header = _elm_lang$html$Html$node('header'); +var _elm_lang$html$Html$footer = _elm_lang$html$Html$node('footer'); +var _elm_lang$html$Html$address = _elm_lang$html$Html$node('address'); +var _elm_lang$html$Html$main$ = _elm_lang$html$Html$node('main'); +var _elm_lang$html$Html$p = _elm_lang$html$Html$node('p'); +var _elm_lang$html$Html$hr = _elm_lang$html$Html$node('hr'); +var _elm_lang$html$Html$pre = _elm_lang$html$Html$node('pre'); +var _elm_lang$html$Html$blockquote = _elm_lang$html$Html$node('blockquote'); +var _elm_lang$html$Html$ol = _elm_lang$html$Html$node('ol'); +var _elm_lang$html$Html$ul = _elm_lang$html$Html$node('ul'); +var _elm_lang$html$Html$li = _elm_lang$html$Html$node('li'); +var _elm_lang$html$Html$dl = _elm_lang$html$Html$node('dl'); +var _elm_lang$html$Html$dt = _elm_lang$html$Html$node('dt'); +var _elm_lang$html$Html$dd = _elm_lang$html$Html$node('dd'); +var _elm_lang$html$Html$figure = _elm_lang$html$Html$node('figure'); +var _elm_lang$html$Html$figcaption = _elm_lang$html$Html$node('figcaption'); +var _elm_lang$html$Html$div = _elm_lang$html$Html$node('div'); +var _elm_lang$html$Html$a = _elm_lang$html$Html$node('a'); +var _elm_lang$html$Html$em = _elm_lang$html$Html$node('em'); +var _elm_lang$html$Html$strong = _elm_lang$html$Html$node('strong'); +var _elm_lang$html$Html$small = _elm_lang$html$Html$node('small'); +var _elm_lang$html$Html$s = _elm_lang$html$Html$node('s'); +var _elm_lang$html$Html$cite = _elm_lang$html$Html$node('cite'); +var _elm_lang$html$Html$q = _elm_lang$html$Html$node('q'); +var _elm_lang$html$Html$dfn = _elm_lang$html$Html$node('dfn'); +var _elm_lang$html$Html$abbr = _elm_lang$html$Html$node('abbr'); +var _elm_lang$html$Html$time = _elm_lang$html$Html$node('time'); +var _elm_lang$html$Html$code = _elm_lang$html$Html$node('code'); +var _elm_lang$html$Html$var = _elm_lang$html$Html$node('var'); +var _elm_lang$html$Html$samp = _elm_lang$html$Html$node('samp'); +var _elm_lang$html$Html$kbd = _elm_lang$html$Html$node('kbd'); +var _elm_lang$html$Html$sub = _elm_lang$html$Html$node('sub'); +var _elm_lang$html$Html$sup = _elm_lang$html$Html$node('sup'); +var _elm_lang$html$Html$i = _elm_lang$html$Html$node('i'); +var _elm_lang$html$Html$b = _elm_lang$html$Html$node('b'); +var _elm_lang$html$Html$u = _elm_lang$html$Html$node('u'); +var _elm_lang$html$Html$mark = _elm_lang$html$Html$node('mark'); +var _elm_lang$html$Html$ruby = _elm_lang$html$Html$node('ruby'); +var _elm_lang$html$Html$rt = _elm_lang$html$Html$node('rt'); +var _elm_lang$html$Html$rp = _elm_lang$html$Html$node('rp'); +var _elm_lang$html$Html$bdi = _elm_lang$html$Html$node('bdi'); +var _elm_lang$html$Html$bdo = _elm_lang$html$Html$node('bdo'); +var _elm_lang$html$Html$span = _elm_lang$html$Html$node('span'); +var _elm_lang$html$Html$br = _elm_lang$html$Html$node('br'); +var _elm_lang$html$Html$wbr = _elm_lang$html$Html$node('wbr'); +var _elm_lang$html$Html$ins = _elm_lang$html$Html$node('ins'); +var _elm_lang$html$Html$del = _elm_lang$html$Html$node('del'); +var _elm_lang$html$Html$img = _elm_lang$html$Html$node('img'); +var _elm_lang$html$Html$iframe = _elm_lang$html$Html$node('iframe'); +var _elm_lang$html$Html$embed = _elm_lang$html$Html$node('embed'); +var _elm_lang$html$Html$object = _elm_lang$html$Html$node('object'); +var _elm_lang$html$Html$param = _elm_lang$html$Html$node('param'); +var _elm_lang$html$Html$video = _elm_lang$html$Html$node('video'); +var _elm_lang$html$Html$audio = _elm_lang$html$Html$node('audio'); +var _elm_lang$html$Html$source = _elm_lang$html$Html$node('source'); +var _elm_lang$html$Html$track = _elm_lang$html$Html$node('track'); +var _elm_lang$html$Html$canvas = _elm_lang$html$Html$node('canvas'); +var _elm_lang$html$Html$svg = _elm_lang$html$Html$node('svg'); +var _elm_lang$html$Html$math = _elm_lang$html$Html$node('math'); +var _elm_lang$html$Html$table = _elm_lang$html$Html$node('table'); +var _elm_lang$html$Html$caption = _elm_lang$html$Html$node('caption'); +var _elm_lang$html$Html$colgroup = _elm_lang$html$Html$node('colgroup'); +var _elm_lang$html$Html$col = _elm_lang$html$Html$node('col'); +var _elm_lang$html$Html$tbody = _elm_lang$html$Html$node('tbody'); +var _elm_lang$html$Html$thead = _elm_lang$html$Html$node('thead'); +var _elm_lang$html$Html$tfoot = _elm_lang$html$Html$node('tfoot'); +var _elm_lang$html$Html$tr = _elm_lang$html$Html$node('tr'); +var _elm_lang$html$Html$td = _elm_lang$html$Html$node('td'); +var _elm_lang$html$Html$th = _elm_lang$html$Html$node('th'); +var _elm_lang$html$Html$form = _elm_lang$html$Html$node('form'); +var _elm_lang$html$Html$fieldset = _elm_lang$html$Html$node('fieldset'); +var _elm_lang$html$Html$legend = _elm_lang$html$Html$node('legend'); +var _elm_lang$html$Html$label = _elm_lang$html$Html$node('label'); +var _elm_lang$html$Html$input = _elm_lang$html$Html$node('input'); +var _elm_lang$html$Html$button = _elm_lang$html$Html$node('button'); +var _elm_lang$html$Html$select = _elm_lang$html$Html$node('select'); +var _elm_lang$html$Html$datalist = _elm_lang$html$Html$node('datalist'); +var _elm_lang$html$Html$optgroup = _elm_lang$html$Html$node('optgroup'); +var _elm_lang$html$Html$option = _elm_lang$html$Html$node('option'); +var _elm_lang$html$Html$textarea = _elm_lang$html$Html$node('textarea'); +var _elm_lang$html$Html$keygen = _elm_lang$html$Html$node('keygen'); +var _elm_lang$html$Html$output = _elm_lang$html$Html$node('output'); +var _elm_lang$html$Html$progress = _elm_lang$html$Html$node('progress'); +var _elm_lang$html$Html$meter = _elm_lang$html$Html$node('meter'); +var _elm_lang$html$Html$details = _elm_lang$html$Html$node('details'); +var _elm_lang$html$Html$summary = _elm_lang$html$Html$node('summary'); +var _elm_lang$html$Html$menuitem = _elm_lang$html$Html$node('menuitem'); +var _elm_lang$html$Html$menu = _elm_lang$html$Html$node('menu'); + +var _elm_lang$html$Html_App$programWithFlags = _elm_lang$virtual_dom$VirtualDom$programWithFlags; +var _elm_lang$html$Html_App$program = function (app) { + return _elm_lang$html$Html_App$programWithFlags( + _elm_lang$core$Native_Utils.update( + app, + { + init: function (_p0) { + return app.init; + } + })); +}; +var _elm_lang$html$Html_App$beginnerProgram = function (_p1) { + var _p2 = _p1; + return _elm_lang$html$Html_App$programWithFlags( + { + init: function (_p3) { + return A2( + _elm_lang$core$Platform_Cmd_ops['!'], + _p2.model, + _elm_lang$core$Native_List.fromArray( + [])); + }, + update: F2( + function (msg, model) { + return A2( + _elm_lang$core$Platform_Cmd_ops['!'], + A2(_p2.update, msg, model), + _elm_lang$core$Native_List.fromArray( + [])); + }), + view: _p2.view, + subscriptions: function (_p4) { + return _elm_lang$core$Platform_Sub$none; + } + }); +}; +var _elm_lang$html$Html_App$map = _elm_lang$virtual_dom$VirtualDom$map; + +var _elm_lang$keyboard$Keyboard$onSelfMsg = F3( + function (router, _p0, state) { + var _p1 = _p0; + var _p2 = A2(_elm_lang$core$Dict$get, _p1.category, state); + if (_p2.ctor === 'Nothing') { + return _elm_lang$core$Task$succeed(state); + } else { + var send = function (tagger) { + return A2( + _elm_lang$core$Platform$sendToApp, + router, + tagger(_p1.keyCode)); + }; + return A2( + _elm_lang$core$Task$andThen, + _elm_lang$core$Task$sequence( + A2(_elm_lang$core$List$map, send, _p2._0.taggers)), + function (_p3) { + return _elm_lang$core$Task$succeed(state); + }); + } + }); +var _elm_lang$keyboard$Keyboard_ops = _elm_lang$keyboard$Keyboard_ops || {}; +_elm_lang$keyboard$Keyboard_ops['&>'] = F2( + function (t1, t2) { + return A2( + _elm_lang$core$Task$andThen, + t1, + function (_p4) { + return t2; + }); + }); +var _elm_lang$keyboard$Keyboard$init = _elm_lang$core$Task$succeed(_elm_lang$core$Dict$empty); +var _elm_lang$keyboard$Keyboard$categorizeHelpHelp = F2( + function (value, maybeValues) { + var _p5 = maybeValues; + if (_p5.ctor === 'Nothing') { + return _elm_lang$core$Maybe$Just( + _elm_lang$core$Native_List.fromArray( + [value])); + } else { + return _elm_lang$core$Maybe$Just( + A2(_elm_lang$core$List_ops['::'], value, _p5._0)); + } + }); +var _elm_lang$keyboard$Keyboard$categorizeHelp = F2( + function (subs, subDict) { + categorizeHelp: + while (true) { + var _p6 = subs; + if (_p6.ctor === '[]') { + return subDict; + } else { + var _v4 = _p6._1, + _v5 = A3( + _elm_lang$core$Dict$update, + _p6._0._0, + _elm_lang$keyboard$Keyboard$categorizeHelpHelp(_p6._0._1), + subDict); + subs = _v4; + subDict = _v5; + continue categorizeHelp; + } + } + }); +var _elm_lang$keyboard$Keyboard$categorize = function (subs) { + return A2(_elm_lang$keyboard$Keyboard$categorizeHelp, subs, _elm_lang$core$Dict$empty); +}; +var _elm_lang$keyboard$Keyboard$keyCode = A2(_elm_lang$core$Json_Decode_ops[':='], 'keyCode', _elm_lang$core$Json_Decode$int); +var _elm_lang$keyboard$Keyboard$subscription = _elm_lang$core$Native_Platform.leaf('Keyboard'); +var _elm_lang$keyboard$Keyboard$Watcher = F2( + function (a, b) { + return {taggers: a, pid: b}; + }); +var _elm_lang$keyboard$Keyboard$Msg = F2( + function (a, b) { + return {category: a, keyCode: b}; + }); +var _elm_lang$keyboard$Keyboard$onEffects = F3( + function (router, newSubs, oldState) { + var rightStep = F3( + function (category, taggers, task) { + return A2( + _elm_lang$core$Task$andThen, + task, + function (state) { + return A2( + _elm_lang$core$Task$andThen, + _elm_lang$core$Process$spawn( + A3( + _elm_lang$dom$Dom_LowLevel$onDocument, + category, + _elm_lang$keyboard$Keyboard$keyCode, + function (_p7) { + return A2( + _elm_lang$core$Platform$sendToSelf, + router, + A2(_elm_lang$keyboard$Keyboard$Msg, category, _p7)); + })), + function (pid) { + return _elm_lang$core$Task$succeed( + A3( + _elm_lang$core$Dict$insert, + category, + A2(_elm_lang$keyboard$Keyboard$Watcher, taggers, pid), + state)); + }); + }); + }); + var bothStep = F4( + function (category, _p8, taggers, task) { + var _p9 = _p8; + return A2( + _elm_lang$core$Task$andThen, + task, + function (state) { + return _elm_lang$core$Task$succeed( + A3( + _elm_lang$core$Dict$insert, + category, + A2(_elm_lang$keyboard$Keyboard$Watcher, taggers, _p9.pid), + state)); + }); + }); + var leftStep = F3( + function (category, _p10, task) { + var _p11 = _p10; + return A2( + _elm_lang$keyboard$Keyboard_ops['&>'], + _elm_lang$core$Process$kill(_p11.pid), + task); + }); + return A6( + _elm_lang$core$Dict$merge, + leftStep, + bothStep, + rightStep, + oldState, + _elm_lang$keyboard$Keyboard$categorize(newSubs), + _elm_lang$core$Task$succeed(_elm_lang$core$Dict$empty)); + }); +var _elm_lang$keyboard$Keyboard$MySub = F2( + function (a, b) { + return {ctor: 'MySub', _0: a, _1: b}; + }); +var _elm_lang$keyboard$Keyboard$presses = function (tagger) { + return _elm_lang$keyboard$Keyboard$subscription( + A2(_elm_lang$keyboard$Keyboard$MySub, 'keypress', tagger)); +}; +var _elm_lang$keyboard$Keyboard$downs = function (tagger) { + return _elm_lang$keyboard$Keyboard$subscription( + A2(_elm_lang$keyboard$Keyboard$MySub, 'keydown', tagger)); +}; +var _elm_lang$keyboard$Keyboard$ups = function (tagger) { + return _elm_lang$keyboard$Keyboard$subscription( + A2(_elm_lang$keyboard$Keyboard$MySub, 'keyup', tagger)); +}; +var _elm_lang$keyboard$Keyboard$subMap = F2( + function (func, _p12) { + var _p13 = _p12; + return A2( + _elm_lang$keyboard$Keyboard$MySub, + _p13._0, + function (_p14) { + return func( + _p13._1(_p14)); + }); + }); +_elm_lang$core$Native_Platform.effectManagers['Keyboard'] = {pkg: 'elm-lang/keyboard', init: _elm_lang$keyboard$Keyboard$init, onEffects: _elm_lang$keyboard$Keyboard$onEffects, onSelfMsg: _elm_lang$keyboard$Keyboard$onSelfMsg, tag: 'sub', subMap: _elm_lang$keyboard$Keyboard$subMap}; + +var _elm_lang$svg$Svg$text = _elm_lang$virtual_dom$VirtualDom$text; +var _elm_lang$svg$Svg$svgNamespace = A2( + _elm_lang$virtual_dom$VirtualDom$property, + 'namespace', + _elm_lang$core$Json_Encode$string('http://www.w3.org/2000/svg')); +var _elm_lang$svg$Svg$node = F3( + function (name, attributes, children) { + return A3( + _elm_lang$virtual_dom$VirtualDom$node, + name, + A2(_elm_lang$core$List_ops['::'], _elm_lang$svg$Svg$svgNamespace, attributes), + children); + }); +var _elm_lang$svg$Svg$svg = _elm_lang$svg$Svg$node('svg'); +var _elm_lang$svg$Svg$foreignObject = _elm_lang$svg$Svg$node('foreignObject'); +var _elm_lang$svg$Svg$animate = _elm_lang$svg$Svg$node('animate'); +var _elm_lang$svg$Svg$animateColor = _elm_lang$svg$Svg$node('animateColor'); +var _elm_lang$svg$Svg$animateMotion = _elm_lang$svg$Svg$node('animateMotion'); +var _elm_lang$svg$Svg$animateTransform = _elm_lang$svg$Svg$node('animateTransform'); +var _elm_lang$svg$Svg$mpath = _elm_lang$svg$Svg$node('mpath'); +var _elm_lang$svg$Svg$set = _elm_lang$svg$Svg$node('set'); +var _elm_lang$svg$Svg$a = _elm_lang$svg$Svg$node('a'); +var _elm_lang$svg$Svg$defs = _elm_lang$svg$Svg$node('defs'); +var _elm_lang$svg$Svg$g = _elm_lang$svg$Svg$node('g'); +var _elm_lang$svg$Svg$marker = _elm_lang$svg$Svg$node('marker'); +var _elm_lang$svg$Svg$mask = _elm_lang$svg$Svg$node('mask'); +var _elm_lang$svg$Svg$missingGlyph = _elm_lang$svg$Svg$node('missingGlyph'); +var _elm_lang$svg$Svg$pattern = _elm_lang$svg$Svg$node('pattern'); +var _elm_lang$svg$Svg$switch = _elm_lang$svg$Svg$node('switch'); +var _elm_lang$svg$Svg$symbol = _elm_lang$svg$Svg$node('symbol'); +var _elm_lang$svg$Svg$desc = _elm_lang$svg$Svg$node('desc'); +var _elm_lang$svg$Svg$metadata = _elm_lang$svg$Svg$node('metadata'); +var _elm_lang$svg$Svg$title = _elm_lang$svg$Svg$node('title'); +var _elm_lang$svg$Svg$feBlend = _elm_lang$svg$Svg$node('feBlend'); +var _elm_lang$svg$Svg$feColorMatrix = _elm_lang$svg$Svg$node('feColorMatrix'); +var _elm_lang$svg$Svg$feComponentTransfer = _elm_lang$svg$Svg$node('feComponentTransfer'); +var _elm_lang$svg$Svg$feComposite = _elm_lang$svg$Svg$node('feComposite'); +var _elm_lang$svg$Svg$feConvolveMatrix = _elm_lang$svg$Svg$node('feConvolveMatrix'); +var _elm_lang$svg$Svg$feDiffuseLighting = _elm_lang$svg$Svg$node('feDiffuseLighting'); +var _elm_lang$svg$Svg$feDisplacementMap = _elm_lang$svg$Svg$node('feDisplacementMap'); +var _elm_lang$svg$Svg$feFlood = _elm_lang$svg$Svg$node('feFlood'); +var _elm_lang$svg$Svg$feFuncA = _elm_lang$svg$Svg$node('feFuncA'); +var _elm_lang$svg$Svg$feFuncB = _elm_lang$svg$Svg$node('feFuncB'); +var _elm_lang$svg$Svg$feFuncG = _elm_lang$svg$Svg$node('feFuncG'); +var _elm_lang$svg$Svg$feFuncR = _elm_lang$svg$Svg$node('feFuncR'); +var _elm_lang$svg$Svg$feGaussianBlur = _elm_lang$svg$Svg$node('feGaussianBlur'); +var _elm_lang$svg$Svg$feImage = _elm_lang$svg$Svg$node('feImage'); +var _elm_lang$svg$Svg$feMerge = _elm_lang$svg$Svg$node('feMerge'); +var _elm_lang$svg$Svg$feMergeNode = _elm_lang$svg$Svg$node('feMergeNode'); +var _elm_lang$svg$Svg$feMorphology = _elm_lang$svg$Svg$node('feMorphology'); +var _elm_lang$svg$Svg$feOffset = _elm_lang$svg$Svg$node('feOffset'); +var _elm_lang$svg$Svg$feSpecularLighting = _elm_lang$svg$Svg$node('feSpecularLighting'); +var _elm_lang$svg$Svg$feTile = _elm_lang$svg$Svg$node('feTile'); +var _elm_lang$svg$Svg$feTurbulence = _elm_lang$svg$Svg$node('feTurbulence'); +var _elm_lang$svg$Svg$font = _elm_lang$svg$Svg$node('font'); +var _elm_lang$svg$Svg$fontFace = _elm_lang$svg$Svg$node('fontFace'); +var _elm_lang$svg$Svg$fontFaceFormat = _elm_lang$svg$Svg$node('fontFaceFormat'); +var _elm_lang$svg$Svg$fontFaceName = _elm_lang$svg$Svg$node('fontFaceName'); +var _elm_lang$svg$Svg$fontFaceSrc = _elm_lang$svg$Svg$node('fontFaceSrc'); +var _elm_lang$svg$Svg$fontFaceUri = _elm_lang$svg$Svg$node('fontFaceUri'); +var _elm_lang$svg$Svg$hkern = _elm_lang$svg$Svg$node('hkern'); +var _elm_lang$svg$Svg$vkern = _elm_lang$svg$Svg$node('vkern'); +var _elm_lang$svg$Svg$linearGradient = _elm_lang$svg$Svg$node('linearGradient'); +var _elm_lang$svg$Svg$radialGradient = _elm_lang$svg$Svg$node('radialGradient'); +var _elm_lang$svg$Svg$stop = _elm_lang$svg$Svg$node('stop'); +var _elm_lang$svg$Svg$circle = _elm_lang$svg$Svg$node('circle'); +var _elm_lang$svg$Svg$ellipse = _elm_lang$svg$Svg$node('ellipse'); +var _elm_lang$svg$Svg$image = _elm_lang$svg$Svg$node('image'); +var _elm_lang$svg$Svg$line = _elm_lang$svg$Svg$node('line'); +var _elm_lang$svg$Svg$path = _elm_lang$svg$Svg$node('path'); +var _elm_lang$svg$Svg$polygon = _elm_lang$svg$Svg$node('polygon'); +var _elm_lang$svg$Svg$polyline = _elm_lang$svg$Svg$node('polyline'); +var _elm_lang$svg$Svg$rect = _elm_lang$svg$Svg$node('rect'); +var _elm_lang$svg$Svg$use = _elm_lang$svg$Svg$node('use'); +var _elm_lang$svg$Svg$feDistantLight = _elm_lang$svg$Svg$node('feDistantLight'); +var _elm_lang$svg$Svg$fePointLight = _elm_lang$svg$Svg$node('fePointLight'); +var _elm_lang$svg$Svg$feSpotLight = _elm_lang$svg$Svg$node('feSpotLight'); +var _elm_lang$svg$Svg$altGlyph = _elm_lang$svg$Svg$node('altGlyph'); +var _elm_lang$svg$Svg$altGlyphDef = _elm_lang$svg$Svg$node('altGlyphDef'); +var _elm_lang$svg$Svg$altGlyphItem = _elm_lang$svg$Svg$node('altGlyphItem'); +var _elm_lang$svg$Svg$glyph = _elm_lang$svg$Svg$node('glyph'); +var _elm_lang$svg$Svg$glyphRef = _elm_lang$svg$Svg$node('glyphRef'); +var _elm_lang$svg$Svg$textPath = _elm_lang$svg$Svg$node('textPath'); +var _elm_lang$svg$Svg$text$ = _elm_lang$svg$Svg$node('text'); +var _elm_lang$svg$Svg$tref = _elm_lang$svg$Svg$node('tref'); +var _elm_lang$svg$Svg$tspan = _elm_lang$svg$Svg$node('tspan'); +var _elm_lang$svg$Svg$clipPath = _elm_lang$svg$Svg$node('clipPath'); +var _elm_lang$svg$Svg$colorProfile = _elm_lang$svg$Svg$node('colorProfile'); +var _elm_lang$svg$Svg$cursor = _elm_lang$svg$Svg$node('cursor'); +var _elm_lang$svg$Svg$filter = _elm_lang$svg$Svg$node('filter'); +var _elm_lang$svg$Svg$script = _elm_lang$svg$Svg$node('script'); +var _elm_lang$svg$Svg$style = _elm_lang$svg$Svg$node('style'); +var _elm_lang$svg$Svg$view = _elm_lang$svg$Svg$node('view'); + +var _elm_lang$svg$Svg_Attributes$writingMode = _elm_lang$virtual_dom$VirtualDom$attribute('writing-mode'); +var _elm_lang$svg$Svg_Attributes$wordSpacing = _elm_lang$virtual_dom$VirtualDom$attribute('word-spacing'); +var _elm_lang$svg$Svg_Attributes$visibility = _elm_lang$virtual_dom$VirtualDom$attribute('visibility'); +var _elm_lang$svg$Svg_Attributes$unicodeBidi = _elm_lang$virtual_dom$VirtualDom$attribute('unicode-bidi'); +var _elm_lang$svg$Svg_Attributes$textRendering = _elm_lang$virtual_dom$VirtualDom$attribute('text-rendering'); +var _elm_lang$svg$Svg_Attributes$textDecoration = _elm_lang$virtual_dom$VirtualDom$attribute('text-decoration'); +var _elm_lang$svg$Svg_Attributes$textAnchor = _elm_lang$virtual_dom$VirtualDom$attribute('text-anchor'); +var _elm_lang$svg$Svg_Attributes$stroke = _elm_lang$virtual_dom$VirtualDom$attribute('stroke'); +var _elm_lang$svg$Svg_Attributes$strokeWidth = _elm_lang$virtual_dom$VirtualDom$attribute('stroke-width'); +var _elm_lang$svg$Svg_Attributes$strokeOpacity = _elm_lang$virtual_dom$VirtualDom$attribute('stroke-opacity'); +var _elm_lang$svg$Svg_Attributes$strokeMiterlimit = _elm_lang$virtual_dom$VirtualDom$attribute('stroke-miterlimit'); +var _elm_lang$svg$Svg_Attributes$strokeLinejoin = _elm_lang$virtual_dom$VirtualDom$attribute('stroke-linejoin'); +var _elm_lang$svg$Svg_Attributes$strokeLinecap = _elm_lang$virtual_dom$VirtualDom$attribute('stroke-linecap'); +var _elm_lang$svg$Svg_Attributes$strokeDashoffset = _elm_lang$virtual_dom$VirtualDom$attribute('stroke-dashoffset'); +var _elm_lang$svg$Svg_Attributes$strokeDasharray = _elm_lang$virtual_dom$VirtualDom$attribute('stroke-dasharray'); +var _elm_lang$svg$Svg_Attributes$stopOpacity = _elm_lang$virtual_dom$VirtualDom$attribute('stop-opacity'); +var _elm_lang$svg$Svg_Attributes$stopColor = _elm_lang$virtual_dom$VirtualDom$attribute('stop-color'); +var _elm_lang$svg$Svg_Attributes$shapeRendering = _elm_lang$virtual_dom$VirtualDom$attribute('shape-rendering'); +var _elm_lang$svg$Svg_Attributes$pointerEvents = _elm_lang$virtual_dom$VirtualDom$attribute('pointer-events'); +var _elm_lang$svg$Svg_Attributes$overflow = _elm_lang$virtual_dom$VirtualDom$attribute('overflow'); +var _elm_lang$svg$Svg_Attributes$opacity = _elm_lang$virtual_dom$VirtualDom$attribute('opacity'); +var _elm_lang$svg$Svg_Attributes$mask = _elm_lang$virtual_dom$VirtualDom$attribute('mask'); +var _elm_lang$svg$Svg_Attributes$markerStart = _elm_lang$virtual_dom$VirtualDom$attribute('marker-start'); +var _elm_lang$svg$Svg_Attributes$markerMid = _elm_lang$virtual_dom$VirtualDom$attribute('marker-mid'); +var _elm_lang$svg$Svg_Attributes$markerEnd = _elm_lang$virtual_dom$VirtualDom$attribute('marker-end'); +var _elm_lang$svg$Svg_Attributes$lightingColor = _elm_lang$virtual_dom$VirtualDom$attribute('lighting-color'); +var _elm_lang$svg$Svg_Attributes$letterSpacing = _elm_lang$virtual_dom$VirtualDom$attribute('letter-spacing'); +var _elm_lang$svg$Svg_Attributes$kerning = _elm_lang$virtual_dom$VirtualDom$attribute('kerning'); +var _elm_lang$svg$Svg_Attributes$imageRendering = _elm_lang$virtual_dom$VirtualDom$attribute('image-rendering'); +var _elm_lang$svg$Svg_Attributes$glyphOrientationVertical = _elm_lang$virtual_dom$VirtualDom$attribute('glyph-orientation-vertical'); +var _elm_lang$svg$Svg_Attributes$glyphOrientationHorizontal = _elm_lang$virtual_dom$VirtualDom$attribute('glyph-orientation-horizontal'); +var _elm_lang$svg$Svg_Attributes$fontWeight = _elm_lang$virtual_dom$VirtualDom$attribute('font-weight'); +var _elm_lang$svg$Svg_Attributes$fontVariant = _elm_lang$virtual_dom$VirtualDom$attribute('font-variant'); +var _elm_lang$svg$Svg_Attributes$fontStyle = _elm_lang$virtual_dom$VirtualDom$attribute('font-style'); +var _elm_lang$svg$Svg_Attributes$fontStretch = _elm_lang$virtual_dom$VirtualDom$attribute('font-stretch'); +var _elm_lang$svg$Svg_Attributes$fontSize = _elm_lang$virtual_dom$VirtualDom$attribute('font-size'); +var _elm_lang$svg$Svg_Attributes$fontSizeAdjust = _elm_lang$virtual_dom$VirtualDom$attribute('font-size-adjust'); +var _elm_lang$svg$Svg_Attributes$fontFamily = _elm_lang$virtual_dom$VirtualDom$attribute('font-family'); +var _elm_lang$svg$Svg_Attributes$floodOpacity = _elm_lang$virtual_dom$VirtualDom$attribute('flood-opacity'); +var _elm_lang$svg$Svg_Attributes$floodColor = _elm_lang$virtual_dom$VirtualDom$attribute('flood-color'); +var _elm_lang$svg$Svg_Attributes$filter = _elm_lang$virtual_dom$VirtualDom$attribute('filter'); +var _elm_lang$svg$Svg_Attributes$fill = _elm_lang$virtual_dom$VirtualDom$attribute('fill'); +var _elm_lang$svg$Svg_Attributes$fillRule = _elm_lang$virtual_dom$VirtualDom$attribute('fill-rule'); +var _elm_lang$svg$Svg_Attributes$fillOpacity = _elm_lang$virtual_dom$VirtualDom$attribute('fill-opacity'); +var _elm_lang$svg$Svg_Attributes$enableBackground = _elm_lang$virtual_dom$VirtualDom$attribute('enable-background'); +var _elm_lang$svg$Svg_Attributes$dominantBaseline = _elm_lang$virtual_dom$VirtualDom$attribute('dominant-baseline'); +var _elm_lang$svg$Svg_Attributes$display = _elm_lang$virtual_dom$VirtualDom$attribute('display'); +var _elm_lang$svg$Svg_Attributes$direction = _elm_lang$virtual_dom$VirtualDom$attribute('direction'); +var _elm_lang$svg$Svg_Attributes$cursor = _elm_lang$virtual_dom$VirtualDom$attribute('cursor'); +var _elm_lang$svg$Svg_Attributes$color = _elm_lang$virtual_dom$VirtualDom$attribute('color'); +var _elm_lang$svg$Svg_Attributes$colorRendering = _elm_lang$virtual_dom$VirtualDom$attribute('color-rendering'); +var _elm_lang$svg$Svg_Attributes$colorProfile = _elm_lang$virtual_dom$VirtualDom$attribute('color-profile'); +var _elm_lang$svg$Svg_Attributes$colorInterpolation = _elm_lang$virtual_dom$VirtualDom$attribute('color-interpolation'); +var _elm_lang$svg$Svg_Attributes$colorInterpolationFilters = _elm_lang$virtual_dom$VirtualDom$attribute('color-interpolation-filters'); +var _elm_lang$svg$Svg_Attributes$clip = _elm_lang$virtual_dom$VirtualDom$attribute('clip'); +var _elm_lang$svg$Svg_Attributes$clipRule = _elm_lang$virtual_dom$VirtualDom$attribute('clip-rule'); +var _elm_lang$svg$Svg_Attributes$clipPath = _elm_lang$virtual_dom$VirtualDom$attribute('clip-path'); +var _elm_lang$svg$Svg_Attributes$baselineShift = _elm_lang$virtual_dom$VirtualDom$attribute('baseline-shift'); +var _elm_lang$svg$Svg_Attributes$alignmentBaseline = _elm_lang$virtual_dom$VirtualDom$attribute('alignment-baseline'); +var _elm_lang$svg$Svg_Attributes$zoomAndPan = _elm_lang$virtual_dom$VirtualDom$attribute('zoomAndPan'); +var _elm_lang$svg$Svg_Attributes$z = _elm_lang$virtual_dom$VirtualDom$attribute('z'); +var _elm_lang$svg$Svg_Attributes$yChannelSelector = _elm_lang$virtual_dom$VirtualDom$attribute('yChannelSelector'); +var _elm_lang$svg$Svg_Attributes$y2 = _elm_lang$virtual_dom$VirtualDom$attribute('y2'); +var _elm_lang$svg$Svg_Attributes$y1 = _elm_lang$virtual_dom$VirtualDom$attribute('y1'); +var _elm_lang$svg$Svg_Attributes$y = _elm_lang$virtual_dom$VirtualDom$attribute('y'); +var _elm_lang$svg$Svg_Attributes$xmlSpace = A2(_elm_lang$virtual_dom$VirtualDom$attributeNS, 'http://www.w3.org/XML/1998/namespace', 'xml:space'); +var _elm_lang$svg$Svg_Attributes$xmlLang = A2(_elm_lang$virtual_dom$VirtualDom$attributeNS, 'http://www.w3.org/XML/1998/namespace', 'xml:lang'); +var _elm_lang$svg$Svg_Attributes$xmlBase = A2(_elm_lang$virtual_dom$VirtualDom$attributeNS, 'http://www.w3.org/XML/1998/namespace', 'xml:base'); +var _elm_lang$svg$Svg_Attributes$xlinkType = A2(_elm_lang$virtual_dom$VirtualDom$attributeNS, 'http://www.w3.org/1999/xlink', 'xlink:type'); +var _elm_lang$svg$Svg_Attributes$xlinkTitle = A2(_elm_lang$virtual_dom$VirtualDom$attributeNS, 'http://www.w3.org/1999/xlink', 'xlink:title'); +var _elm_lang$svg$Svg_Attributes$xlinkShow = A2(_elm_lang$virtual_dom$VirtualDom$attributeNS, 'http://www.w3.org/1999/xlink', 'xlink:show'); +var _elm_lang$svg$Svg_Attributes$xlinkRole = A2(_elm_lang$virtual_dom$VirtualDom$attributeNS, 'http://www.w3.org/1999/xlink', 'xlink:role'); +var _elm_lang$svg$Svg_Attributes$xlinkHref = A2(_elm_lang$virtual_dom$VirtualDom$attributeNS, 'http://www.w3.org/1999/xlink', 'xlink:href'); +var _elm_lang$svg$Svg_Attributes$xlinkArcrole = A2(_elm_lang$virtual_dom$VirtualDom$attributeNS, 'http://www.w3.org/1999/xlink', 'xlink:arcrole'); +var _elm_lang$svg$Svg_Attributes$xlinkActuate = A2(_elm_lang$virtual_dom$VirtualDom$attributeNS, 'http://www.w3.org/1999/xlink', 'xlink:actuate'); +var _elm_lang$svg$Svg_Attributes$xChannelSelector = _elm_lang$virtual_dom$VirtualDom$attribute('xChannelSelector'); +var _elm_lang$svg$Svg_Attributes$x2 = _elm_lang$virtual_dom$VirtualDom$attribute('x2'); +var _elm_lang$svg$Svg_Attributes$x1 = _elm_lang$virtual_dom$VirtualDom$attribute('x1'); +var _elm_lang$svg$Svg_Attributes$xHeight = _elm_lang$virtual_dom$VirtualDom$attribute('x-height'); +var _elm_lang$svg$Svg_Attributes$x = _elm_lang$virtual_dom$VirtualDom$attribute('x'); +var _elm_lang$svg$Svg_Attributes$widths = _elm_lang$virtual_dom$VirtualDom$attribute('widths'); +var _elm_lang$svg$Svg_Attributes$width = _elm_lang$virtual_dom$VirtualDom$attribute('width'); +var _elm_lang$svg$Svg_Attributes$viewTarget = _elm_lang$virtual_dom$VirtualDom$attribute('viewTarget'); +var _elm_lang$svg$Svg_Attributes$viewBox = _elm_lang$virtual_dom$VirtualDom$attribute('viewBox'); +var _elm_lang$svg$Svg_Attributes$vertOriginY = _elm_lang$virtual_dom$VirtualDom$attribute('vert-origin-y'); +var _elm_lang$svg$Svg_Attributes$vertOriginX = _elm_lang$virtual_dom$VirtualDom$attribute('vert-origin-x'); +var _elm_lang$svg$Svg_Attributes$vertAdvY = _elm_lang$virtual_dom$VirtualDom$attribute('vert-adv-y'); +var _elm_lang$svg$Svg_Attributes$version = _elm_lang$virtual_dom$VirtualDom$attribute('version'); +var _elm_lang$svg$Svg_Attributes$values = _elm_lang$virtual_dom$VirtualDom$attribute('values'); +var _elm_lang$svg$Svg_Attributes$vMathematical = _elm_lang$virtual_dom$VirtualDom$attribute('v-mathematical'); +var _elm_lang$svg$Svg_Attributes$vIdeographic = _elm_lang$virtual_dom$VirtualDom$attribute('v-ideographic'); +var _elm_lang$svg$Svg_Attributes$vHanging = _elm_lang$virtual_dom$VirtualDom$attribute('v-hanging'); +var _elm_lang$svg$Svg_Attributes$vAlphabetic = _elm_lang$virtual_dom$VirtualDom$attribute('v-alphabetic'); +var _elm_lang$svg$Svg_Attributes$unitsPerEm = _elm_lang$virtual_dom$VirtualDom$attribute('units-per-em'); +var _elm_lang$svg$Svg_Attributes$unicodeRange = _elm_lang$virtual_dom$VirtualDom$attribute('unicode-range'); +var _elm_lang$svg$Svg_Attributes$unicode = _elm_lang$virtual_dom$VirtualDom$attribute('unicode'); +var _elm_lang$svg$Svg_Attributes$underlineThickness = _elm_lang$virtual_dom$VirtualDom$attribute('underline-thickness'); +var _elm_lang$svg$Svg_Attributes$underlinePosition = _elm_lang$virtual_dom$VirtualDom$attribute('underline-position'); +var _elm_lang$svg$Svg_Attributes$u2 = _elm_lang$virtual_dom$VirtualDom$attribute('u2'); +var _elm_lang$svg$Svg_Attributes$u1 = _elm_lang$virtual_dom$VirtualDom$attribute('u1'); +var _elm_lang$svg$Svg_Attributes$type$ = _elm_lang$virtual_dom$VirtualDom$attribute('type'); +var _elm_lang$svg$Svg_Attributes$transform = _elm_lang$virtual_dom$VirtualDom$attribute('transform'); +var _elm_lang$svg$Svg_Attributes$to = _elm_lang$virtual_dom$VirtualDom$attribute('to'); +var _elm_lang$svg$Svg_Attributes$title = _elm_lang$virtual_dom$VirtualDom$attribute('title'); +var _elm_lang$svg$Svg_Attributes$textLength = _elm_lang$virtual_dom$VirtualDom$attribute('textLength'); +var _elm_lang$svg$Svg_Attributes$targetY = _elm_lang$virtual_dom$VirtualDom$attribute('targetY'); +var _elm_lang$svg$Svg_Attributes$targetX = _elm_lang$virtual_dom$VirtualDom$attribute('targetX'); +var _elm_lang$svg$Svg_Attributes$target = _elm_lang$virtual_dom$VirtualDom$attribute('target'); +var _elm_lang$svg$Svg_Attributes$tableValues = _elm_lang$virtual_dom$VirtualDom$attribute('tableValues'); +var _elm_lang$svg$Svg_Attributes$systemLanguage = _elm_lang$virtual_dom$VirtualDom$attribute('systemLanguage'); +var _elm_lang$svg$Svg_Attributes$surfaceScale = _elm_lang$virtual_dom$VirtualDom$attribute('surfaceScale'); +var _elm_lang$svg$Svg_Attributes$style = _elm_lang$virtual_dom$VirtualDom$attribute('style'); +var _elm_lang$svg$Svg_Attributes$string = _elm_lang$virtual_dom$VirtualDom$attribute('string'); +var _elm_lang$svg$Svg_Attributes$strikethroughThickness = _elm_lang$virtual_dom$VirtualDom$attribute('strikethrough-thickness'); +var _elm_lang$svg$Svg_Attributes$strikethroughPosition = _elm_lang$virtual_dom$VirtualDom$attribute('strikethrough-position'); +var _elm_lang$svg$Svg_Attributes$stitchTiles = _elm_lang$virtual_dom$VirtualDom$attribute('stitchTiles'); +var _elm_lang$svg$Svg_Attributes$stemv = _elm_lang$virtual_dom$VirtualDom$attribute('stemv'); +var _elm_lang$svg$Svg_Attributes$stemh = _elm_lang$virtual_dom$VirtualDom$attribute('stemh'); +var _elm_lang$svg$Svg_Attributes$stdDeviation = _elm_lang$virtual_dom$VirtualDom$attribute('stdDeviation'); +var _elm_lang$svg$Svg_Attributes$startOffset = _elm_lang$virtual_dom$VirtualDom$attribute('startOffset'); +var _elm_lang$svg$Svg_Attributes$spreadMethod = _elm_lang$virtual_dom$VirtualDom$attribute('spreadMethod'); +var _elm_lang$svg$Svg_Attributes$speed = _elm_lang$virtual_dom$VirtualDom$attribute('speed'); +var _elm_lang$svg$Svg_Attributes$specularExponent = _elm_lang$virtual_dom$VirtualDom$attribute('specularExponent'); +var _elm_lang$svg$Svg_Attributes$specularConstant = _elm_lang$virtual_dom$VirtualDom$attribute('specularConstant'); +var _elm_lang$svg$Svg_Attributes$spacing = _elm_lang$virtual_dom$VirtualDom$attribute('spacing'); +var _elm_lang$svg$Svg_Attributes$slope = _elm_lang$virtual_dom$VirtualDom$attribute('slope'); +var _elm_lang$svg$Svg_Attributes$seed = _elm_lang$virtual_dom$VirtualDom$attribute('seed'); +var _elm_lang$svg$Svg_Attributes$scale = _elm_lang$virtual_dom$VirtualDom$attribute('scale'); +var _elm_lang$svg$Svg_Attributes$ry = _elm_lang$virtual_dom$VirtualDom$attribute('ry'); +var _elm_lang$svg$Svg_Attributes$rx = _elm_lang$virtual_dom$VirtualDom$attribute('rx'); +var _elm_lang$svg$Svg_Attributes$rotate = _elm_lang$virtual_dom$VirtualDom$attribute('rotate'); +var _elm_lang$svg$Svg_Attributes$result = _elm_lang$virtual_dom$VirtualDom$attribute('result'); +var _elm_lang$svg$Svg_Attributes$restart = _elm_lang$virtual_dom$VirtualDom$attribute('restart'); +var _elm_lang$svg$Svg_Attributes$requiredFeatures = _elm_lang$virtual_dom$VirtualDom$attribute('requiredFeatures'); +var _elm_lang$svg$Svg_Attributes$requiredExtensions = _elm_lang$virtual_dom$VirtualDom$attribute('requiredExtensions'); +var _elm_lang$svg$Svg_Attributes$repeatDur = _elm_lang$virtual_dom$VirtualDom$attribute('repeatDur'); +var _elm_lang$svg$Svg_Attributes$repeatCount = _elm_lang$virtual_dom$VirtualDom$attribute('repeatCount'); +var _elm_lang$svg$Svg_Attributes$renderingIntent = _elm_lang$virtual_dom$VirtualDom$attribute('rendering-intent'); +var _elm_lang$svg$Svg_Attributes$refY = _elm_lang$virtual_dom$VirtualDom$attribute('refY'); +var _elm_lang$svg$Svg_Attributes$refX = _elm_lang$virtual_dom$VirtualDom$attribute('refX'); +var _elm_lang$svg$Svg_Attributes$radius = _elm_lang$virtual_dom$VirtualDom$attribute('radius'); +var _elm_lang$svg$Svg_Attributes$r = _elm_lang$virtual_dom$VirtualDom$attribute('r'); +var _elm_lang$svg$Svg_Attributes$primitiveUnits = _elm_lang$virtual_dom$VirtualDom$attribute('primitiveUnits'); +var _elm_lang$svg$Svg_Attributes$preserveAspectRatio = _elm_lang$virtual_dom$VirtualDom$attribute('preserveAspectRatio'); +var _elm_lang$svg$Svg_Attributes$preserveAlpha = _elm_lang$virtual_dom$VirtualDom$attribute('preserveAlpha'); +var _elm_lang$svg$Svg_Attributes$pointsAtZ = _elm_lang$virtual_dom$VirtualDom$attribute('pointsAtZ'); +var _elm_lang$svg$Svg_Attributes$pointsAtY = _elm_lang$virtual_dom$VirtualDom$attribute('pointsAtY'); +var _elm_lang$svg$Svg_Attributes$pointsAtX = _elm_lang$virtual_dom$VirtualDom$attribute('pointsAtX'); +var _elm_lang$svg$Svg_Attributes$points = _elm_lang$virtual_dom$VirtualDom$attribute('points'); +var _elm_lang$svg$Svg_Attributes$pointOrder = _elm_lang$virtual_dom$VirtualDom$attribute('point-order'); +var _elm_lang$svg$Svg_Attributes$patternUnits = _elm_lang$virtual_dom$VirtualDom$attribute('patternUnits'); +var _elm_lang$svg$Svg_Attributes$patternTransform = _elm_lang$virtual_dom$VirtualDom$attribute('patternTransform'); +var _elm_lang$svg$Svg_Attributes$patternContentUnits = _elm_lang$virtual_dom$VirtualDom$attribute('patternContentUnits'); +var _elm_lang$svg$Svg_Attributes$pathLength = _elm_lang$virtual_dom$VirtualDom$attribute('pathLength'); +var _elm_lang$svg$Svg_Attributes$path = _elm_lang$virtual_dom$VirtualDom$attribute('path'); +var _elm_lang$svg$Svg_Attributes$panose1 = _elm_lang$virtual_dom$VirtualDom$attribute('panose-1'); +var _elm_lang$svg$Svg_Attributes$overlineThickness = _elm_lang$virtual_dom$VirtualDom$attribute('overline-thickness'); +var _elm_lang$svg$Svg_Attributes$overlinePosition = _elm_lang$virtual_dom$VirtualDom$attribute('overline-position'); +var _elm_lang$svg$Svg_Attributes$origin = _elm_lang$virtual_dom$VirtualDom$attribute('origin'); +var _elm_lang$svg$Svg_Attributes$orientation = _elm_lang$virtual_dom$VirtualDom$attribute('orientation'); +var _elm_lang$svg$Svg_Attributes$orient = _elm_lang$virtual_dom$VirtualDom$attribute('orient'); +var _elm_lang$svg$Svg_Attributes$order = _elm_lang$virtual_dom$VirtualDom$attribute('order'); +var _elm_lang$svg$Svg_Attributes$operator = _elm_lang$virtual_dom$VirtualDom$attribute('operator'); +var _elm_lang$svg$Svg_Attributes$offset = _elm_lang$virtual_dom$VirtualDom$attribute('offset'); +var _elm_lang$svg$Svg_Attributes$numOctaves = _elm_lang$virtual_dom$VirtualDom$attribute('numOctaves'); +var _elm_lang$svg$Svg_Attributes$name = _elm_lang$virtual_dom$VirtualDom$attribute('name'); +var _elm_lang$svg$Svg_Attributes$mode = _elm_lang$virtual_dom$VirtualDom$attribute('mode'); +var _elm_lang$svg$Svg_Attributes$min = _elm_lang$virtual_dom$VirtualDom$attribute('min'); +var _elm_lang$svg$Svg_Attributes$method = _elm_lang$virtual_dom$VirtualDom$attribute('method'); +var _elm_lang$svg$Svg_Attributes$media = _elm_lang$virtual_dom$VirtualDom$attribute('media'); +var _elm_lang$svg$Svg_Attributes$max = _elm_lang$virtual_dom$VirtualDom$attribute('max'); +var _elm_lang$svg$Svg_Attributes$mathematical = _elm_lang$virtual_dom$VirtualDom$attribute('mathematical'); +var _elm_lang$svg$Svg_Attributes$maskUnits = _elm_lang$virtual_dom$VirtualDom$attribute('maskUnits'); +var _elm_lang$svg$Svg_Attributes$maskContentUnits = _elm_lang$virtual_dom$VirtualDom$attribute('maskContentUnits'); +var _elm_lang$svg$Svg_Attributes$markerWidth = _elm_lang$virtual_dom$VirtualDom$attribute('markerWidth'); +var _elm_lang$svg$Svg_Attributes$markerUnits = _elm_lang$virtual_dom$VirtualDom$attribute('markerUnits'); +var _elm_lang$svg$Svg_Attributes$markerHeight = _elm_lang$virtual_dom$VirtualDom$attribute('markerHeight'); +var _elm_lang$svg$Svg_Attributes$local = _elm_lang$virtual_dom$VirtualDom$attribute('local'); +var _elm_lang$svg$Svg_Attributes$limitingConeAngle = _elm_lang$virtual_dom$VirtualDom$attribute('limitingConeAngle'); +var _elm_lang$svg$Svg_Attributes$lengthAdjust = _elm_lang$virtual_dom$VirtualDom$attribute('lengthAdjust'); +var _elm_lang$svg$Svg_Attributes$lang = _elm_lang$virtual_dom$VirtualDom$attribute('lang'); +var _elm_lang$svg$Svg_Attributes$keyTimes = _elm_lang$virtual_dom$VirtualDom$attribute('keyTimes'); +var _elm_lang$svg$Svg_Attributes$keySplines = _elm_lang$virtual_dom$VirtualDom$attribute('keySplines'); +var _elm_lang$svg$Svg_Attributes$keyPoints = _elm_lang$virtual_dom$VirtualDom$attribute('keyPoints'); +var _elm_lang$svg$Svg_Attributes$kernelUnitLength = _elm_lang$virtual_dom$VirtualDom$attribute('kernelUnitLength'); +var _elm_lang$svg$Svg_Attributes$kernelMatrix = _elm_lang$virtual_dom$VirtualDom$attribute('kernelMatrix'); +var _elm_lang$svg$Svg_Attributes$k4 = _elm_lang$virtual_dom$VirtualDom$attribute('k4'); +var _elm_lang$svg$Svg_Attributes$k3 = _elm_lang$virtual_dom$VirtualDom$attribute('k3'); +var _elm_lang$svg$Svg_Attributes$k2 = _elm_lang$virtual_dom$VirtualDom$attribute('k2'); +var _elm_lang$svg$Svg_Attributes$k1 = _elm_lang$virtual_dom$VirtualDom$attribute('k1'); +var _elm_lang$svg$Svg_Attributes$k = _elm_lang$virtual_dom$VirtualDom$attribute('k'); +var _elm_lang$svg$Svg_Attributes$intercept = _elm_lang$virtual_dom$VirtualDom$attribute('intercept'); +var _elm_lang$svg$Svg_Attributes$in2 = _elm_lang$virtual_dom$VirtualDom$attribute('in2'); +var _elm_lang$svg$Svg_Attributes$in$ = _elm_lang$virtual_dom$VirtualDom$attribute('in'); +var _elm_lang$svg$Svg_Attributes$ideographic = _elm_lang$virtual_dom$VirtualDom$attribute('ideographic'); +var _elm_lang$svg$Svg_Attributes$id = _elm_lang$virtual_dom$VirtualDom$attribute('id'); +var _elm_lang$svg$Svg_Attributes$horizOriginY = _elm_lang$virtual_dom$VirtualDom$attribute('horiz-origin-y'); +var _elm_lang$svg$Svg_Attributes$horizOriginX = _elm_lang$virtual_dom$VirtualDom$attribute('horiz-origin-x'); +var _elm_lang$svg$Svg_Attributes$horizAdvX = _elm_lang$virtual_dom$VirtualDom$attribute('horiz-adv-x'); +var _elm_lang$svg$Svg_Attributes$height = _elm_lang$virtual_dom$VirtualDom$attribute('height'); +var _elm_lang$svg$Svg_Attributes$hanging = _elm_lang$virtual_dom$VirtualDom$attribute('hanging'); +var _elm_lang$svg$Svg_Attributes$gradientUnits = _elm_lang$virtual_dom$VirtualDom$attribute('gradientUnits'); +var _elm_lang$svg$Svg_Attributes$gradientTransform = _elm_lang$virtual_dom$VirtualDom$attribute('gradientTransform'); +var _elm_lang$svg$Svg_Attributes$glyphRef = _elm_lang$virtual_dom$VirtualDom$attribute('glyphRef'); +var _elm_lang$svg$Svg_Attributes$glyphName = _elm_lang$virtual_dom$VirtualDom$attribute('glyph-name'); +var _elm_lang$svg$Svg_Attributes$g2 = _elm_lang$virtual_dom$VirtualDom$attribute('g2'); +var _elm_lang$svg$Svg_Attributes$g1 = _elm_lang$virtual_dom$VirtualDom$attribute('g1'); +var _elm_lang$svg$Svg_Attributes$fy = _elm_lang$virtual_dom$VirtualDom$attribute('fy'); +var _elm_lang$svg$Svg_Attributes$fx = _elm_lang$virtual_dom$VirtualDom$attribute('fx'); +var _elm_lang$svg$Svg_Attributes$from = _elm_lang$virtual_dom$VirtualDom$attribute('from'); +var _elm_lang$svg$Svg_Attributes$format = _elm_lang$virtual_dom$VirtualDom$attribute('format'); +var _elm_lang$svg$Svg_Attributes$filterUnits = _elm_lang$virtual_dom$VirtualDom$attribute('filterUnits'); +var _elm_lang$svg$Svg_Attributes$filterRes = _elm_lang$virtual_dom$VirtualDom$attribute('filterRes'); +var _elm_lang$svg$Svg_Attributes$externalResourcesRequired = _elm_lang$virtual_dom$VirtualDom$attribute('externalResourcesRequired'); +var _elm_lang$svg$Svg_Attributes$exponent = _elm_lang$virtual_dom$VirtualDom$attribute('exponent'); +var _elm_lang$svg$Svg_Attributes$end = _elm_lang$virtual_dom$VirtualDom$attribute('end'); +var _elm_lang$svg$Svg_Attributes$elevation = _elm_lang$virtual_dom$VirtualDom$attribute('elevation'); +var _elm_lang$svg$Svg_Attributes$edgeMode = _elm_lang$virtual_dom$VirtualDom$attribute('edgeMode'); +var _elm_lang$svg$Svg_Attributes$dy = _elm_lang$virtual_dom$VirtualDom$attribute('dy'); +var _elm_lang$svg$Svg_Attributes$dx = _elm_lang$virtual_dom$VirtualDom$attribute('dx'); +var _elm_lang$svg$Svg_Attributes$dur = _elm_lang$virtual_dom$VirtualDom$attribute('dur'); +var _elm_lang$svg$Svg_Attributes$divisor = _elm_lang$virtual_dom$VirtualDom$attribute('divisor'); +var _elm_lang$svg$Svg_Attributes$diffuseConstant = _elm_lang$virtual_dom$VirtualDom$attribute('diffuseConstant'); +var _elm_lang$svg$Svg_Attributes$descent = _elm_lang$virtual_dom$VirtualDom$attribute('descent'); +var _elm_lang$svg$Svg_Attributes$decelerate = _elm_lang$virtual_dom$VirtualDom$attribute('decelerate'); +var _elm_lang$svg$Svg_Attributes$d = _elm_lang$virtual_dom$VirtualDom$attribute('d'); +var _elm_lang$svg$Svg_Attributes$cy = _elm_lang$virtual_dom$VirtualDom$attribute('cy'); +var _elm_lang$svg$Svg_Attributes$cx = _elm_lang$virtual_dom$VirtualDom$attribute('cx'); +var _elm_lang$svg$Svg_Attributes$contentStyleType = _elm_lang$virtual_dom$VirtualDom$attribute('contentStyleType'); +var _elm_lang$svg$Svg_Attributes$contentScriptType = _elm_lang$virtual_dom$VirtualDom$attribute('contentScriptType'); +var _elm_lang$svg$Svg_Attributes$clipPathUnits = _elm_lang$virtual_dom$VirtualDom$attribute('clipPathUnits'); +var _elm_lang$svg$Svg_Attributes$class = _elm_lang$virtual_dom$VirtualDom$attribute('class'); +var _elm_lang$svg$Svg_Attributes$capHeight = _elm_lang$virtual_dom$VirtualDom$attribute('cap-height'); +var _elm_lang$svg$Svg_Attributes$calcMode = _elm_lang$virtual_dom$VirtualDom$attribute('calcMode'); +var _elm_lang$svg$Svg_Attributes$by = _elm_lang$virtual_dom$VirtualDom$attribute('by'); +var _elm_lang$svg$Svg_Attributes$bias = _elm_lang$virtual_dom$VirtualDom$attribute('bias'); +var _elm_lang$svg$Svg_Attributes$begin = _elm_lang$virtual_dom$VirtualDom$attribute('begin'); +var _elm_lang$svg$Svg_Attributes$bbox = _elm_lang$virtual_dom$VirtualDom$attribute('bbox'); +var _elm_lang$svg$Svg_Attributes$baseProfile = _elm_lang$virtual_dom$VirtualDom$attribute('baseProfile'); +var _elm_lang$svg$Svg_Attributes$baseFrequency = _elm_lang$virtual_dom$VirtualDom$attribute('baseFrequency'); +var _elm_lang$svg$Svg_Attributes$azimuth = _elm_lang$virtual_dom$VirtualDom$attribute('azimuth'); +var _elm_lang$svg$Svg_Attributes$autoReverse = _elm_lang$virtual_dom$VirtualDom$attribute('autoReverse'); +var _elm_lang$svg$Svg_Attributes$attributeType = _elm_lang$virtual_dom$VirtualDom$attribute('attributeType'); +var _elm_lang$svg$Svg_Attributes$attributeName = _elm_lang$virtual_dom$VirtualDom$attribute('attributeName'); +var _elm_lang$svg$Svg_Attributes$ascent = _elm_lang$virtual_dom$VirtualDom$attribute('ascent'); +var _elm_lang$svg$Svg_Attributes$arabicForm = _elm_lang$virtual_dom$VirtualDom$attribute('arabic-form'); +var _elm_lang$svg$Svg_Attributes$amplitude = _elm_lang$virtual_dom$VirtualDom$attribute('amplitude'); +var _elm_lang$svg$Svg_Attributes$allowReorder = _elm_lang$virtual_dom$VirtualDom$attribute('allowReorder'); +var _elm_lang$svg$Svg_Attributes$alphabetic = _elm_lang$virtual_dom$VirtualDom$attribute('alphabetic'); +var _elm_lang$svg$Svg_Attributes$additive = _elm_lang$virtual_dom$VirtualDom$attribute('additive'); +var _elm_lang$svg$Svg_Attributes$accumulate = _elm_lang$virtual_dom$VirtualDom$attribute('accumulate'); +var _elm_lang$svg$Svg_Attributes$accelerate = _elm_lang$virtual_dom$VirtualDom$attribute('accelerate'); +var _elm_lang$svg$Svg_Attributes$accentHeight = _elm_lang$virtual_dom$VirtualDom$attribute('accent-height'); + +var _ohanhi$keyboard_extra$Keyboard_Arrows$boolToInt = function (bool) { + return bool ? 1 : 0; +}; +var _ohanhi$keyboard_extra$Keyboard_Arrows$determineArrows = function (keys) { + var toInt = function (key) { + return _ohanhi$keyboard_extra$Keyboard_Arrows$boolToInt( + A2(_elm_lang$core$Set$member, key, keys)); + }; + var x = toInt(39) - toInt(37); + var y = toInt(38) - toInt(40); + return {x: x, y: y}; +}; +var _ohanhi$keyboard_extra$Keyboard_Arrows$determineWasd = function (keys) { + var toInt = function (key) { + return _ohanhi$keyboard_extra$Keyboard_Arrows$boolToInt( + A2(_elm_lang$core$Set$member, key, keys)); + }; + var x = toInt(68) - toInt(65); + var y = toInt(87) - toInt(83); + return {x: x, y: y}; +}; +var _ohanhi$keyboard_extra$Keyboard_Arrows$init = {x: 0, y: 0}; +var _ohanhi$keyboard_extra$Keyboard_Arrows$Arrows = F2( + function (a, b) { + return {x: a, y: b}; + }); + +var _ohanhi$keyboard_extra$Keyboard_Extra$wasd = function (model) { + return _ohanhi$keyboard_extra$Keyboard_Arrows$determineWasd(model.keysDown); +}; +var _ohanhi$keyboard_extra$Keyboard_Extra$arrows = function (model) { + return _ohanhi$keyboard_extra$Keyboard_Arrows$determineArrows(model.keysDown); +}; +var _ohanhi$keyboard_extra$Keyboard_Extra$update = F2( + function (msg, model) { + var _p0 = msg; + if (_p0.ctor === 'Down') { + var keysDown = A2(_elm_lang$core$Set$insert, _p0._0, model.keysDown); + return A2( + _elm_lang$core$Platform_Cmd_ops['!'], + _elm_lang$core$Native_Utils.update( + model, + {keysDown: keysDown}), + _elm_lang$core$Native_List.fromArray( + [])); + } else { + var keysDown = A2(_elm_lang$core$Set$remove, _p0._0, model.keysDown); + return A2( + _elm_lang$core$Platform_Cmd_ops['!'], + _elm_lang$core$Native_Utils.update( + model, + {keysDown: keysDown}), + _elm_lang$core$Native_List.fromArray( + [])); + } + }); +var _ohanhi$keyboard_extra$Keyboard_Extra$Model = function (a) { + return {keysDown: a}; +}; +var _ohanhi$keyboard_extra$Keyboard_Extra$init = { + ctor: '_Tuple2', + _0: _ohanhi$keyboard_extra$Keyboard_Extra$Model(_elm_lang$core$Set$empty), + _1: _elm_lang$core$Platform_Cmd$none +}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Up = function (a) { + return {ctor: 'Up', _0: a}; +}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Down = function (a) { + return {ctor: 'Down', _0: a}; +}; +var _ohanhi$keyboard_extra$Keyboard_Extra$subscriptions = _elm_lang$core$Platform_Sub$batch( + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$keyboard$Keyboard$downs(_ohanhi$keyboard_extra$Keyboard_Extra$Down), + _elm_lang$keyboard$Keyboard$ups(_ohanhi$keyboard_extra$Keyboard_Extra$Up) + ])); +var _ohanhi$keyboard_extra$Keyboard_Extra$NoDirection = {ctor: 'NoDirection'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$NorthWest = {ctor: 'NorthWest'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$West = {ctor: 'West'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$SouthWest = {ctor: 'SouthWest'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$South = {ctor: 'South'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$SouthEast = {ctor: 'SouthEast'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$East = {ctor: 'East'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$NorthEast = {ctor: 'NorthEast'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$North = {ctor: 'North'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$arrowsToDir = function (_p1) { + var _p2 = _p1; + var _p3 = {ctor: '_Tuple2', _0: _p2.x, _1: _p2.y}; + _v2_8: + do { + if (_p3.ctor === '_Tuple2') { + switch (_p3._0) { + case 1: + switch (_p3._1) { + case 1: + return _ohanhi$keyboard_extra$Keyboard_Extra$NorthEast; + case 0: + return _ohanhi$keyboard_extra$Keyboard_Extra$East; + case -1: + return _ohanhi$keyboard_extra$Keyboard_Extra$SouthEast; + default: + break _v2_8; + } + case 0: + switch (_p3._1) { + case 1: + return _ohanhi$keyboard_extra$Keyboard_Extra$North; + case -1: + return _ohanhi$keyboard_extra$Keyboard_Extra$South; + default: + break _v2_8; + } + case -1: + switch (_p3._1) { + case -1: + return _ohanhi$keyboard_extra$Keyboard_Extra$SouthWest; + case 0: + return _ohanhi$keyboard_extra$Keyboard_Extra$West; + case 1: + return _ohanhi$keyboard_extra$Keyboard_Extra$NorthWest; + default: + break _v2_8; + } + default: + break _v2_8; + } + } else { + break _v2_8; + } + } while(false); + return _ohanhi$keyboard_extra$Keyboard_Extra$NoDirection; +}; +var _ohanhi$keyboard_extra$Keyboard_Extra$arrowsDirection = function (_p4) { + return _ohanhi$keyboard_extra$Keyboard_Extra$arrowsToDir( + _ohanhi$keyboard_extra$Keyboard_Extra$arrows(_p4)); +}; +var _ohanhi$keyboard_extra$Keyboard_Extra$wasdDirection = function (_p5) { + return _ohanhi$keyboard_extra$Keyboard_Extra$arrowsToDir( + _ohanhi$keyboard_extra$Keyboard_Extra$wasd(_p5)); +}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Other = {ctor: 'Other'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Altgr = {ctor: 'Altgr'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Meta = {ctor: 'Meta'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Quote = {ctor: 'Quote'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CloseBracket = {ctor: 'CloseBracket'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$BackSlash = {ctor: 'BackSlash'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$OpenBracket = {ctor: 'OpenBracket'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$BackQuote = {ctor: 'BackQuote'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Slash = {ctor: 'Slash'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Period = {ctor: 'Period'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Minus = {ctor: 'Minus'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Comma = {ctor: 'Comma'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$VolumeUp = {ctor: 'VolumeUp'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$VolumeDown = {ctor: 'VolumeDown'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$VolumeMute = {ctor: 'VolumeMute'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Tilde = {ctor: 'Tilde'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CloseCurlyBracket = {ctor: 'CloseCurlyBracket'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$OpenCurlyBracket = {ctor: 'OpenCurlyBracket'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$HyphenMinus = {ctor: 'HyphenMinus'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Pipe = {ctor: 'Pipe'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Plus = {ctor: 'Plus'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Asterisk = {ctor: 'Asterisk'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CloseParen = {ctor: 'CloseParen'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$OpenParen = {ctor: 'OpenParen'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Underscore = {ctor: 'Underscore'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Ampersand = {ctor: 'Ampersand'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Percent = {ctor: 'Percent'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Dollar = {ctor: 'Dollar'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Hash = {ctor: 'Hash'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$DoubleQuote = {ctor: 'DoubleQuote'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Exclamation = {ctor: 'Exclamation'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Circumflex = {ctor: 'Circumflex'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$ScrollLock = {ctor: 'ScrollLock'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$NumLock = {ctor: 'NumLock'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F24 = {ctor: 'F24'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F23 = {ctor: 'F23'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F22 = {ctor: 'F22'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F21 = {ctor: 'F21'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F20 = {ctor: 'F20'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F19 = {ctor: 'F19'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F18 = {ctor: 'F18'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F17 = {ctor: 'F17'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F16 = {ctor: 'F16'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F15 = {ctor: 'F15'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F14 = {ctor: 'F14'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F13 = {ctor: 'F13'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F12 = {ctor: 'F12'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F11 = {ctor: 'F11'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F10 = {ctor: 'F10'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F9 = {ctor: 'F9'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F8 = {ctor: 'F8'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F7 = {ctor: 'F7'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F6 = {ctor: 'F6'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F5 = {ctor: 'F5'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F4 = {ctor: 'F4'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F3 = {ctor: 'F3'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F2 = {ctor: 'F2'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$F1 = {ctor: 'F1'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Divide = {ctor: 'Divide'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Decimal = {ctor: 'Decimal'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Subtract = {ctor: 'Subtract'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Separator = {ctor: 'Separator'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Add = {ctor: 'Add'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Multiply = {ctor: 'Multiply'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Numpad9 = {ctor: 'Numpad9'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Numpad8 = {ctor: 'Numpad8'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Numpad7 = {ctor: 'Numpad7'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Numpad6 = {ctor: 'Numpad6'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Numpad5 = {ctor: 'Numpad5'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Numpad4 = {ctor: 'Numpad4'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Numpad3 = {ctor: 'Numpad3'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Numpad2 = {ctor: 'Numpad2'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Numpad1 = {ctor: 'Numpad1'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Numpad0 = {ctor: 'Numpad0'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Sleep = {ctor: 'Sleep'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$ContextMenu = {ctor: 'ContextMenu'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Super = {ctor: 'Super'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharZ = {ctor: 'CharZ'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharY = {ctor: 'CharY'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharX = {ctor: 'CharX'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharW = {ctor: 'CharW'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharV = {ctor: 'CharV'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharU = {ctor: 'CharU'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharT = {ctor: 'CharT'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharS = {ctor: 'CharS'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharR = {ctor: 'CharR'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharQ = {ctor: 'CharQ'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharP = {ctor: 'CharP'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharO = {ctor: 'CharO'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharN = {ctor: 'CharN'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharM = {ctor: 'CharM'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharL = {ctor: 'CharL'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharK = {ctor: 'CharK'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharJ = {ctor: 'CharJ'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharI = {ctor: 'CharI'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharH = {ctor: 'CharH'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharG = {ctor: 'CharG'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharF = {ctor: 'CharF'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharE = {ctor: 'CharE'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharD = {ctor: 'CharD'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharC = {ctor: 'CharC'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharB = {ctor: 'CharB'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CharA = {ctor: 'CharA'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$At = {ctor: 'At'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$QuestionMark = {ctor: 'QuestionMark'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$GreaterThan = {ctor: 'GreaterThan'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Equals = {ctor: 'Equals'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$LessThan = {ctor: 'LessThan'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Semicolon = {ctor: 'Semicolon'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Colon = {ctor: 'Colon'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Number9 = {ctor: 'Number9'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Number8 = {ctor: 'Number8'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Number7 = {ctor: 'Number7'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Number6 = {ctor: 'Number6'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Number5 = {ctor: 'Number5'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Number4 = {ctor: 'Number4'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Number3 = {ctor: 'Number3'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Number2 = {ctor: 'Number2'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Number1 = {ctor: 'Number1'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Number0 = {ctor: 'Number0'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Delete = {ctor: 'Delete'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Insert = {ctor: 'Insert'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$PrintScreen = {ctor: 'PrintScreen'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Execute = {ctor: 'Execute'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Print = {ctor: 'Print'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Select = {ctor: 'Select'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$ArrowDown = {ctor: 'ArrowDown'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$ArrowRight = {ctor: 'ArrowRight'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$ArrowUp = {ctor: 'ArrowUp'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$ArrowLeft = {ctor: 'ArrowLeft'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Home = {ctor: 'Home'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$End = {ctor: 'End'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$PageDown = {ctor: 'PageDown'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$PageUp = {ctor: 'PageUp'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Space = {ctor: 'Space'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$ModeChange = {ctor: 'ModeChange'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Accept = {ctor: 'Accept'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$NonConvert = {ctor: 'NonConvert'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Convert = {ctor: 'Convert'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Escape = {ctor: 'Escape'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$CapsLock = {ctor: 'CapsLock'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Pause = {ctor: 'Pause'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Alt = {ctor: 'Alt'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Control = {ctor: 'Control'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Shift = {ctor: 'Shift'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Enter = {ctor: 'Enter'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Clear = {ctor: 'Clear'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Tab = {ctor: 'Tab'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$BackSpace = {ctor: 'BackSpace'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Help = {ctor: 'Help'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$Cancel = {ctor: 'Cancel'}; +var _ohanhi$keyboard_extra$Keyboard_Extra$codeBook = _elm_lang$core$Native_List.fromArray( + [ + {ctor: '_Tuple2', _0: 3, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Cancel}, + {ctor: '_Tuple2', _0: 6, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Help}, + {ctor: '_Tuple2', _0: 8, _1: _ohanhi$keyboard_extra$Keyboard_Extra$BackSpace}, + {ctor: '_Tuple2', _0: 9, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Tab}, + {ctor: '_Tuple2', _0: 12, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Clear}, + {ctor: '_Tuple2', _0: 13, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Enter}, + {ctor: '_Tuple2', _0: 16, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Shift}, + {ctor: '_Tuple2', _0: 17, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Control}, + {ctor: '_Tuple2', _0: 18, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Alt}, + {ctor: '_Tuple2', _0: 19, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Pause}, + {ctor: '_Tuple2', _0: 20, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CapsLock}, + {ctor: '_Tuple2', _0: 27, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Escape}, + {ctor: '_Tuple2', _0: 28, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Convert}, + {ctor: '_Tuple2', _0: 29, _1: _ohanhi$keyboard_extra$Keyboard_Extra$NonConvert}, + {ctor: '_Tuple2', _0: 30, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Accept}, + {ctor: '_Tuple2', _0: 31, _1: _ohanhi$keyboard_extra$Keyboard_Extra$ModeChange}, + {ctor: '_Tuple2', _0: 32, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Space}, + {ctor: '_Tuple2', _0: 33, _1: _ohanhi$keyboard_extra$Keyboard_Extra$PageUp}, + {ctor: '_Tuple2', _0: 34, _1: _ohanhi$keyboard_extra$Keyboard_Extra$PageDown}, + {ctor: '_Tuple2', _0: 35, _1: _ohanhi$keyboard_extra$Keyboard_Extra$End}, + {ctor: '_Tuple2', _0: 36, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Home}, + {ctor: '_Tuple2', _0: 37, _1: _ohanhi$keyboard_extra$Keyboard_Extra$ArrowLeft}, + {ctor: '_Tuple2', _0: 38, _1: _ohanhi$keyboard_extra$Keyboard_Extra$ArrowUp}, + {ctor: '_Tuple2', _0: 39, _1: _ohanhi$keyboard_extra$Keyboard_Extra$ArrowRight}, + {ctor: '_Tuple2', _0: 40, _1: _ohanhi$keyboard_extra$Keyboard_Extra$ArrowDown}, + {ctor: '_Tuple2', _0: 41, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Select}, + {ctor: '_Tuple2', _0: 42, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Print}, + {ctor: '_Tuple2', _0: 43, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Execute}, + {ctor: '_Tuple2', _0: 44, _1: _ohanhi$keyboard_extra$Keyboard_Extra$PrintScreen}, + {ctor: '_Tuple2', _0: 45, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Insert}, + {ctor: '_Tuple2', _0: 46, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Delete}, + {ctor: '_Tuple2', _0: 48, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Number0}, + {ctor: '_Tuple2', _0: 49, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Number1}, + {ctor: '_Tuple2', _0: 50, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Number2}, + {ctor: '_Tuple2', _0: 51, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Number3}, + {ctor: '_Tuple2', _0: 52, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Number4}, + {ctor: '_Tuple2', _0: 53, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Number5}, + {ctor: '_Tuple2', _0: 54, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Number6}, + {ctor: '_Tuple2', _0: 55, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Number7}, + {ctor: '_Tuple2', _0: 56, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Number8}, + {ctor: '_Tuple2', _0: 57, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Number9}, + {ctor: '_Tuple2', _0: 58, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Colon}, + {ctor: '_Tuple2', _0: 59, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Semicolon}, + {ctor: '_Tuple2', _0: 60, _1: _ohanhi$keyboard_extra$Keyboard_Extra$LessThan}, + {ctor: '_Tuple2', _0: 61, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Equals}, + {ctor: '_Tuple2', _0: 62, _1: _ohanhi$keyboard_extra$Keyboard_Extra$GreaterThan}, + {ctor: '_Tuple2', _0: 63, _1: _ohanhi$keyboard_extra$Keyboard_Extra$QuestionMark}, + {ctor: '_Tuple2', _0: 64, _1: _ohanhi$keyboard_extra$Keyboard_Extra$At}, + {ctor: '_Tuple2', _0: 65, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharA}, + {ctor: '_Tuple2', _0: 66, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharB}, + {ctor: '_Tuple2', _0: 67, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharC}, + {ctor: '_Tuple2', _0: 68, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharD}, + {ctor: '_Tuple2', _0: 69, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharE}, + {ctor: '_Tuple2', _0: 70, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharF}, + {ctor: '_Tuple2', _0: 71, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharG}, + {ctor: '_Tuple2', _0: 72, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharH}, + {ctor: '_Tuple2', _0: 73, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharI}, + {ctor: '_Tuple2', _0: 74, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharJ}, + {ctor: '_Tuple2', _0: 75, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharK}, + {ctor: '_Tuple2', _0: 76, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharL}, + {ctor: '_Tuple2', _0: 77, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharM}, + {ctor: '_Tuple2', _0: 78, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharN}, + {ctor: '_Tuple2', _0: 79, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharO}, + {ctor: '_Tuple2', _0: 80, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharP}, + {ctor: '_Tuple2', _0: 81, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharQ}, + {ctor: '_Tuple2', _0: 82, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharR}, + {ctor: '_Tuple2', _0: 83, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharS}, + {ctor: '_Tuple2', _0: 84, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharT}, + {ctor: '_Tuple2', _0: 85, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharU}, + {ctor: '_Tuple2', _0: 86, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharV}, + {ctor: '_Tuple2', _0: 87, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharW}, + {ctor: '_Tuple2', _0: 88, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharX}, + {ctor: '_Tuple2', _0: 89, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharY}, + {ctor: '_Tuple2', _0: 90, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CharZ}, + {ctor: '_Tuple2', _0: 91, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Super}, + {ctor: '_Tuple2', _0: 93, _1: _ohanhi$keyboard_extra$Keyboard_Extra$ContextMenu}, + {ctor: '_Tuple2', _0: 95, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Sleep}, + {ctor: '_Tuple2', _0: 96, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Numpad0}, + {ctor: '_Tuple2', _0: 97, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Numpad1}, + {ctor: '_Tuple2', _0: 98, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Numpad2}, + {ctor: '_Tuple2', _0: 99, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Numpad3}, + {ctor: '_Tuple2', _0: 100, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Numpad4}, + {ctor: '_Tuple2', _0: 101, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Numpad5}, + {ctor: '_Tuple2', _0: 102, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Numpad6}, + {ctor: '_Tuple2', _0: 103, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Numpad7}, + {ctor: '_Tuple2', _0: 104, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Numpad8}, + {ctor: '_Tuple2', _0: 105, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Numpad9}, + {ctor: '_Tuple2', _0: 106, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Multiply}, + {ctor: '_Tuple2', _0: 107, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Add}, + {ctor: '_Tuple2', _0: 108, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Separator}, + {ctor: '_Tuple2', _0: 109, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Subtract}, + {ctor: '_Tuple2', _0: 110, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Decimal}, + {ctor: '_Tuple2', _0: 111, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Divide}, + {ctor: '_Tuple2', _0: 112, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F1}, + {ctor: '_Tuple2', _0: 113, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F2}, + {ctor: '_Tuple2', _0: 114, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F3}, + {ctor: '_Tuple2', _0: 115, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F4}, + {ctor: '_Tuple2', _0: 116, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F5}, + {ctor: '_Tuple2', _0: 117, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F6}, + {ctor: '_Tuple2', _0: 118, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F7}, + {ctor: '_Tuple2', _0: 119, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F8}, + {ctor: '_Tuple2', _0: 120, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F9}, + {ctor: '_Tuple2', _0: 121, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F10}, + {ctor: '_Tuple2', _0: 122, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F11}, + {ctor: '_Tuple2', _0: 123, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F12}, + {ctor: '_Tuple2', _0: 124, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F13}, + {ctor: '_Tuple2', _0: 125, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F14}, + {ctor: '_Tuple2', _0: 126, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F15}, + {ctor: '_Tuple2', _0: 127, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F16}, + {ctor: '_Tuple2', _0: 128, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F17}, + {ctor: '_Tuple2', _0: 129, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F18}, + {ctor: '_Tuple2', _0: 130, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F19}, + {ctor: '_Tuple2', _0: 131, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F20}, + {ctor: '_Tuple2', _0: 132, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F21}, + {ctor: '_Tuple2', _0: 133, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F22}, + {ctor: '_Tuple2', _0: 134, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F23}, + {ctor: '_Tuple2', _0: 135, _1: _ohanhi$keyboard_extra$Keyboard_Extra$F24}, + {ctor: '_Tuple2', _0: 144, _1: _ohanhi$keyboard_extra$Keyboard_Extra$NumLock}, + {ctor: '_Tuple2', _0: 145, _1: _ohanhi$keyboard_extra$Keyboard_Extra$ScrollLock}, + {ctor: '_Tuple2', _0: 160, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Circumflex}, + {ctor: '_Tuple2', _0: 161, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Exclamation}, + {ctor: '_Tuple2', _0: 162, _1: _ohanhi$keyboard_extra$Keyboard_Extra$DoubleQuote}, + {ctor: '_Tuple2', _0: 163, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Hash}, + {ctor: '_Tuple2', _0: 164, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Dollar}, + {ctor: '_Tuple2', _0: 165, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Percent}, + {ctor: '_Tuple2', _0: 166, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Ampersand}, + {ctor: '_Tuple2', _0: 167, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Underscore}, + {ctor: '_Tuple2', _0: 168, _1: _ohanhi$keyboard_extra$Keyboard_Extra$OpenParen}, + {ctor: '_Tuple2', _0: 169, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CloseParen}, + {ctor: '_Tuple2', _0: 170, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Asterisk}, + {ctor: '_Tuple2', _0: 171, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Plus}, + {ctor: '_Tuple2', _0: 172, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Pipe}, + {ctor: '_Tuple2', _0: 173, _1: _ohanhi$keyboard_extra$Keyboard_Extra$HyphenMinus}, + {ctor: '_Tuple2', _0: 174, _1: _ohanhi$keyboard_extra$Keyboard_Extra$OpenCurlyBracket}, + {ctor: '_Tuple2', _0: 175, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CloseCurlyBracket}, + {ctor: '_Tuple2', _0: 176, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Tilde}, + {ctor: '_Tuple2', _0: 181, _1: _ohanhi$keyboard_extra$Keyboard_Extra$VolumeMute}, + {ctor: '_Tuple2', _0: 182, _1: _ohanhi$keyboard_extra$Keyboard_Extra$VolumeDown}, + {ctor: '_Tuple2', _0: 183, _1: _ohanhi$keyboard_extra$Keyboard_Extra$VolumeUp}, + {ctor: '_Tuple2', _0: 186, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Semicolon}, + {ctor: '_Tuple2', _0: 187, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Equals}, + {ctor: '_Tuple2', _0: 188, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Comma}, + {ctor: '_Tuple2', _0: 189, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Minus}, + {ctor: '_Tuple2', _0: 190, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Period}, + {ctor: '_Tuple2', _0: 191, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Slash}, + {ctor: '_Tuple2', _0: 192, _1: _ohanhi$keyboard_extra$Keyboard_Extra$BackQuote}, + {ctor: '_Tuple2', _0: 219, _1: _ohanhi$keyboard_extra$Keyboard_Extra$OpenBracket}, + {ctor: '_Tuple2', _0: 220, _1: _ohanhi$keyboard_extra$Keyboard_Extra$BackSlash}, + {ctor: '_Tuple2', _0: 221, _1: _ohanhi$keyboard_extra$Keyboard_Extra$CloseBracket}, + {ctor: '_Tuple2', _0: 222, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Quote}, + {ctor: '_Tuple2', _0: 224, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Meta}, + {ctor: '_Tuple2', _0: 225, _1: _ohanhi$keyboard_extra$Keyboard_Extra$Altgr} + ]); +var _ohanhi$keyboard_extra$Keyboard_Extra$toCode = function (key) { + return A2( + _elm_lang$core$Maybe$withDefault, + 0, + _elm_lang$core$List$head( + A2( + _elm_lang$core$List$map, + _elm_lang$core$Basics$fst, + A2( + _elm_lang$core$List$filter, + function (_p6) { + return A2( + F2( + function (x, y) { + return _elm_lang$core$Native_Utils.eq(x, y); + }), + key, + _elm_lang$core$Basics$snd(_p6)); + }, + _ohanhi$keyboard_extra$Keyboard_Extra$codeBook)))); +}; +var _ohanhi$keyboard_extra$Keyboard_Extra$isPressed = F2( + function (key, model) { + return A2( + _elm_lang$core$Set$member, + _ohanhi$keyboard_extra$Keyboard_Extra$toCode(key), + model.keysDown); + }); +var _ohanhi$keyboard_extra$Keyboard_Extra$codeDict = _elm_lang$core$Dict$fromList(_ohanhi$keyboard_extra$Keyboard_Extra$codeBook); +var _ohanhi$keyboard_extra$Keyboard_Extra$fromCode = function (code) { + return A2( + _elm_lang$core$Maybe$withDefault, + _ohanhi$keyboard_extra$Keyboard_Extra$Other, + A2(_elm_lang$core$Dict$get, code, _ohanhi$keyboard_extra$Keyboard_Extra$codeDict)); +}; +var _ohanhi$keyboard_extra$Keyboard_Extra$pressedDown = function (model) { + return A2( + _elm_lang$core$List$map, + _ohanhi$keyboard_extra$Keyboard_Extra$fromCode, + _elm_lang$core$Set$toList(model.keysDown)); +}; + +var _mgold$elm_random_pcg$Random_Pcg$toJson = function (_p0) { + var _p1 = _p0; + return _elm_lang$core$Json_Encode$list( + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$core$Json_Encode$int(_p1._0), + _elm_lang$core$Json_Encode$int(_p1._1) + ])); +}; +var _mgold$elm_random_pcg$Random_Pcg$mul32 = F2( + function (a, b) { + var bl = A2(_elm_lang$core$Bitwise$and, b, 65535); + var bh = A2( + _elm_lang$core$Bitwise$and, + A2(_elm_lang$core$Bitwise$shiftRightLogical, b, 16), + 65535); + var al = A2(_elm_lang$core$Bitwise$and, a, 65535); + var ah = A2( + _elm_lang$core$Bitwise$and, + A2(_elm_lang$core$Bitwise$shiftRightLogical, a, 16), + 65535); + return A2( + _elm_lang$core$Bitwise$or, + 0, + (al * bl) + A2( + _elm_lang$core$Bitwise$shiftRightLogical, + A2(_elm_lang$core$Bitwise$shiftLeft, (ah * bl) + (al * bh), 16), + 0)); + }); +var _mgold$elm_random_pcg$Random_Pcg$listHelp = F4( + function (list, n, generate, seed) { + listHelp: + while (true) { + if (_elm_lang$core$Native_Utils.cmp(n, 1) < 0) { + return {ctor: '_Tuple2', _0: list, _1: seed}; + } else { + var _p2 = generate(seed); + var value = _p2._0; + var newSeed = _p2._1; + var _v1 = A2(_elm_lang$core$List_ops['::'], value, list), + _v2 = n - 1, + _v3 = generate, + _v4 = newSeed; + list = _v1; + n = _v2; + generate = _v3; + seed = _v4; + continue listHelp; + } + } + }); +var _mgold$elm_random_pcg$Random_Pcg$minInt = -2147483648; +var _mgold$elm_random_pcg$Random_Pcg$maxInt = 2147483647; +var _mgold$elm_random_pcg$Random_Pcg$bit27 = 1.34217728e8; +var _mgold$elm_random_pcg$Random_Pcg$bit53 = 9.007199254740992e15; +var _mgold$elm_random_pcg$Random_Pcg$peel = function (_p3) { + var _p4 = _p3; + var _p5 = _p4._0; + var word = A2( + _elm_lang$core$Bitwise$xor, + A2( + _elm_lang$core$Bitwise$shiftRightLogical, + _p5, + A2(_elm_lang$core$Bitwise$shiftRightLogical, _p5, 28) + 4), + _p5) * 277803737; + return A2( + _elm_lang$core$Bitwise$shiftRightLogical, + A2( + _elm_lang$core$Bitwise$xor, + A2(_elm_lang$core$Bitwise$shiftRightLogical, word, 22), + word), + 0); +}; +var _mgold$elm_random_pcg$Random_Pcg$never = function (a) { + never: + while (true) { + var _v6 = a; + a = _v6; + continue never; + } +}; +var _mgold$elm_random_pcg$Random_Pcg$step = F2( + function (_p6, seed) { + var _p7 = _p6; + return _p7._0(seed); + }); +var _mgold$elm_random_pcg$Random_Pcg$retry = F3( + function (generator, predicate, seed) { + retry: + while (true) { + var _p8 = A2(_mgold$elm_random_pcg$Random_Pcg$step, generator, seed); + var candidate = _p8._0; + var newSeed = _p8._1; + if (predicate(candidate)) { + return {ctor: '_Tuple2', _0: candidate, _1: newSeed}; + } else { + var _v8 = generator, + _v9 = predicate, + _v10 = newSeed; + generator = _v8; + predicate = _v9; + seed = _v10; + continue retry; + } + } + }); +var _mgold$elm_random_pcg$Random_Pcg$Generator = function (a) { + return {ctor: 'Generator', _0: a}; +}; +var _mgold$elm_random_pcg$Random_Pcg$list = F2( + function (n, _p9) { + var _p10 = _p9; + return _mgold$elm_random_pcg$Random_Pcg$Generator( + function (seed) { + return A4( + _mgold$elm_random_pcg$Random_Pcg$listHelp, + _elm_lang$core$Native_List.fromArray( + []), + n, + _p10._0, + seed); + }); + }); +var _mgold$elm_random_pcg$Random_Pcg$constant = function (value) { + return _mgold$elm_random_pcg$Random_Pcg$Generator( + function (seed) { + return {ctor: '_Tuple2', _0: value, _1: seed}; + }); +}; +var _mgold$elm_random_pcg$Random_Pcg$map = F2( + function (func, _p11) { + var _p12 = _p11; + return _mgold$elm_random_pcg$Random_Pcg$Generator( + function (seed0) { + var _p13 = _p12._0(seed0); + var a = _p13._0; + var seed1 = _p13._1; + return { + ctor: '_Tuple2', + _0: func(a), + _1: seed1 + }; + }); + }); +var _mgold$elm_random_pcg$Random_Pcg$map2 = F3( + function (func, _p15, _p14) { + var _p16 = _p15; + var _p17 = _p14; + return _mgold$elm_random_pcg$Random_Pcg$Generator( + function (seed0) { + var _p18 = _p16._0(seed0); + var a = _p18._0; + var seed1 = _p18._1; + var _p19 = _p17._0(seed1); + var b = _p19._0; + var seed2 = _p19._1; + return { + ctor: '_Tuple2', + _0: A2(func, a, b), + _1: seed2 + }; + }); + }); +var _mgold$elm_random_pcg$Random_Pcg$pair = F2( + function (genA, genB) { + return A3( + _mgold$elm_random_pcg$Random_Pcg$map2, + F2( + function (v0, v1) { + return {ctor: '_Tuple2', _0: v0, _1: v1}; + }), + genA, + genB); + }); +var _mgold$elm_random_pcg$Random_Pcg$andMap = _mgold$elm_random_pcg$Random_Pcg$map2( + F2( + function (x, y) { + return x(y); + })); +var _mgold$elm_random_pcg$Random_Pcg$map3 = F4( + function (func, _p22, _p21, _p20) { + var _p23 = _p22; + var _p24 = _p21; + var _p25 = _p20; + return _mgold$elm_random_pcg$Random_Pcg$Generator( + function (seed0) { + var _p26 = _p23._0(seed0); + var a = _p26._0; + var seed1 = _p26._1; + var _p27 = _p24._0(seed1); + var b = _p27._0; + var seed2 = _p27._1; + var _p28 = _p25._0(seed2); + var c = _p28._0; + var seed3 = _p28._1; + return { + ctor: '_Tuple2', + _0: A3(func, a, b, c), + _1: seed3 + }; + }); + }); +var _mgold$elm_random_pcg$Random_Pcg$map4 = F5( + function (func, _p32, _p31, _p30, _p29) { + var _p33 = _p32; + var _p34 = _p31; + var _p35 = _p30; + var _p36 = _p29; + return _mgold$elm_random_pcg$Random_Pcg$Generator( + function (seed0) { + var _p37 = _p33._0(seed0); + var a = _p37._0; + var seed1 = _p37._1; + var _p38 = _p34._0(seed1); + var b = _p38._0; + var seed2 = _p38._1; + var _p39 = _p35._0(seed2); + var c = _p39._0; + var seed3 = _p39._1; + var _p40 = _p36._0(seed3); + var d = _p40._0; + var seed4 = _p40._1; + return { + ctor: '_Tuple2', + _0: A4(func, a, b, c, d), + _1: seed4 + }; + }); + }); +var _mgold$elm_random_pcg$Random_Pcg$map5 = F6( + function (func, _p45, _p44, _p43, _p42, _p41) { + var _p46 = _p45; + var _p47 = _p44; + var _p48 = _p43; + var _p49 = _p42; + var _p50 = _p41; + return _mgold$elm_random_pcg$Random_Pcg$Generator( + function (seed0) { + var _p51 = _p46._0(seed0); + var a = _p51._0; + var seed1 = _p51._1; + var _p52 = _p47._0(seed1); + var b = _p52._0; + var seed2 = _p52._1; + var _p53 = _p48._0(seed2); + var c = _p53._0; + var seed3 = _p53._1; + var _p54 = _p49._0(seed3); + var d = _p54._0; + var seed4 = _p54._1; + var _p55 = _p50._0(seed4); + var e = _p55._0; + var seed5 = _p55._1; + return { + ctor: '_Tuple2', + _0: A5(func, a, b, c, d, e), + _1: seed5 + }; + }); + }); +var _mgold$elm_random_pcg$Random_Pcg$andThen = F2( + function (_p56, callback) { + var _p57 = _p56; + return _mgold$elm_random_pcg$Random_Pcg$Generator( + function (seed) { + var _p58 = _p57._0(seed); + var result = _p58._0; + var newSeed = _p58._1; + var _p59 = callback(result); + var generateB = _p59._0; + return generateB(newSeed); + }); + }); +var _mgold$elm_random_pcg$Random_Pcg$maybe = F2( + function (genBool, genA) { + return A2( + _mgold$elm_random_pcg$Random_Pcg$andThen, + genBool, + function (b) { + return b ? A2(_mgold$elm_random_pcg$Random_Pcg$map, _elm_lang$core$Maybe$Just, genA) : _mgold$elm_random_pcg$Random_Pcg$constant(_elm_lang$core$Maybe$Nothing); + }); + }); +var _mgold$elm_random_pcg$Random_Pcg$filter = F2( + function (predicate, generator) { + return _mgold$elm_random_pcg$Random_Pcg$Generator( + A2(_mgold$elm_random_pcg$Random_Pcg$retry, generator, predicate)); + }); +var _mgold$elm_random_pcg$Random_Pcg$Seed = F2( + function (a, b) { + return {ctor: 'Seed', _0: a, _1: b}; + }); +var _mgold$elm_random_pcg$Random_Pcg$next = function (_p60) { + var _p61 = _p60; + var _p62 = _p61._1; + return A2( + _mgold$elm_random_pcg$Random_Pcg$Seed, + A2(_elm_lang$core$Bitwise$shiftRightLogical, (_p61._0 * 1664525) + _p62, 0), + _p62); +}; +var _mgold$elm_random_pcg$Random_Pcg$initialSeed = function (x) { + var _p63 = _mgold$elm_random_pcg$Random_Pcg$next( + A2(_mgold$elm_random_pcg$Random_Pcg$Seed, 0, 1013904223)); + var state1 = _p63._0; + var incr = _p63._1; + var state2 = A2(_elm_lang$core$Bitwise$shiftRightLogical, state1 + x, 0); + return _mgold$elm_random_pcg$Random_Pcg$next( + A2(_mgold$elm_random_pcg$Random_Pcg$Seed, state2, incr)); +}; +var _mgold$elm_random_pcg$Random_Pcg$generate = F2( + function (toMsg, generator) { + return A3( + _elm_lang$core$Task$perform, + _mgold$elm_random_pcg$Random_Pcg$never, + toMsg, + A2( + _elm_lang$core$Task$map, + function (_p64) { + return _elm_lang$core$Basics$fst( + A2( + _mgold$elm_random_pcg$Random_Pcg$step, + generator, + _mgold$elm_random_pcg$Random_Pcg$initialSeed( + _elm_lang$core$Basics$round(_p64)))); + }, + _elm_lang$core$Time$now)); + }); +var _mgold$elm_random_pcg$Random_Pcg$int = F2( + function (a, b) { + return _mgold$elm_random_pcg$Random_Pcg$Generator( + function (seed0) { + var _p65 = (_elm_lang$core$Native_Utils.cmp(a, b) < 0) ? {ctor: '_Tuple2', _0: a, _1: b} : {ctor: '_Tuple2', _0: b, _1: a}; + var lo = _p65._0; + var hi = _p65._1; + var range = (hi - lo) + 1; + if (_elm_lang$core$Native_Utils.eq( + A2(_elm_lang$core$Bitwise$and, range, range - 1), + 0)) { + return { + ctor: '_Tuple2', + _0: A2( + _elm_lang$core$Bitwise$shiftRightLogical, + A2( + _elm_lang$core$Bitwise$and, + _mgold$elm_random_pcg$Random_Pcg$peel(seed0), + range - 1), + 0) + lo, + _1: _mgold$elm_random_pcg$Random_Pcg$next(seed0) + }; + } else { + var threshhold = A2( + _elm_lang$core$Bitwise$shiftRightLogical, + A2( + _elm_lang$core$Basics$rem, + A2(_elm_lang$core$Bitwise$shiftRightLogical, 0 - range, 0), + range), + 0); + var accountForBias = function (seed) { + accountForBias: + while (true) { + var seedN = _mgold$elm_random_pcg$Random_Pcg$next(seed); + var x = _mgold$elm_random_pcg$Random_Pcg$peel(seed); + if (_elm_lang$core$Native_Utils.cmp(x, threshhold) < 0) { + var _v29 = seedN; + seed = _v29; + continue accountForBias; + } else { + return { + ctor: '_Tuple2', + _0: A2(_elm_lang$core$Basics$rem, x, range) + lo, + _1: seedN + }; + } + } + }; + return accountForBias(seed0); + } + }); + }); +var _mgold$elm_random_pcg$Random_Pcg$bool = A2( + _mgold$elm_random_pcg$Random_Pcg$map, + F2( + function (x, y) { + return _elm_lang$core$Native_Utils.eq(x, y); + })(1), + A2(_mgold$elm_random_pcg$Random_Pcg$int, 0, 1)); +var _mgold$elm_random_pcg$Random_Pcg$choice = F2( + function (x, y) { + return A2( + _mgold$elm_random_pcg$Random_Pcg$map, + function (b) { + return b ? x : y; + }, + _mgold$elm_random_pcg$Random_Pcg$bool); + }); +var _mgold$elm_random_pcg$Random_Pcg$oneIn = function (n) { + return A2( + _mgold$elm_random_pcg$Random_Pcg$map, + F2( + function (x, y) { + return _elm_lang$core$Native_Utils.eq(x, y); + })(1), + A2(_mgold$elm_random_pcg$Random_Pcg$int, 1, n)); +}; +var _mgold$elm_random_pcg$Random_Pcg$sample = function () { + var find = F2( + function (k, ys) { + find: + while (true) { + var _p66 = ys; + if (_p66.ctor === '[]') { + return _elm_lang$core$Maybe$Nothing; + } else { + if (_elm_lang$core$Native_Utils.eq(k, 0)) { + return _elm_lang$core$Maybe$Just(_p66._0); + } else { + var _v31 = k - 1, + _v32 = _p66._1; + k = _v31; + ys = _v32; + continue find; + } + } + } + }); + return function (xs) { + return A2( + _mgold$elm_random_pcg$Random_Pcg$map, + function (i) { + return A2(find, i, xs); + }, + A2( + _mgold$elm_random_pcg$Random_Pcg$int, + 0, + _elm_lang$core$List$length(xs) - 1)); + }; +}(); +var _mgold$elm_random_pcg$Random_Pcg$float = F2( + function (min, max) { + return _mgold$elm_random_pcg$Random_Pcg$Generator( + function (seed0) { + var range = _elm_lang$core$Basics$abs(max - min); + var n0 = _mgold$elm_random_pcg$Random_Pcg$peel(seed0); + var hi = _elm_lang$core$Basics$toFloat( + A2(_elm_lang$core$Bitwise$and, n0, 67108863)) * 1.0; + var seed1 = _mgold$elm_random_pcg$Random_Pcg$next(seed0); + var n1 = _mgold$elm_random_pcg$Random_Pcg$peel(seed1); + var lo = _elm_lang$core$Basics$toFloat( + A2(_elm_lang$core$Bitwise$and, n1, 134217727)) * 1.0; + var val = ((hi * _mgold$elm_random_pcg$Random_Pcg$bit27) + lo) / _mgold$elm_random_pcg$Random_Pcg$bit53; + var scaled = (val * range) + min; + return { + ctor: '_Tuple2', + _0: scaled, + _1: _mgold$elm_random_pcg$Random_Pcg$next(seed1) + }; + }); + }); +var _mgold$elm_random_pcg$Random_Pcg$frequency = function (pairs) { + var pick = F2( + function (choices, n) { + pick: + while (true) { + var _p67 = choices; + if ((_p67.ctor === '::') && (_p67._0.ctor === '_Tuple2')) { + var _p68 = _p67._0._0; + if (_elm_lang$core$Native_Utils.cmp(n, _p68) < 1) { + return _p67._0._1; + } else { + var _v34 = _p67._1, + _v35 = n - _p68; + choices = _v34; + n = _v35; + continue pick; + } + } else { + return _elm_lang$core$Native_Utils.crashCase( + 'Random.Pcg', + { + start: {line: 688, column: 13}, + end: {line: 696, column: 77} + }, + _p67)('Empty list passed to Random.Pcg.frequency!'); + } + } + }); + var total = _elm_lang$core$List$sum( + A2( + _elm_lang$core$List$map, + function (_p70) { + return _elm_lang$core$Basics$abs( + _elm_lang$core$Basics$fst(_p70)); + }, + pairs)); + return A2( + _mgold$elm_random_pcg$Random_Pcg$andThen, + A2(_mgold$elm_random_pcg$Random_Pcg$float, 0, total), + pick(pairs)); +}; +var _mgold$elm_random_pcg$Random_Pcg$choices = function (gens) { + return _mgold$elm_random_pcg$Random_Pcg$frequency( + A2( + _elm_lang$core$List$map, + function (g) { + return {ctor: '_Tuple2', _0: 1, _1: g}; + }, + gens)); +}; +var _mgold$elm_random_pcg$Random_Pcg$independentSeed = _mgold$elm_random_pcg$Random_Pcg$Generator( + function (seed0) { + var gen = A2(_mgold$elm_random_pcg$Random_Pcg$int, 0, 4294967295); + var _p71 = A2( + _mgold$elm_random_pcg$Random_Pcg$step, + A4( + _mgold$elm_random_pcg$Random_Pcg$map3, + F3( + function (v0, v1, v2) { + return {ctor: '_Tuple3', _0: v0, _1: v1, _2: v2}; + }), + gen, + gen, + gen), + seed0); + var state = _p71._0._0; + var b = _p71._0._1; + var c = _p71._0._2; + var seed1 = _p71._1; + var incr = A2( + _elm_lang$core$Bitwise$or, + A2(_elm_lang$core$Bitwise$xor, b, c), + 1); + return { + ctor: '_Tuple2', + _0: seed1, + _1: _mgold$elm_random_pcg$Random_Pcg$next( + A2(_mgold$elm_random_pcg$Random_Pcg$Seed, state, incr)) + }; + }); +var _mgold$elm_random_pcg$Random_Pcg$fastForward = F2( + function (delta0, _p72) { + var _p73 = _p72; + var _p76 = _p73._1; + var helper = F6( + function (accMult, accPlus, curMult, curPlus, delta, repeat) { + helper: + while (true) { + var newDelta = A2(_elm_lang$core$Bitwise$shiftRightLogical, delta, 1); + var curMult$ = A2(_mgold$elm_random_pcg$Random_Pcg$mul32, curMult, curMult); + var curPlus$ = A2(_mgold$elm_random_pcg$Random_Pcg$mul32, curMult + 1, curPlus); + var _p74 = _elm_lang$core$Native_Utils.eq( + A2(_elm_lang$core$Bitwise$and, delta, 1), + 1) ? { + ctor: '_Tuple2', + _0: A2(_mgold$elm_random_pcg$Random_Pcg$mul32, accMult, curMult), + _1: A2( + _elm_lang$core$Bitwise$shiftRightLogical, + A2(_mgold$elm_random_pcg$Random_Pcg$mul32, accPlus, curMult) + curPlus, + 0) + } : {ctor: '_Tuple2', _0: accMult, _1: accPlus}; + var accMult$ = _p74._0; + var accPlus$ = _p74._1; + if (_elm_lang$core$Native_Utils.eq(newDelta, 0)) { + if ((_elm_lang$core$Native_Utils.cmp(delta0, 0) < 0) && repeat) { + var _v37 = accMult$, + _v38 = accPlus$, + _v39 = curMult$, + _v40 = curPlus$, + _v41 = -1, + _v42 = false; + accMult = _v37; + accPlus = _v38; + curMult = _v39; + curPlus = _v40; + delta = _v41; + repeat = _v42; + continue helper; + } else { + return {ctor: '_Tuple2', _0: accMult$, _1: accPlus$}; + } + } else { + var _v43 = accMult$, + _v44 = accPlus$, + _v45 = curMult$, + _v46 = curPlus$, + _v47 = newDelta, + _v48 = repeat; + accMult = _v43; + accPlus = _v44; + curMult = _v45; + curPlus = _v46; + delta = _v47; + repeat = _v48; + continue helper; + } + } + }); + var _p75 = A6(helper, 1, 0, 1664525, _p76, delta0, true); + var accMultFinal = _p75._0; + var accPlusFinal = _p75._1; + return A2( + _mgold$elm_random_pcg$Random_Pcg$Seed, + A2( + _elm_lang$core$Bitwise$shiftRightLogical, + A2(_mgold$elm_random_pcg$Random_Pcg$mul32, accMultFinal, _p73._0) + accPlusFinal, + 0), + _p76); + }); +var _mgold$elm_random_pcg$Random_Pcg$fromJson = _elm_lang$core$Json_Decode$oneOf( + _elm_lang$core$Native_List.fromArray( + [ + A3(_elm_lang$core$Json_Decode$tuple2, _mgold$elm_random_pcg$Random_Pcg$Seed, _elm_lang$core$Json_Decode$int, _elm_lang$core$Json_Decode$int), + A2(_elm_lang$core$Json_Decode$map, _mgold$elm_random_pcg$Random_Pcg$initialSeed, _elm_lang$core$Json_Decode$int) + ])); + +var _guyonvarch$catchvoid$Msg$Transform = {ctor: 'Transform'}; +var _guyonvarch$catchvoid$Msg$Keyboard = function (a) { + return {ctor: 'Keyboard', _0: a}; +}; +var _guyonvarch$catchvoid$Msg$Time = function (a) { + return {ctor: 'Time', _0: a}; +}; +var _guyonvarch$catchvoid$Msg$NoOp = {ctor: 'NoOp'}; + +var _guyonvarch$catchvoid$Model_Vec2$originVec = {x: 0, y: 0}; +var _guyonvarch$catchvoid$Model_Vec2$isNull = function (v) { + return _elm_lang$core$Native_Utils.eq(v.x, 0) && _elm_lang$core$Native_Utils.eq(v.y, 0); +}; +var _guyonvarch$catchvoid$Model_Vec2$clockwiseRotate90 = function (v) { + return {x: 0 - v.y, y: v.x}; +}; +var _guyonvarch$catchvoid$Model_Vec2$norm = function (v) { + return _elm_lang$core$Basics$sqrt( + Math.pow(v.x, 2) + Math.pow(v.y, 2)); +}; +var _guyonvarch$catchvoid$Model_Vec2$div = F2( + function (v, d) { + return {x: v.x / d, y: v.y / d}; + }); +var _guyonvarch$catchvoid$Model_Vec2$mul = F2( + function (m, v) { + return {x: m * v.x, y: m * v.y}; + }); +var _guyonvarch$catchvoid$Model_Vec2$sub = F2( + function (v1, v2) { + return {x: v1.x - v2.x, y: v1.y - v2.y}; + }); +var _guyonvarch$catchvoid$Model_Vec2$add = F2( + function (v1, v2) { + return {x: v1.x + v2.x, y: v1.y + v2.y}; + }); +var _guyonvarch$catchvoid$Model_Vec2$Vec2 = F2( + function (a, b) { + return {x: a, y: b}; + }); + +var _guyonvarch$catchvoid$Model_Config$Black = {ctor: 'Black'}; +var _guyonvarch$catchvoid$Model_Config$White = {ctor: 'White'}; +var _guyonvarch$catchvoid$Model_Config$otherConfig = function (config) { + var _p0 = config; + if (_p0.ctor === 'White') { + return _guyonvarch$catchvoid$Model_Config$Black; + } else { + return _guyonvarch$catchvoid$Model_Config$White; + } +}; + +var _guyonvarch$catchvoid$Model_Color$mergeColors = F3( + function (ratio, c1, c2) { + var mergePart = F2( + function (x, y) { + return _elm_lang$core$Basics$truncate( + (ratio * _elm_lang$core$Basics$toFloat(x)) + ((1 - ratio) * _elm_lang$core$Basics$toFloat(y))); + }); + return { + red: A2(mergePart, c1.red, c2.red), + green: A2(mergePart, c1.green, c2.green), + blue: A2(mergePart, c1.blue, c2.blue) + }; + }); +var _guyonvarch$catchvoid$Model_Color$htmlOutput = function (color) { + return A2( + _elm_lang$core$Basics_ops['++'], + 'rgb(', + A2( + _elm_lang$core$Basics_ops['++'], + _elm_lang$core$Basics$toString(color.red), + A2( + _elm_lang$core$Basics_ops['++'], + ', ', + A2( + _elm_lang$core$Basics_ops['++'], + _elm_lang$core$Basics$toString(color.green), + A2( + _elm_lang$core$Basics_ops['++'], + ', ', + A2( + _elm_lang$core$Basics_ops['++'], + _elm_lang$core$Basics$toString(color.blue), + ')')))))); +}; +var _guyonvarch$catchvoid$Model_Color$Color = F3( + function (a, b, c) { + return {red: a, green: b, blue: c}; + }); + +var _guyonvarch$catchvoid$Model_Board$boardDiagonal = function (boardSize) { + return _elm_lang$core$Basics$sqrt( + Math.pow(boardSize.x, 2) + Math.pow(boardSize.y, 2)); +}; +var _guyonvarch$catchvoid$Model_Board$initBoardSize = {x: 500, y: 500}; + +var _guyonvarch$catchvoid$Model_Point$pointSpeed = function (dt) { + return dt / 20; +}; +var _guyonvarch$catchvoid$Model_Point$pointSize = 10; +var _guyonvarch$catchvoid$Model_Point$pointSpawnDist = function (boardSize) { + return ((_guyonvarch$catchvoid$Model_Board$boardDiagonal(boardSize) * 2.5) / 5) + _guyonvarch$catchvoid$Model_Point$pointSize; +}; +var _guyonvarch$catchvoid$Model_Point$pointAwayDist = function (boardSize) { + return ((_guyonvarch$catchvoid$Model_Board$boardDiagonal(boardSize) * 3) / 5) + _guyonvarch$catchvoid$Model_Point$pointSize; +}; +var _guyonvarch$catchvoid$Model_Point$pointMove = F2( + function (_p0, time) { + var _p1 = _p0; + return A4(_p1.move, _p1.initTime, _p1.initPos, _p1.initDest, time); + }); +var _guyonvarch$catchvoid$Model_Point$Point = F4( + function (a, b, c, d) { + return {initTime: a, initPos: b, initDest: c, move: d}; + }); + +var _guyonvarch$catchvoid$Utils_Physics$getNewSpeed = F3( + function (dt, acc, speed) { + return A2( + _guyonvarch$catchvoid$Model_Vec2$add, + A2(_guyonvarch$catchvoid$Model_Vec2$mul, dt, acc), + speed); + }); +var _guyonvarch$catchvoid$Utils_Physics$getNewPos = F4( + function (dt, acc, speed, pos) { + return A2( + _guyonvarch$catchvoid$Model_Vec2$add, + A2( + _guyonvarch$catchvoid$Model_Vec2$mul, + Math.pow(dt, 2) / 2, + acc), + A2( + _guyonvarch$catchvoid$Model_Vec2$add, + A2(_guyonvarch$catchvoid$Model_Vec2$mul, dt, speed), + pos)); + }); +var _guyonvarch$catchvoid$Utils_Physics$getAcc = F2( + function (move, speed) { + return A2( + _guyonvarch$catchvoid$Model_Vec2$sub, + A2(_guyonvarch$catchvoid$Model_Vec2$div, move, 300), + A2(_guyonvarch$catchvoid$Model_Vec2$div, speed, 300)); + }); +var _guyonvarch$catchvoid$Utils_Physics$getMove = F2( + function (speed, dir) { + if (_guyonvarch$catchvoid$Model_Vec2$isNull(dir)) { + return {x: 0, y: 0}; + } else { + var angle = A2(_elm_lang$core$Basics$atan2, dir.y, dir.x); + return { + x: speed * _elm_lang$core$Basics$cos(angle), + y: speed * _elm_lang$core$Basics$sin(angle) + }; + } + }); +var _guyonvarch$catchvoid$Utils_Physics$getWaveMove = F4( + function (speed, dir, amplitude, period) { + var move = A2(_guyonvarch$catchvoid$Utils_Physics$getMove, speed, dir); + var perpendMove = A2( + _guyonvarch$catchvoid$Utils_Physics$getMove, + amplitude * _elm_lang$core$Basics$sin( + _guyonvarch$catchvoid$Model_Vec2$norm(move) / period), + _guyonvarch$catchvoid$Model_Vec2$clockwiseRotate90(move)); + return A2(_guyonvarch$catchvoid$Model_Vec2$add, move, perpendMove); + }); +var _guyonvarch$catchvoid$Utils_Physics$getNewPosAndSpeed = F4( + function (dt, dir, computeSpeed, _p0) { + var _p1 = _p0; + var _p2 = _p1._1; + var move = A2( + _guyonvarch$catchvoid$Utils_Physics$getMove, + computeSpeed(dt), + dir); + var acc = A2(_guyonvarch$catchvoid$Utils_Physics$getAcc, move, _p2); + var newPos = A4(_guyonvarch$catchvoid$Utils_Physics$getNewPos, dt, acc, _p2, _p1._0); + var newSpeed = A3(_guyonvarch$catchvoid$Utils_Physics$getNewSpeed, dt, acc, _p2); + return {ctor: '_Tuple2', _0: newPos, _1: newSpeed}; + }); + +var _guyonvarch$catchvoid$Model_Level$lastLevel = { + color: {red: 156, green: 225, blue: 233}, + move: F3( + function (initPos, initDest, delta) { + return A4( + _guyonvarch$catchvoid$Utils_Physics$getWaveMove, + delta / 5, + A2(_guyonvarch$catchvoid$Model_Vec2$sub, initDest, initPos), + 30, + 30); + }) +}; +var _guyonvarch$catchvoid$Model_Level$levels = _elm_lang$core$Native_List.fromArray( + [ + { + color: {red: 156, green: 168, blue: 233}, + move: F3( + function (initPos, initDest, delta) { + return A2( + _guyonvarch$catchvoid$Utils_Physics$getMove, + delta / 20, + A2(_guyonvarch$catchvoid$Model_Vec2$sub, initDest, initPos)); + }) + }, + { + color: {red: 190, green: 156, blue: 233}, + move: F3( + function (initPos, initDest, delta) { + return A4( + _guyonvarch$catchvoid$Utils_Physics$getWaveMove, + delta / 20, + A2(_guyonvarch$catchvoid$Model_Vec2$sub, initDest, initPos), + 10, + 10); + }) + }, + { + color: {red: 233, green: 156, blue: 232}, + move: F3( + function (initPos, initDest, delta) { + return A2( + _guyonvarch$catchvoid$Utils_Physics$getMove, + delta / 18, + A2(_guyonvarch$catchvoid$Model_Vec2$sub, initDest, initPos)); + }) + }, + { + color: {red: 233, green: 156, blue: 187}, + move: F3( + function (initPos, initDest, delta) { + return A4( + _guyonvarch$catchvoid$Utils_Physics$getWaveMove, + delta / 18, + A2(_guyonvarch$catchvoid$Model_Vec2$sub, initDest, initPos), + 20, + 20); + }) + }, + { + color: {red: 233, green: 171, blue: 156}, + move: F3( + function (initPos, initDest, delta) { + return A2( + _guyonvarch$catchvoid$Utils_Physics$getMove, + delta / 13, + A2(_guyonvarch$catchvoid$Model_Vec2$sub, initDest, initPos)); + }) + }, + { + color: {red: 233, green: 215, blue: 156}, + move: F3( + function (initPos, initDest, delta) { + return A4( + _guyonvarch$catchvoid$Utils_Physics$getWaveMove, + delta / 16, + A2(_guyonvarch$catchvoid$Model_Vec2$sub, initDest, initPos), + 10, + 50); + }) + }, + { + color: {red: 206, green: 233, blue: 156}, + move: F3( + function (initPos, initDest, delta) { + return A2( + _guyonvarch$catchvoid$Utils_Physics$getMove, + delta / 11, + A2(_guyonvarch$catchvoid$Model_Vec2$sub, initDest, initPos)); + }) + }, + { + color: {red: 162, green: 233, blue: 156}, + move: F3( + function (initPos, initDest, delta) { + return A4( + _guyonvarch$catchvoid$Utils_Physics$getWaveMove, + delta / 14, + A2(_guyonvarch$catchvoid$Model_Vec2$sub, initDest, initPos), + 30, + 15); + }) + }, + { + color: {red: 156, green: 233, blue: 196}, + move: F3( + function (initPos, initDest, delta) { + return A2( + _guyonvarch$catchvoid$Utils_Physics$getMove, + delta / 8, + A2(_guyonvarch$catchvoid$Model_Vec2$sub, initDest, initPos)); + }) + }, + { + color: {red: 156, green: 225, blue: 233}, + move: F3( + function (initPos, initDest, delta) { + return A4( + _guyonvarch$catchvoid$Utils_Physics$getWaveMove, + delta / 12, + A2(_guyonvarch$catchvoid$Model_Vec2$sub, initDest, initPos), + 30, + 30); + }) + } + ]); +var _guyonvarch$catchvoid$Model_Level$progressiveRatio = F2( + function (a, b) { + return Math.pow( + _elm_lang$core$Basics$toFloat(a), + 7) / Math.pow( + _elm_lang$core$Basics$toFloat(b), + 7); + }); +var _guyonvarch$catchvoid$Model_Level$levelScoreDuration = 20; +var _guyonvarch$catchvoid$Model_Level$currentLevelNumber = function (currentScore) { + return A2( + _elm_lang$core$Basics$min, + _elm_lang$core$List$length(_guyonvarch$catchvoid$Model_Level$levels) + 1, + ((currentScore / _guyonvarch$catchvoid$Model_Level$levelScoreDuration) | 0) + 1); +}; +var _guyonvarch$catchvoid$Model_Level$currentLevelScore = function (currentScore) { + return currentScore - ((_guyonvarch$catchvoid$Model_Level$currentLevelNumber(currentScore) - 1) * _guyonvarch$catchvoid$Model_Level$levelScoreDuration); +}; +var _guyonvarch$catchvoid$Model_Level$currentLevel = function (currentScore) { + return A2( + _elm_lang$core$Maybe$withDefault, + _guyonvarch$catchvoid$Model_Level$lastLevel, + _elm_lang$core$List$head( + A2(_elm_lang$core$List$drop, (currentScore / _guyonvarch$catchvoid$Model_Level$levelScoreDuration) | 0, _guyonvarch$catchvoid$Model_Level$levels))); +}; +var _guyonvarch$catchvoid$Model_Level$nextLevel = function (currentScore) { + return _guyonvarch$catchvoid$Model_Level$currentLevel(currentScore + _guyonvarch$catchvoid$Model_Level$levelScoreDuration); +}; +var _guyonvarch$catchvoid$Model_Level$progressiveColor = function (currentScore) { + var nextColor = _guyonvarch$catchvoid$Model_Level$nextLevel(currentScore).color; + var currentColor = _guyonvarch$catchvoid$Model_Level$currentLevel(currentScore).color; + var reminder = A2(_elm_lang$core$Basics$rem, currentScore, _guyonvarch$catchvoid$Model_Level$levelScoreDuration); + var ratio = A2(_guyonvarch$catchvoid$Model_Level$progressiveRatio, reminder, _guyonvarch$catchvoid$Model_Level$levelScoreDuration); + return A3(_guyonvarch$catchvoid$Model_Color$mergeColors, ratio, nextColor, currentColor); +}; +var _guyonvarch$catchvoid$Model_Level$Level = F2( + function (a, b) { + return {color: a, move: b}; + }); + +var _guyonvarch$catchvoid$Model_Player$playerSpeed = function (dt) { + return dt / 200; +}; +var _guyonvarch$catchvoid$Model_Player$levelCurve = F3( + function (maxAbs, maxOrd, x) { + var n = 4; + var exp = (Math.pow( + _elm_lang$core$Basics$toFloat(x), + n) * _elm_lang$core$Basics$toFloat(maxOrd)) / Math.pow( + _elm_lang$core$Basics$toFloat(maxAbs), + n); + var linear = (_elm_lang$core$Basics$toFloat(x) * _elm_lang$core$Basics$toFloat(maxOrd)) / _elm_lang$core$Basics$toFloat(maxAbs); + return linear - exp; + }); +var _guyonvarch$catchvoid$Model_Player$getPlayerSize = function (score) { + return A3( + _guyonvarch$catchvoid$Model_Player$levelCurve, + _guyonvarch$catchvoid$Model_Level$levelScoreDuration, + 15, + _guyonvarch$catchvoid$Model_Level$currentLevelScore(score)) + 15; +}; +var _guyonvarch$catchvoid$Model_Player$initPlayer = {pos: _guyonvarch$catchvoid$Model_Vec2$originVec, speed: _guyonvarch$catchvoid$Model_Vec2$originVec, config: _guyonvarch$catchvoid$Model_Config$White}; +var _guyonvarch$catchvoid$Model_Player$Player = F3( + function (a, b, c) { + return {pos: a, speed: b, config: c}; + }); + +var _guyonvarch$catchvoid$Utils_Geometry$inBoard = F3( + function (boardSize, size, pos) { + var topY = (boardSize.y / 2) - size; + var bottomY = ((0 - boardSize.y) / 2) + size; + var rightX = (boardSize.x / 2) - size; + var leftX = ((0 - boardSize.x) / 2) + size; + return { + x: A3(_elm_lang$core$Basics$clamp, leftX, rightX, pos.x), + y: A3(_elm_lang$core$Basics$clamp, bottomY, topY, pos.y) + }; + }); +var _guyonvarch$catchvoid$Utils_Geometry$distance = F2( + function (v1, v2) { + return _elm_lang$core$Basics$sqrt( + Math.pow(v2.x - v1.x, 2) + Math.pow(v2.y - v1.y, 2)); + }); +var _guyonvarch$catchvoid$Utils_Geometry$polarToCartesian = F2( + function (angle, dist) { + return { + x: dist * _elm_lang$core$Basics$cos(angle), + y: dist * _elm_lang$core$Basics$sin(angle) + }; + }); + +var _guyonvarch$catchvoid$Model_Cloud$playerPointCollision = F4( + function (elapsedTime, player, playerSize, point) { + var pointPos = A2(_guyonvarch$catchvoid$Model_Point$pointMove, point, elapsedTime); + return _elm_lang$core$Native_Utils.cmp( + A2(_guyonvarch$catchvoid$Utils_Geometry$distance, pointPos, player.pos), + _guyonvarch$catchvoid$Model_Point$pointSize + playerSize) < 0; + }); +var _guyonvarch$catchvoid$Model_Cloud$playerPointsCollision = F4( + function (elapsedTime, player, playerSize, points) { + var collision = A3(_guyonvarch$catchvoid$Model_Cloud$playerPointCollision, elapsedTime, player, playerSize); + return _elm_lang$core$Native_Utils.cmp( + _elm_lang$core$List$length( + A2(_elm_lang$core$List$filter, collision, points)), + 0) > 0; + }); +var _guyonvarch$catchvoid$Model_Cloud$initCloud = function () { + var spawn = 600; + return { + points: function (config) { + var _p0 = config; + if (_p0.ctor === 'White') { + return _elm_lang$core$Native_List.fromArray( + []); + } else { + return _elm_lang$core$Native_List.fromArray( + []); + } + }, + spawn: spawn, + lastSpawn: 0 - spawn + }; +}(); +var _guyonvarch$catchvoid$Model_Cloud$Cloud = F3( + function (a, b, c) { + return {points: a, spawn: b, lastSpawn: c}; + }); + +var _guyonvarch$catchvoid$Model_Round$roundOrder = F2( + function (round1, round2) { + return _elm_lang$core$Native_Utils.eq(round1.score, round2.score) ? A2(_elm_lang$core$Basics$compare, round2.duration, round1.duration) : A2(_elm_lang$core$Basics$compare, round1.score, round2.score); + }); +var _guyonvarch$catchvoid$Model_Round$maybeBestRound = function (rounds) { + var orderedRounds = _elm_lang$core$List$reverse( + A2(_elm_lang$core$List$sortWith, _guyonvarch$catchvoid$Model_Round$roundOrder, rounds)); + var _p0 = orderedRounds; + if (_p0.ctor === '[]') { + return _elm_lang$core$Maybe$Nothing; + } else { + return _elm_lang$core$Maybe$Just(_p0._0); + } +}; +var _guyonvarch$catchvoid$Model_Round$Round = F2( + function (a, b) { + return {duration: a, score: b}; + }); + +var _guyonvarch$catchvoid$Model$init = function (time) { + var _p0 = _ohanhi$keyboard_extra$Keyboard_Extra$init; + var keyboard = _p0._0; + var keyboardCmd = _p0._1; + return { + ctor: '_Tuple2', + _0: { + time: time, + elapsedTime: 0, + boardSize: _guyonvarch$catchvoid$Model_Board$initBoardSize, + currentScore: 0, + player: _guyonvarch$catchvoid$Model_Player$initPlayer, + cloud: _guyonvarch$catchvoid$Model_Cloud$initCloud, + rounds: _elm_lang$core$Native_List.fromArray( + []), + seed: _mgold$elm_random_pcg$Random_Pcg$initialSeed( + _elm_lang$core$Basics$round(time)), + keyboard: keyboard, + transform: false + }, + _1: A2(_elm_lang$core$Platform_Cmd$map, _guyonvarch$catchvoid$Msg$Keyboard, keyboardCmd) + }; +}; +var _guyonvarch$catchvoid$Model$Model = 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 function (j) { + return {time: a, elapsedTime: b, boardSize: c, currentScore: d, player: e, cloud: f, rounds: g, seed: h, keyboard: i, transform: j}; + }; + }; + }; + }; + }; + }; + }; + }; + }; +}; + +var _guyonvarch$catchvoid$Update_CloudUpdate$randomBoardPosition = F3( + function (boardSize, _p1, _p0) { + var _p2 = _p1; + var _p3 = _p0; + var height = boardSize.y * _p3._1; + var width = boardSize.x * _p3._0; + return {x: (width * _p2._0) - (width / 2), y: (height * _p2._1) - (height / 2)}; + }); +var _guyonvarch$catchvoid$Update_CloudUpdate$pointDestination = F2( + function (boardSize, seed) { + var _p4 = A2( + _mgold$elm_random_pcg$Random_Pcg$step, + A2( + _mgold$elm_random_pcg$Random_Pcg$list, + 4, + A2(_mgold$elm_random_pcg$Random_Pcg$float, 0, 1)), + seed); + if ((((((_p4.ctor === '_Tuple2') && (_p4._0.ctor === '::')) && (_p4._0._1.ctor === '::')) && (_p4._0._1._1.ctor === '::')) && (_p4._0._1._1._1.ctor === '::')) && (_p4._0._1._1._1._1.ctor === '[]')) { + return { + ctor: '_Tuple2', + _0: A3( + _guyonvarch$catchvoid$Update_CloudUpdate$randomBoardPosition, + boardSize, + {ctor: '_Tuple2', _0: _p4._0._0, _1: _p4._0._1._0}, + {ctor: '_Tuple2', _0: _p4._0._1._1._0, _1: _p4._0._1._1._1._0}), + _1: _p4._1 + }; + } else { + return { + ctor: '_Tuple2', + _0: A3( + _guyonvarch$catchvoid$Update_CloudUpdate$randomBoardPosition, + boardSize, + {ctor: '_Tuple2', _0: 0, _1: 0}, + {ctor: '_Tuple2', _0: 0, _1: 0}), + _1: seed + }; + } + }); +var _guyonvarch$catchvoid$Update_CloudUpdate$pointInitPos = F2( + function (boardSize, seed) { + var dist = _guyonvarch$catchvoid$Model_Point$pointSpawnDist(boardSize); + var _p5 = A2( + _mgold$elm_random_pcg$Random_Pcg$step, + A2(_mgold$elm_random_pcg$Random_Pcg$float, 0, 1), + seed); + var rand = _p5._0; + var seed$ = _p5._1; + var angle = rand * _elm_lang$core$Basics$degrees(360); + return { + ctor: '_Tuple2', + _0: A2(_guyonvarch$catchvoid$Utils_Geometry$polarToCartesian, angle, dist), + _1: seed$ + }; + }); +var _guyonvarch$catchvoid$Update_CloudUpdate$getNewPoint = F4( + function (elapsedTime, boardSize, seed, currentScore) { + var _p6 = A2(_guyonvarch$catchvoid$Update_CloudUpdate$pointInitPos, boardSize, seed); + var initPos = _p6._0; + var seed$ = _p6._1; + var _p7 = A2(_guyonvarch$catchvoid$Update_CloudUpdate$pointDestination, boardSize, seed$); + var initDest = _p7._0; + var seed$$ = _p7._1; + return { + ctor: '_Tuple2', + _0: { + initTime: elapsedTime, + initPos: initPos, + initDest: initDest, + move: F4( + function (initTime, initPos, initDest, elapsedTime) { + var delta = elapsedTime - initTime; + var move = A3( + _guyonvarch$catchvoid$Model_Level$currentLevel(currentScore).move, + initPos, + initDest, + delta); + return A2(_guyonvarch$catchvoid$Model_Vec2$add, initPos, move); + }) + }, + _1: seed$$ + }; + }); +var _guyonvarch$catchvoid$Update_CloudUpdate$presentPoints = F3( + function (elapsedTime, boardSize, points) { + var isPresent = function (point) { + return _elm_lang$core$Native_Utils.cmp( + A2( + _guyonvarch$catchvoid$Utils_Geometry$distance, + A2(_guyonvarch$catchvoid$Model_Point$pointMove, point, elapsedTime), + _guyonvarch$catchvoid$Model_Vec2$originVec), + _guyonvarch$catchvoid$Model_Point$pointAwayDist(boardSize)) < 0; + }; + return A2(_elm_lang$core$List$filter, isPresent, points); + }); +var _guyonvarch$catchvoid$Update_CloudUpdate$cloudUpdate = F7( + function (elapsedTime, boardSize, seed, player, playerSize, _p8, currentScore) { + var _p9 = _p8; + var _p16 = _p9.spawn; + var _p15 = _p9.points; + var _p14 = _p9.lastSpawn; + var presentOtherPoints = A3( + _guyonvarch$catchvoid$Update_CloudUpdate$presentPoints, + elapsedTime, + boardSize, + _p15( + _guyonvarch$catchvoid$Model_Config$otherConfig(player.config))); + var pointsToCatch = A3( + _guyonvarch$catchvoid$Update_CloudUpdate$presentPoints, + elapsedTime, + boardSize, + _p15(player.config)); + var presentAndNotCaughtPoints = A2( + _elm_lang$core$List$filter, + function (_p10) { + return _elm_lang$core$Basics$not( + A4(_guyonvarch$catchvoid$Model_Cloud$playerPointCollision, elapsedTime, player, playerSize, _p10)); + }, + pointsToCatch); + var _p11 = function () { + if (_elm_lang$core$Native_Utils.cmp(elapsedTime, _p14 + _p16) > 0) { + var _p12 = A4(_guyonvarch$catchvoid$Update_CloudUpdate$getNewPoint, elapsedTime, boardSize, seed, currentScore); + var newPoint1 = _p12._0; + var seed$ = _p12._1; + var _p13 = A4(_guyonvarch$catchvoid$Update_CloudUpdate$getNewPoint, elapsedTime, boardSize, seed$, currentScore); + var newPoint2 = _p13._0; + var seed$$ = _p13._1; + return { + ctor: '_Tuple2', + _0: { + points: function (config) { + return _elm_lang$core$Native_Utils.eq(config, player.config) ? A2(_elm_lang$core$List_ops['::'], newPoint1, presentAndNotCaughtPoints) : A2(_elm_lang$core$List_ops['::'], newPoint2, presentOtherPoints); + }, + spawn: _p16 - (_elm_lang$core$Basics$sqrt(_p16) / 50), + lastSpawn: elapsedTime + }, + _1: seed$$ + }; + } else { + return { + ctor: '_Tuple2', + _0: { + points: function (config) { + return _elm_lang$core$Native_Utils.eq(config, player.config) ? presentAndNotCaughtPoints : presentOtherPoints; + }, + spawn: _p16, + lastSpawn: _p14 + }, + _1: seed + }; + } + }(); + var newCloud = _p11._0; + var seed$ = _p11._1; + var addScore = _elm_lang$core$List$length(pointsToCatch) - _elm_lang$core$List$length(presentAndNotCaughtPoints); + return {ctor: '_Tuple3', _0: newCloud, _1: addScore, _2: seed$}; + }); + +var _guyonvarch$catchvoid$Update$updatePlayer = F6( + function (dt, boardSize, dir, transform, player, playerSize) { + var newConfig = transform ? _guyonvarch$catchvoid$Model_Config$otherConfig(player.config) : player.config; + var _p0 = A4( + _guyonvarch$catchvoid$Utils_Physics$getNewPosAndSpeed, + dt, + dir, + _guyonvarch$catchvoid$Model_Player$playerSpeed, + {ctor: '_Tuple2', _0: player.pos, _1: player.speed}); + var pos = _p0._0; + var speed = _p0._1; + return { + pos: A3(_guyonvarch$catchvoid$Utils_Geometry$inBoard, boardSize, playerSize, pos), + speed: speed, + config: newConfig + }; + }); +var _guyonvarch$catchvoid$Update$updateTime = F2( + function (time, model) { + var hostilePoints = model.cloud.points( + _guyonvarch$catchvoid$Model_Config$otherConfig(model.player.config)); + var dir = function () { + var _p1 = _ohanhi$keyboard_extra$Keyboard_Extra$arrows(model.keyboard); + return { + x: _elm_lang$core$Basics$toFloat(_p1.x), + y: _elm_lang$core$Basics$toFloat(_p1.y) + }; + }(); + var delta = time - model.time; + if (A4( + _guyonvarch$catchvoid$Model_Cloud$playerPointsCollision, + model.elapsedTime, + model.player, + _guyonvarch$catchvoid$Model_Player$getPlayerSize(model.currentScore), + hostilePoints)) { + return _elm_lang$core$Native_Utils.update( + model, + { + time: time, + elapsedTime: 0, + currentScore: 0, + cloud: _guyonvarch$catchvoid$Model_Cloud$initCloud, + rounds: A2( + _elm_lang$core$List_ops['::'], + A2(_guyonvarch$catchvoid$Model_Round$Round, model.elapsedTime, model.currentScore), + model.rounds) + }); + } else { + var newPlayer = A6( + _guyonvarch$catchvoid$Update$updatePlayer, + delta, + model.boardSize, + dir, + A2(_elm_lang$core$Debug$log, 'transform', model.transform), + model.player, + _guyonvarch$catchvoid$Model_Player$getPlayerSize(model.currentScore)); + var _p2 = A7( + _guyonvarch$catchvoid$Update_CloudUpdate$cloudUpdate, + model.elapsedTime, + model.boardSize, + model.seed, + newPlayer, + _guyonvarch$catchvoid$Model_Player$getPlayerSize(model.currentScore), + model.cloud, + model.currentScore); + var newCloud = _p2._0; + var addScore = _p2._1; + var newSeed = _p2._2; + return _elm_lang$core$Native_Utils.update( + model, + {time: time, elapsedTime: model.elapsedTime + delta, currentScore: model.currentScore + addScore, player: newPlayer, cloud: newCloud, seed: newSeed, transform: false}); + } + }); +var _guyonvarch$catchvoid$Update$update = F2( + function (msg, model) { + var _p3 = msg; + switch (_p3.ctor) { + case 'NoOp': + return {ctor: '_Tuple2', _0: model, _1: _elm_lang$core$Platform_Cmd$none}; + case 'Time': + return { + ctor: '_Tuple2', + _0: A2(_guyonvarch$catchvoid$Update$updateTime, _p3._0, model), + _1: _elm_lang$core$Platform_Cmd$none + }; + case 'Keyboard': + var _p4 = A2(_ohanhi$keyboard_extra$Keyboard_Extra$update, _p3._0, model.keyboard); + var keyboard = _p4._0; + var keyboardCmd = _p4._1; + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Native_Utils.update( + model, + {keyboard: keyboard}), + _1: A2(_elm_lang$core$Platform_Cmd$map, _guyonvarch$catchvoid$Msg$Keyboard, keyboardCmd) + }; + default: + return { + ctor: '_Tuple2', + _0: _elm_lang$core$Native_Utils.update( + model, + {transform: true}), + _1: _elm_lang$core$Platform_Cmd$none + }; + } + }); + +var _guyonvarch$catchvoid$View_Time$timeView = function (time) { + var s = _elm_lang$core$Basics$truncate(time / 1000); + return A2( + _elm_lang$core$Basics_ops['++'], + _elm_lang$core$Basics$toString(s), + ' seconds'); +}; + +var _guyonvarch$catchvoid$View_Round$roundView = function (round) { + var duration = _guyonvarch$catchvoid$View_Time$timeView(round.duration); + var hits = A2( + _elm_lang$core$Basics_ops['++'], + 'hit', + (_elm_lang$core$Native_Utils.cmp(round.score, 1) > 0) ? 's' : ''); + var score = _elm_lang$core$Basics$toString(round.score); + return A2( + _elm_lang$core$Basics_ops['++'], + score, + A2( + _elm_lang$core$Basics_ops['++'], + ' ', + A2( + _elm_lang$core$Basics_ops['++'], + hits, + A2(_elm_lang$core$Basics_ops['++'], ' within ', duration)))); +}; + +var _guyonvarch$catchvoid$View$pointColor = function (config) { + var _p0 = config; + if (_p0.ctor === 'White') { + return 'white'; + } else { + return 'black'; + } +}; +var _guyonvarch$catchvoid$View$playerColor = function (config) { + var _p1 = config; + if (_p1.ctor === 'White') { + return '#F0F0F0'; + } else { + return '#0E1121'; + } +}; +var _guyonvarch$catchvoid$View$backgroundColor = '#1B203F'; +var _guyonvarch$catchvoid$View$headerHeight = 115; +var _guyonvarch$catchvoid$View$renderHeader = function (model) { + return A2( + _elm_lang$svg$Svg$g, + _elm_lang$core$Native_List.fromArray( + []), + _elm_lang$core$Native_List.fromArray( + [ + A2( + _elm_lang$svg$Svg$rect, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$width('100%'), + _elm_lang$svg$Svg_Attributes$height( + _elm_lang$core$Basics$toString(_guyonvarch$catchvoid$View$headerHeight)), + _elm_lang$svg$Svg_Attributes$fill('#1B203F') + ]), + _elm_lang$core$Native_List.fromArray( + [])), + A2( + _elm_lang$svg$Svg$text$, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$x('10'), + _elm_lang$svg$Svg_Attributes$y('45'), + _elm_lang$svg$Svg_Attributes$fontSize('36'), + _elm_lang$svg$Svg_Attributes$fill('white'), + _elm_lang$svg$Svg_Attributes$fontWeight('bold') + ]), + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg$text('cAtchVoid') + ])), + A2( + _elm_lang$svg$Svg$text$, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$fill('white'), + _elm_lang$svg$Svg_Attributes$fontSize('12'), + _elm_lang$svg$Svg_Attributes$fontStyle('italic') + ]), + _elm_lang$core$Native_List.fromArray( + [ + A2( + _elm_lang$svg$Svg$tspan, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$x( + _elm_lang$core$Basics$toString(model.boardSize.x / 2)), + _elm_lang$svg$Svg_Attributes$y('75'), + _elm_lang$svg$Svg_Attributes$textAnchor('middle') + ]), + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg$text('Catch the points of your color, avoid the other points.') + ])), + A2( + _elm_lang$svg$Svg$tspan, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$x( + _elm_lang$core$Basics$toString(model.boardSize.x / 2)), + _elm_lang$svg$Svg_Attributes$y('92'), + _elm_lang$svg$Svg_Attributes$textAnchor('middle') + ]), + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg$text('Use the arrow keys to move and \'e\' to change your color.') + ])) + ])), + function () { + var _p2 = _guyonvarch$catchvoid$Model_Round$maybeBestRound(model.rounds); + if (_p2.ctor === 'Nothing') { + return _elm_lang$svg$Svg$text(''); + } else { + return A2( + _elm_lang$svg$Svg$text$, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$fill('yellow'), + _elm_lang$svg$Svg_Attributes$x('355'), + _elm_lang$svg$Svg_Attributes$y('38'), + _elm_lang$svg$Svg_Attributes$fontSize('13') + ]), + _elm_lang$core$Native_List.fromArray( + [ + A2( + _elm_lang$svg$Svg$tspan, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$textAnchor('middle') + ]), + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg$text( + A2( + _elm_lang$core$Basics_ops['++'], + 'Top: ', + _guyonvarch$catchvoid$View_Round$roundView(_p2._0))) + ])) + ])); + } + }() + ])); +}; +var _guyonvarch$catchvoid$View$renderBoard = function (currentScore) { + return A2( + _elm_lang$svg$Svg$rect, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$y( + _elm_lang$core$Basics$toString(_guyonvarch$catchvoid$View$headerHeight)), + _elm_lang$svg$Svg_Attributes$width('100%'), + _elm_lang$svg$Svg_Attributes$height('100%'), + _elm_lang$svg$Svg_Attributes$fill( + _guyonvarch$catchvoid$Model_Color$htmlOutput( + _guyonvarch$catchvoid$Model_Level$progressiveColor(currentScore))) + ]), + _elm_lang$core$Native_List.fromArray( + [])); +}; +var _guyonvarch$catchvoid$View$renderCircle = F4( + function (boardSize, pos, size, color) { + return A2( + _elm_lang$svg$Svg$circle, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$cx( + _elm_lang$core$Basics$toString(pos.x + (boardSize.x / 2))), + _elm_lang$svg$Svg_Attributes$cy( + _elm_lang$core$Basics$toString(((-1 * pos.y) + (boardSize.y / 2)) + _guyonvarch$catchvoid$View$headerHeight)), + _elm_lang$svg$Svg_Attributes$r( + _elm_lang$core$Basics$toString(size)), + _elm_lang$svg$Svg_Attributes$fill(color) + ]), + _elm_lang$core$Native_List.fromArray( + [])); + }); +var _guyonvarch$catchvoid$View$renderPlayer = F3( + function (boardSize, player, playerSize) { + return A4( + _guyonvarch$catchvoid$View$renderCircle, + boardSize, + player.pos, + playerSize, + _guyonvarch$catchvoid$View$playerColor(player.config)); + }); +var _guyonvarch$catchvoid$View$renderPoint = F4( + function (boardSize, elapsedTime, config, point) { + var pos = A2(_guyonvarch$catchvoid$Model_Point$pointMove, point, elapsedTime); + return A4( + _guyonvarch$catchvoid$View$renderCircle, + boardSize, + pos, + _guyonvarch$catchvoid$Model_Point$pointSize, + _guyonvarch$catchvoid$View$playerColor(config)); + }); +var _guyonvarch$catchvoid$View$renderText = F3( + function (boardSize, pos, content) { + return A2( + _elm_lang$svg$Svg$text$, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$x( + _elm_lang$core$Basics$toString(pos.x + (boardSize.x / 2))), + _elm_lang$svg$Svg_Attributes$y( + _elm_lang$core$Basics$toString(((-1 * pos.y) + (boardSize.y / 2)) + _guyonvarch$catchvoid$View$headerHeight)), + _elm_lang$svg$Svg_Attributes$fontFamily('calibri'), + _elm_lang$svg$Svg_Attributes$fontSize('24'), + _elm_lang$svg$Svg_Attributes$color('#0E1121'), + _elm_lang$svg$Svg_Attributes$fontWeight('bold') + ]), + _elm_lang$core$Native_List.fromArray( + [ + A2( + _elm_lang$svg$Svg$tspan, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$textAnchor('middle') + ]), + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg$text(content) + ])) + ])); + }); +var _guyonvarch$catchvoid$View$renderScore = F4( + function (boardSize, elapsedTime, rounds, score) { + var scoreText = A2( + _elm_lang$core$Basics_ops['++'], + 'L', + A2( + _elm_lang$core$Basics_ops['++'], + function (_p3) { + return _elm_lang$core$Basics$toString( + _guyonvarch$catchvoid$Model_Level$currentLevelNumber(_p3)); + }(score), + A2( + _elm_lang$core$Basics_ops['++'], + ' - ', + _elm_lang$core$Basics$toString(score)))); + var scorePos = {x: 0.0, y: (boardSize.y / 2) - 35}; + if (_elm_lang$core$Native_Utils.cmp(elapsedTime, 5000) < 0) { + var _p4 = _elm_lang$core$List$head(rounds); + if (_p4.ctor === 'Just') { + return A3( + _guyonvarch$catchvoid$View$renderText, + boardSize, + scorePos, + _guyonvarch$catchvoid$View_Round$roundView(_p4._0)); + } else { + return A3(_guyonvarch$catchvoid$View$renderText, boardSize, scorePos, scoreText); + } + } else { + return A3(_guyonvarch$catchvoid$View$renderText, boardSize, scorePos, scoreText); + } + }); +var _guyonvarch$catchvoid$View$hideNewPoints = function (boardSize) { + var size = _elm_lang$core$Basics$toString( + (_guyonvarch$catchvoid$Model_Point$pointAwayDist(boardSize) + _guyonvarch$catchvoid$Model_Point$pointSize) - (A2(_elm_lang$core$Basics$max, boardSize.x, boardSize.y) / 2)); + return A2( + _elm_lang$svg$Svg$g, + _elm_lang$core$Native_List.fromArray( + []), + _elm_lang$core$Native_List.fromArray( + [ + A2( + _elm_lang$svg$Svg$rect, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$x( + A2(_elm_lang$core$Basics_ops['++'], '-', size)), + _elm_lang$svg$Svg_Attributes$width(size), + _elm_lang$svg$Svg_Attributes$height('100%'), + _elm_lang$svg$Svg_Attributes$fill(_guyonvarch$catchvoid$View$backgroundColor) + ]), + _elm_lang$core$Native_List.fromArray( + [])), + A2( + _elm_lang$svg$Svg$rect, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$x( + _elm_lang$core$Basics$toString(boardSize.x)), + _elm_lang$svg$Svg_Attributes$width(size), + _elm_lang$svg$Svg_Attributes$height('100%'), + _elm_lang$svg$Svg_Attributes$fill(_guyonvarch$catchvoid$View$backgroundColor) + ]), + _elm_lang$core$Native_List.fromArray( + [])), + A2( + _elm_lang$svg$Svg$rect, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$y( + A2(_elm_lang$core$Basics_ops['++'], '-', size)), + _elm_lang$svg$Svg_Attributes$width('100%'), + _elm_lang$svg$Svg_Attributes$height(size), + _elm_lang$svg$Svg_Attributes$fill(_guyonvarch$catchvoid$View$backgroundColor) + ]), + _elm_lang$core$Native_List.fromArray( + [])), + A2( + _elm_lang$svg$Svg$rect, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$y( + _elm_lang$core$Basics$toString(boardSize.y + _guyonvarch$catchvoid$View$headerHeight)), + _elm_lang$svg$Svg_Attributes$width('100%'), + _elm_lang$svg$Svg_Attributes$height(size), + _elm_lang$svg$Svg_Attributes$fill(_guyonvarch$catchvoid$View$backgroundColor) + ]), + _elm_lang$core$Native_List.fromArray( + [])) + ])); +}; +var _guyonvarch$catchvoid$View$view = function (model) { + var renderPoints = function (config) { + return A2( + _elm_lang$core$List$map, + A3(_guyonvarch$catchvoid$View$renderPoint, model.boardSize, model.elapsedTime, config), + model.cloud.points(config)); + }; + return A2( + _elm_lang$svg$Svg$svg, + _elm_lang$core$Native_List.fromArray( + [ + _elm_lang$svg$Svg_Attributes$width('100%'), + _elm_lang$svg$Svg_Attributes$height('100%'), + _elm_lang$svg$Svg_Attributes$style( + A2( + _elm_lang$core$Basics_ops['++'], + 'background-color: ', + A2(_elm_lang$core$Basics_ops['++'], _guyonvarch$catchvoid$View$backgroundColor, ';'))), + _elm_lang$svg$Svg_Attributes$viewBox( + A2( + _elm_lang$core$Basics_ops['++'], + '0 0 ', + A2( + _elm_lang$core$Basics_ops['++'], + _elm_lang$core$Basics$toString(model.boardSize.x), + A2( + _elm_lang$core$Basics_ops['++'], + ' ', + _elm_lang$core$Basics$toString(model.boardSize.y + _guyonvarch$catchvoid$View$headerHeight))))) + ]), + _elm_lang$core$Native_List.fromArray( + [ + _guyonvarch$catchvoid$View$renderBoard(model.currentScore), + A3( + _guyonvarch$catchvoid$View$renderPlayer, + model.boardSize, + model.player, + _guyonvarch$catchvoid$Model_Player$getPlayerSize(model.currentScore)), + A2( + _elm_lang$svg$Svg$g, + _elm_lang$core$Native_List.fromArray( + []), + renderPoints(_guyonvarch$catchvoid$Model_Config$White)), + A2( + _elm_lang$svg$Svg$g, + _elm_lang$core$Native_List.fromArray( + []), + renderPoints(_guyonvarch$catchvoid$Model_Config$Black)), + A4(_guyonvarch$catchvoid$View$renderScore, model.boardSize, model.elapsedTime, model.rounds, model.currentScore), + _guyonvarch$catchvoid$View$hideNewPoints(model.boardSize), + _guyonvarch$catchvoid$View$renderHeader(model) + ])); +}; + +var _guyonvarch$catchvoid$Main$main = { + main: _elm_lang$html$Html_App$programWithFlags( + { + init: _guyonvarch$catchvoid$Model$init, + update: _guyonvarch$catchvoid$Update$update, + subscriptions: function (model) { + return _elm_lang$core$Platform_Sub$batch( + _elm_lang$core$Native_List.fromArray( + [ + A2(_elm_lang$core$Time$every, 40, _guyonvarch$catchvoid$Msg$Time), + A2(_elm_lang$core$Platform_Sub$map, _guyonvarch$catchvoid$Msg$Keyboard, _ohanhi$keyboard_extra$Keyboard_Extra$subscriptions), + _elm_lang$keyboard$Keyboard$downs( + function (keycode) { + return _elm_lang$core$Native_Utils.eq(keycode, 69) ? _guyonvarch$catchvoid$Msg$Transform : _guyonvarch$catchvoid$Msg$NoOp; + }) + ])); + }, + view: _guyonvarch$catchvoid$View$view + }), + flags: _elm_lang$core$Json_Decode$float +}; + +var Elm = {}; +Elm['Main'] = Elm['Main'] || {}; +_elm_lang$core$Native_Platform.addPublicModule(Elm['Main'], 'Main', typeof _guyonvarch$catchvoid$Main$main === 'undefined' ? null : _guyonvarch$catchvoid$Main$main); + +if (typeof define === "function" && define['amd']) +{ + define([], function() { return Elm; }); + return; +} + +if (typeof module === "object") +{ + module['exports'] = Elm; + return; +} + +var globalElm = this['Elm']; +if (typeof globalElm === "undefined") +{ + this['Elm'] = Elm; + return; +} + +for (var publicModule in Elm) +{ + if (publicModule in globalElm) + { + throw new Error('There are two Elm modules called `' + publicModule + '` on this page! Rename one of them.'); + } + globalElm[publicModule] = Elm[publicModule]; +} + +}).call(this); + |