Skip to content

Instantly share code, notes, and snippets.

@Apanatshka

Apanatshka/stresstest.elm

Created May 30, 2014 17:38
Show Gist options
  • Save Apanatshka/4992ef379d9a82318035 to your computer and use it in GitHub Desktop.
Save Apanatshka/4992ef379d9a82318035 to your computer and use it in GitHub Desktop.
Download ZIP
Stresstest that shows the influence of duplicate tracking
Raw
stresstest.elm
time = fps 60
longList = [1..1000000]
sumSig = sum <~ (sampleOn time <| constant longList)
main = asText <~ ((,) <~ time ~ sumSig)
Raw
stresstest.html
<!DOCTYPE HTML>
<html>
<head>
<meta charset="UTF-8">
<title>stresstest</title>
<script type="text/javascript">
'use strict';
var Elm = {}; Elm.Native = {}; Elm.Native.Graphics = {};
var ElmRuntime = {}; ElmRuntime.Render = {};
Elm.Native.Error = {};
Elm.Native.Error.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Error = elm.Native.Error || {};
if (elm.Native.Error.values) return elm.Native.Error.values;
function indent(lines) {
var msg = '';
for (var i = 0; i < lines.length; ++i) {
msg += '<br/>&nbsp; &nbsp; ' + lines[i];
}
return msg;
}
function Case(moduleName, span) {
var msg = indent(['Non-exhaustive pattern match in case-expression.',
'Make sure your patterns cover every case!']);
throw new Error('Runtime error in module ' + moduleName + ' (' + span + '):' + msg);
}
function If(moduleName, span) {
var msg = indent(['Non-exhaustive pattern match in multi-way-if expression.',
'It is best to use \'otherwise\' as the last branch of multi-way-if.']);
throw new Error('Runtime error in module ' + moduleName + ' (' + span + '):' + msg);
}
function raise(str) { throw new Error(str); }
return elm.Native.Error.values = { Case: Case, If: If, raise: raise };
};
Elm.Native.Trampoline = {};
Elm.Native.Trampoline.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Trampoline = elm.Native.Trampoline || {};
if (elm.Native.Trampoline.values) return elm.Native.Trampoline.values;
// trampoline : Trampoline a -> a
function trampoline(t) {
var tramp = t;
while(true) {
switch(tramp.ctor) {
case "Done":
return tramp._0;
case "Continue":
tramp = tramp._0({ctor: "_Tuple0"});
continue;
}
}
}
return elm.Native.Trampoline.values = {
trampoline:trampoline
};
};
Elm.Native.Char = {};
Elm.Native.Char.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Char = elm.Native.Char || {};
if (elm.Native.Char.values) return elm.Native.Char.values;
function isBetween(lo,hi) { return function(chr) {
var c = chr.charCodeAt(0);
return lo <= c && c <= hi;
};
}
var isDigit = isBetween('0'.charCodeAt(0),'9'.charCodeAt(0));
var chk1 = isBetween('a'.charCodeAt(0),'f'.charCodeAt(0));
var chk2 = isBetween('A'.charCodeAt(0),'F'.charCodeAt(0));
return elm.Native.Char.values = {
fromCode : function(c) { return String.fromCharCode(c); },
toCode : function(c) { return c.toUpperCase().charCodeAt(0); },
toUpper : function(c) { return c.toUpperCase(); },
toLower : function(c) { return c.toLowerCase(); },
toLocaleUpper : function(c) { return c.toLocaleUpperCase(); },
toLocaleLower : function(c) { return c.toLocaleLowerCase(); },
isLower : isBetween('a'.charCodeAt(0),'z'.charCodeAt(0)),
isUpper : isBetween('A'.charCodeAt(0),'Z'.charCodeAt(0)),
isDigit : isDigit,
isOctDigit : isBetween('0'.charCodeAt(0),'7'.charCodeAt(0)),
isHexDigit : function(c) { return isDigit(c) || chk1(c) || chk2(c); }
};
};
Elm.Native.Debug = {};
Elm.Native.Debug.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Debug = elm.Native.Debug || {};
if (elm.Native.Debug.values) return elm.Native.Debug.values;
var show = Elm.Native.Show.make(elm).show;
function log(tag,value) {
var msg = tag + ': ' + show(value);
var process = process || {};
if (process.stdout) {
process.stdout.write(msg);
} else {
console.log(msg);
}
return value;
}
return elm.Native.Debug.values = {
log: F2(log)
};
};
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);
}
Elm.Native.Color = {};
Elm.Native.Color.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Color = elm.Native.Color || {};
if (elm.Native.Color.values) return elm.Native.Color.values;
var Utils = Elm.Native.Utils.make(elm);
function toCss(c) {
var format = '';
var colors = '';
if (c.ctor === 'RGBA') {
format = 'rgb';
colors = c._0 + ', ' + c._1 + ', ' + c._2;
} else {
format = 'hsl';
colors = (c._0 * 180 / Math.PI) + ', ' +
(c._1 * 100) + '%, ' +
(c._2 * 100) + '%';
}
if (c._3 === 1) {
return format + '(' + colors + ')';
} else {
return format + 'a(' + colors + ', ' + c._3 + ')';
}
}
return elm.Native.Color.values = {
toCss:toCss
};
};
Elm.Native.Json = {};
Elm.Native.Json.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Json = elm.Native.Json || {};
if (elm.Native.Json.values) return elm.Native.Json.values;
var Maybe = Elm.Maybe.make(elm);
var Dict = Elm.Dict.make(elm);
var List = Elm.Native.List.make(elm);
var Utils = Elm.Native.Utils.make(elm);
function toJS(v) {
switch (v.ctor) {
case 'Null' : return null;
case 'String' : return v._0;
case 'Number' : return v._0;
case 'Boolean': return v._0;
case 'Object' :
var obj = {};
var array = List.toArray(Dict.toList(v._0));
for (var i = array.length; i--; ) {
var entry = array[i];
obj[entry._0] = toJS(entry._1);
}
return obj;
case 'Array' :
var array = List.toArray(v._0);
for (var i = array.length; i--; ) {
array[i] = toJS(array[i]);
}
return array;
}
}
function toString(sep, value) {
return JSON.stringify(toJS(value), null, sep);
}
function fromJS(v) {
switch (typeof v) {
case 'string' : return { ctor:"String" , _0: v };
case 'number' : return { ctor:"Number" , _0: v };
case 'boolean': return { ctor:"Boolean", _0: v };
case 'object' :
if (v === null) return { ctor:"Null" };
if (v instanceof Array) {
var array = new Array(v.length);
for (var i = v.length; i--; ) {
array[i] = fromJS(v[i]);
}
return {
ctor:"Array",
_0: List.fromArray(array)
};
}
var array = [];
for (var key in v) {
var value = fromJS(v[key]);
array.push(Utils.Tuple2(key, value));
}
var list = List.fromArray(array);
return {
ctor:"Object",
_0: Dict.fromList(list)
};
}
}
function fromString(str) {
try {
return Maybe.Just(fromJS(JSON.parse(str)));
} catch (e) {
return Maybe.Nothing;
}
}
return elm.Native.Json.values = {
toString : F2(toString),
fromString : fromString,
fromJS : fromJS,
toJS : toJS
};
};
Elm.Native.List = {};
Elm.Native.List.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.List = elm.Native.List || {};
if (elm.Native.List.values) return elm.Native.List.values;
if ('values' in Elm.Native.List)
return elm.Native.List.values = Elm.Native.List.values;
var Utils = Elm.Native.Utils.make(elm);
// TODO: Improve Nil handling
// We can change places like: if (xs.ctor === '[]') ... to if (xs === Nil) ...
// but only if we're confident Nil can only be defined once.
// Currently (27Mar2013) each module can have different instantiations, so multiple Nil objects can exist
// (and if they're used interchangeably then direct object comparison fails where ctor doesn't).
// So, this can only be fixed when modules initialisation is also fixed.
// The performance overhead of the .ctor calls is 5-10% according to jsperf (depending on fn + list size)
// (on firefox 19)
var Nil = { ctor:'[]' };
// using freeze for every cons would be nice but is a huge (9x on firefox 19)
// performance penalty
function Cons(hd,tl) { return { ctor:"::", _0:hd, _1:tl }; }
function throwError(f) {
throw new Error("Function '" + f + "' expects a non-empty list!");
}
function toArray(xs) {
var out = [];
while (xs.ctor !== '[]') {
out.push(xs._0);
xs = xs._1;
}
return out;
}
function fromArray(arr) {
var out = Nil;
for (var i = arr.length; i--; ) {
out = Cons(arr[i], out);
}
return out;
}
function range(lo,hi) {
var lst = Nil;
if (lo <= hi) {
do { lst = Cons(hi,lst) } while (hi-->lo);
}
return lst
}
function append(xs,ys) {
// append Text
if (xs.text || ys.text) {
return Utils.txt(Utils.makeText(xs) + Utils.makeText(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;
}
function head(v) { return v.ctor === '[]' ? throwError('head') : v._0; }
function tail(v) { return v.ctor === '[]' ? throwError('tail') : v._1; }
function last(xs) {
if (xs.ctor === '[]') { throwError('last'); }
var out = xs._0;
while (xs.ctor !== '[]') {
out = xs._0;
xs = xs._1;
}
return out;
}
function map(f, xs) {
var arr = [];
while (xs.ctor !== '[]') {
arr.push(f(xs._0));
xs = xs._1;
}
return fromArray(arr);
}
// f defined similarly for both foldl and foldr (NB: different from Haskell)
// ie, foldl : (a -> b -> b) -> b -> [a] -> b
function foldl(f, b, xs) {
var acc = b;
while (xs.ctor !== '[]') {
acc = A2(f, xs._0, acc);
xs = xs._1;
}
return acc;
}
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 foldl1(f, xs) {
return xs.ctor === '[]' ? throwError('foldl1') : foldl(f, xs._0, xs._1);
}
function foldr1(f, xs) {
if (xs.ctor === '[]') { throwError('foldr1'); }
var arr = toArray(xs);
var acc = arr.pop();
for (var i = arr.length; i--; ) {
acc = A2(f, arr[i], acc);
}
return acc;
}
function scanl(f, b, xs) {
var arr = toArray(xs);
arr.unshift(b);
var len = arr.length;
for (var i = 1; i < len; ++i) {
arr[i] = A2(f, arr[i], arr[i-1]);
}
return fromArray(arr);
}
function scanl1(f, xs) {
return xs.ctor === '[]' ? throwError('scanl1') : scanl(f, xs._0, xs._1);
}
function filter(pred, xs) {
var arr = [];
while (xs.ctor !== '[]') {
if (pred(xs._0)) { arr.push(xs._0); }
xs = xs._1;
}
return fromArray(arr);
}
function length(xs) {
var out = 0;
while (xs.ctor !== '[]') {
out += 1;
xs = xs._1;
}
return out;
}
function member(x, xs) {
while (xs.ctor !== '[]') {
if (Utils.eq(x,xs._0)) return true;
xs = xs._1;
}
return false;
}
function reverse(xs) { return fromArray(toArray(xs).reverse()); }
function concat(xss) {
if (xss.ctor === '[]') return xss;
var arr = toArray(xss);
var xs = arr[arr.length-1];
for (var i = arr.length-1; i--; ) {
xs = append(arr[i], xs);
}
return xs;
}
function all(pred, xs) {
while (xs.ctor !== '[]') {
if (!pred(xs._0)) return false;
xs = xs._1;
}
return true;
}
function any(pred, xs) {
while (xs.ctor !== '[]') {
if (pred(xs._0)) return true;
xs = xs._1;
}
return false;
}
function zip(xs, ys) {
var arr = [];
while (xs.ctor !== '[]' && ys.ctor !== '[]') {
arr.push(Utils.Tuple2(xs._0, ys._0));
xs = xs._1;
ys = ys._1;
}
return fromArray(arr);
}
function zipWith(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 zipWith3(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 zipWith4(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 zipWith5(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 sort(xs) {
return fromArray(toArray(xs).sort(Utils.cmp));
}
function sortBy(f, xs) {
return fromArray(toArray(xs).sort(function(a,b){
return 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;
}));
}
function nth(xs, n) {
return toArray(xs)[n];
}
function take(n, xs) {
var arr = [];
while (xs.ctor !== '[]' && n > 0) {
arr.push(xs._0);
xs = xs._1;
--n;
}
return fromArray(arr);
}
function drop(n, xs) {
while (xs.ctor !== '[]' && n > 0) {
xs = xs._1;
--n;
}
return xs;
}
function repeat(n, x) {
var arr = [];
var pattern = [x];
while (n > 0) {
if (n & 1) arr = arr.concat(pattern);
n >>= 1, pattern = pattern.concat(pattern);
}
return fromArray(arr);
}
function join(sep, xss) {
if (sep.text) {
sep = Utils.makeText(sep);
xss = toArray(xss);
for (var i = xss.length; i--; ) {
xss[i] = Utils.makeText(xss[i]);
}
return Utils.txt(xss.join(sep));
}
if (typeof sep === 'string') return toArray(xss).join(sep);
if (xss.ctor === '[]') return Nil;
var s = toArray(sep);
var out = toArray(xss._0);
xss = xss._1;
while (xss.ctor !== '[]') {
out = out.concat(s, toArray(xss._0));
xss = xss._1;
}
return fromArray(out);
}
/*
* Only to be used internally; do some side effects for each elem
*/
function each(action, xs) {
while(xs.ctor !== '[]') {
action(xs._0);
xs = xs._1;
}
}
Elm.Native.List.values = {
Nil:Nil,
Cons:Cons,
cons:F2(Cons),
toArray:toArray,
fromArray:fromArray,
range:range,
append:append,
head:head,
tail:tail,
last:last,
map:F2(map),
foldl:F3(foldl),
foldr:F3(foldr),
foldl1:F2(foldl1),
foldr1:F2(foldr1),
scanl:F3(scanl),
scanl1:F2(scanl1),
filter:F2(filter),
length:length,
member:F2(member),
reverse:reverse,
concat:concat,
all:F2(all),
any:F2(any),
zipWith :F3(zipWith ),
zipWith3:F4(zipWith3),
zipWith4:F5(zipWith4),
zipWith5:F6(zipWith5),
zip:F2(zip),
sort:sort,
sortBy:F2(sortBy),
sortWith:F2(sortWith),
nth:F2(nth),
take:F2(take),
drop:F2(drop),
repeat:F2(repeat),
join:F2(join),
each:each
};
return elm.Native.List.values = Elm.Native.List.values;
};
Elm.Native.Array = {};
Elm.Native.Array.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Array = elm.Native.Array || {};
if (elm.Native.Array.values) return elm.Native.Array.values;
if ('values' in Elm.Native.Array)
return elm.Native.Array.values = Elm.Native.Array.values;
var List = Elm.Native.List.make(elm);
// 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:new Array() };
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);
if (slot > 0) {
while (array.lengths[slot - 1] > i) { slot--; }
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 == List.Nil) { return empty; }
// Allocate M sized blocks (table) and write list elements to it.
var table = new Array(M);
var nodes = new Array();
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) {
fromListPush({ ctor:"_Array", height:0, table:table }
, nodes);
table = new Array(M);
i = 0;
}
}
// Maybe there is something left on the table.
if (i > 0) {
fromListPush({ ctor:"_Array", height:0, table:table.splice(0,i) }
, 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) {
nodes.push({ ctor:"_Array", height:h + 1
, table:new Array()
, lengths:new Array() });
}
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:new Array()
, lengths:new Array() };
}
}
// 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_(List.Nil, a);
}
function toList_(list, a) {
for (var i = a.table.length - 1; i >= 0; i--) {
list = a.height == 0 ? 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) };
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) };
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 ? 0 : a.lengths[i - 1]);
}
return newA;
}
function foldl(f, b, a) {
for (var i = 0; i < a.table.length; i++) {
b = A2(f, a.height == 0 ? a.table[i] : foldl(f, b, a.table[i]), b);
}
return b;
}
function foldr(f, b, a) {
for (var i = a.table.length; i--; ) {
b = A2(f, a.height == 0 ? a.table[i] : foldr(f, b, a.table[i]), b);
}
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 + 1)
, lengths:a.lengths.slice(0, right + 1) };
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[left] = 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.
// TODO: Add support for appending trees of different sizes. Current
// behavior will just rise the lower tree and then append them.
function append(a,b) {
if (b.height > a.height) { return append(parentise(a, b.height), b); }
if (a.height > b.height) { return append(a, parentise(b, a.height)); }
if (a.height == 0) { return append(parentise(a, 1), parentise(b, 1)); }
var c = append_(a, b);
if (c[1].table.length > 0) {
return siblise(c[0], c[1]);
} else {
return c[0];
}
}
// Returns an array of two nodes. The second node _may_ be empty. This case
// needs to be handled by the function, that called append_. May be only
// called for trees with an minimal height of 1.
function append_(a, b) {
if (a.height == 1) {
// Check if balancing is needed and return based on that.
var toRemove = calcToRemove(a, b);
if (toRemove <= E) {
return [a,b];
}
return shuffle(a, b, toRemove);
}
var appended = append_(botRight(a), botLeft(b));
a = nodeCopy(a), b = nodeCopy(b);
// Adjust the bottom right side of the new tree.
a.table[a.table.length - 1] = appended[0];
a.lengths[a.lengths.length - 1] = length(appended[0])
a.lengths[a.lengths.length - 1] += a.lengths.length > 1 ? a.lengths[a.lengths.length - 2] : 0;
// Adjust the bottom left side of the new tree.
if (appended[1].table.length > 0) {
b.table[0] = appended[1];
b.lengths[0] = length(appended[1]);
for (var i = 1, len = length(b.table[0]); i < b.lengths.length; i++) {
len += length(b.table[i]);
b.lengths[i] = len;
}
} else {
b.table.shift();
for (var i = 1; i < b.lengths.length; i++) {
b.lengths[i] = b.lengths[i] - b.lengths[0];
}
b.lengths.shift();
}
// Check if balancing is needed and return based on that.
var toRemove = calcToRemove(a, b);
if (toRemove <= E || b.table.length == 0) {
return [a,b];
}
return shuffle(a, b, toRemove);
}
// 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 - 1] > 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] };
} else {
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;
} else {
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 };
}
Elm.Native.Array.values = {
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
};
return elm.Native.Array.values = Elm.Native.Array.values;
}
Elm.Native.JavaScript = {};
Elm.Native.JavaScript.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.JavaScript = elm.Native.JavaScript || {};
if (elm.Native.JavaScript.values) return elm.Native.JavaScript.values;
var List = Elm.Native.List.make(elm);
var Render = ElmRuntime.use(ElmRuntime.Render.Element);
function fromJS(v) {
var type = typeof v;
if (type === 'number' ) return v;
if (type === 'boolean') return v;
if (type === 'string' ) return v;
if (v instanceof Array) {
var arr = [];
var len = v.length;
for (var i = 0; i < len; ++i) {
var x = fromJS(v[i]);
if (x !== null) arr.push(x);
}
return List.fromArray(arr);
}
if (type === 'object') {
var rec = { _:{} };
for (var f in v) {
var x = fromJS(v[f]);
if (x !== null) rec[f] = x;
}
return rec;
}
return null;
}
function toJS(v) {
var type = typeof v;
if (type === 'number' || type === 'boolean' || type === 'string') return v;
if (type === 'object' && '_' in v) {
var obj = {};
for (var k in v) {
var x = toJS(v[k]);
if (x !== null) obj[k] = x;
}
return obj;
}
if (type === 'object' && (v.ctor === '::' || v.ctor === '[]')) {
var array = List.toArray(v);
for (var i = array.length; i--; ) {
array[i] = toJS(array[i]);
}
return array;
}
return null;
}
function fromRecord(r) {
if (typeof r === 'object' && '_' in r) {
return toJS(r);
}
throw new Error("'fromRecord' must be called on a record.");
}
return elm.Native.JavaScript.values = {
toRecord : fromJS,
fromRecord : fromRecord
};
};
Elm.Native.Utils = {};
Elm.Native.Utils.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Utils = elm.Native.Utils || {};
if (elm.Native.Utils.values) return elm.Native.Utils.values;
function eq(l,r) {
var stack = [{'x': l, 'y': r}]
while (stack.length > 0) {
var front = stack.pop();
var x = front.x;
var y = front.y;
if (x === y) continue;
if (typeof x === "object") {
var c = 0;
for (var i in x) {
++c;
if (i in y) {
if (i !== 'ctor') {
stack.push({ 'x': x[i], 'y': y[i] });
}
} else {
return false;
}
}
if ('ctor' in x) {
stack.push({'x': x.ctor, 'y': y.ctor});
}
if (c !== Object.keys(y).length) {
return false;
};
} else if (typeof x === 'function') {
throw new Error('Equality error: general function equality is ' +
'undecidable, and therefore, unsupported');
} else {
return false;
}
}
return true;
}
// code in Generate/JavaScript.hs depends on the particular
// integer values assigned to LT, EQ, and GT
var LT = -1, EQ = 0, GT = 1, ord = ['LT','EQ','GT'];
function compare(x,y) { return { ctor: ord[cmp(x,y)+1] } }
function cmp(x,y) {
var ord;
if (typeof x !== 'object'){
return x === y ? EQ : x < y ? LT : GT;
}
else if (x.isChar){
var a = x.toString();
var b = y.toString();
return a === b ? EQ : a < b ? LT : GT;
}
else if (x.ctor === "::" || x.ctor === "[]") {
while (true) {
if (x.ctor === "[]" && y.ctor === "[]") return EQ;
if (x.ctor !== y.ctor) return x.ctor === '[]' ? LT : GT;
ord = cmp(x._0, y._0);
if (ord !== EQ) return ord;
x = x._1;
y = y._1;
}
}
else if (x.ctor.slice(0,6) === '_Tuple') {
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;
}
else {
throw new Error('Comparison error: comparison is only defined on ints, ' +
'floats, times, chars, strings, lists of comparable values, ' +
'and tuples of comparable values.');
}
}
var Tuple0 = { ctor: "_Tuple0" };
function Tuple2(x,y) { return { ctor:"_Tuple2", _0:x, _1:y } }
function chr(c) {
var x = new String(c);
x.isChar = true;
return x;
}
function txt(str) {
var t = new String(str);
t.text = true;
return t;
}
function makeText(text) {
var style = '';
var href = '';
while (true) {
if (text.style) {
style += text.style;
text = text.text;
continue;
}
if (text.href) {
href = text.href;
text = text.text;
continue;
}
if (href) text = '<a href="' + href + '">' + text + '</a>';
if (style) text = '<span style="' + style + '">' + text + '</span>';
return text;
}
}
var count = 0;
function guid(_) { return count++ }
function copy(r) {
var o = {};
for (var i in r) { o[i] = r[i]; }
return o;
}
function remove(x,r) {
var o = copy(r);
if (x in o._) {
o[x] = o._[x][0];
o._[x] = o._[x].slice(1);
if (o._[x].length === 0) { delete o._[x]; }
} else {
delete o[x];
}
return o;
}
function replace(kvs,r) {
var o = copy(r);
for (var i = kvs.length; i--; ) {
var kvsi = kvs[i];
o[kvsi[0]] = kvsi[1];
}
return o;
}
function insert(x,v,r) {
var o = copy(r);
if (x in o) o._[x] = [o[x]].concat(x in o._ ? o._[x].slice(0) : []);
o[x] = v;
return o;
}
function max(a,b) { return a > b ? a : b }
function min(a,b) { return a < b ? 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 htmlHeight(width, rawHtml) {
// create dummy node
var html = rawHtml.html;
var t = document.createElement('div');
t.innerHTML = html;
if (width > 0) { t.style.width = width + "px"; }
t.style.visibility = "hidden";
t.style.styleFloat = "left";
t.style.cssFloat = "left";
document.body.appendChild(t);
// insert interpolated values
var args = rawHtml.args;
var guid = rawHtml.guid;
for (var i = args.length; i--; ) {
var arg = args[i];
var span = document.getElementById('md-' + guid + '-' + i);
if (arg.isElement) {
span.style.width = arg.props.width + 'px';
span.style.height = arg.props.height + 'px';
} else {
span.innerHTML = arg;
}
}
// get dimensions
var style = window.getComputedStyle(t, null);
var w = Math.ceil(style.getPropertyValue("width").slice(0,-2) - 0);
var h = Math.ceil(style.getPropertyValue("height").slice(0,-2) - 0);
document.body.removeChild(t);
return Tuple2(w,h);
}
function getXY(e) {
var posx = 0;
var posy = 0;
if (e.pageX || e.pageY) {
posx = e.pageX;
posy = e.pageY;
} else if (e.clientX || e.clientY) {
posx = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
posy = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;
}
if (elm.display === ElmRuntime.Display.COMPONENT) {
var rect = elm.node.getBoundingClientRect();
var relx = rect.left + document.body.scrollLeft + document.documentElement.scrollLeft;
var rely = rect.top + document.body.scrollTop + document.documentElement.scrollTop;
// TODO: figure out if there is a way to avoid rounding here
posx = posx - Math.round(relx) - elm.node.clientLeft;
posy = posy - Math.round(rely) - elm.node.clientTop;
}
return Tuple2(posx, posy);
}
function isJSArray(a) {
return a instanceof Array;
}
return elm.Native.Utils.values = {
eq:eq,
cmp:cmp,
compare:F2(compare),
Tuple0:Tuple0,
Tuple2:Tuple2,
chr:chr,
txt:txt,
makeText:makeText,
copy: copy,
remove: remove,
replace: replace,
insert: insert,
guid: guid,
max : F2(max),
min : F2(min),
mod : F2(mod),
htmlHeight: F2(htmlHeight),
getXY: getXY,
isJSArray: isJSArray,
toFloat: function(x) { return +x; }
};
};
Elm.Native.Regex = {};
Elm.Native.Regex.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Regex = elm.Native.Regex || {};
if (elm.Native.Regex.values) return elm.Native.Regex.values;
if ('values' in Elm.Native.Regex)
return elm.Native.Regex.values = Elm.Native.Regex.values;
var List = Elm.Native.List.make(elm);
var Maybe = Elm.Maybe.make(elm);
function escape(str) {
return str.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
}
function caseInsensitive(re) {
return new RegExp(re.source, 'gi');
}
function regex(raw) {
return new RegExp(raw, 'g');
}
function contains(re, string) {
return string.match(re) !== null;
}
function find(n, re, str) {
n = n.ctor === "All" ? Infinity : n._0;
var out = [];
var number = 0;
var string = str;
var result;
while (number++ < n && (result = re.exec(string))) {
var i = result.length - 1;
var subs = new Array(i);
while (i > 0) {
var submatch = result[i];
subs[--i] = submatch === undefined
? Maybe.Nothing
: Maybe.Just(submatch);
}
out.push({
_:{},
match: result[0],
submatches: List.fromArray(subs),
index: result.index,
number: number
});
}
return List.fromArray(out);
}
function replace(n, re, replacer, string) {
n = n.ctor === "All" ? Infinity : n._0;
var count = 0;
function jsReplacer(match) {
if (count++ > n) return match;
var i = arguments.length-3;
var submatches = new Array(i);
while (i > 0) {
var submatch = arguments[i];
submatches[--i] = submatch === undefined
? Maybe.Nothing
: Maybe.Just(submatch);
}
return replacer({
_:{},
match:match,
submatches:List.fromArray(submatches),
index:arguments[i-1],
number:count
});
}
return string.replace(re, jsReplacer);
}
function split(n, re, str) {
if (n === Infinity) {
return List.fromArray(string.split(re));
}
var string = str;
var result;
var out = [];
var start = re.lastIndex;
while (n--) {
if (!(result = re.exec(string))) break;
out.push(string.slice(start, result.index));
start = re.lastIndex;
}
out.push(string.slice(start));
return List.fromArray(out);
}
return Elm.Native.Regex.values = {
regex: regex,
caseInsensitive: caseInsensitive,
escape: escape,
contains: F2(contains),
find: F3(find),
replace: F4(replace),
split: F3(split)
};
};
Elm.Native.Ports = {};
Elm.Native.Ports.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Ports = elm.Native.Ports || {};
if (elm.Native.Ports.values) return elm.Native.Ports.values;
var Signal = Elm.Signal.make(elm);
function incomingSignal(converter) {
converter.isSignal = true;
return converter;
}
function outgoingSignal(converter) {
return function(signal) {
var subscribers = []
function subscribe(handler) {
subscribers.push(handler);
}
function unsubscribe(handler) {
subscribers.pop(subscribers.indexOf(handler));
}
A2( Signal.lift, function(value) {
var val = converter(value);
var len = subscribers.length;
for (var i = 0; i < len; ++i) {
subscribers[i](val);
}
}, signal);
return { subscribe:subscribe, unsubscribe:unsubscribe };
}
}
function portIn(name, converter) {
var jsValue = elm.ports.incoming[name];
if (jsValue === undefined) {
throw new Error("Initialization Error: port '" + name +
"' was not given an input!");
}
elm.ports.uses[name] += 1;
try {
var elmValue = converter(jsValue);
} catch(e) {
throw new Error("Initialization Error on port '" + name + "': \n" + e.message);
}
// just return a static value if it is not a signal
if (!converter.isSignal) {
return elmValue;
}
// create a signal if necessary
var signal = Signal.constant(elmValue);
function send(jsValue) {
try {
var elmValue = converter(jsValue);
} catch(e) {
throw new Error("Error sending to port '" + name + "': \n" + e.message);
}
setTimeout(function() {
elm.notify(signal.id, elmValue);
}, 0);
}
elm.ports.outgoing[name] = { send:send };
return signal;
}
function portOut(name, converter, value) {
try {
elm.ports.outgoing[name] = converter(value);
} catch(e) {
throw new Error("Initialization Error on port '" + name + "': \n" + e.message);
}
return value;
}
return elm.Native.Ports.values = {
incomingSignal: incomingSignal,
outgoingSignal: outgoingSignal,
portOut: portOut,
portIn: portIn
};
};
Elm.Native.Basics = {};
Elm.Native.Basics.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Basics = elm.Native.Basics || {};
if (elm.Native.Basics.values) return elm.Native.Basics.values;
var JS = Elm.Native.JavaScript.make(elm);
var Utils = Elm.Native.Utils.make(elm);
function div(a,b) { return (a/b)|0; }
function rem(a,b) { return a % b; }
var mod = Utils.mod;
function abs(x) { return x < 0 ? -x : x; }
function logBase(base,n) { return Math.log(n) / Math.log(base); }
function min(a,b) { return Utils.cmp(a,b) < 0 ? a : b; }
function max(a,b) { return Utils.cmp(a,b) > 0 ? a : b; }
function clamp(lo,hi,n) {
return Utils.cmp(n,lo) < 0 ? lo : Utils.cmp(n,hi) > 0 ? hi : n; }
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; }
var basics = {
div:F2(div),
rem:F2(rem),
mod: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),
sqrt:Math.sqrt,
abs:abs,
logBase:F2(logBase),
min:F2(min),
max:F2(max),
clamp:F3(clamp),
compare:Utils.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
};
return elm.Native.Basics.values = basics;
};
Elm.Native.Text = {};
Elm.Native.Text.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Text = elm.Native.Text || {};
if (elm.Native.Text.values) return elm.Native.Text.values;
var toCss = Elm.Native.Color.make(elm).toCss;
var Element = Elm.Graphics.Element.make(elm);
var List = Elm.Native.List.make(elm);
var Utils = Elm.Native.Utils.make(elm);
function makeSpaces(s) {
if (s.length == 0) { return s; }
var arr = s.split('');
if (arr[0] == ' ') { arr[0] = "&nbsp;" }
for (var i = arr.length; --i; ) {
if (arr[i][0] == ' ' && arr[i-1] == ' ') {
arr[i-1] = arr[i-1] + arr[i];
arr[i] = '';
}
}
for (var i = arr.length; i--; ) {
if (arr[i].length > 1 && arr[i][0] == ' ') {
var spaces = arr[i].split('');
for (var j = spaces.length - 2; j >= 0; j -= 2) {
spaces[j] = '&nbsp;';
}
arr[i] = spaces.join('');
}
}
arr = arr.join('');
if (arr[arr.length-1] === " ") {
return arr.slice(0,-1) + '&nbsp;';
}
return arr;
}
function properEscape(str) {
if (str.length == 0) return str;
str = str //.replace(/&/g, "&#38;")
.replace(/"/g, '&#34;')
.replace(/'/g, "&#39;")
.replace(/</g, "&#60;")
.replace(/>/g, "&#62;")
.replace(/\n/g, "<br/>");
var arr = str.split('<br/>');
for (var i = arr.length; i--; ) {
arr[i] = makeSpaces(arr[i]);
}
return arr.join('<br/>');
}
function toText(str) { return Utils.txt(properEscape(str)); }
// conversions from Elm values to CSS
function toTypefaces(list) {
var typefaces = List.toArray(list);
for (var i = typefaces.length; i--; ) {
var typeface = typefaces[i];
if (typeface.indexOf(' ') > -1) {
typefaces[i] = "'" + typeface + "'";
}
}
return typefaces.join(',');
}
function toLine(line) {
var ctor = line.ctor;
return ctor === 'Under' ? 'underline' :
ctor === 'Over' ? 'overline' : 'line-through';
}
// setting styles of Text
function style(style, text) {
var newText = '<span style="color:' + toCss(style.color) + ';'
if (style.typeface.ctor !== '[]') {
newText += 'font-family:' + toTypefaces(style.typeface) + ';'
}
if (style.height.ctor !== "Nothing") {
newText += 'font-size:' + style.height._0 + 'px;';
}
if (style.bold) {
newText += 'font-weight:bold;';
}
if (style.italic) {
newText += 'font-style:italic;';
}
if (style.line.ctor !== 'Nothing') {
newText += 'text-decoration:' + toLine(style.line._0) + ';';
}
newText += '">' + Utils.makeText(text) + '</span>'
return Utils.txt(newText);
}
function height(px, text) {
return { style: 'font-size:' + px + 'px;', text:text }
}
function typeface(names, text) {
return { style: 'font-family:' + toTypefaces(names) + ';', text:text }
}
function monospace(text) {
return { style: 'font-family:monospace;', text:text }
}
function italic(text) {
return { style: 'font-style:italic;', text:text }
}
function bold(text) {
return { style: 'font-weight:bold;', text:text }
}
function link(href, text) {
return { href: toText(href), text:text };
}
function line(line, text) {
return { style: 'text-decoration:' + toLine(line) + ';', text:text };
}
function color(color, text) {
return { style: 'color:' + toCss(color) + ';', text:text };
}
function block(align) {
return function(text) {
var raw = {
ctor :'RawHtml',
html : Utils.makeText(text),
align: align,
guid : null,
args : []
};
var pos = A2(Utils.htmlHeight, 0, raw);
return A3(Element.newElement, pos._0, pos._1, raw);
}
}
function markdown(text, guid) {
var raw = {
ctor:'RawHtml',
html: text,
align: null,
guid: guid,
args: []
};
var pos = A2(Utils.htmlHeight, 0, raw);
return A3(Element.newElement, pos._0, pos._1, raw);
}
return elm.Native.Text.values = {
toText: toText,
height : F2(height),
italic : italic,
bold : bold,
line : F2(line),
monospace : monospace,
typeface : F2(typeface),
color : F2(color),
link : F2(link),
style : F2(style),
leftAligned : block('left'),
rightAligned : block('right'),
centered : block('center'),
justified : block('justify'),
markdown : markdown,
toTypefaces:toTypefaces,
toLine:toLine
};
};
Elm.Native.Bitwise = {};
Elm.Native.Bitwise.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Bitwise = elm.Native.Bitwise || {};
if (elm.Native.Bitwise.values) return elm.Native.Bitwise.values;
function and(a,b) { return a & b; }
function or (a,b) { return a | b; }
function xor(a,b) { return a ^ b; }
function not(a) { return ~a; }
function sll(a,offset) { return a << offset; }
function sra(a,offset) { return a >> offset; }
function srl(a,offset) { return a >>> offset; }
return elm.Native.Bitwise.values = {
and: F2(and),
or : F2(or ),
xor: F2(xor),
complement: not,
shiftLeft : F2(sll),
shiftRightArithmatic: F2(sra),
shiftRightLogical : F2(srl)
};
};
Elm.Native.Date = {};
Elm.Native.Date.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Date = elm.Native.Date || {};
if (elm.Native.Date.values) return elm.Native.Date.values;
var Maybe = Elm.Maybe.make(elm);
function dateNow() { return new window.Date; }
function readDate(str) {
var d = new window.Date(str);
if (isNaN(d.getTime())) return Maybe.Nothing;
return Maybe.Just(d);
}
var dayTable = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
var monthTable = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
return elm.Native.Date.values = {
read : readDate,
year : function(d) { return d.getFullYear(); },
month : function(d) { return { ctor:monthTable[d.getMonth()] }; },
day : function(d) { return d.getDate(); },
hour : function(d) { return d.getHours(); },
minute : function(d) { return d.getMinutes(); },
second : function(d) { return d.getSeconds(); },
toTime : function(d) { return d.getTime(); },
fromTime: function(t) { return new window.Date(t); },
dayOfWeek : function(d) { return { ctor:dayTable[d.getDay()] }; }
};
};
Elm.Native.Show = {};
Elm.Native.Show.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Show = elm.Native.Show || {};
if (elm.Native.Show.values) return elm.Native.Show.values;
var NList = Elm.Native.List.make(elm);
var Array = Elm.Array.make(elm);
var List = Elm.List.make(elm);
var Dict = Elm.Dict.make(elm);
var Tuple2 = Elm.Native.Utils.make(elm).Tuple2;
var toString = function(v) {
var type = typeof v;
if (type === "function") {
var name = v.func ? v.func.name : v.name;
return '<function' + (name === '' ? '' : ': ') + name + '>';
} else if (type === "boolean") {
return v ? "True" : "False";
} else if (type === "number") {
return v+"";
} else if ((v instanceof String) && v.isChar) {
return "'" + addSlashes(v) + "'";
} else if (type === "string") {
return '"' + addSlashes(v) + '"';
} else if (type === "object" && '_' in v && probablyPublic(v)) {
var output = [];
for (var k in v._) {
for (var i = v._[k].length; i--; ) {
output.push(k + " = " + toString(v._[k][i]));
}
}
for (var k in v) {
if (k === '_') continue;
output.push(k + " = " + toString(v[k]));
}
if (output.length === 0) return "{}";
return "{ " + output.join(", ") + " }";
} else if (type === "object" && 'ctor' in v) {
if (v.ctor.substring(0,6) === "_Tuple") {
var output = [];
for (var k in v) {
if (k === 'ctor') continue;
output.push(toString(v[k]));
}
return "(" + output.join(",") + ")";
} else if (v.ctor === "_Array") {
var list = Array.toList(v);
return "Array.fromList " + toString(list);
} else if (v.ctor === "::") {
var output = '[' + toString(v._0);
v = v._1;
while (v.ctor === "::") {
output += "," + toString(v._0);
v = v._1;
}
return output + ']';
} else if (v.ctor === "[]") {
return "[]";
} else if (v.ctor === "RBNode" || v.ctor === "RBEmpty") {
var cons = F3(function(k,v,acc){return NList.Cons(Tuple2(k,v),acc)});
var list = A3(Dict.foldr, cons, NList.Nil, v);
var name = "Dict";
if (list.ctor === "::" && list._0._1.ctor === "_Tuple0") {
name = "Set";
list = A2(List.map, function(x){return x._0}, list);
}
return name + ".fromList " + toString(list);
} else {
var output = "";
for (var i in v) {
if (i === 'ctor') continue;
var str = toString(v[i]);
var parenless = str[0] === '{' || str[0] === '<' || str.indexOf(' ') < 0;
output += ' ' + (parenless ? str : '(' + str + ')');
}
return v.ctor + output;
}
}
if (type === 'object' && 'recv' in v) return '<signal>';
return "<internal structure>";
};
function addSlashes(str) {
return str.replace(/\\/g, '\\\\')
.replace(/\n/g, '\\n')
.replace(/\t/g, '\\t')
.replace(/\r/g, '\\r')
.replace(/\v/g, '\\v')
.replace(/\0/g, '\\0')
.replace(/\'/g, "\\'")
.replace(/\"/g, '\\"');
}
function probablyPublic(v) {
var keys = Object.keys(v);
var len = keys.length;
if (len === 3
&& 'props' in v
&& 'element' in v) return false;
if (len === 5
&& 'horizontal' in v
&& 'vertical' in v
&& 'x' in v
&& 'y' in v) return false;
if (len === 7
&& 'theta' in v
&& 'scale' in v
&& 'x' in v
&& 'y' in v
&& 'alpha' in v
&& 'form' in v) return false;
return true;
}
return elm.Native.Show.values = { show:toString };
};
Elm.Native.Transform2D = {};
Elm.Native.Transform2D.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Transform2D = elm.Native.Transform2D || {};
if (elm.Native.Transform2D.values) return elm.Native.Transform2D.values;
var A;
if (typeof Float32Array === 'undefined') {
A = function(arr) {
this.length = arr.length;
this[0] = arr[0];
this[1] = arr[1];
this[2] = arr[2];
this[3] = arr[3];
this[4] = arr[4];
this[5] = arr[5];
};
} else {
A = Float32Array;
}
// layout of matrix in an array is
//
// | m11 m12 dx |
// | m21 m22 dy |
// | 0 0 1 |
//
// new A([ m11, m12, dx, m21, m22, dy ])
var identity = new A([1,0,0,0,1,0]);
function matrix(m11, m12, m21, m22, dx, dy) {
return new A([m11, m12, dx, m21, m22, dy]);
}
function rotation(t) {
var c = Math.cos(t);
var s = Math.sin(t);
return new A([c, -s, 0, s, c, 0]);
}
function rotate(t,m) {
var c = Math.cos(t);
var s = Math.sin(t);
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];
return new A([m11*c + m12*s, -m11*s + m12*c, m[2],
m21*c + m22*s, -m21*s + m22*c, m[5]]);
}
/*
function move(xy,m) {
var x = xy._0;
var y = xy._1;
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];
return new A([m11, m12, m11*x + m12*y + m[2],
m21, m22, m21*x + m22*y + m[5]]);
}
function scale(s,m) { return new A([m[0]*s, m[1]*s, m[2], m[3]*s, m[4]*s, m[5]]); }
function scaleX(x,m) { return new A([m[0]*x, m[1], m[2], m[3]*x, m[4], m[5]]); }
function scaleY(y,m) { return new A([m[0], m[1]*y, m[2], m[3], m[4]*y, m[5]]); }
function reflectX(m) { return new A([-m[0], m[1], m[2], -m[3], m[4], m[5]]); }
function reflectY(m) { return new A([m[0], -m[1], m[2], m[3], -m[4], m[5]]); }
function transform(m11, m21, m12, m22, mdx, mdy, n) {
var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5];
return new A([m11*n11 + m12*n21,
m11*n12 + m12*n22,
m11*ndx + m12*ndy + mdx,
m21*n11 + m22*n21,
m21*n12 + m22*n22,
m21*ndx + m22*ndy + mdy]);
}
*/
function multiply(m, n) {
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4], mdx = m[2], mdy = m[5];
var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5];
return new A([m11*n11 + m12*n21,
m11*n12 + m12*n22,
m11*ndx + m12*ndy + mdx,
m21*n11 + m22*n21,
m21*n12 + m22*n22,
m21*ndx + m22*ndy + mdy]);
}
return elm.Native.Transform2D.values = {
identity:identity,
matrix:F6(matrix),
rotation:rotation,
multiply:F2(multiply)
/*
transform:F7(transform),
rotate:F2(rotate),
move:F2(move),
scale:F2(scale),
scaleX:F2(scaleX),
scaleY:F2(scaleY),
reflectX:reflectX,
reflectY:reflectY
*/
};
};
Elm.Native.String = {};
Elm.Native.String.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.String = elm.Native.String || {};
if (elm.Native.String.values) return elm.Native.String.values;
if ('values' in Elm.Native.String)
return elm.Native.String.values = Elm.Native.String.values;
var Char = Elm.Char.make(elm);
var Maybe = Elm.Maybe.make(elm);
var List = Elm.Native.List.make(elm);
var Utils = Elm.Native.Utils.make(elm);
function isEmpty(str) {
return str.length === 0;
}
function cons(chr,str) {
return chr + str;
}
function uncons(str) {
var hd;
return (hd = str[0]) ? Maybe.Just(Utils.Tuple2(Utils.chr(hd), str.slice(1)))
: Maybe.Nothing;
}
function append(a,b) {
return a + b;
}
function concat(strs) {
return 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(Utils.chr(out[i]));
}
return out.join('');
}
function filter(pred,str) {
return str.split('').map(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, Utils.chr(str[i]), b);
}
return b;
}
function foldr(f,b,str) {
for (var i = str.length; i--; ) {
b = A2(f, Utils.chr(str[i]), b);
}
return b;
}
function split(sep, str) {
return List.fromArray(str.split(sep));
}
function join(sep, strs) {
return 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.trimLeft();
}
function trimRight(str) {
return str.trimRight();
}
function words(str) {
return List.fromArray(str.trim().split(/\s+/g));
}
function lines(str) {
return 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(Utils.chr(str[i]))) return true;
}
return false;
}
function all(pred, str) {
for (var i = str.length; i--; ) {
if (!pred(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;
var i = 0;
var is = [];
while ((i = str.indexOf(sub, i)) > -1) {
is.push(i);
i = i + subLen;
}
return List.fromArray(is);
}
function toInt(s) {
var len = s.length;
if (len === 0) { return Maybe.Nothing; }
var start = 0;
if (s[0] == '-') {
if (len === 1) { return Maybe.Nothing; }
start = 1;
}
for (var i = start; i < len; ++i) {
if (!Char.isDigit(s[i])) { return Maybe.Nothing; }
}
return Maybe.Just(parseInt(s, 10));
}
function toFloat(s) {
var len = s.length;
if (len === 0) { return Maybe.Nothing; }
var start = 0;
if (s[0] == '-') {
if (len === 1) { return Maybe.Nothing; }
start = 1;
}
var dotCount = 0;
for (var i = start; i < len; ++i) {
if (Char.isDigit(s[i])) { continue; }
if (s[i] === '.') {
dotCount += 1;
if (dotCount <= 1) { continue; }
}
return Maybe.Nothing;
}
return Maybe.Just(parseFloat(s));
}
function toList(str) {
return List.fromArray(str.split('').map(Utils.chr));
}
function fromList(chars) {
return List.toArray(chars).join('');
}
return Elm.Native.String.values = {
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
};
};
Elm.Native.Graphics.Input = {};
Elm.Native.Graphics.Input.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Graphics = elm.Native.Graphics || {};
elm.Native.Graphics.Input = elm.Native.Graphics.Input || {};
if (elm.Native.Graphics.Input.values) return elm.Native.Graphics.Input.values;
var Render = ElmRuntime.use(ElmRuntime.Render.Element);
var newNode = ElmRuntime.use(ElmRuntime.Render.Utils).newElement;
var toCss = Elm.Native.Color.make(elm).toCss;
var Text = Elm.Native.Text.make(elm);
var Signal = Elm.Signal.make(elm);
var newElement = Elm.Graphics.Element.make(elm).newElement;
var List = Elm.Native.List.make(elm);
var Utils = Elm.Native.Utils.make(elm);
var Tuple2 = Utils.Tuple2;
function input(initialValue) {
var signal = Signal.constant(initialValue);
return { _:{}, signal:signal, handle:signal };
}
function renderDropDown(signal, values) {
return function(_) {
var entries = List.toArray(values);
var drop = newNode('select');
drop.style.border = '0 solid';
drop.style.pointerEvents = 'auto';
for (var i = 0; i < entries.length; ++i) {
var option = newNode('option');
var name = entries[i]._0;
option.value = name;
option.innerHTML = name;
drop.appendChild(option);
}
drop.addEventListener('change', function() {
elm.notify(signal.id, entries[drop.selectedIndex]._1);
});
var t = drop.cloneNode(true);
t.style.visibility = "hidden";
elm.node.appendChild(t);
var style = window.getComputedStyle(t, null);
var w = Math.ceil(style.getPropertyValue("width").slice(0,-2) - 0);
var h = Math.ceil(style.getPropertyValue("height").slice(0,-2) - 0);
elm.node.removeChild(t);
return drop;
};
}
function updateDropDown(node, oldModel, newModel) {
}
function dropDown(signal, values) {
return A3(newElement, 100, 24, {
ctor: 'Custom',
type: 'DropDown',
render: renderDropDown(signal,values),
update: updateDropDown,
model: {}
});
}
function renderButton(model) {
var node = newNode('button');
node.style.display = 'block';
node.style.pointerEvents = 'auto';
node.elm_signal = model.signal;
node.elm_value = model.value;
function click() {
elm.notify(node.elm_signal.id, node.elm_value);
}
node.addEventListener('click', click);
node.innerHTML = model.text;
return node;
}
function updateButton(node, oldModel, newModel) {
node.elm_signal = newModel.signal;
node.elm_value = newModel.value;
var txt = newModel.text;
if (oldModel.text !== txt) node.innerHTML = txt;
}
function button(signal, value, text) {
return A3(newElement, 100, 40, {
ctor: 'Custom',
type: 'Button',
render: renderButton,
update: updateButton,
model: { signal:signal, value:value, text:text }
});
}
function renderCustomButton(model) {
var btn = newNode('div');
btn.style.pointerEvents = 'auto';
btn.elm_signal = model.signal;
btn.elm_value = model.value;
btn.elm_up = Render.render(model.up);
btn.elm_hover = Render.render(model.hover);
btn.elm_down = Render.render(model.down);
function replace(node) {
if (node !== btn.firstChild) {
btn.replaceChild(node, btn.firstChild);
}
}
var overCount = 0;
function over(e) {
if (overCount++ > 0) return;
replace(btn.elm_hover);
}
function out(e) {
if (btn.contains(e.toElement || e.relatedTarget)) return;
overCount = 0;
replace(btn.elm_up);
}
function up() {
replace(btn.elm_hover);
elm.notify(btn.elm_signal.id, btn.elm_value);
}
function down() {
replace(btn.elm_down);
}
btn.addEventListener('mouseover', over);
btn.addEventListener('mouseout' , out);
btn.addEventListener('mousedown', down);
btn.addEventListener('mouseup' , up);
btn.appendChild(btn.elm_up);
return btn;
}
function updateCustomButton(node, oldModel, newModel) {
var signal = newModel.signal;
node.elm_up.elm_signal = signal;
node.elm_hover.elm_signal = signal;
node.elm_down.elm_signal = signal;
var value = newModel.value;
node.elm_up.elm_value = value;
node.elm_hover.elm_value = value;
node.elm_down.elm_value = value;
Render.update(node.elm_up, oldModel.up, newModel.up)
Render.update(node.elm_hover, oldModel.hover, newModel.hover)
Render.update(node.elm_down, oldModel.down, newModel.down)
}
function max3(a,b,c) {
var ab = a > b ? a : b;
return ab > c ? ab : c;
}
function customButton(signal, value, up, hover, down) {
return A3(newElement,
max3(up.props.width, hover.props.width, down.props.width),
max3(up.props.height, hover.props.height, down.props.height),
{ ctor: 'Custom',
type: 'CustomButton',
render: renderCustomButton,
update: updateCustomButton,
model: { signal:signal, value:value, up:up, hover:hover, down:down }
});
}
function renderCheckbox(model) {
var node = newNode('input');
node.type = 'checkbox';
node.checked = model.checked;
node.style.display = 'block';
node.style.pointerEvents = 'auto';
node.elm_signal = model.signal;
node.elm_handler = model.handler;
function change() {
elm.notify(node.elm_signal.id, node.elm_handler(node.checked));
}
node.addEventListener('change', change);
return node;
}
function updateCheckbox(node, oldModel, newModel) {
node.elm_signal = newModel.signal;
node.elm_handler = newModel.handler;
node.checked = newModel.checked;
return true;
}
function checkbox(signal, handler, checked) {
return A3(newElement, 13, 13, {
ctor: 'Custom',
type: 'CheckBox',
render: renderCheckbox,
update: updateCheckbox,
model: { signal:signal, handler:handler, checked:checked }
});
}
function setRange(node, start, end, dir) {
if (node.parentNode) {
node.setSelectionRange(start, end, dir);
} else {
setTimeout(function(){node.setSelectionRange(start, end, dir);}, 0);
}
}
function updateIfNeeded(css, attribute, latestAttribute) {
if (css[attribute] !== latestAttribute) {
css[attribute] = latestAttribute;
}
}
function cssDimensions(dimensions) {
return dimensions.top + 'px ' +
dimensions.right + 'px ' +
dimensions.bottom + 'px ' +
dimensions.left + 'px';
}
function updateFieldStyle(css, style) {
updateIfNeeded(css, 'padding', cssDimensions(style.padding));
var outline = style.outline;
updateIfNeeded(css, 'border-width', cssDimensions(outline.width));
updateIfNeeded(css, 'border-color', toCss(outline.color));
updateIfNeeded(css, 'border-radius', outline.radius + 'px');
var highlight = style.highlight;
if (highlight.width === 0) {
css.outline = 'none';
} else {
updateIfNeeded(css, 'outline-width', highlight.width + 'px');
updateIfNeeded(css, 'outline-color', toCss(highlight.color));
}
var textStyle = style.style;
updateIfNeeded(css, 'color', toCss(textStyle.color));
if (textStyle.typeface.ctor !== '[]') {
updateIfNeeded(css, 'font-family', Text.toTypefaces(textStyle.typeface));
}
if (textStyle.height.ctor !== "Nothing") {
updateIfNeeded(css, 'font-size', textStyle.height._0 + 'px');
}
updateIfNeeded(css, 'font-weight', textStyle.bold ? 'bold' : 'normal');
updateIfNeeded(css, 'font-style', textStyle.italic ? 'italic' : 'normal');
if (textStyle.line.ctor !== 'Nothing') {
updateIfNeeded(css, 'text-decoration', Text.toLine(textStyle.line._0));
}
}
function renderField(model) {
var field = newNode('input');
updateFieldStyle(field.style, model.style);
field.style.borderStyle = 'solid';
field.style.pointerEvents = 'auto';
field.type = model.type;
field.placeholder = model.placeHolder;
field.value = model.content.string;
field.elm_signal = model.signal;
field.elm_handler = model.handler;
field.elm_old_value = field.value;
function inputUpdate(event) {
var curr = field.elm_old_value;
var next = field.value;
if (curr === next) {
return;
}
var direction = field.selectionDirection === 'forward' ? 'Forward' : 'Backward';
var start = field.selectionStart;
var end = field.selectionEnd;
field.value = field.elm_old_value;
elm.notify(field.elm_signal.id, field.elm_handler({
_:{},
string: next,
selection: {
_:{},
start: start,
end: end,
direction: { ctor: direction }
}
}));
}
field.addEventListener('input', inputUpdate);
field.addEventListener('focus', function() {
field.elm_hasFocus = true;
});
field.addEventListener('blur', function() {
field.elm_hasFocus = false;
});
return field;
}
function updateField(field, oldModel, newModel) {
if (oldModel.style !== newModel.style) {
updateFieldStyle(field.style, newModel.style);
}
field.elm_signal = newModel.signal;
field.elm_handler = newModel.handler;
field.type = newModel.type;
field.placeholder = newModel.placeHolder;
var value = newModel.content.string;
field.value = value;
field.elm_old_value = value;
if (field.elm_hasFocus) {
var selection = newModel.content.selection;
var direction = selection.direction.ctor === 'Forward' ? 'forward' : 'backward';
setRange(field, selection.start, selection.end, direction);
}
}
function mkField(type) {
function field(style, signal, handler, placeHolder, content) {
var padding = style.padding;
var outline = style.outline.width;
var adjustWidth = padding.left + padding.right + outline.left + outline.right;
var adjustHeight = padding.top + padding.bottom + outline.top + outline.bottom;
return A3(newElement, 200, 30, {
ctor: 'Custom',
type: type + 'Field',
adjustWidth: adjustWidth,
adjustHeight: adjustHeight,
render: renderField,
update: updateField,
model: {
signal:signal,
handler:handler,
placeHolder:placeHolder,
content:content,
style:style,
type:type
}
});
}
return F5(field);
}
function hoverable(signal, handler, elem) {
function onHover(bool) {
elm.notify(signal.id, handler(bool));
}
var props = Utils.replace([['hover',onHover]], elem.props);
return { props:props, element:elem.element };
}
function clickable(signal, value, elem) {
function onClick(bool) {
elm.notify(signal.id, value);
}
var props = Utils.replace([['click',onClick]], elem.props);
return { props:props, element:elem.element };
}
return elm.Native.Graphics.Input.values = {
input:input,
button:F3(button),
customButton:F5(customButton),
checkbox:F3(checkbox),
dropDown:F2(dropDown),
field:mkField('text'),
email:mkField('email'),
password:mkField('password'),
hoverable:F3(hoverable),
clickable:F3(clickable)
};
};
Elm.Native.Graphics.Collage = {};
Elm.Native.Graphics.Collage.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Graphics = elm.Native.Graphics || {};
elm.Native.Graphics.Collage = elm.Native.Graphics.Collage || {};
if (elm.Native.Graphics.Collage.values) return elm.Native.Graphics.Collage.values;
var newElement = Elm.Graphics.Element.make(elm).newElement;
var C = ElmRuntime.use(ElmRuntime.Render.Collage);
function collage(w,h,forms) {
return A3(newElement, w, h, {
ctor: 'Custom',
type: 'Collage',
render: C.render,
update: C.update,
model: {w:w, h:h, forms:forms}
});
}
return elm.Native.Graphics.Collage.values = { collage:F3(collage) };
};Elm.Native.Time = {};
Elm.Native.Time.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Time = elm.Native.Time || {};
if (elm.Native.Time.values) return elm.Native.Time.values;
var Signal = Elm.Signal.make(elm);
var NS = Elm.Native.Signal.make(elm);
var Maybe = Elm.Maybe.make(elm);
var Utils = Elm.Native.Utils.make(elm);
function fpsWhen(desiredFPS, isOn) {
var msPerFrame = 1000 / desiredFPS;
var prev = Date.now(), curr = prev, diff = 0, wasOn = true;
var ticker = Signal.constant(diff);
function tick(zero) { return function() {
curr = Date.now();
diff = zero ? 0 : curr - prev;
prev = curr;
elm.notify(ticker.id, diff);
};
}
var timeoutID = 0;
function f(isOn, t) {
if (isOn) {
timeoutID = setTimeout(tick(!wasOn && isOn), msPerFrame);
} else if (wasOn) {
clearTimeout(timeoutID);
}
wasOn = isOn;
return t;
}
return A3( NS.liftImpure2, F2(f), isOn, ticker );
}
function every(t) {
var clock = Signal.constant(Date.now());
setInterval(function() {
elm.notify(clock.id, Date.now());
}, t);
return clock;
}
function since(t, s) {
function cmp(a,b) { return !Utils.eq(a,b); }
var dcount = Signal.count(A2(NS.delay, t, s));
return A3( Signal.lift2, F2(cmp), Signal.count(s), dcount );
}
function read(s) {
var t = Date.parse(s);
return isNaN(t) ? Maybe.Nothing : Maybe.Just(t);
}
return elm.Native.Time.values = {
fpsWhen : F2(fpsWhen),
fps : function(t) { return fpsWhen(t, Signal.constant(true)); },
every : every,
delay : NS.delay,
timestamp : NS.timestamp,
since : F2(since),
toDate : function(t) { return new window.Date(t); },
read : read
};
};
Elm.Native.Random = {};
Elm.Native.Random.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Random = elm.Native.Random || {};
if (elm.Native.Random.values) return elm.Native.Random.values;
var Signal = Elm.Signal.make(elm);
var NS = Elm.Native.Signal.make(elm);
var List = Elm.Native.List.make(elm);
function range(min, max, signal) {
function f(x) { return Math.floor(Math.random() * (max-min+1)) + min; }
return A2( NS.liftImpure, f, signal );
}
function float_(signal) {
function f(x) { return Math.random(); }
return A2( NS.liftImpure, f, signal );
}
function floatList(signal) {
function f(n) {
if (n < 0) return List.Nil;
var arr = new Array(n);
for (var i = n; i--; ) {
arr[i] = Math.random();
}
return List.fromArray(arr);
}
return A2( NS.liftImpure, f, signal );
}
return elm.Native.Random.values = {
range: F3(range),
float_: float_,
floatList: floatList
};
};
Elm.Native.Window = {};
Elm.Native.Window.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Window = elm.Native.Window || {};
if (elm.Native.Window.values) return elm.Native.Window.values;
var Signal = Elm.Signal.make(elm);
var Tuple2 = Elm.Native.Utils.make(elm).Tuple2;
function getWidth() { return elm.node.clientWidth; }
function getHeight() {
if (elm.display === ElmRuntime.Display.FULLSCREEN) {
return window.innerHeight;
}
return elm.node.clientHeight;
}
var dimensions = Signal.constant(Tuple2(getWidth(), getHeight()));
dimensions.defaultNumberOfKids = 2;
// Do not move width and height into Elm. By setting the default number of kids,
// the resize listener can be detached.
var width = A2(Signal.lift, function(p){return p._0;}, dimensions);
width.defaultNumberOfKids = 0;
var height = A2(Signal.lift, function(p){return p._1;}, dimensions);
height.defaultNumberOfKids = 0;
function resizeIfNeeded() {
// Do not trigger event if the dimensions have not changed.
// This should be most of the time.
var w = getWidth();
var h = getHeight();
if (dimensions.value._0 === w && dimensions.value._1 === h) return;
setTimeout(function () {
// Check again to see if the dimensions have changed.
// It is conceivable that the dimensions have changed
// again while some other event was being processed.
var w = getWidth();
var h = getHeight();
if (dimensions.value._0 === w && dimensions.value._1 === h) return;
elm.notify(dimensions.id, Tuple2(w,h));
}, 0);
}
elm.addListener([dimensions.id], window, 'resize', resizeIfNeeded);
return elm.Native.Window.values = {
dimensions:dimensions,
width:width,
height:height,
resizeIfNeeded:resizeIfNeeded
};
};
Elm.Native.Http = {};
Elm.Native.Http.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Http = elm.Native.Http || {};
if (elm.Native.Http.values) return elm.Native.Http.values;
var List = Elm.List.make(elm);
var Signal = Elm.Signal.make(elm);
var NS = Elm.Native.Signal.make(elm);
function registerReq(queue,responses) {
return function(req) {
if (req.url.length > 0) {
sendReq(queue,responses,req);
}
};
}
function updateQueue(queue,responses) {
if (queue.length > 0) {
elm.notify(responses.id, queue[0].value);
if (queue[0].value.ctor !== 'Waiting') {
queue.shift();
setTimeout(function() { updateQueue(queue,responses); }, 0);
}
}
}
function sendReq(queue,responses,req) {
var response = { value: { ctor:'Waiting' } };
queue.push(response);
var request = (window.ActiveXObject
? new ActiveXObject("Microsoft.XMLHTTP")
: new XMLHttpRequest());
request.onreadystatechange = function(e) {
if (request.readyState === 4) {
response.value = (request.status >= 200 && request.status < 300 ?
{ ctor:'Success', _0:request.responseText } :
{ ctor:'Failure', _0:request.status, _1:request.statusText });
setTimeout(function() { updateQueue(queue,responses); }, 0);
}
};
request.open(req.verb, req.url, true);
function setHeader(pair) {
request.setRequestHeader( pair._0, pair._1 );
}
A2( List.map, setHeader, req.headers );
request.send(req.body);
}
function send(requests) {
var responses = Signal.constant(elm.Http.values.Waiting);
var sender = A2( NS.liftImpure, registerReq([],responses), requests );
function f(x) { return function(y) { return x; } }
return A3( Signal.lift2, f, responses, sender );
}
return elm.Native.Http.values = {
send:send
};
};
Elm.Native.Keyboard = {};
Elm.Native.Keyboard.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Keyboard = elm.Native.Keyboard || {};
if (elm.Native.Keyboard.values) return elm.Native.Keyboard.values;
// Duplicated from Native.Signal
function send(node, timestep, updated, duplicate) {
var kids = node.kids;
for (var i = kids.length; i--; ) {
kids[i].recv(timestep, updated, duplicate, node.id);
}
}
var Signal = Elm.Signal.make(elm);
var NList = Elm.Native.List.make(elm);
var Utils = Elm.Native.Utils.make(elm);
var downEvents = Signal.constant(0);
var upEvents = Signal.constant(0);
var blurEvents = Signal.constant(0);
elm.addListener([downEvents.id], document, 'keydown', function down(e) {
elm.notify(downEvents.id, e.keyCode);
});
elm.addListener([upEvents.id], document, 'keyup', function up(e) {
elm.notify(upEvents.id, e.keyCode);
});
elm.addListener([blurEvents.id], document, 'blur', function blur(e) {
elm.notify(blurEvents.id, NList.Nil);
});
function KeyMerge(down, up, blur) {
var args = [down,up,blur];
this.id = Utils.guid();
// Ignore starting values here
this.value = NList.Nil
this.kids = [];
var n = args.length;
var count = 0;
var oneUpdated = false;
this.recv = function(timestep, updated, duplicate, parentID) {
++count;
if (updated) {
// We know this a change must only be one of the following cases
if (parentID === down.id && !(NList.member(down.value)(this.value))) {
oneUpdated = true;
this.value = NList.Cons(down.value, this.value);
}
if (parentID === up.id) {
oneUpdated = true;
var notEq = function(kc) { return kc !== up.value };
this.value = NList.filter(notEq)(this.value);
}
if (parentID === blur.id) {
oneUpdated = true;
this.value = NList.Nil;
}
}
if (count == n) {
send(this, timestep, oneUpdated, !oneUpdated);
oneUpdated = false;
count = 0;
}
};
for (var i = n; i--; ) { args[i].kids.push(this); }
}
var keysDown = Signal.dropRepeats(new KeyMerge(downEvents,upEvents,blurEvents));
function keySignal(f) {
var signal = A2(Signal.lift, f, keysDown);
// must set the default number of kids to make it possible to filter
// these signals if they are not actually used.
keysDown.defaultNumberOfKids += 1;
signal.defaultNumberOfKids = 1;
var filtered = Signal.dropRepeats(signal)
filtered.defaultNumberOfKids = 0;
return filtered;
}
function dir(up, down, left, right) {
function f(ks) {
var x = 0, y = 0;
while (ks.ctor === "::") {
switch (ks._0) {
case left : --x; break;
case right: ++x; break;
case up : ++y; break;
case down : --y; break;
}
ks = ks._1;
}
return { _:{}, x:x, y:y };
}
return keySignal(f);
}
function is(key) { return keySignal(NList.member(key)); }
var lastPressed = downEvents;
return elm.Native.Keyboard.values = {
isDown:is,
directions:F4(dir),
keysDown:keysDown,
lastPressed:lastPressed
};
};
Elm.Native.Touch = {};
Elm.Native.Touch.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Touch = elm.Native.Touch || {};
if (elm.Native.Touch.values) return elm.Native.Touch.values;
var Signal = Elm.Signal.make(elm);
var NS = Elm.Native.Signal.make(elm);
var List = Elm.Native.List.make(elm);
var Utils = Elm.Native.Utils.make(elm);
function Dict() {
this.keys = [];
this.values = [];
this.insert = function(key,value) {
this.keys.push(key);
this.values.push(value);
};
this.lookup = function(key) {
var i = this.keys.indexOf(key)
return i >= 0 ? this.values[i] : {x:0,y:0,t:0};
};
this.remove = function(key) {
var i = this.keys.indexOf(key);
if (i < 0) return;
var t = this.values[i];
this.keys.splice(i,1);
this.values.splice(i,1);
return t;
};
this.clear = function() {
this.keys = [];
this.values = [];
};
}
var root = Signal.constant([]),
tapTime = 500,
hasTap = false,
tap = {_:{},x:0,y:0},
dict = new Dict();
function touch(t) {
var r = dict.lookup(t.identifier);
var point = Utils.getXY(t);
return {_ : {},
id: t.identifier,
x : point._0,
y : point._1,
x0: r.x,
y0: r.y,
t0: r.t
};
}
var node = elm.display === ElmRuntime.Display.FULLSCREEN ? document : elm.node;
function start(e) {
var point = Utils.getXY(e);
dict.insert(e.identifier,
{x: point._0,
y: point._1,
t: Date.now()});
}
function end(e) {
var t = dict.remove(e.identifier);
if (Date.now() - t.t < tapTime) {
hasTap = true;
tap = {_:{}, x:t.x, y:t.y};
}
}
function listen(name, f) {
function update(e) {
for (var i = e.changedTouches.length; i--; ) { f(e.changedTouches[i]); }
var ts = new Array(e.touches.length);
for (var i = e.touches.length; i--; ) { ts[i] = touch(e.touches[i]); }
elm.notify(root.id, ts);
e.preventDefault();
}
elm.addListener([root.id], node, name, update);
}
listen("touchstart", start);
listen("touchmove", function(_){});
listen("touchend", end);
listen("touchcancel", end);
listen("touchleave", end);
var mouseID = -1;
function move(e) {
var point = Utils.getXY(e);
for (var i = root.value.length; i--; ) {
if (root.value[i].id === mouseID) {
root.value[i].x = point._0;
root.value[i].y = point._1;
elm.notify(root.id, root.value);
break;
}
}
}
elm.addListener([root.id], node, "mousedown", function down(e) {
node.addEventListener("mousemove", move);
e.identifier = mouseID;
start(e);
root.value.push(touch(e));
elm.notify(root.id, root.value);
});
elm.addListener([root.id], node, "mouseup", function up(e) {
node.removeEventListener("mousemove", move);
e.identifier = mouseID;
end(e);
for (var i = root.value.length; i--; ) {
if (root.value[i].id === mouseID) {
root.value.splice(i, 1);
--mouseID;
break;
}
}
elm.notify(root.id, root.value);
});
elm.addListener([root.id], node, "blur", function blur(e) {
node.removeEventListener("mousemove", move);
if (root.value.length > 0) {
elm.notify(root.id, []);
--mouseID;
}
dict.clear();
});
function dependency(f) {
var sig = A2( NS.liftImpure, f, root );
root.defaultNumberOfKids += 1;
sig.defaultNumberOfKids = 0;
return sig;
}
var touches = dependency(List.fromArray);
var taps = function() {
var sig = dependency(function(_) { return tap; });
sig.defaultNumberOfKids = 1;
function pred(_) { var b = hasTap; hasTap = false; return b; }
var sig2 = A3( Signal.keepIf, pred, {_:{},x:0,y:0}, sig);
sig2.defaultNumberOfKids = 0;
return sig2;
}();
return elm.Native.Touch.values = { touches: touches, taps: taps };
};
Elm.Native.Mouse = {};
Elm.Native.Mouse.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Mouse = elm.Native.Mouse || {};
if (elm.Native.Mouse.values) return elm.Native.Mouse.values;
var Signal = Elm.Signal.make(elm);
var Utils = Elm.Native.Utils.make(elm);
var position = Signal.constant(Utils.Tuple2(0,0));
position.defaultNumberOfKids = 2;
// do not move x and y into Elm. By setting their default number
// of kids, it is possible to detatch the mouse listeners if
// they are not needed.
var x = A2( Signal.lift, function(p){return p._0}, position);
x.defaultNumberOfKids = 0;
var y = A2( Signal.lift, function(p){return p._1}, position);
y.defaultNumberOfKids = 0;
var isDown = Signal.constant(false);
var clicks = Signal.constant(Utils.Tuple0);
var node = elm.display === ElmRuntime.Display.FULLSCREEN ? document : elm.node;
elm.addListener([clicks.id], node, 'click', function click() {
elm.notify(clicks.id, Utils.Tuple0);
});
elm.addListener([isDown.id], node, 'mousedown', function down() {
elm.notify(isDown.id, true);
});
elm.addListener([isDown.id], node, 'mouseup', function up() {
elm.notify(isDown.id, false);
});
elm.addListener([position.id], node, 'mousemove', function move(e) {
elm.notify(position.id, Utils.getXY(e));
});
return elm.Native.Mouse.values = {
position: position,
x:x,
y:y,
isDown: isDown,
clicks: clicks
};
};
Elm.Native.Signal = {};
Elm.Native.Signal.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Signal = elm.Native.Signal || {};
if (elm.Native.Signal.values) return elm.Native.Signal.values;
var Utils = Elm.Native.Utils.make(elm);
var foldr1 = Elm.List.make(elm).foldr1;
function send(node, timestep, updated, duplicate) {
var kids = node.kids;
for (var i = kids.length; i--; ) {
kids[i].recv(timestep, updated, duplicate, node.id);
}
}
function Input(base) {
this.id = Utils.guid();
this.value = base;
this.kids = [];
this.defaultNumberOfKids = 0;
this.recv = function(timestep, eid, v) {
var updated = eid === this.id;
if (updated) { this.value = v; }
// TODO: consider changing this to an actual duplicate check
var duplicate = !updated;
send(this, timestep, updated, duplicate);
return updated;
};
elm.inputs.push(this);
}
function LiftN(pure, update, args) {
this.id = Utils.guid();
this.value = update();
this.kids = [];
var n = args.length;
var count = 0;
var oneUpdated = false;
var allDuplicate = true;
this.recv = function(timestep, updated, duplicate, parentID) {
++count;
if (updated) { oneUpdated = true; }
if (!duplicate) { allDuplicate = false; }
if (count === n) {
if (!(pure && allDuplicate)) { this.value = update(); }
send(this, timestep, oneUpdated, pure && allDuplicate);
oneUpdated = false;
allDuplicate = true;
count = 0;
}
};
for (var i = n; i--; ) { args[i].kids.push(this); }
}
function lift(func, a) {
function update() { return func(a.value); }
return new LiftN(true, update, [a]);
}
function lift2(func, a, b) {
function update() { return A2( func, a.value, b.value ); }
return new LiftN(true, update, [a,b]);
}
function lift3(func, a, b, c) {
function update() { return A3( func, a.value, b.value, c.value ); }
return new LiftN(true, update, [a,b,c]);
}
function lift4(func, a, b, c, d) {
function update() { return A4( func, a.value, b.value, c.value, d.value ); }
return new LiftN(true, update, [a,b,c,d]);
}
function lift5(func, a, b, c, d, e) {
function update() { return A5( func, a.value, b.value, c.value, d.value, e.value ); }
return new LiftN(true, update, [a,b,c,d,e]);
}
function lift6(func, a, b, c, d, e, f) {
function update() { return A6( func, a.value, b.value, c.value, d.value, e.value, f.value ); }
return new LiftN(true, update, [a,b,c,d,e,f]);
}
function lift7(func, a, b, c, d, e, f, g) {
function update() { return A7( func, a.value, b.value, c.value, d.value, e.value, f.value, g.value ); }
return new LiftN(true, update, [a,b,c,d,e,f,g]);
}
function lift8(func, a, b, c, d, e, f, g, h) {
function update() { return A8( func, a.value, b.value, c.value, d.value, e.value, f.value, g.value, h.value ); }
return new LiftN(true, update, [a,b,c,d,e,f,g,h]);
}
function liftImpure(func, a) {
function update() { return func(a.value); }
return new LiftN(false, update, [a]);
}
function liftImpure2(func, a, b) {
function update() { return A2( func, a.value, b.value ); }
return new LiftN(false, update, [a,b]);
}
//For lifting side-effecting functions
function RawLift(func, recvF, s) {
this.id = Utils.guid();
this.value = func(s.value);
this.kids = [];
this.recv = recvF(this);
s.kids.push(this);
}
function rawLift(f, r, a) {
return new RawLift(f,r,a);
}
function Foldp(step, state, input) {
this.id = Utils.guid();
this.value = state;
this.kids = [];
this.recv = function(timestep, updated, _, parentID) {
if (updated) {
this.value = A2( step, input.value, this.value );
}
var duplicate = !updated;
send(this, timestep, updated, duplicate);
};
input.kids.push(this);
}
function foldp(step, state, input) {
return new Foldp(step, state, input);
}
function DropIf(pred,base,input) {
this.id = Utils.guid();
var shouldDrop = pred(input.value);
this.value = shouldDrop ? base : input.value;
this.kids = [];
this.recv = function(timestep, updated, duplicate, parentID) {
if (duplicate) {
// runtime sanity check
// can be commented out when reasonably certain this doesn't occur.
if (!Utils.eq(this.value, input.value)) {
throw new Error(
'Runtime check of duplicate tracking went wrong!\n' +
'A changed value was called a duplicate.\n' +
'Definitely report this to <https://github.com/elm-lang/Elm/issues>\n');
}
}
if (duplicate && shouldDrop) { // Duplicate, pred
updated = false; // -> NoUpdate
}
if (!duplicate) { // MaybeChanged
shouldDrop = pred(input.value); // -> update pred
if (shouldDrop) { // MaybeChanged, pred
updated = false; // -> NoUpdate
duplicate = true; // -> Duplicate
} else { // MaybeChanged, !pred
this.value = input.value; // -> update value
}
}
send(this, timestep, updated, duplicate);
};
input.kids.push(this);
}
function DropRepeats(input) {
this.id = Utils.guid();
this.value = input.value;
this.kids = [];
this.recv = function(timestep, updated, duplicate, parentID) {
if (duplicate || Utils.eq(this.value,input.value)) { // Duplicate || MaybeChanged but found to be a duplicate
duplicate = true; // -> Duplicate
updated = false; // -> NoUpdate
} else { // really changed value
this.value = input.value; // -> update value
}
send(this, timestep, updated, duplicate);
};
input.kids.push(this);
}
function timestamp(a) {
function update() { return Utils.Tuple2(Date.now(), a.value); }
return new LiftN(update, [a]);
}
function SampleOn(s1,s2) {
this.id = Utils.guid();
this.value = s2.value;
this.kids = [];
var count = 0;
var s1Updated = false;
var s2Updated = false;
var s2Duplicate = false;
var skip = false;
this.recv = function(timestep, updated, duplicate, parentID) {
if (parentID === s1.id) { s1Updated = updated; }
if (parentID === s2.id) {
s2Updated = updated;
s2Duplicate = duplicate;
}
++count;
if (count === 2) {
if (s1Updated) {
if (s2Duplicate && skip) { // if an update from s2 was skipped
s2Duplicate = false; // then this event could change the output
}
this.value = s2.value;
skip = false;
} else if (!s2Duplicate) {
skip = true;
}
send(this, timestep, s1Updated, s2Duplicate);
count = 0;
s1Updated = false;
s2Updated = false;
s2Duplicate = false;
}
};
s1.kids.push(this);
s2.kids.push(this);
}
function sampleOn(s1,s2) { return new SampleOn(s1,s2); }
function delay(t,s) {
var delayed = new Input(s.value);
var firstEvent = true;
function update(rawLiftNode) {
return function(timestep, updated, duplicate, parentID) {
if(updated) {
setTimeout(function() { elm.notify(delayed.id, s.value); }, t);
}
}
}
A3(rawLift, function(_){}, update, s);
function first(a,b) { return a; }
// TODO find out why you would even do this whole
// `sampleOn delayed (uncurry fst <~ delayed ~ s)`
return new SampleOn(delayed, lift2(F2(first), delayed, s));
}
function Merge(s1,s2) {
this.id = Utils.guid();
var count = 0;
var current = { s : s1
, updated : true
, duplicate : false };
var next = null;
this.value = current.value;
this.kids = [];
this.recv = function(timestep, updated, duplicate, parentID) {
++count;
if (parentID === s2.id && next === null) {
next = { s : s2
, updated : updated
, duplicate : duplicate };
} else if (parentID === s1.id) {
next = { s : s1
, updated : updated
, duplicate : duplicate };
}
if (count === 2) {
if (current.s !== next.s) {
next.duplicate = false;
}
current = next;
this.value = current.s.value;
send(this, timestep, current.updated, current.duplicate);
next = null;
count = 0;
}
};
s1.kids.push(this);
s2.kids.push(this);
}
function merge(s1,s2) { return new Merge(s1,s2); }
function merges(ss) { return A2(foldr1, F2(merge), ss); }
return elm.Native.Signal.values = {
constant : function(v) { return new Input(v); },
lift : F2(lift ),
lift2 : F3(lift2),
lift3 : F4(lift3),
lift4 : F5(lift4),
lift5 : F6(lift5),
lift6 : F7(lift6),
lift7 : F8(lift7),
lift8 : F9(lift8),
liftImpure : F2(liftImpure ),
liftImpure2 : F3(liftImpure2),
rawLift : F3(rawLift),
foldp : F3(foldp),
delay : F2(delay),
merge : F2(merge),
merges : merges,
count : function(s) { return foldp(F2(function(_,c) { return c+1; }), 0, s); },
countIf : F2(function(pred,s) {
return foldp(F2(function(x,c){
return pred(x) ? c+1 : c; }), 0, s)}),
keepIf : F3(function(pred,base,sig) {
return new DropIf(function(x) {return !pred(x);},base,sig); }),
dropIf : F3(function(pred,base,sig) { return new DropIf(pred,base,sig); }),
dropRepeats : function(s) { return new DropRepeats(s);},
sampleOn : F2(sampleOn),
timestamp : timestamp
};
};
Elm.Native.WebSocket = {};
Elm.Native.WebSocket.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.WebSocket = elm.Native.WebSocket || {};
if (elm.Native.WebSocket.values) return elm.Native.WebSocket.values;
var Signal = Elm.Signal.make(elm);
var NS = Elm.Native.Signal.make(elm);
var List = Elm.Native.List.make(elm);
function open(url, outgoing) {
var incoming = Signal.constant(List.Nil);
var ws = new WebSocket(url);
var pending = [];
var ready = false;
ws.onopen = function(e) {
var len = pending.length;
for (var i = 0; i < len; ++i) { ws.send(pending[i]); }
ready = true;
};
ws.onmessage = function(event) {
elm.notify(incoming.id, event.data);
};
function send(msg) {
ready ? ws.send(msg) : pending.push(msg);
}
function take1(x,y) { return x }
return A3(Signal.lift2, F2(take1), incoming, A2(NS.liftImpure, send, outgoing));
}
return elm.Native.WebSocket.values = { connect: F2(open) };
};
Elm.Trampoline = Elm.Trampoline || {};
Elm.Trampoline.make = function (_elm)
{
"use strict";
_elm.Trampoline = _elm.Trampoline || {};
if (_elm.Trampoline.values)
return _elm.Trampoline.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Trampoline";
var Native = Native || {};
Native.Trampoline = Elm.Native.Trampoline.make(_elm);
var _op = {};
var trampoline = Native.Trampoline.trampoline;
var Continue = function (a)
{
return {ctor: "Continue", _0: a};
};
var Done = function (a)
{
return {ctor: "Done", _0: a};
};
_elm.Trampoline.values = {_op: _op, trampoline: trampoline, Done: Done, Continue: Continue};
return _elm.Trampoline.values;
};Elm.Time = Elm.Time || {};
Elm.Time.make = function (_elm)
{
"use strict";
_elm.Time = _elm.Time || {};
if (_elm.Time.values)
return _elm.Time.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Time";
var Basics = Elm.Basics.make(_elm);
var Native = Native || {};
Native.Time = Elm.Native.Time.make(_elm);
var Signal = Elm.Signal.make(_elm);
var _op = {};
var delay = Native.Time.delay;
var timestamp = Native.Time.timestamp;
var since = Native.Time.since;
var every = Native.Time.every;
var fpsWhen = Native.Time.fpsWhen;
var fps = Native.Time.fps;
var inMilliseconds = function (t)
{
return t;
};
var millisecond = 1;
var second = 1000 * millisecond;
var minute = 60 * second;
var hour = 60 * minute;
var inHours = function (t)
{
return t / hour;
};
var inMinutes = function (t)
{
return t / minute;
};
var inSeconds = function (t)
{
return t / second;
};
_elm.Time.values = {_op: _op, millisecond: millisecond, second: second, minute: minute, hour: hour, inMilliseconds: inMilliseconds, inSeconds: inSeconds, inMinutes: inMinutes, inHours: inHours, fps: fps, fpsWhen: fpsWhen, every: every, since: since, timestamp: timestamp, delay: delay};
return _elm.Time.values;
};Elm.Maybe = Elm.Maybe || {};
Elm.Maybe.make = function (_elm)
{
"use strict";
_elm.Maybe = _elm.Maybe || {};
if (_elm.Maybe.values)
return _elm.Maybe.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Maybe";
var Basics = Elm.Basics.make(_elm);
var List = Elm.List.make(_elm);
var _op = {};
var Nothing = {ctor: "Nothing"};
var Just = function (a)
{
return {ctor: "Just", _0: a};
};
var maybe = F3(function (b,f,m)
{
return function ()
{
switch (m.ctor)
{case
"Just" :
return f(m._0);
case
"Nothing" :
return b;}
_E.Case($moduleName,"between lines 35 and 44");
}();
});
var isJust = A2(maybe,
false,
function (_v2)
{
return function ()
{
return true;
}();
});
var isNothing = function ($)
{
return Basics.not(isJust($));
};
var cons = F2(function (mx,xs)
{
return A3(maybe,
xs,
function (x)
{
return {ctor: "::", _0: x, _1: xs};
},
mx);
});
var justs = A2(List.foldr,cons,_L.fromArray([]));
_elm.Maybe.values = {_op: _op, maybe: maybe, isJust: isJust, isNothing: isNothing, cons: cons, justs: justs, Just: Just, Nothing: Nothing};
return _elm.Maybe.values;
};Elm.Json = Elm.Json || {};
Elm.Json.make = function (_elm)
{
"use strict";
_elm.Json = _elm.Json || {};
if (_elm.Json.values)
return _elm.Json.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Json";
var Dict = Elm.Dict.make(_elm);
var Maybe = Elm.Maybe.make(_elm);
var Native = Native || {};
Native.Json = Elm.Native.Json.make(_elm);
var _op = {};
var fromString = function (str)
{
return Native.Json.fromString(str);
};
var toString = F2(function (sep,value)
{
return A2(Native.Json.toString,sep,value);
});
var Object = function (a)
{
return {ctor: "Object", _0: a};
};
var Array = function (a)
{
return {ctor: "Array", _0: a};
};
var Null = {ctor: "Null"};
var Boolean = function (a)
{
return {ctor: "Boolean", _0: a};
};
var Number = function (a)
{
return {ctor: "Number", _0: a};
};
var String = function (a)
{
return {ctor: "String", _0: a};
};
_elm.Json.values = {_op: _op, toString: toString, fromString: fromString, String: String, Number: Number, Boolean: Boolean, Null: Null, Array: Array, Object: Object};
return _elm.Json.values;
};Elm.Set = Elm.Set || {};
Elm.Set.make = function (_elm)
{
"use strict";
_elm.Set = _elm.Set || {};
if (_elm.Set.values)
return _elm.Set.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Set";
var Dict = Elm.Dict.make(_elm);
var List = Elm.List.make(_elm);
var Maybe = Elm.Maybe.make(_elm);
var _op = {};
var partition = F2(function (p,set)
{
return A2(Dict.partition,
F2(function (k,_v0)
{
return function ()
{
return p(k);
}();
}),
set);
});
var filter = F2(function (p,set)
{
return A2(Dict.filter,
F2(function (k,_v2)
{
return function ()
{
return p(k);
}();
}),
set);
});
var foldr = F3(function (f,b,s)
{
return A3(Dict.foldr,
F3(function (k,_v4,b)
{
return function ()
{
return A2(f,k,b);
}();
}),
b,
s);
});
var foldl = F3(function (f,b,s)
{
return A3(Dict.foldl,
F3(function (k,_v6,b)
{
return function ()
{
return A2(f,k,b);
}();
}),
b,
s);
});
var toList = Dict.keys;
var diff = Dict.diff;
var intersect = Dict.intersect;
var union = Dict.union;
var member = Dict.member;
var remove = Dict.remove;
var insert = function (k)
{
return A2(Dict.insert,k,{ctor: "_Tuple0"});
};
var singleton = function (k)
{
return A2(Dict.singleton,k,{ctor: "_Tuple0"});
};
var empty = Dict.empty;
var fromList = function (xs)
{
return A3(List.foldl,insert,empty,xs);
};
var map = F2(function (f,s)
{
return fromList(A2(List.map,f,toList(s)));
});
_elm.Set.values = {_op: _op, empty: empty, singleton: singleton, insert: insert, remove: remove, member: member, foldl: foldl, foldr: foldr, map: map, filter: filter, partition: partition, union: union, intersect: intersect, diff: diff, toList: toList, fromList: fromList};
return _elm.Set.values;
};Elm.Either = Elm.Either || {};
Elm.Either.make = function (_elm)
{
"use strict";
_elm.Either = _elm.Either || {};
if (_elm.Either.values)
return _elm.Either.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Either";
var List = Elm.List.make(_elm);
var _op = {};
var Right = function (a)
{
return {ctor: "Right", _0: a};
};
var isRight = function (e)
{
return function ()
{
switch (e.ctor)
{case
"Right" :
return true;}
return false;
}();
};
var Left = function (a)
{
return {ctor: "Left", _0: a};
};
var either = F3(function (f,g,e)
{
return function ()
{
switch (e.ctor)
{case
"Left" :
return f(e._0);
case
"Right" :
return g(e._0);}
_E.Case($moduleName,"on line 37, column 16 to 60");
}();
});
var isLeft = function (e)
{
return function ()
{
switch (e.ctor)
{case
"Left" :
return true;}
return false;
}();
};
var consLeft = F2(function (e,vs)
{
return function ()
{
switch (e.ctor)
{case
"Left" :
return {ctor: "::", _0: e._0, _1: vs};
case
"Right" :
return vs;}
_E.Case($moduleName,"between lines 78 and 80");
}();
});
var lefts = function (es)
{
return A3(List.foldr,consLeft,_L.fromArray([]),es);
};
var consRight = F2(function (e,vs)
{
return function ()
{
switch (e.ctor)
{case
"Left" :
return vs;
case
"Right" :
return {ctor: "::", _0: e._0, _1: vs};}
_E.Case($moduleName,"between lines 83 and 85");
}();
});
var rights = function (es)
{
return A3(List.foldr,consRight,_L.fromArray([]),es);
};
var consEither = F2(function (e,_v13)
{
return function ()
{
switch (_v13.ctor)
{case
"_Tuple2" :
return function ()
{
switch (e.ctor)
{case
"Left" :
return {ctor: "_Tuple2", _0: {ctor: "::", _0: e._0, _1: _v13._0}, _1: _v13._1};
case
"Right" :
return {ctor: "_Tuple2", _0: _v13._0, _1: {ctor: "::", _0: e._0, _1: _v13._1}};}
_E.Case($moduleName,
"between lines 88 and 90");
}();}
_E.Case($moduleName,"between lines 88 and 90");
}();
});
var partition = function (es)
{
return A3(List.foldr,
consEither,
{ctor: "_Tuple2", _0: _L.fromArray([]), _1: _L.fromArray([])},
es);
};
_elm.Either.values = {_op: _op, either: either, isLeft: isLeft, isRight: isRight, lefts: lefts, rights: rights, partition: partition, consLeft: consLeft, consRight: consRight, consEither: consEither, Left: Left, Right: Right};
return _elm.Either.values;
};Elm.Basics = Elm.Basics || {};
Elm.Basics.make = function (_elm)
{
"use strict";
_elm.Basics = _elm.Basics || {};
if (_elm.Basics.values)
return _elm.Basics.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Basics";
var Native = Native || {};
Native.Basics = Elm.Native.Basics.make(_elm);
var _op = {};
var uncurry = F2(function (f,_v0)
{
return function ()
{
switch (_v0.ctor)
{case
"_Tuple2" :
return A2(f,_v0._0,_v0._1);}
_E.Case($moduleName,"on line 381, column 19 to 24");
}();
});
var curry = F3(function (f,a,b)
{
return f({ctor: "_Tuple2", _0: a, _1: b});
});
var flip = F3(function (f,b,a)
{
return A2(f,a,b);
});
var snd = function (_v4)
{
return function ()
{
switch (_v4.ctor)
{case
"_Tuple2" :
return _v4._1;}
_E.Case($moduleName,"on line 365, column 13 to 14");
}();
};
var fst = function (_v8)
{
return function ()
{
switch (_v8.ctor)
{case
"_Tuple2" :
return _v8._0;}
_E.Case($moduleName,"on line 361, column 13 to 14");
}();
};
var always = F2(function (a,_v12)
{
return function ()
{
return a;
}();
});
var id = function (x)
{
return x;
};
_op["<|"] = F2(function (f,x)
{
return f(x);
});
_op["|>"] = F2(function (x,f)
{
return f(x);
});
_op["."] = F3(function (f,g,x)
{
return f(g(x));
});
var isInfinite = Native.Basics.isInfinite;
var isNaN = Native.Basics.isNaN;
var toFloat = Native.Basics.toFloat;
var ceiling = Native.Basics.ceiling;
var floor = Native.Basics.floor;
var truncate = Native.Basics.truncate;
var round = Native.Basics.round;
var otherwise = true;
var not = Native.Basics.not;
var xor = Native.Basics.xor;
_op["||"] = Native.Basics.or;
_op["&&"] = Native.Basics.and;
var max = Native.Basics.max;
var min = Native.Basics.min;
var GT = {ctor: "GT"};
var EQ = {ctor: "EQ"};
var LT = {ctor: "LT"};
var compare = Native.Basics.compare;
_op[">="] = Native.Basics.ge;
_op["<="] = Native.Basics.le;
_op[">"] = Native.Basics.gt;
_op["<"] = Native.Basics.lt;
_op["/="] = Native.Basics.neq;
_op["=="] = Native.Basics.eq;
var e = Native.Basics.e;
var pi = Native.Basics.pi;
var clamp = Native.Basics.clamp;
var logBase = Native.Basics.logBase;
var abs = Native.Basics.abs;
var sqrt = Native.Basics.sqrt;
var atan2 = Native.Basics.atan2;
var atan = Native.Basics.atan;
var asin = Native.Basics.asin;
var acos = Native.Basics.acos;
var tan = Native.Basics.tan;
var sin = Native.Basics.sin;
var cos = Native.Basics.cos;
_op["^"] = Native.Basics.exp;
var mod = Native.Basics.mod;
var rem = Native.Basics.rem;
var div = Native.Basics.div;
_op["/"] = Native.Basics.floatDiv;
_op["*"] = Native.Basics.mul;
_op["-"] = Native.Basics.sub;
_op["+"] = Native.Basics.add;
var toPolar = function (_v14)
{
return function ()
{
switch (_v14.ctor)
{case
"_Tuple2" :
return {ctor: "_Tuple2", _0: Native.Basics.sqrt(Math.pow(_v14._0,
2) + Math.pow(_v14._1,
2)), _1: A2(Native.Basics.atan2,
_v14._1,
_v14._0)};}
_E.Case($moduleName,"on line 79, column 18 to 73");
}();
};
var fromPolar = function (_v18)
{
return function ()
{
switch (_v18.ctor)
{case
"_Tuple2" :
return {ctor: "_Tuple2", _0: _v18._0 * Native.Basics.cos(_v18._1), _1: _v18._0 * Native.Basics.sin(_v18._1)};}
_E.Case($moduleName,"on line 73, column 20 to 68");
}();
};
var turns = function (r)
{
return 2 * Native.Basics.pi * r;
};
var degrees = function (d)
{
return d * Native.Basics.pi / 180;
};
var radians = function (t)
{
return t;
};
_elm.Basics.values = {_op: _op, radians: radians, degrees: degrees, turns: turns, fromPolar: fromPolar, toPolar: toPolar, div: div, rem: rem, mod: mod, cos: cos, sin: sin, tan: tan, acos: acos, asin: asin, atan: atan, atan2: atan2, sqrt: sqrt, abs: abs, logBase: logBase, clamp: clamp, pi: pi, e: e, compare: compare, min: min, max: max, xor: xor, not: not, otherwise: otherwise, round: round, truncate: truncate, floor: floor, ceiling: ceiling, toFloat: toFloat, isNaN: isNaN, isInfinite: isInfinite, id: id, always: always, fst: fst, snd: snd, flip: flip, curry: curry, uncurry: uncurry, LT: LT, EQ: EQ, GT: GT};
return _elm.Basics.values;
};Elm.Color = Elm.Color || {};
Elm.Color.make = function (_elm)
{
"use strict";
_elm.Color = _elm.Color || {};
if (_elm.Color.values)
return _elm.Color.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Color";
var Basics = Elm.Basics.make(_elm);
var _op = {};
var Radial = F5(function (a,b,c,d,e)
{
return {ctor: "Radial", _0: a, _1: b, _2: c, _3: d, _4: e};
});
var radial = Radial;
var Linear = F3(function (a,b,c)
{
return {ctor: "Linear", _0: a, _1: b, _2: c};
});
var linear = Linear;
var fmod = F2(function (f,n)
{
return function ()
{
var integer = Basics.floor(f);
return Basics.toFloat(A2(Basics.mod,
integer,
n)) + f - Basics.toFloat(integer);
}();
});
var rgbToHsl = F3(function (red,green,blue)
{
return function ()
{
var b = Basics.toFloat(blue) / 255;
var g = Basics.toFloat(green) / 255;
var r = Basics.toFloat(red) / 255;
var cMax = A2(Basics.max,A2(Basics.max,r,g),b);
var cMin = A2(Basics.min,A2(Basics.min,r,g),b);
var c = cMax - cMin;
var lightness = (cMax + cMin) / 2;
var saturation = _U.eq(lightness,
0) ? 0 : c / (1 - Basics.abs(2 * lightness - 1));
var hue = Basics.degrees(60) * (_U.eq(cMax,
r) ? A2(fmod,
(g - b) / c,
6) : _U.eq(cMax,
g) ? (b - r) / c + 2 : _U.eq(cMax,
b) ? (r - g) / c + 4 : _E.If($moduleName,
"between lines 140 and 142"));
return {ctor: "_Tuple3", _0: hue, _1: saturation, _2: lightness};
}();
});
var hslToRgb = F3(function (hue,saturation,lightness)
{
return function ()
{
var hue$ = hue / Basics.degrees(60);
var chroma = (1 - Basics.abs(2 * lightness - 1)) * saturation;
var x = chroma * (1 - Basics.abs(A2(fmod,
hue$,
2) - 1));
var $ = _U.cmp(hue$,
0) < 0 ? {ctor: "_Tuple3", _0: 0, _1: 0, _2: 0} : _U.cmp(hue$,
1) < 0 ? {ctor: "_Tuple3", _0: chroma, _1: x, _2: 0} : _U.cmp(hue$,
2) < 0 ? {ctor: "_Tuple3", _0: x, _1: chroma, _2: 0} : _U.cmp(hue$,
3) < 0 ? {ctor: "_Tuple3", _0: 0, _1: chroma, _2: x} : _U.cmp(hue$,
4) < 0 ? {ctor: "_Tuple3", _0: 0, _1: x, _2: chroma} : _U.cmp(hue$,
5) < 0 ? {ctor: "_Tuple3", _0: x, _1: 0, _2: chroma} : _U.cmp(hue$,
6) < 0 ? {ctor: "_Tuple3", _0: chroma, _1: 0, _2: x} : {ctor: "_Tuple3", _0: 0, _1: 0, _2: 0},
r = $._0,
g = $._1,
b = $._2;
var m = lightness - chroma / 2;
return {ctor: "_Tuple3", _0: r + m, _1: g + m, _2: b + m};
}();
});
var HSLA = F4(function (a,b,c,d)
{
return {ctor: "HSLA", _0: a, _1: b, _2: c, _3: d};
});
var hsla = F4(function (hue,saturation,lightness,alpha)
{
return A4(HSLA,
hue - Basics.toFloat(Basics.floor(hue / (2 * Basics.pi))),
saturation,
lightness,
alpha);
});
var hsl = F3(function (hue,saturation,lightness)
{
return A4(hsla,hue,saturation,lightness,1);
});
var grayscale = function (p)
{
return A4(HSLA,0,0,1 - p,1);
};
var greyscale = function (p)
{
return A4(HSLA,0,0,1 - p,1);
};
var RGBA = F4(function (a,b,c,d)
{
return {ctor: "RGBA", _0: a, _1: b, _2: c, _3: d};
});
var rgba = RGBA;
var rgb = F3(function (r,g,b)
{
return A4(RGBA,r,g,b,1);
});
var complement = function (color)
{
return function ()
{
switch (color.ctor)
{case
"HSLA" :
return A4(hsla,
color._0 + Basics.degrees(180),
color._1,
color._2,
color._3);
case
"RGBA" :
return function ()
{
var $ = A3(rgbToHsl,
color._0,
color._1,
color._2),
h = $._0,
s = $._1,
l = $._2;
return A4(hsla,
h + Basics.degrees(180),
s,
l,
color._3);
}();}
_E.Case($moduleName,"between lines 95 and 101");
}();
};
var toHsl = function (color)
{
return function ()
{
switch (color.ctor)
{case
"HSLA" :
return {_: {}, alpha: color._3, hue: color._0, lightness: color._2, saturation: color._1};
case
"RGBA" :
return function ()
{
var $ = A3(rgbToHsl,
color._0,
color._1,
color._2),
h = $._0,
s = $._1,
l = $._2;
return {_: {}, alpha: color._3, hue: h, lightness: l, saturation: s};
}();}
_E.Case($moduleName,"between lines 104 and 111");
}();
};
var toRgb = function (color)
{
return function ()
{
switch (color.ctor)
{case
"HSLA" :
return function ()
{
var $ = A3(hslToRgb,
color._0,
color._1,
color._2),
r = $._0,
g = $._1,
b = $._2;
return {_: {}, alpha: color._3, blue: Basics.round(255 * b), green: Basics.round(255 * g), red: Basics.round(255 * r)};
}();
case
"RGBA" :
return {_: {}, alpha: color._3, blue: color._2, green: color._1, red: color._0};}
_E.Case($moduleName,"between lines 114 and 122");
}();
};
var lightRed = A4(RGBA,239,41,41,1);
var red = A4(RGBA,204,0,0,1);
var darkRed = A4(RGBA,164,0,0,1);
var lightOrange = A4(RGBA,252,175,62,1);
var orange = A4(RGBA,245,121,0,1);
var darkOrange = A4(RGBA,206,92,0,1);
var lightYellow = A4(RGBA,255,233,79,1);
var yellow = A4(RGBA,237,212,0,1);
var darkYellow = A4(RGBA,196,160,0,1);
var lightGreen = A4(RGBA,138,226,52,1);
var green = A4(RGBA,115,210,22,1);
var darkGreen = A4(RGBA,78,154,6,1);
var lightBlue = A4(RGBA,114,159,207,1);
var blue = A4(RGBA,52,101,164,1);
var darkBlue = A4(RGBA,32,74,135,1);
var lightPurple = A4(RGBA,173,127,168,1);
var purple = A4(RGBA,117,80,123,1);
var darkPurple = A4(RGBA,92,53,102,1);
var lightBrown = A4(RGBA,233,185,110,1);
var brown = A4(RGBA,193,125,17,1);
var darkBrown = A4(RGBA,143,89,2,1);
var black = A4(RGBA,0,0,0,1);
var white = A4(RGBA,255,255,255,1);
var lightGrey = A4(RGBA,238,238,236,1);
var grey = A4(RGBA,211,215,207,1);
var darkGrey = A4(RGBA,186,189,182,1);
var lightGray = A4(RGBA,238,238,236,1);
var gray = A4(RGBA,211,215,207,1);
var darkGray = A4(RGBA,186,189,182,1);
var lightCharcoal = A4(RGBA,136,138,133,1);
var charcoal = A4(RGBA,85,87,83,1);
var darkCharcoal = A4(RGBA,46,52,54,1);
_elm.Color.values = {_op: _op, rgba: rgba, rgb: rgb, hsla: hsla, hsl: hsl, grayscale: grayscale, greyscale: greyscale, complement: complement, toHsl: toHsl, toRgb: toRgb, fmod: fmod, rgbToHsl: rgbToHsl, hslToRgb: hslToRgb, linear: linear, radial: radial, lightRed: lightRed, red: red, darkRed: darkRed, lightOrange: lightOrange, orange: orange, darkOrange: darkOrange, lightYellow: lightYellow, yellow: yellow, darkYellow: darkYellow, lightGreen: lightGreen, green: green, darkGreen: darkGreen, lightBlue: lightBlue, blue: blue, darkBlue: darkBlue, lightPurple: lightPurple, purple: purple, darkPurple: darkPurple, lightBrown: lightBrown, brown: brown, darkBrown: darkBrown, black: black, white: white, lightGrey: lightGrey, grey: grey, darkGrey: darkGrey, lightGray: lightGray, gray: gray, darkGray: darkGray, lightCharcoal: lightCharcoal, charcoal: charcoal, darkCharcoal: darkCharcoal, RGBA: RGBA, HSLA: HSLA, Linear: Linear, Radial: Radial};
return _elm.Color.values;
};Elm.Window = Elm.Window || {};
Elm.Window.make = function (_elm)
{
"use strict";
_elm.Window = _elm.Window || {};
if (_elm.Window.values)
return _elm.Window.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Window";
var Native = Native || {};
Native.Window = Elm.Native.Window.make(_elm);
var Signal = Elm.Signal.make(_elm);
var _op = {};
var height = Native.Window.height;
var width = Native.Window.width;
var dimensions = Native.Window.dimensions;
_elm.Window.values = {_op: _op, dimensions: dimensions, width: width, height: height};
return _elm.Window.values;
};Elm.Keyboard = Elm.Keyboard || {};
Elm.Keyboard.make = function (_elm)
{
"use strict";
_elm.Keyboard = _elm.Keyboard || {};
if (_elm.Keyboard.values)
return _elm.Keyboard.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Keyboard";
var Native = Native || {};
Native.Keyboard = Elm.Native.Keyboard.make(_elm);
var Signal = Elm.Signal.make(_elm);
var _op = {};
var lastPressed = Native.Keyboard.lastPressed;
var keysDown = Native.Keyboard.keysDown;
var isDown = Native.Keyboard.isDown;
var shift = isDown(16);
var ctrl = isDown(17);
var space = isDown(32);
var enter = isDown(13);
var directions = Native.Keyboard.directions;
var arrows = A4(directions,38,40,37,39);
var wasd = A4(directions,87,83,65,68);
_elm.Keyboard.values = {_op: _op, directions: directions, arrows: arrows, wasd: wasd, isDown: isDown, shift: shift, ctrl: ctrl, space: space, enter: enter, keysDown: keysDown, lastPressed: lastPressed};
return _elm.Keyboard.values;
};Elm.Text = Elm.Text || {};
Elm.Text.make = function (_elm)
{
"use strict";
_elm.Text = _elm.Text || {};
if (_elm.Text.values)
return _elm.Text.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Text";
var Basics = Elm.Basics.make(_elm);
var Color = Elm.Color.make(_elm);
var Graphics = Graphics || {};
Graphics.Element = Elm.Graphics.Element.make(_elm);
var Maybe = Elm.Maybe.make(_elm);
var Native = Native || {};
Native.Show = Elm.Native.Show.make(_elm);
var Native = Native || {};
Native.Text = Elm.Native.Text.make(_elm);
var String = Elm.String.make(_elm);
var _op = {};
var markdown = Native.Text.markdown;
var justified = Native.Text.justified;
var centered = Native.Text.centered;
var rightAligned = Native.Text.rightAligned;
var leftAligned = Native.Text.leftAligned;
var line = Native.Text.line;
var italic = Native.Text.italic;
var bold = Native.Text.bold;
var color = Native.Text.color;
var height = Native.Text.height;
var link = Native.Text.link;
var monospace = Native.Text.monospace;
var typeface = Native.Text.typeface;
var style = Native.Text.style;
var toText = Native.Text.toText;
var plainText = function (str)
{
return leftAligned(toText(str));
};
var asText = function (value)
{
return leftAligned(monospace(toText(Native.Show.show(value))));
};
var defaultStyle = {_: {}, bold: false, color: Color.black, height: Maybe.Nothing, italic: false, line: Maybe.Nothing, typeface: _L.fromArray([])};
var Style = F6(function (a,b,c,d,e,f)
{
return {_: {}, bold: d, color: c, height: b, italic: e, line: f, typeface: a};
});
var Through = {ctor: "Through"};
var Over = {ctor: "Over"};
var Under = {ctor: "Under"};
var Text = {ctor: "Text"};
_elm.Text.values = {_op: _op, defaultStyle: defaultStyle, toText: toText, style: style, typeface: typeface, monospace: monospace, link: link, height: height, color: color, bold: bold, italic: italic, line: line, leftAligned: leftAligned, rightAligned: rightAligned, centered: centered, justified: justified, plainText: plainText, markdown: markdown, asText: asText, Text: Text, Under: Under, Over: Over, Through: Through, Style: Style};
return _elm.Text.values;
};Elm.Touch = Elm.Touch || {};
Elm.Touch.make = function (_elm)
{
"use strict";
_elm.Touch = _elm.Touch || {};
if (_elm.Touch.values)
return _elm.Touch.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Touch";
var Native = Native || {};
Native.Touch = Elm.Native.Touch.make(_elm);
var Signal = Elm.Signal.make(_elm);
var Time = Elm.Time.make(_elm);
var _op = {};
var taps = Native.Touch.taps;
var touches = Native.Touch.touches;
var Touch = F6(function (a,b,c,d,e,f)
{
return {_: {}, id: c, t0: f, x: a, x0: d, y: b, y0: e};
});
_elm.Touch.values = {_op: _op, touches: touches, taps: taps, Touch: Touch};
return _elm.Touch.values;
};Elm.Bitwise = Elm.Bitwise || {};
Elm.Bitwise.make = function (_elm)
{
"use strict";
_elm.Bitwise = _elm.Bitwise || {};
if (_elm.Bitwise.values)
return _elm.Bitwise.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Bitwise";
var Native = Native || {};
Native.Bitwise = Elm.Native.Bitwise.make(_elm);
var _op = {};
var shiftRightLogical = Native.Bitwise.shiftRightLogical;
var shiftRight = Native.Bitwise.shiftRightArithmatic;
var shiftLeft = Native.Bitwise.shiftLeft;
var complement = Native.Bitwise.complement;
var xor = Native.Bitwise.xor;
var or = Native.Bitwise.or;
var and = Native.Bitwise.and;
_elm.Bitwise.values = {_op: _op, and: and, or: or, xor: xor, complement: complement, shiftLeft: shiftLeft, shiftRight: shiftRight, shiftRightLogical: shiftRightLogical};
return _elm.Bitwise.values;
};Elm.Array = Elm.Array || {};
Elm.Array.make = function (_elm)
{
"use strict";
_elm.Array = _elm.Array || {};
if (_elm.Array.values)
return _elm.Array.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Array";
var Basics = Elm.Basics.make(_elm);
var List = Elm.List.make(_elm);
var Maybe = Elm.Maybe.make(_elm);
var Native = Native || {};
Native.Array = Elm.Native.Array.make(_elm);
var _op = {};
var append = Native.Array.append;
var length = Native.Array.length;
var slice = Native.Array.slice;
var set = Native.Array.set;
var getOrElse = F3(function ($default,i,array)
{
return _U.cmp(0,i) < 1 && _U.cmp(i,
Native.Array.length(array)) < 0 ? A2(Native.Array.get,
i,
array) : $default;
});
var get = F2(function (i,array)
{
return _U.cmp(0,i) < 1 && _U.cmp(i,
Native.Array.length(array)) < 0 ? Maybe.Just(A2(Native.Array.get,
i,
array)) : Maybe.Nothing;
});
var getOrFail = Native.Array.get;
var push = Native.Array.push;
var empty = Native.Array.empty;
var filter = F2(function (isOkay,arr)
{
return function ()
{
var update = F2(function (x,xs)
{
return isOkay(x) ? A2(Native.Array.push,
x,
xs) : xs;
});
return A3(Native.Array.foldl,
update,
Native.Array.empty,
arr);
}();
});
var foldr = Native.Array.foldr;
var foldl = Native.Array.foldl;
var indexedMap = Native.Array.indexedMap;
var map = Native.Array.map;
var toIndexedList = function (array)
{
return A2(List.zip,
_L.range(0,Native.Array.length(array) - 1),
Native.Array.toList(array));
};
var toList = Native.Array.toList;
var fromList = Native.Array.fromList;
var initialize = Native.Array.initialize;
var repeat = F2(function (n,e)
{
return A2(initialize,n,Basics.always(e));
});
var Array = {ctor: "Array"};
_elm.Array.values = {_op: _op, initialize: initialize, repeat: repeat, fromList: fromList, toList: toList, toIndexedList: toIndexedList, map: map, indexedMap: indexedMap, foldl: foldl, foldr: foldr, filter: filter, empty: empty, push: push, getOrFail: getOrFail, get: get, getOrElse: getOrElse, set: set, slice: slice, length: length, append: append, Array: Array};
return _elm.Array.values;
};Elm.Char = Elm.Char || {};
Elm.Char.make = function (_elm)
{
"use strict";
_elm.Char = _elm.Char || {};
if (_elm.Char.values)
return _elm.Char.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Char";
var Native = Native || {};
Native.Char = Elm.Native.Char.make(_elm);
var _op = {};
var fromCode = Native.Char.fromCode;
var toCode = Native.Char.toCode;
var toLocaleLower = Native.Char.toLocaleLower;
var toLocaleUpper = Native.Char.toLocaleUpper;
var toLower = Native.Char.toLower;
var toUpper = Native.Char.toUpper;
var isHexDigit = Native.Char.isHexDigit;
var isOctDigit = Native.Char.isOctDigit;
var isDigit = Native.Char.isDigit;
var isLower = Native.Char.isLower;
var isUpper = Native.Char.isUpper;
_elm.Char.values = {_op: _op, isUpper: isUpper, isLower: isLower, isDigit: isDigit, isOctDigit: isOctDigit, isHexDigit: isHexDigit, toUpper: toUpper, toLower: toLower, toLocaleUpper: toLocaleUpper, toLocaleLower: toLocaleLower, toCode: toCode, fromCode: fromCode};
return _elm.Char.values;
};Elm.Dict = Elm.Dict || {};
Elm.Dict.make = function (_elm)
{
"use strict";
_elm.Dict = _elm.Dict || {};
if (_elm.Dict.values)
return _elm.Dict.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Dict";
var Basics = Elm.Basics.make(_elm);
var List = Elm.List.make(_elm);
var Maybe = Elm.Maybe.make(_elm);
var Native = Native || {};
Native.Error = Elm.Native.Error.make(_elm);
var Native = Native || {};
Native.Utils = Elm.Native.Utils.make(_elm);
var _op = {};
var Same = {ctor: "Same"};
var Remove = {ctor: "Remove"};
var Insert = {ctor: "Insert"};
var showFlag = function (f)
{
return function ()
{
switch (f.ctor)
{case
"Insert" :
return "Insert";
case
"Remove" :
return "Remove";
case
"Same" :
return "Same";}
_E.Case($moduleName,"between lines 179 and 184");
}();
};
var RBEmpty = function (a)
{
return {ctor: "RBEmpty", _0: a};
};
var RBNode = F5(function (a,b,c,d,e)
{
return {ctor: "RBNode", _0: a, _1: b, _2: c, _3: d, _4: e};
});
var max = function (t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
return Native.Error.raise("(max Empty) is not defined");
case
"RBNode" :
switch (t._4.ctor)
{case
"RBEmpty" :
return {ctor: "_Tuple2", _0: t._1, _1: t._2};}
return max(t._4);}
_E.Case($moduleName,"between lines 84 and 101");
}();
};
var LBBlack = {ctor: "LBBlack"};
var LBlack = {ctor: "LBlack"};
var showLColor = function (c)
{
return function ()
{
switch (c.ctor)
{case
"LBBlack" :
return "LBBlack";
case
"LBlack" :
return "LBlack";}
_E.Case($moduleName,"between lines 64 and 66");
}();
};
var empty = RBEmpty(LBlack);
var min = function (t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
switch (t._0.ctor)
{case
"LBlack" :
return Native.Error.raise("(min Empty) is not defined");}
break;
case
"RBNode" :
switch (t._3.ctor)
{case
"RBEmpty" :
switch (t._3._0.ctor)
{case
"LBlack" :
return {ctor: "_Tuple2", _0: t._1, _1: t._2};}
break;}
return min(t._3);}
_E.Case($moduleName,"between lines 77 and 80");
}();
};
var get = F2(function (k,t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
switch (t._0.ctor)
{case
"LBlack" :
return Maybe.Nothing;}
break;
case
"RBNode" :
return function ()
{
var _v25 = A2(Native.Utils.compare,k,t._1);
switch (_v25.ctor)
{case
"EQ" :
return Maybe.Just(t._2);
case
"GT" :
return A2(get,k,t._4);
case
"LT" :
return A2(get,k,t._3);}
_E.Case($moduleName,
"between lines 107 and 120");
}();}
_E.Case($moduleName,"between lines 104 and 120");
}();
});
var member = F2(function (k,t)
{
return Maybe.isJust(A2(get,k,t));
});
var getOrElse = F3(function (base,k,t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
switch (t._0.ctor)
{case
"LBlack" :
return base;}
break;
case
"RBNode" :
return function ()
{
var _v33 = A2(Native.Utils.compare,
k,
t._1);
switch (_v33.ctor)
{case
"EQ" :
return t._2;
case
"GT" :
return A3(getOrElse,base,k,t._4);
case
"LT" :
return A3(getOrElse,base,k,t._3);}
_E.Case($moduleName,
"between lines 126 and 142");
}();}
_E.Case($moduleName,"between lines 123 and 142");
}();
});
var getOrFail = F2(function (k,t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
switch (t._0.ctor)
{case
"LBlack" :
return Native.Error.raise("key not found when using \'getOrFail\'");}
break;
case
"RBNode" :
return function ()
{
var _v41 = A2(Native.Utils.compare,
k,
t._1);
switch (_v41.ctor)
{case
"EQ" :
return t._2;
case
"GT" :
return A2(getOrFail,k,t._4);
case
"LT" :
return A2(getOrFail,k,t._3);}
_E.Case($moduleName,
"between lines 148 and 153");
}();}
_E.Case($moduleName,"between lines 145 and 153");
}();
});
var map = F2(function (f,t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
switch (t._0.ctor)
{case
"LBlack" :
return RBEmpty(LBlack);}
break;
case
"RBNode" :
return A5(RBNode,
t._0,
t._1,
f(t._2),
A2(map,f,t._3),
A2(map,f,t._4));}
_E.Case($moduleName,"between lines 345 and 350");
}();
});
var foldl = F3(function (f,acc,t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
switch (t._0.ctor)
{case
"LBlack" :
return acc;}
break;
case
"RBNode" :
return A3(foldl,
f,
A3(f,t._1,t._2,A3(foldl,f,acc,t._3)),
t._4);}
_E.Case($moduleName,"between lines 353 and 358");
}();
});
var foldr = F3(function (f,acc,t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
switch (t._0.ctor)
{case
"LBlack" :
return acc;}
break;
case
"RBNode" :
return A3(foldr,
f,
A3(f,t._1,t._2,A3(foldr,f,acc,t._4)),
t._3);}
_E.Case($moduleName,"between lines 361 and 366");
}();
});
var keys = function (t)
{
return A3(foldr,
F3(function (k,v,acc)
{
return {ctor: "::", _0: k, _1: acc};
}),
_L.fromArray([]),
t);
};
var values = function (t)
{
return A3(foldr,
F3(function (k,v,acc)
{
return {ctor: "::", _0: v, _1: acc};
}),
_L.fromArray([]),
t);
};
var toList = function (t)
{
return A3(foldr,
F3(function (k,v,acc)
{
return {ctor: "::", _0: {ctor: "_Tuple2", _0: k, _1: v}, _1: acc};
}),
_L.fromArray([]),
t);
};
var NBlack = {ctor: "NBlack"};
var BBlack = {ctor: "BBlack"};
var isBBlack = function (t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
switch (t._0.ctor)
{case
"LBBlack" :
return true;}
break;
case
"RBNode" :
switch (t._0.ctor)
{case
"BBlack" :
return true;}
break;}
return false;
}();
};
var Black = {ctor: "Black"};
var blackish = function (t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
return true;
case
"RBNode" :
return _U.eq(t._0,Black) || _U.eq(t._0,BBlack);}
_E.Case($moduleName,"between lines 296 and 298");
}();
};
var blacken = function (t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
return RBEmpty(LBlack);
case
"RBNode" :
return A5(RBNode,Black,t._1,t._2,t._3,t._4);}
_E.Case($moduleName,"between lines 332 and 334");
}();
};
var Red = {ctor: "Red"};
var showNColor = function (c)
{
return function ()
{
switch (c.ctor)
{case
"BBlack" :
return "BBlack";
case
"Black" :
return "Black";
case
"NBlack" :
return "NBlack";
case
"Red" :
return "Red";}
_E.Case($moduleName,"between lines 53 and 57");
}();
};
var reportRemBug = F4(function (msg,c,lgot,rgot)
{
return Native.Error.raise(List.concat(_L.fromArray(["Internal red-black tree invariant violated, expected ",
msg,
"and got",
showNColor(c),
" ",
lgot,
" ",
rgot,
"\nPlease report this bug to https://github.com/elm-lang/Elm/issues"])));
});
var ensureBlackRoot = function (t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
switch (t._0.ctor)
{case
"LBlack" :
return t;}
break;
case
"RBNode" :
switch (t._0.ctor)
{case
"Black" :
return t;
case
"Red" :
return A5(RBNode,
Black,
t._1,
t._2,
t._3,
t._4);}
break;}
_E.Case($moduleName,"between lines 160 and 166");
}();
};
var moreBlack = function (c)
{
return function ()
{
switch (c.ctor)
{case
"BBlack" :
return Native.Error.raise("Can\'t make a double black node more black!");
case
"Black" :
return BBlack;
case
"NBlack" :
return Red;
case
"Red" :
return Black;}
_E.Case($moduleName,"between lines 222 and 226");
}();
};
var lessBlack = function (c)
{
return function ()
{
switch (c.ctor)
{case
"BBlack" :
return Black;
case
"Black" :
return Red;
case
"NBlack" :
return Native.Error.raise("Can\'t make a negative black node less black!");
case
"Red" :
return NBlack;}
_E.Case($moduleName,"between lines 229 and 233");
}();
};
var lessBlackTree = function (t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
switch (t._0.ctor)
{case
"LBBlack" :
return RBEmpty(LBlack);}
break;
case
"RBNode" :
return A5(RBNode,
lessBlack(t._0),
t._1,
t._2,
t._3,
t._4);}
_E.Case($moduleName,"between lines 236 and 238");
}();
};
var redden = function (t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
return Native.Error.raise("can\'t make a Leaf red");
case
"RBNode" :
return A5(RBNode,Red,t._1,t._2,t._3,t._4);}
_E.Case($moduleName,"between lines 338 and 342");
}();
};
var balance_node = function (t)
{
return function ()
{
var assemble = 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(RBNode,
lessBlack(col),
yk,
yv,
A5(RBNode,
Black,
xk,
xv,
a,
b),
A5(RBNode,
Black,
zk,
zv,
c,
d));
};
};
};
};
};
};
};
};
};
};
};
return blackish(t) ? function ()
{
switch (t.ctor)
{case
"RBNode" :
switch (t._3.ctor)
{case
"RBNode" :
switch (t._3._0.ctor)
{case
"Red" :
switch (t._3._3.ctor)
{case
"RBNode" :
switch (t._3._3._0.ctor)
{case
"Red" :
return assemble(t._0)(t._3._3._1)(t._3._3._2)(t._3._1)(t._3._2)(t._1)(t._2)(t._3._3._3)(t._3._3._4)(t._3._4)(t._4);}
break;}
switch (t._3._4.ctor)
{case
"RBNode" :
switch (t._3._4._0.ctor)
{case
"Red" :
return assemble(t._0)(t._3._1)(t._3._2)(t._3._4._1)(t._3._4._2)(t._1)(t._2)(t._3._3)(t._3._4._3)(t._3._4._4)(t._4);}
break;}
break;}
break;}
switch (t._4.ctor)
{case
"RBNode" :
switch (t._4._0.ctor)
{case
"Red" :
switch (t._4._3.ctor)
{case
"RBNode" :
switch (t._4._3._0.ctor)
{case
"Red" :
return assemble(t._0)(t._1)(t._2)(t._4._3._1)(t._4._3._2)(t._4._1)(t._4._2)(t._3)(t._4._3._3)(t._4._3._4)(t._4._4);}
break;}
switch (t._4._4.ctor)
{case
"RBNode" :
switch (t._4._4._0.ctor)
{case
"Red" :
return assemble(t._0)(t._1)(t._2)(t._4._1)(t._4._2)(t._4._4._1)(t._4._4._2)(t._3)(t._4._3)(t._4._4._3)(t._4._4._4);}
break;}
break;}
break;}
switch (t._0.ctor)
{case
"BBlack" :
switch (t._4.ctor)
{case
"RBNode" :
switch (t._4._0.ctor)
{case
"NBlack" :
switch (t._4._3.ctor)
{case
"RBNode" :
switch (t._4._3._0.ctor)
{case
"Black" :
return function ()
{
switch (t._4._4.ctor)
{case
"RBNode" :
switch (t._4._4._0.ctor)
{case
"Black" :
return A5(RBNode,
Black,
t._4._3._1,
t._4._3._2,
A5(RBNode,
Black,
t._1,
t._2,
t._3,
t._4._3._3),
A5(balance,
Black,
t._4._1,
t._4._2,
t._4._3._4,
redden(t._4._4)));}
break;}
return t;
}();}
break;}
break;}
break;}
switch (t._3.ctor)
{case
"RBNode" :
switch (t._3._0.ctor)
{case
"NBlack" :
switch (t._3._4.ctor)
{case
"RBNode" :
switch (t._3._4._0.ctor)
{case
"Black" :
return function ()
{
switch (t._3._3.ctor)
{case
"RBNode" :
switch (t._3._3._0.ctor)
{case
"Black" :
return A5(RBNode,
Black,
t._3._4._1,
t._3._4._2,
A5(balance,
Black,
t._3._1,
t._3._2,
redden(t._3._3),
t._3._4._3),
A5(RBNode,
Black,
t._1,
t._2,
t._3._4._4,
t._4));}
break;}
return t;
}();}
break;}
break;}
break;}
break;}
break;}
return t;
}() : t;
}();
};
var balance = F5(function (c,k,v,l,r)
{
return balance_node(A5(RBNode,c,k,v,l,r));
});
var bubble = F5(function (c,k,v,l,r)
{
return isBBlack(l) || isBBlack(r) ? A5(balance,
moreBlack(c),
k,
v,
lessBlackTree(l),
lessBlackTree(r)) : A5(RBNode,
c,
k,
v,
l,
r);
});
var remove_max = F5(function (c,k,v,l,r)
{
return function ()
{
switch (r.ctor)
{case
"RBEmpty" :
return A3(rem,c,l,r);
case
"RBNode" :
return A5(bubble,
c,
k,
v,
l,
A5(remove_max,
r._0,
r._1,
r._2,
r._3,
r._4));}
_E.Case($moduleName,"between lines 284 and 287");
}();
});
var rem = F3(function (c,l,r)
{
return function ()
{
var _v183 = {ctor: "_Tuple2", _0: l, _1: r};
switch (_v183.ctor)
{case
"_Tuple2" :
switch (_v183._0.ctor)
{case
"RBEmpty" :
switch (_v183._1.ctor)
{case
"RBEmpty" :
return function ()
{
switch (c.ctor)
{case
"Black" :
return RBEmpty(LBBlack);
case
"Red" :
return RBEmpty(LBlack);}
_E.Case($moduleName,
"between lines 257 and 260");
}();
case
"RBNode" :
return function ()
{
var _v205 = {ctor: "_Tuple3", _0: c, _1: _v183._0._0, _2: _v183._1._0};
switch (_v205.ctor)
{case
"_Tuple3" :
switch (_v205._0.ctor)
{case
"Black" :
switch (_v205._1.ctor)
{case
"LBlack" :
switch (_v205._2.ctor)
{case
"Red" :
return A5(RBNode,
Black,
_v183._1._1,
_v183._1._2,
_v183._1._3,
_v183._1._4);}
break;}
break;}
break;}
return A4(reportRemBug,
"Black, LBlack, Red",
c,
showLColor(_v183._0._0),
showNColor(_v183._1._0));
}();}
break;
case
"RBNode" :
switch (_v183._1.ctor)
{case
"RBEmpty" :
return function ()
{
var _v209 = {ctor: "_Tuple3", _0: c, _1: _v183._0._0, _2: _v183._1._0};
switch (_v209.ctor)
{case
"_Tuple3" :
switch (_v209._0.ctor)
{case
"Black" :
switch (_v209._1.ctor)
{case
"Red" :
switch (_v209._2.ctor)
{case
"LBlack" :
return A5(RBNode,
Black,
_v183._0._1,
_v183._0._2,
_v183._0._3,
_v183._0._4);}
break;}
break;}
break;}
return A4(reportRemBug,
"Black, Red, LBlack",
c,
showNColor(_v183._0._0),
showLColor(_v183._1._0));
}();
case
"RBNode" :
return function ()
{
var l$ = A5(remove_max,
_v183._0._0,
_v183._0._1,
_v183._0._2,
_v183._0._3,
_v183._0._4);
var r = A5(RBNode,
_v183._1._0,
_v183._1._1,
_v183._1._2,
_v183._1._3,
_v183._1._4);
var l = A5(RBNode,
_v183._0._0,
_v183._0._1,
_v183._0._2,
_v183._0._3,
_v183._0._4);
var $ = max(l),k = $._0,v = $._1;
return A5(bubble,c,k,v,l$,r);
}();}
break;}
break;}
_E.Case($moduleName,"between lines 256 and 274");
}();
});
var update = F3(function (k,u,t)
{
return function ()
{
var up = function (t)
{
return function ()
{
switch (t.ctor)
{case
"RBEmpty" :
switch (t._0.ctor)
{case
"LBlack" :
return function ()
{
var _v220 = u(Maybe.Nothing);
switch (_v220.ctor)
{case
"Just" :
return {ctor: "_Tuple2", _0: Insert, _1: A5(RBNode,
Red,
k,
_v220._0,
empty,
empty)};
case
"Nothing" :
return {ctor: "_Tuple2", _0: Same, _1: empty};}
_E.Case($moduleName,
"between lines 188 and 191");
}();}
break;
case
"RBNode" :
return function ()
{
var _v222 = A2(Native.Utils.compare,
k,
t._1);
switch (_v222.ctor)
{case
"EQ" :
return function ()
{
var _v223 = u(Maybe.Just(t._2));
switch (_v223.ctor)
{case
"Just" :
return {ctor: "_Tuple2", _0: Same, _1: A5(RBNode,
t._0,
t._1,
_v223._0,
t._3,
t._4)};
case
"Nothing" :
return {ctor: "_Tuple2", _0: Remove, _1: A3(rem,
t._0,
t._3,
t._4)};}
_E.Case($moduleName,
"between lines 192 and 195");
}();
case
"GT" :
return function ()
{
var $ = up(t._4),
fl = $._0,
r$ = $._1;
return function ()
{
switch (fl.ctor)
{case
"Insert" :
return {ctor: "_Tuple2", _0: Insert, _1: A5(balance,
t._0,
t._1,
t._2,
t._3,
r$)};
case
"Remove" :
return {ctor: "_Tuple2", _0: Remove, _1: A5(bubble,
t._0,
t._1,
t._2,
t._3,
r$)};
case
"Same" :
return {ctor: "_Tuple2", _0: Same, _1: A5(RBNode,
t._0,
t._1,
t._2,
t._3,
r$)};}
_E.Case($moduleName,
"between lines 201 and 205");
}();
}();
case
"LT" :
return function ()
{
var $ = up(t._3),
fl = $._0,
l$ = $._1;
return function ()
{
switch (fl.ctor)
{case
"Insert" :
return {ctor: "_Tuple2", _0: Insert, _1: A5(balance,
t._0,
t._1,
t._2,
l$,
t._4)};
case
"Remove" :
return {ctor: "_Tuple2", _0: Remove, _1: A5(bubble,
t._0,
t._1,
t._2,
l$,
t._4)};
case
"Same" :
return {ctor: "_Tuple2", _0: Same, _1: A5(RBNode,
t._0,
t._1,
t._2,
l$,
t._4)};}
_E.Case($moduleName,
"between lines 196 and 200");
}();
}();}
_E.Case($moduleName,
"between lines 191 and 205");
}();}
_E.Case($moduleName,
"between lines 187 and 205");
}();
};
var $ = up(t),fl = $._0,t$ = $._1;
return function ()
{
switch (fl.ctor)
{case
"Insert" :
return ensureBlackRoot(t$);
case
"Remove" :
return blacken(t$);
case
"Same" :
return t$;}
_E.Case($moduleName,
"between lines 206 and 211");
}();
}();
});
var insert = F3(function (k,v,t)
{
return function ()
{
var u = function (_v228)
{
return function ()
{
return Maybe.Just(v);
}();
};
return A3(update,k,u,t);
}();
});
var singleton = F2(function (k,v)
{
return A3(insert,k,v,RBEmpty(LBlack));
});
var union = F2(function (t1,t2)
{
return A3(foldl,insert,t2,t1);
});
var fromList = function (assocs)
{
return A3(List.foldl,
F2(function (_v230,d)
{
return function ()
{
switch (_v230.ctor)
{case
"_Tuple2" :
return A3(insert,
_v230._0,
_v230._1,
d);}
_E.Case($moduleName,
"on line 394, column 43 to 55");
}();
}),
empty,
assocs);
};
var filter = F2(function (p,dict)
{
return function ()
{
var add = F3(function (k,v,t)
{
return A2(p,k,v) ? A3(insert,k,v,t) : t;
});
return A3(foldl,add,empty,dict);
}();
});
var intersect = F2(function (t1,t2)
{
return A2(filter,
F2(function (k,_v234)
{
return function ()
{
return A2(member,k,t2);
}();
}),
t1);
});
var partition = F2(function (p,dict)
{
return function ()
{
var add = F3(function (k,v,_v236)
{
return function ()
{
switch (_v236.ctor)
{case
"_Tuple2" :
return A2(p,
k,
v) ? {ctor: "_Tuple2", _0: A3(insert,
k,
v,
_v236._0), _1: _v236._1} : {ctor: "_Tuple2", _0: _v236._0, _1: A3(insert,
k,
v,
_v236._1)};}
_E.Case($moduleName,
"between lines 408 and 410");
}();
});
return A3(foldl,
add,
{ctor: "_Tuple2", _0: empty, _1: empty},
dict);
}();
});
var remove = F2(function (k,t)
{
return function ()
{
var u = function (_v240)
{
return function ()
{
return Maybe.Nothing;
}();
};
return A3(update,k,u,t);
}();
});
var diff = F2(function (t1,t2)
{
return A3(foldl,
F3(function (k,v,t)
{
return A2(remove,k,t);
}),
t1,
t2);
});
_elm.Dict.values = {_op: _op, empty: empty, singleton: singleton, insert: insert, update: update, get: get, getOrElse: getOrElse, getOrFail: getOrFail, remove: remove, member: member, filter: filter, partition: partition, foldl: foldl, foldr: foldr, map: map, union: union, intersect: intersect, diff: diff, keys: keys, values: values, toList: toList, fromList: fromList};
return _elm.Dict.values;
};Elm.Transform2D = Elm.Transform2D || {};
Elm.Transform2D.make = function (_elm)
{
"use strict";
_elm.Transform2D = _elm.Transform2D || {};
if (_elm.Transform2D.values)
return _elm.Transform2D.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Transform2D";
var Native = Native || {};
Native.Transform2D = Elm.Native.Transform2D.make(_elm);
var _op = {};
var multiply = Native.Transform2D.multiply;
var rotation = Native.Transform2D.rotation;
var matrix = Native.Transform2D.matrix;
var translation = F2(function (x,y)
{
return A6(matrix,1,0,0,1,x,y);
});
var scale = function (s)
{
return A6(matrix,s,0,0,s,0,0);
};
var scaleX = function (x)
{
return A6(matrix,x,0,0,1,0,0);
};
var scaleY = function (y)
{
return A6(matrix,1,0,0,y,0,0);
};
var identity = Native.Transform2D.identity;
var Transform2D = {ctor: "Transform2D"};
_elm.Transform2D.values = {_op: _op, identity: identity, matrix: matrix, rotation: rotation, translation: translation, scale: scale, scaleX: scaleX, scaleY: scaleY, multiply: multiply, Transform2D: Transform2D};
return _elm.Transform2D.values;
};Elm.Signal = Elm.Signal || {};
Elm.Signal.make = function (_elm)
{
"use strict";
_elm.Signal = _elm.Signal || {};
if (_elm.Signal.values)
return _elm.Signal.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Signal";
var Basics = Elm.Basics.make(_elm);
var List = Elm.List.make(_elm);
var Native = Native || {};
Native.Signal = Elm.Native.Signal.make(_elm);
var _op = {};
_op["~"] = F2(function (sf,s)
{
return A3(Native.Signal.lift2,
F2(function (f,x)
{
return f(x);
}),
sf,
s);
});
_op["<~"] = F2(function (f,s)
{
return A2(Native.Signal.lift,f,s);
});
var sampleOn = Native.Signal.sampleOn;
var dropRepeats = Native.Signal.dropRepeats;
var dropIf = Native.Signal.dropIf;
var keepIf = Native.Signal.keepIf;
var keepWhen = F3(function (bs,def,sig)
{
return A2(_op["<~"],
Basics.snd,
A3(keepIf,
Basics.fst,
{ctor: "_Tuple2", _0: false, _1: def},
A2(_op["~"],
A2(_op["<~"],
F2(function (v0,v1)
{
return {ctor: "_Tuple2", _0: v0, _1: v1};
}),
A2(sampleOn,sig,bs)),
sig)));
});
var dropWhen = function (bs)
{
return keepWhen(A2(_op["<~"],Basics.not,bs));
};
var countIf = Native.Signal.countIf;
var count = Native.Signal.count;
var combine = A2(List.foldr,
Native.Signal.lift2(F2(function (x,y)
{
return {ctor: "::", _0: x, _1: y};
})),
Native.Signal.constant(_L.fromArray([])));
var merges = Native.Signal.merges;
var merge = Native.Signal.merge;
var foldp = Native.Signal.foldp;
var lift8 = Native.Signal.lift8;
var lift7 = Native.Signal.lift7;
var lift6 = Native.Signal.lift6;
var lift5 = Native.Signal.lift5;
var lift4 = Native.Signal.lift4;
var lift3 = Native.Signal.lift3;
var lift2 = Native.Signal.lift2;
var lift = Native.Signal.lift;
var constant = Native.Signal.constant;
var Signal = {ctor: "Signal"};
_elm.Signal.values = {_op: _op, constant: constant, lift: lift, lift2: lift2, lift3: lift3, lift4: lift4, lift5: lift5, lift6: lift6, lift7: lift7, lift8: lift8, foldp: foldp, merge: merge, merges: merges, combine: combine, count: count, countIf: countIf, keepIf: keepIf, dropIf: dropIf, keepWhen: keepWhen, dropWhen: dropWhen, dropRepeats: dropRepeats, sampleOn: sampleOn, Signal: Signal};
return _elm.Signal.values;
};Elm.String = Elm.String || {};
Elm.String.make = function (_elm)
{
"use strict";
_elm.String = _elm.String || {};
if (_elm.String.values)
return _elm.String.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "String";
var Maybe = Elm.Maybe.make(_elm);
var Native = Native || {};
Native.Show = Elm.Native.Show.make(_elm);
var Native = Native || {};
Native.String = Elm.Native.String.make(_elm);
var _op = {};
var fromList = Native.String.fromList;
var toList = Native.String.toList;
var toFloat = Native.String.toFloat;
var toInt = Native.String.toInt;
var show = Native.Show.show;
var indices = Native.String.indexes;
var indexes = Native.String.indexes;
var endsWith = Native.String.endsWith;
var startsWith = Native.String.startsWith;
var contains = Native.String.contains;
var all = Native.String.all;
var any = Native.String.any;
var toLower = Native.String.toLower;
var toUpper = Native.String.toUpper;
var lines = Native.String.lines;
var words = Native.String.words;
var trimRight = Native.String.trimRight;
var trimLeft = Native.String.trimLeft;
var trim = Native.String.trim;
var padRight = Native.String.padRight;
var padLeft = Native.String.padLeft;
var pad = Native.String.pad;
var dropRight = Native.String.dropRight;
var dropLeft = Native.String.dropLeft;
var right = Native.String.right;
var left = Native.String.left;
var slice = Native.String.slice;
var repeat = Native.String.repeat;
var join = Native.String.join;
var split = Native.String.split;
var foldr = Native.String.foldr;
var foldl = Native.String.foldl;
var reverse = Native.String.reverse;
var filter = Native.String.filter;
var map = Native.String.map;
var length = Native.String.length;
var concat = Native.String.concat;
var append = Native.String.append;
var uncons = Native.String.uncons;
var cons = Native.String.cons;
var isEmpty = Native.String.isEmpty;
_elm.String.values = {_op: _op, isEmpty: isEmpty, cons: cons, uncons: uncons, append: append, concat: concat, length: length, map: map, filter: filter, reverse: reverse, foldl: foldl, foldr: foldr, split: split, join: join, repeat: repeat, slice: slice, left: left, right: right, dropLeft: dropLeft, dropRight: dropRight, pad: pad, padLeft: padLeft, padRight: padRight, trim: trim, trimLeft: trimLeft, trimRight: trimRight, words: words, lines: lines, toUpper: toUpper, toLower: toLower, any: any, all: all, contains: contains, startsWith: startsWith, endsWith: endsWith, indexes: indexes, indices: indices, show: show, toInt: toInt, toFloat: toFloat, toList: toList, fromList: fromList};
return _elm.String.values;
};Elm.Regex = Elm.Regex || {};
Elm.Regex.make = function (_elm)
{
"use strict";
_elm.Regex = _elm.Regex || {};
if (_elm.Regex.values)
return _elm.Regex.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Regex";
var Maybe = Elm.Maybe.make(_elm);
var Native = Native || {};
Native.Regex = Elm.Native.Regex.make(_elm);
var _op = {};
var split = Native.Regex.split;
var replace = Native.Regex.replace;
var find = Native.Regex.find;
var AtMost = function (a)
{
return {ctor: "AtMost", _0: a};
};
var All = {ctor: "All"};
var Match = F4(function (a,b,c,d)
{
return {_: {}, index: c, match: a, number: d, submatches: b};
});
var contains = Native.Regex.contains;
var caseInsensitive = Native.Regex.caseInsensitive;
var regex = Native.Regex.regex;
var escape = Native.Regex.escape;
var Regex = {ctor: "Regex"};
_elm.Regex.values = {_op: _op, escape: escape, regex: regex, caseInsensitive: caseInsensitive, contains: contains, find: find, replace: replace, split: split, Regex: Regex, All: All, AtMost: AtMost, Match: Match};
return _elm.Regex.values;
};Elm.WebSocket = Elm.WebSocket || {};
Elm.WebSocket.make = function (_elm)
{
"use strict";
_elm.WebSocket = _elm.WebSocket || {};
if (_elm.WebSocket.values)
return _elm.WebSocket.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "WebSocket";
var Basics = Elm.Basics.make(_elm);
var Native = Native || {};
Native.WebSocket = Elm.Native.WebSocket.make(_elm);
var Signal = Elm.Signal.make(_elm);
var _op = {};
var connect = Native.WebSocket.connect;
_elm.WebSocket.values = {_op: _op, connect: connect};
return _elm.WebSocket.values;
};Elm.Debug = Elm.Debug || {};
Elm.Debug.make = function (_elm)
{
"use strict";
_elm.Debug = _elm.Debug || {};
if (_elm.Debug.values)
return _elm.Debug.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Debug";
var Native = Native || {};
Native.Debug = Elm.Native.Debug.make(_elm);
var _op = {};
var log = Native.Debug.log;
_elm.Debug.values = {_op: _op, log: log};
return _elm.Debug.values;
};Elm.Mouse = Elm.Mouse || {};
Elm.Mouse.make = function (_elm)
{
"use strict";
_elm.Mouse = _elm.Mouse || {};
if (_elm.Mouse.values)
return _elm.Mouse.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Mouse";
var Native = Native || {};
Native.Mouse = Elm.Native.Mouse.make(_elm);
var Signal = Elm.Signal.make(_elm);
var _op = {};
var clicks = Native.Mouse.clicks;
var isDown = Native.Mouse.isDown;
var y = Native.Mouse.y;
var x = Native.Mouse.x;
var position = Native.Mouse.position;
_elm.Mouse.values = {_op: _op, position: position, x: x, y: y, isDown: isDown, clicks: clicks};
return _elm.Mouse.values;
};Elm.Http = Elm.Http || {};
Elm.Http.make = function (_elm)
{
"use strict";
_elm.Http = _elm.Http || {};
if (_elm.Http.values)
return _elm.Http.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Http";
var Native = Native || {};
Native.Http = Elm.Native.Http.make(_elm);
var Signal = Elm.Signal.make(_elm);
var _op = {};
var send = Native.Http.send;
var Request = F4(function (a,b,c,d)
{
return {_: {}, body: c, headers: d, url: b, verb: a};
});
var request = Request;
var get = function (url)
{
return A4(Request,"GET",url,"",_L.fromArray([]));
};
var sendGet = function (reqs)
{
return send(A2(Signal.lift,get,reqs));
};
var post = F2(function (url,body)
{
return A4(Request,"POST",url,body,_L.fromArray([]));
});
var Failure = F2(function (a,b)
{
return {ctor: "Failure", _0: a, _1: b};
});
var Waiting = {ctor: "Waiting"};
var Success = function (a)
{
return {ctor: "Success", _0: a};
};
_elm.Http.values = {_op: _op, request: request, get: get, post: post, send: send, sendGet: sendGet, Success: Success, Waiting: Waiting, Failure: Failure, Request: Request};
return _elm.Http.values;
};Elm.Random = Elm.Random || {};
Elm.Random.make = function (_elm)
{
"use strict";
_elm.Random = _elm.Random || {};
if (_elm.Random.values)
return _elm.Random.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Random";
var Native = Native || {};
Native.Random = Elm.Native.Random.make(_elm);
var Signal = Elm.Signal.make(_elm);
var _op = {};
var floatList = Native.Random.floatList;
var $float = Native.Random.float_;
var range = Native.Random.range;
_elm.Random.values = {_op: _op, range: range, $float: $float, floatList: floatList};
return _elm.Random.values;
};Elm.Date = Elm.Date || {};
Elm.Date.make = function (_elm)
{
"use strict";
_elm.Date = _elm.Date || {};
if (_elm.Date.values)
return _elm.Date.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Date";
var Maybe = Elm.Maybe.make(_elm);
var Native = Native || {};
Native.Date = Elm.Native.Date.make(_elm);
var Time = Elm.Time.make(_elm);
var _op = {};
var second = Native.Date.second;
var minute = Native.Date.minute;
var hour = Native.Date.hour;
var dayOfWeek = Native.Date.dayOfWeek;
var day = Native.Date.day;
var month = Native.Date.month;
var year = Native.Date.year;
var fromTime = Native.Date.fromTime;
var toTime = Native.Date.toTime;
var read = Native.Date.read;
var Dec = {ctor: "Dec"};
var Nov = {ctor: "Nov"};
var Oct = {ctor: "Oct"};
var Sep = {ctor: "Sep"};
var Aug = {ctor: "Aug"};
var Jul = {ctor: "Jul"};
var Jun = {ctor: "Jun"};
var May = {ctor: "May"};
var Apr = {ctor: "Apr"};
var Mar = {ctor: "Mar"};
var Feb = {ctor: "Feb"};
var Jan = {ctor: "Jan"};
var Sun = {ctor: "Sun"};
var Sat = {ctor: "Sat"};
var Fri = {ctor: "Fri"};
var Thu = {ctor: "Thu"};
var Wed = {ctor: "Wed"};
var Tue = {ctor: "Tue"};
var Mon = {ctor: "Mon"};
var Date = {ctor: "Date"};
_elm.Date.values = {_op: _op, read: read, toTime: toTime, fromTime: fromTime, year: year, month: month, day: day, dayOfWeek: dayOfWeek, hour: hour, minute: minute, second: second, Date: Date, Mon: Mon, Tue: Tue, Wed: Wed, Thu: Thu, Fri: Fri, Sat: Sat, Sun: Sun, Jan: Jan, Feb: Feb, Mar: Mar, Apr: Apr, May: May, Jun: Jun, Jul: Jul, Aug: Aug, Sep: Sep, Oct: Oct, Nov: Nov, Dec: Dec};
return _elm.Date.values;
};Elm.List = Elm.List || {};
Elm.List.make = function (_elm)
{
"use strict";
_elm.List = _elm.List || {};
if (_elm.List.values)
return _elm.List.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "List";
var Basics = Elm.Basics.make(_elm);
var Native = Native || {};
Native.List = Elm.Native.List.make(_elm);
var _op = {};
var sortWith = Native.List.sortWith;
var sortBy = Native.List.sortBy;
var sort = Native.List.sort;
var repeat = Native.List.repeat;
var drop = Native.List.drop;
var take = Native.List.take;
var join = Native.List.join;
var zipWith5 = Native.List.zipWith5;
var zipWith4 = Native.List.zipWith4;
var zipWith3 = Native.List.zipWith3;
var zipWith = Native.List.zipWith;
var zip5 = Native.List.zipWith5(F5(function (v0,v1,v2,v3,v4)
{
return {ctor: "_Tuple5", _0: v0, _1: v1, _2: v2, _3: v3, _4: v4};
}));
var zip4 = Native.List.zipWith4(F4(function (v0,v1,v2,v3)
{
return {ctor: "_Tuple4", _0: v0, _1: v1, _2: v2, _3: v3};
}));
var zip3 = Native.List.zipWith3(F3(function (v0,v1,v2)
{
return {ctor: "_Tuple3", _0: v0, _1: v1, _2: v2};
}));
var zip = Native.List.zip;
var concat = Native.List.concat;
var any = Native.List.any;
var all = Native.List.all;
var reverse = Native.List.reverse;
var length = Native.List.length;
var filter = Native.List.filter;
var scanl1 = Native.List.scanl1;
var scanl = Native.List.scanl;
var foldr1 = Native.List.foldr1;
var foldl1 = Native.List.foldl1;
var maximum = foldl1(Basics.max);
var minimum = foldl1(Basics.min);
var foldr = Native.List.foldr;
var foldl = Native.List.foldl;
var and = A2(foldl,
F2(function (x,y)
{
return x && y;
}),
true);
var or = A2(foldl,
F2(function (x,y)
{
return x || y;
}),
false);
var sum = A2(foldl,
F2(function (x,y)
{
return x + y;
}),
0);
var product = A2(foldl,
F2(function (x,y)
{
return x * y;
}),
1);
var map = Native.List.map;
var concatMap = F2(function (f,list)
{
return concat(A2(map,f,list));
});
var isEmpty = function (xs)
{
return function ()
{
switch (xs.ctor)
{case
"[]" :
return true;}
return false;
}();
};
var last = Native.List.last;
var tail = Native.List.tail;
var head = Native.List.head;
_op["++"] = Native.List.append;
_op["::"] = Native.List.cons;
var partition = function (pred)
{
return function ()
{
var step = F2(function (x,_v1)
{
return function ()
{
switch (_v1.ctor)
{case
"_Tuple2" :
return pred(x) ? {ctor: "_Tuple2", _0: {ctor: "::", _0: x, _1: _v1._0}, _1: _v1._1} : {ctor: "_Tuple2", _0: _v1._0, _1: {ctor: "::", _0: x, _1: _v1._1}};}
_E.Case($moduleName,
"between lines 184 and 186");
}();
});
return A2(foldr,
step,
{ctor: "_Tuple2", _0: _L.fromArray([]), _1: _L.fromArray([])});
}();
};
var unzip = function ()
{
var step = F2(function (_v5,_v6)
{
return function ()
{
switch (_v6.ctor)
{case
"_Tuple2" :
return function ()
{
switch (_v5.ctor)
{case
"_Tuple2" :
return {ctor: "_Tuple2", _0: {ctor: "::", _0: _v5._0, _1: _v6._0}, _1: {ctor: "::", _0: _v5._1, _1: _v6._1}};}
_E.Case($moduleName,
"on line 230, column 32 to 44");
}();}
_E.Case($moduleName,
"on line 230, column 32 to 44");
}();
});
return A2(foldr,
step,
{ctor: "_Tuple2", _0: _L.fromArray([]), _1: _L.fromArray([])});
}();
var intersperse = F2(function (sep,xs)
{
return function ()
{
switch (xs.ctor)
{case
"::" :
return function ()
{
var step = F2(function (x,rest)
{
return {ctor: "::", _0: sep, _1: {ctor: "::", _0: x, _1: rest}};
});
var spersed = A3(foldr,
step,
_L.fromArray([]),
xs._1);
return {ctor: "::", _0: xs._0, _1: spersed};
}();
case
"[]" :
return _L.fromArray([]);}
_E.Case($moduleName,"between lines 247 and 254");
}();
});
_elm.List.values = {_op: _op, head: head, tail: tail, last: last, isEmpty: isEmpty, map: map, foldl: foldl, foldr: foldr, foldl1: foldl1, foldr1: foldr1, scanl: scanl, scanl1: scanl1, filter: filter, length: length, reverse: reverse, all: all, any: any, and: and, or: or, concat: concat, concatMap: concatMap, sum: sum, product: product, maximum: maximum, minimum: minimum, partition: partition, zip: zip, zip3: zip3, zip4: zip4, zip5: zip5, zipWith: zipWith, zipWith3: zipWith3, zipWith4: zipWith4, zipWith5: zipWith5, unzip: unzip, join: join, intersperse: intersperse, take: take, drop: drop, repeat: repeat, sort: sort, sortBy: sortBy, sortWith: sortWith};
return _elm.List.values;
};Elm.JavaScript = Elm.JavaScript || {};
Elm.JavaScript.Experimental = Elm.JavaScript.Experimental || {};
Elm.JavaScript.Experimental.make = function (_elm)
{
"use strict";
_elm.JavaScript = _elm.JavaScript || {};
_elm.JavaScript.Experimental = _elm.JavaScript.Experimental || {};
if (_elm.JavaScript.Experimental.values)
return _elm.JavaScript.Experimental.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "JavaScript.Experimental";
var Json = Elm.Json.make(_elm);
var Native = Native || {};
Native.JavaScript = Elm.Native.JavaScript.make(_elm);
var Native = Native || {};
Native.Json = Elm.Native.Json.make(_elm);
var _op = {};
var fromJson = Native.Json.toJS;
var toJson = Native.Json.fromJS;
var fromRecord = Native.JavaScript.fromRecord;
var toRecord = Native.JavaScript.toRecord;
var RawObject = {ctor: "RawObject"};
_elm.JavaScript.Experimental.values = {_op: _op, toRecord: toRecord, fromRecord: fromRecord, toJson: toJson, fromJson: fromJson, RawObject: RawObject};
return _elm.JavaScript.Experimental.values;
};Elm.Graphics = Elm.Graphics || {};
Elm.Graphics.Input = Elm.Graphics.Input || {};
Elm.Graphics.Input.make = function (_elm)
{
"use strict";
_elm.Graphics = _elm.Graphics || {};
_elm.Graphics.Input = _elm.Graphics.Input || {};
if (_elm.Graphics.Input.values)
return _elm.Graphics.Input.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Graphics.Input";
var Graphics = Graphics || {};
Graphics.Element = Elm.Graphics.Element.make(_elm);
var Native = Native || {};
Native.Graphics = Native.Graphics || {};
Native.Graphics.Input = Elm.Native.Graphics.Input.make(_elm);
var Signal = Elm.Signal.make(_elm);
var _op = {};
var clickable = Native.Graphics.Input.clickable;
var hoverable = Native.Graphics.Input.hoverable;
var dropDown = Native.Graphics.Input.dropDown;
var checkbox = Native.Graphics.Input.checkbox;
var customButton = Native.Graphics.Input.customButton;
var button = Native.Graphics.Input.button;
var input = Native.Graphics.Input.input;
var Handle = {ctor: "Handle"};
var Input = F2(function (a,b)
{
return {_: {}, handle: b, signal: a};
});
_elm.Graphics.Input.values = {_op: _op, input: input, button: button, customButton: customButton, checkbox: checkbox, dropDown: dropDown, hoverable: hoverable, clickable: clickable, Handle: Handle, Input: Input};
return _elm.Graphics.Input.values;
};Elm.Graphics = Elm.Graphics || {};
Elm.Graphics.Element = Elm.Graphics.Element || {};
Elm.Graphics.Element.make = function (_elm)
{
"use strict";
_elm.Graphics = _elm.Graphics || {};
_elm.Graphics.Element = _elm.Graphics.Element || {};
if (_elm.Graphics.Element.values)
return _elm.Graphics.Element.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Graphics.Element";
var Basics = Elm.Basics.make(_elm);
var Color = Elm.Color.make(_elm);
var List = Elm.List.make(_elm);
var Maybe = Elm.Maybe.make(_elm);
var Native = Native || {};
Native.Utils = Elm.Native.Utils.make(_elm);
var _op = {};
var DOut = {ctor: "DOut"};
var outward = DOut;
var DIn = {ctor: "DIn"};
var inward = DIn;
var DRight = {ctor: "DRight"};
var right = DRight;
var DLeft = {ctor: "DLeft"};
var left = DLeft;
var DDown = {ctor: "DDown"};
var down = DDown;
var DUp = {ctor: "DUp"};
var up = DUp;
var Position = F4(function (a,b,c,d)
{
return {_: {}, horizontal: a, vertical: b, x: c, y: d};
});
var Relative = function (a)
{
return {ctor: "Relative", _0: a};
};
var relative = Relative;
var Absolute = function (a)
{
return {ctor: "Absolute", _0: a};
};
var absolute = Absolute;
var N = {ctor: "N"};
var bottomLeftAt = F2(function (x,y)
{
return {_: {}, horizontal: N, vertical: N, x: x, y: y};
});
var Z = {ctor: "Z"};
var middle = {_: {}, horizontal: Z, vertical: Z, x: Relative(0.5), y: Relative(0.5)};
var midLeft = _U.replace([["horizontal",N],["x",Absolute(0)]],
middle);
var middleAt = F2(function (x,y)
{
return {_: {}, horizontal: Z, vertical: Z, x: x, y: y};
});
var midLeftAt = F2(function (x,y)
{
return {_: {}, horizontal: N, vertical: Z, x: x, y: y};
});
var midBottomAt = F2(function (x,y)
{
return {_: {}, horizontal: Z, vertical: N, x: x, y: y};
});
var P = {ctor: "P"};
var topLeft = {_: {}, horizontal: N, vertical: P, x: Absolute(0), y: Absolute(0)};
var bottomLeft = _U.replace([["vertical",N]],topLeft);
var topRight = _U.replace([["horizontal",P]],topLeft);
var bottomRight = _U.replace([["horizontal",P]],bottomLeft);
var midRight = _U.replace([["horizontal",P]],midLeft);
var midTop = _U.replace([["vertical",P],["y",Absolute(0)]],middle);
var midBottom = _U.replace([["vertical",N]],midTop);
var topLeftAt = F2(function (x,y)
{
return {_: {}, horizontal: N, vertical: P, x: x, y: y};
});
var topRightAt = F2(function (x,y)
{
return {_: {}, horizontal: P, vertical: P, x: x, y: y};
});
var bottomRightAt = F2(function (x,y)
{
return {_: {}, horizontal: P, vertical: N, x: x, y: y};
});
var midRightAt = F2(function (x,y)
{
return {_: {}, horizontal: P, vertical: Z, x: x, y: y};
});
var midTopAt = F2(function (x,y)
{
return {_: {}, horizontal: Z, vertical: P, x: x, y: y};
});
var Tiled = {ctor: "Tiled"};
var Cropped = function (a)
{
return {ctor: "Cropped", _0: a};
};
var Fitted = {ctor: "Fitted"};
var Plain = {ctor: "Plain"};
var Custom = {ctor: "Custom"};
var RawHtml = {ctor: "RawHtml"};
var Spacer = {ctor: "Spacer"};
var Flow = F2(function (a,b)
{
return {ctor: "Flow", _0: a, _1: b};
});
var Container = F2(function (a,b)
{
return {ctor: "Container", _0: a, _1: b};
});
var Image = F4(function (a,b,c,d)
{
return {ctor: "Image", _0: a, _1: b, _2: c, _3: d};
});
var link = F2(function (href,e)
{
return function ()
{
var p = e.props;
return {_: {}, element: e.element, props: _U.replace([["href",
href]],
p)};
}();
});
var tag = F2(function (name,e)
{
return function ()
{
var p = e.props;
return {_: {}, element: e.element, props: _U.replace([["tag",
name]],
p)};
}();
});
var color = F2(function (c,e)
{
return function ()
{
var p = e.props;
return {_: {}, element: e.element, props: _U.replace([["color",
Maybe.Just(c)]],
p)};
}();
});
var opacity = F2(function (o,e)
{
return function ()
{
var p = e.props;
return {_: {}, element: e.element, props: _U.replace([["opacity",
o]],
p)};
}();
});
var height = F2(function (nh,e)
{
return function ()
{
var p = e.props;
var props = function ()
{
var _v0 = e.element;
switch (_v0.ctor)
{case
"Image" :
return _U.replace([["width",
Basics.round(Basics.toFloat(_v0._1) / Basics.toFloat(_v0._2) * Basics.toFloat(nh))]],
p);}
return p;
}();
return {_: {}, element: e.element, props: _U.replace([["height",
nh]],
p)};
}();
});
var width = F2(function (nw,e)
{
return function ()
{
var p = e.props;
var props = function ()
{
var _v5 = e.element;
switch (_v5.ctor)
{case
"Image" :
return _U.replace([["height",
Basics.round(Basics.toFloat(_v5._2) / Basics.toFloat(_v5._1) * Basics.toFloat(nw))]],
p);
case
"RawHtml" :
return _U.replace([["height",
Basics.snd(A2(Native.Utils.htmlHeight,
nw,
e.element))]],
p);}
return p;
}();
return {_: {}, element: e.element, props: _U.replace([["width",
nw]],
props)};
}();
});
var size = F3(function (w,h,e)
{
return A2(height,h,A2(width,w,e));
});
var sizeOf = function (e)
{
return {ctor: "_Tuple2", _0: e.props.width, _1: e.props.height};
};
var heightOf = function (e)
{
return e.props.height;
};
var widthOf = function (e)
{
return e.props.width;
};
var Element = F2(function (a,b)
{
return {_: {}, element: b, props: a};
});
var Properties = F9(function (a,b,c,d,e,f,g,h,i)
{
return {_: {}, click: i, color: e, height: c, hover: h, href: f, id: a, opacity: d, tag: g, width: b};
});
var newElement = F3(function (w,h,e)
{
return {_: {}, element: e, props: A9(Properties,
Native.Utils.guid({ctor: "_Tuple0"}),
w,
h,
1,
Maybe.Nothing,
"",
"",
{ctor: "_Tuple0"},
{ctor: "_Tuple0"})};
});
var image = F3(function (w,h,src)
{
return A3(newElement,w,h,A4(Image,Plain,w,h,src));
});
var fittedImage = F3(function (w,h,src)
{
return A3(newElement,
w,
h,
A4(Image,Fitted,w,h,src));
});
var croppedImage = F4(function (pos,w,h,src)
{
return A3(newElement,
w,
h,
A4(Image,Cropped(pos),w,h,src));
});
var tiledImage = F3(function (w,h,src)
{
return A3(newElement,
w,
h,
A4(Image,Tiled,w,h,src));
});
var container = F4(function (w,h,pos,e)
{
return A3(newElement,w,h,A2(Container,pos,e));
});
var spacer = F2(function (w,h)
{
return A3(newElement,w,h,Spacer);
});
var empty = A2(spacer,0,0);
var flow = F2(function (dir,es)
{
return function ()
{
var newFlow = F2(function (w,h)
{
return A3(newElement,
w,
h,
A2(Flow,
dir,
es));
});
var hs = A2(List.map,heightOf,es);
var ws = A2(List.map,widthOf,es);
return _U.eq(es,
_L.fromArray([])) ? empty : function ()
{
switch (dir.ctor)
{case
"DDown" :
return A2(newFlow,
List.maximum(ws),
List.sum(hs));
case
"DIn" :
return A2(newFlow,
List.maximum(ws),
List.maximum(hs));
case
"DLeft" :
return A2(newFlow,
List.sum(ws),
List.maximum(hs));
case
"DOut" :
return A2(newFlow,
List.maximum(ws),
List.maximum(hs));
case
"DRight" :
return A2(newFlow,
List.sum(ws),
List.maximum(hs));
case
"DUp" :
return A2(newFlow,
List.maximum(ws),
List.sum(hs));}
_E.Case($moduleName,
"between lines 206 and 216");
}();
}();
});
var above = F2(function (hi,lo)
{
return A3(newElement,
A2(Basics.max,widthOf(hi),widthOf(lo)),
heightOf(hi) + heightOf(lo),
A2(Flow,DDown,_L.fromArray([hi,lo])));
});
var below = F2(function (lo,hi)
{
return A3(newElement,
A2(Basics.max,widthOf(hi),widthOf(lo)),
heightOf(hi) + heightOf(lo),
A2(Flow,DDown,_L.fromArray([hi,lo])));
});
var beside = F2(function (lft,rht)
{
return A3(newElement,
widthOf(lft) + widthOf(rht),
A2(Basics.max,
heightOf(lft),
heightOf(rht)),
A2(Flow,right,_L.fromArray([lft,rht])));
});
var layers = function (es)
{
return function ()
{
var hs = A2(List.map,heightOf,es);
var ws = A2(List.map,widthOf,es);
return A3(newElement,
List.maximum(ws),
List.maximum(hs),
A2(Flow,DOut,es));
}();
};
_elm.Graphics.Element.values = {_op: _op, empty: empty, widthOf: widthOf, heightOf: heightOf, sizeOf: sizeOf, width: width, height: height, size: size, opacity: opacity, color: color, tag: tag, link: link, newElement: newElement, image: image, fittedImage: fittedImage, croppedImage: croppedImage, tiledImage: tiledImage, container: container, spacer: spacer, flow: flow, above: above, below: below, beside: beside, layers: layers, absolute: absolute, relative: relative, middle: middle, topLeft: topLeft, topRight: topRight, bottomLeft: bottomLeft, bottomRight: bottomRight, midLeft: midLeft, midRight: midRight, midTop: midTop, midBottom: midBottom, middleAt: middleAt, topLeftAt: topLeftAt, topRightAt: topRightAt, bottomLeftAt: bottomLeftAt, bottomRightAt: bottomRightAt, midLeftAt: midLeftAt, midRightAt: midRightAt, midTopAt: midTopAt, midBottomAt: midBottomAt, up: up, down: down, left: left, right: right, inward: inward, outward: outward, Image: Image, Container: Container, Flow: Flow, Spacer: Spacer, RawHtml: RawHtml, Custom: Custom, Plain: Plain, Fitted: Fitted, Cropped: Cropped, Tiled: Tiled, P: P, Z: Z, N: N, Absolute: Absolute, Relative: Relative, DUp: DUp, DDown: DDown, DLeft: DLeft, DRight: DRight, DIn: DIn, DOut: DOut, Properties: Properties, Element: Element, Position: Position};
return _elm.Graphics.Element.values;
};Elm.Graphics = Elm.Graphics || {};
Elm.Graphics.Collage = Elm.Graphics.Collage || {};
Elm.Graphics.Collage.make = function (_elm)
{
"use strict";
_elm.Graphics = _elm.Graphics || {};
_elm.Graphics.Collage = _elm.Graphics.Collage || {};
if (_elm.Graphics.Collage.values)
return _elm.Graphics.Collage.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Graphics.Collage";
var Basics = Elm.Basics.make(_elm);
var Color = Elm.Color.make(_elm);
var Either = Elm.Either.make(_elm);
var Graphics = Graphics || {};
Graphics.Element = Elm.Graphics.Element.make(_elm);
var List = Elm.List.make(_elm);
var Maybe = Elm.Maybe.make(_elm);
var Native = Native || {};
Native.Graphics = Native.Graphics || {};
Native.Graphics.Collage = Elm.Native.Graphics.Collage.make(_elm);
var Transform2D = Elm.Transform2D.make(_elm);
var _op = {};
var ngon = F2(function (n,r)
{
return function ()
{
var m = Basics.toFloat(n);
var t = 2 * Basics.pi / m;
var f = function (i)
{
return {ctor: "_Tuple2", _0: r * Basics.cos(t * i), _1: r * Basics.sin(t * i)};
};
return A2(List.map,f,_L.range(0,m - 1));
}();
});
var oval = F2(function (w,h)
{
return function ()
{
var hh = h / 2;
var hw = w / 2;
var n = 50;
var t = 2 * Basics.pi / n;
var f = function (i)
{
return {ctor: "_Tuple2", _0: hw * Basics.cos(t * i), _1: hh * Basics.sin(t * i)};
};
return A2(List.map,f,_L.range(0,n - 1));
}();
});
var circle = function (r)
{
return A2(oval,2 * r,2 * r);
};
var rect = F2(function (w,h)
{
return function ()
{
var hh = h / 2;
var hw = w / 2;
return _L.fromArray([{ctor: "_Tuple2", _0: 0 - hw, _1: 0 - hh},
{ctor: "_Tuple2", _0: 0 - hw, _1: hh},
{ctor: "_Tuple2", _0: hw, _1: hh},
{ctor: "_Tuple2", _0: hw, _1: 0 - hh}]);
}();
});
var square = function (n)
{
return A2(rect,n,n);
};
var polygon = function (points)
{
return points;
};
var segment = F2(function (p1,p2)
{
return _L.fromArray([p1,p2]);
});
var path = function (ps)
{
return ps;
};
var collage = Native.Graphics.Collage.collage;
var alpha = F2(function (a,f)
{
return _U.replace([["alpha",a]],f);
});
var rotate = F2(function (t,f)
{
return _U.replace([["theta",f.theta + t]],f);
});
var scale = F2(function (s,f)
{
return _U.replace([["scale",f.scale * s]],f);
});
var moveY = F2(function (y,f)
{
return _U.replace([["y",f.y + y]],f);
});
var moveX = F2(function (x,f)
{
return _U.replace([["x",f.x + x]],f);
});
var move = F2(function (_v0,f)
{
return function ()
{
switch (_v0.ctor)
{case
"_Tuple2" :
return _U.replace([["x",f.x + _v0._0],
["y",f.y + _v0._1]],
f);}
_E.Case($moduleName,
"on line 169, column 20 to 48");
}();
});
var form = function (f)
{
return {_: {}, alpha: 1, form: f, scale: 1, theta: 0, x: 0, y: 0};
};
var FGroup = F2(function (a,b)
{
return {ctor: "FGroup", _0: a, _1: b};
});
var group = function (fs)
{
return form(A2(FGroup,Transform2D.identity,fs));
};
var groupTransform = F2(function (matrix,fs)
{
return form(A2(FGroup,matrix,fs));
});
var FElement = function (a)
{
return {ctor: "FElement", _0: a};
};
var toForm = function (e)
{
return form(FElement(e));
};
var FImage = F4(function (a,b,c,d)
{
return {ctor: "FImage", _0: a, _1: b, _2: c, _3: d};
});
var sprite = F4(function (w,h,pos,src)
{
return form(A4(FImage,w,h,pos,src));
});
var FShape = F2(function (a,b)
{
return {ctor: "FShape", _0: a, _1: b};
});
var fill = F2(function (style,shape)
{
return form(A2(FShape,Either.Right(style),shape));
});
var outlined = F2(function (style,shape)
{
return form(A2(FShape,Either.Left(style),shape));
});
var FPath = F2(function (a,b)
{
return {ctor: "FPath", _0: a, _1: b};
});
var traced = F2(function (style,path)
{
return form(A2(FPath,style,path));
});
var LineStyle = F6(function (a,b,c,d,e,f)
{
return {_: {}, cap: c, color: a, dashOffset: f, dashing: e, join: d, width: b};
});
var Clipped = {ctor: "Clipped"};
var Sharp = function (a)
{
return {ctor: "Sharp", _0: a};
};
var Smooth = {ctor: "Smooth"};
var Padded = {ctor: "Padded"};
var Round = {ctor: "Round"};
var Flat = {ctor: "Flat"};
var defaultLine = {_: {}, cap: Flat, color: Color.black, dashOffset: 0, dashing: _L.fromArray([]), join: Sharp(10), width: 1};
var solid = function (clr)
{
return _U.replace([["color",clr]],defaultLine);
};
var dashed = function (clr)
{
return _U.replace([["color",clr],
["dashing",_L.fromArray([8,4])]],
defaultLine);
};
var dotted = function (clr)
{
return _U.replace([["color",clr],
["dashing",_L.fromArray([3,3])]],
defaultLine);
};
var Grad = function (a)
{
return {ctor: "Grad", _0: a};
};
var gradient = F2(function (grad,shape)
{
return A2(fill,Grad(grad),shape);
});
var Texture = function (a)
{
return {ctor: "Texture", _0: a};
};
var textured = F2(function (src,shape)
{
return A2(fill,Texture(src),shape);
});
var Solid = function (a)
{
return {ctor: "Solid", _0: a};
};
var filled = F2(function (color,shape)
{
return A2(fill,Solid(color),shape);
});
var Form = F6(function (a,b,c,d,e,f)
{
return {_: {}, alpha: e, form: f, scale: b, theta: a, x: c, y: d};
});
_elm.Graphics.Collage.values = {_op: _op, defaultLine: defaultLine, solid: solid, dashed: dashed, dotted: dotted, form: form, fill: fill, filled: filled, textured: textured, gradient: gradient, outlined: outlined, traced: traced, sprite: sprite, toForm: toForm, group: group, groupTransform: groupTransform, move: move, moveX: moveX, moveY: moveY, scale: scale, rotate: rotate, alpha: alpha, collage: collage, path: path, segment: segment, polygon: polygon, rect: rect, square: square, oval: oval, circle: circle, ngon: ngon, Solid: Solid, Texture: Texture, Grad: Grad, Flat: Flat, Round: Round, Padded: Padded, Smooth: Smooth, Sharp: Sharp, Clipped: Clipped, FPath: FPath, FShape: FShape, FImage: FImage, FElement: FElement, FGroup: FGroup, Form: Form, LineStyle: LineStyle};
return _elm.Graphics.Collage.values;
};Elm.Graphics = Elm.Graphics || {};
Elm.Graphics.Input = Elm.Graphics.Input || {};
Elm.Graphics.Input.Field = Elm.Graphics.Input.Field || {};
Elm.Graphics.Input.Field.make = function (_elm)
{
"use strict";
_elm.Graphics = _elm.Graphics || {};
_elm.Graphics.Input = _elm.Graphics.Input || {};
_elm.Graphics.Input.Field = _elm.Graphics.Input.Field || {};
if (_elm.Graphics.Input.Field.values)
return _elm.Graphics.Input.Field.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Graphics.Input.Field";
var Color = Elm.Color.make(_elm);
var Graphics = Graphics || {};
Graphics.Element = Elm.Graphics.Element.make(_elm);
var Graphics = Graphics || {};
Graphics.Input = Elm.Graphics.Input.make(_elm);
var Native = Native || {};
Native.Graphics = Native.Graphics || {};
Native.Graphics.Input = Elm.Native.Graphics.Input.make(_elm);
var Text = Elm.Text.make(_elm);
var _op = {};
var email = Native.Graphics.Input.email;
var password = Native.Graphics.Input.password;
var field = Native.Graphics.Input.field;
var Backward = {ctor: "Backward"};
var Forward = {ctor: "Forward"};
var Selection = F3(function (a,b,c)
{
return {_: {}, direction: c, end: b, start: a};
});
var Content = F2(function (a,b)
{
return {_: {}, selection: b, string: a};
});
var noContent = A2(Content,"",A3(Selection,0,0,Forward));
var Style = F4(function (a,b,c,d)
{
return {_: {}, highlight: c, outline: b, padding: a, style: d};
});
var Highlight = F2(function (a,b)
{
return {_: {}, color: a, width: b};
});
var noHighlight = A2(Highlight,Color.blue,0);
var Outline = F3(function (a,b,c)
{
return {_: {}, color: a, radius: c, width: b};
});
var Dimensions = F4(function (a,b,c,d)
{
return {_: {}, bottom: d, left: a, right: b, top: c};
});
var uniformly = function (n)
{
return A4(Dimensions,n,n,n,n);
};
var noOutline = A3(Outline,Color.grey,uniformly(0),0);
var defaultStyle = {_: {}, highlight: A2(Highlight,
Color.blue,
1), outline: A3(Outline,
Color.grey,
uniformly(1),
2), padding: uniformly(4), style: Text.defaultStyle};
_elm.Graphics.Input.Field.values = {_op: _op, uniformly: uniformly, noOutline: noOutline, noHighlight: noHighlight, defaultStyle: defaultStyle, noContent: noContent, field: field, password: password, email: email, Forward: Forward, Backward: Backward, Dimensions: Dimensions, Outline: Outline, Highlight: Highlight, Style: Style, Content: Content, Selection: Selection};
return _elm.Graphics.Input.Field.values;
};(function() {
// Returns boolean indicating if the swap was successful.
// Requires that the two signal graphs have exactly the same
// structure.
ElmRuntime.swap = function(from, to) {
function similar(nodeOld,nodeNew) {
var idOkay = nodeOld.id === nodeNew.id;
var lengthOkay = nodeOld.kids.length === nodeNew.kids.length;
return idOkay && lengthOkay;
}
function swap(nodeOld,nodeNew) {
nodeNew.value = nodeOld.value;
return true;
}
var canSwap = depthFirstTraversals(similar, from.inputs, to.inputs);
if (canSwap) { depthFirstTraversals(swap, from.inputs, to.inputs); }
from.node.parentNode.replaceChild(to.node, from.node);
return canSwap;
}
// Returns false if the node operation f ever fails.
function depthFirstTraversals(f, queueOld, queueNew) {
if (queueOld.length !== queueNew.length) return false;
queueOld = queueOld.slice(0);
queueNew = queueNew.slice(0);
var seen = [];
while (queueOld.length > 0 && queueNew.length > 0) {
var nodeOld = queueOld.pop();
var nodeNew = queueNew.pop();
if (seen.indexOf(nodeOld.id) < 0) {
if (!f(nodeOld, nodeNew)) return false;
queueOld = queueOld.concat(nodeOld.kids);
queueNew = queueNew.concat(nodeNew.kids);
seen.push(nodeOld.id);
}
}
return true;
}
}());
(function() {
'use strict';
ElmRuntime.Display = { FULLSCREEN: 0, COMPONENT: 1, NONE: 2 };
ElmRuntime.counter = 0;
ElmRuntime.guid = function() { return ElmRuntime.counter++; }
ElmRuntime.use = function(M) {
if (typeof M === 'function') M = M();
return M;
};
function isAlive(input) {
if (!('defaultNumberOfKids' in input)) return true;
var len = input.kids.length;
if (len === 0) return false;
if (len > input.defaultNumberOfKids) return true;
var alive = false;
for (var i = len; i--; ) {
alive = alive || isAlive(input.kids[i]);
}
return alive;
}
ElmRuntime.filterDeadInputs = function(inputs) {
var temp = [];
for (var i = inputs.length; i--; ) {
if (isAlive(inputs[i])) temp.push(inputs[i]);
}
return temp;
};
// define the draw function
var vendors = ['ms', 'moz', 'webkit', 'o'];
var win = typeof window !== 'undefined' ? window : {};
for (var i = 0; i < vendors.length && !win.requestAnimationFrame; ++i) {
win.requestAnimationFrame = win[vendors[i]+'RequestAnimationFrame'];
win.cancelAnimationFrame = win[vendors[i]+'CancelAnimationFrame'] ||
win[vendors[i]+'CancelRequestAnimationFrame'];
}
if (win.requestAnimationFrame && win.cancelAnimationFrame) {
var previous = 0;
ElmRuntime.draw = function(callback) {
win.cancelAnimationFrame(previous);
previous = win.requestAnimationFrame(callback);
};
} else {
ElmRuntime.draw = function(callback) { callback(); };
}
}());
(function() {
'use strict';
Elm.fullscreen = function(module, ports) {
var style = document.createElement('style');
style.type = 'text/css';
style.innerHTML = "html,head,body { padding:0; margin:0; }" +
"body { font-family: calibri, helvetica, arial, sans-serif; }";
document.head.appendChild(style);
var container = document.createElement('div');
document.body.appendChild(container);
return init(ElmRuntime.Display.FULLSCREEN, container, module, ports || {});
};
Elm.embed = function(module, container, ports) {
var tag = container.tagName;
if (tag !== 'DIV') {
throw new Error('Elm.node must be given a DIV, not a ' + tag + '.');
} else if (container.hasChildNodes()) {
throw new Error('Elm.node must be given an empty DIV. No children allowed!');
}
return init(ElmRuntime.Display.COMPONENT, container, module, ports || {});
};
Elm.worker = function(module, ports) {
return init(ElmRuntime.Display.NONE, {}, module, ports || {});
};
function init(display, container, module, ports, moduleToReplace) {
// defining state needed for an instance of the Elm RTS
var inputs = [];
var updateInProgress = false;
function notify(id, v) {
if (updateInProgress) {
throw new Error(
'The notify function has been called synchronously!\n' +
'This can lead to frames being dropped.\n' +
'Definitely report this to <https://github.com/elm-lang/Elm/issues>\n');
}
updateInProgress = true;
var timestep = Date.now();
for (var i = inputs.length; i--; ) {
inputs[i].recv(timestep, id, v);
}
updateInProgress = false;
}
var listeners = [];
function addListener(relevantInputs, domNode, eventName, func) {
domNode.addEventListener(eventName, func);
var listener = {
relevantInputs: relevantInputs,
domNode: domNode,
eventName: eventName,
func: func
};
listeners.push(listener);
}
var portUses = {}
for (var key in ports) {
portUses[key] = 0;
}
// create the actual RTS. Any impure modules will attach themselves to this
// object. This permits many Elm programs to be embedded per document.
var elm = {
notify:notify,
node:container,
display:display,
id:ElmRuntime.guid(),
addListener:addListener,
inputs:inputs,
ports: { incoming:ports, outgoing:{}, uses:portUses }
};
function swap(newModule) {
removeListeners(listeners);
var div = document.createElement('div');
var newElm = init(display, div, newModule, ports, elm);
inputs = [];
// elm.swap = newElm.swap;
return newElm;
}
var Module = {};
var reportAnyErrors = function() {};
try {
Module = module.make(elm);
checkPorts(elm);
} catch(e) {
var directions = "<br/>&nbsp; &nbsp; Open the developer console for more details."
Module.main = Elm.Text.make(elm).leftAligned('<code>' + e.message + directions + '</code>');
reportAnyErrors = function() { throw e; }
}
inputs = ElmRuntime.filterDeadInputs(inputs);
filterListeners(inputs, listeners);
addReceivers(elm.ports.outgoing);
if (display !== ElmRuntime.Display.NONE) {
var graphicsNode = initGraphics(elm, Module);
}
if (typeof moduleToReplace !== 'undefined') {
ElmRuntime.swap(moduleToReplace, elm);
// rerender scene if graphics are enabled.
if (typeof graphicsNode !== 'undefined') {
graphicsNode.recv(0, true, false, 0);
}
}
reportAnyErrors();
return { swap:swap, ports:elm.ports.outgoing };
};
function checkPorts(elm) {
var portUses = elm.ports.uses;
for (var key in portUses) {
var uses = portUses[key]
if (uses === 0) {
throw new Error(
"Initialization Error: provided port '" + key +
"' to a module that does not take it as in input.\n" +
"Remove '" + key + "' from the module initialization code.");
} else if (uses > 1) {
throw new Error(
"Initialization Error: port '" + key +
"' has been declared multiple times in the Elm code.\n" +
"Remove declarations until there is exactly one.");
}
}
}
function filterListeners(inputs, listeners) {
loop:
for (var i = listeners.length; i--; ) {
var listener = listeners[i];
for (var j = inputs.length; j--; ) {
if (listener.relevantInputs.indexOf(inputs[j].id) >= 0) {
continue loop;
}
}
listener.domNode.removeEventListener(listener.eventName, listener.func);
}
}
function removeListeners(listeners) {
for (var i = listeners.length; i--; ) {
var listener = listeners[i];
listener.domNode.removeEventListener(listener.eventName, listener.func);
}
}
// add receivers for built-in ports if they are defined
function addReceivers(ports) {
if ('log' in ports) {
ports.log.subscribe(function(v) { console.log(v) });
}
if ('stdout' in ports) {
var process = process || {};
var handler = process.stdout
? function(v) { process.stdout.write(v); }
: function(v) { console.log(v); };
ports.stdout.subscribe(handler);
}
if ('stderr' in ports) {
var process = process || {};
var handler = process.stderr
? function(v) { process.stderr.write(v); }
: function(v) { console.log('Error:' + v); };
ports.stderr.subscribe(handler);
}
if ('title' in ports) {
if (typeof ports.title === 'string') {
document.title = ports.title;
} else {
ports.title.subscribe(function(v) { document.title = v; });
}
}
if ('redirect' in ports) {
ports.redirect.subscribe(function(v) {
if (v.length > 0) window.location = v;
});
}
if ('favicon' in ports) {
if (typeof ports.favicon === 'string') {
changeFavicon(ports.favicon);
} else {
ports.favicon.subscribe(changeFavicon);
}
}
function changeFavicon(src) {
var link = document.createElement('link');
var oldLink = document.getElementById('elm-favicon');
link.id = 'elm-favicon';
link.rel = 'shortcut icon';
link.href = src;
if (oldLink) {
document.head.removeChild(oldLink);
}
document.head.appendChild(link);
}
}
function initGraphics(elm, Module) {
if (!('main' in Module))
throw new Error("'main' is missing! What do I display?!");
var signalGraph = Module.main;
// make sure the signal graph is actually a signal & extract the visual model
var Signal = Elm.Signal.make(elm);
var NS = Elm.Native.Signal.make(elm);
if (!('recv' in signalGraph)) {
signalGraph = Signal.constant(signalGraph);
}
var currentScene = signalGraph.value;
// Add the currentScene to the DOM
var Render = ElmRuntime.use(ElmRuntime.Render.Element);
elm.node.appendChild(Render.render(currentScene));
// set up updates so that the DOM is adjusted as necessary.
var savedScene = currentScene;
function domUpdate(newScene) {
ElmRuntime.draw(function(_) {
Render.update(elm.node.firstChild, savedScene, newScene);
if (elm.Native.Window) elm.Native.Window.values.resizeIfNeeded();
savedScene = newScene;
});
}
function domUpdate2(rawLiftNode) {
return function(timestep, updated, duplicate, parentID) {
if(updated && !duplicate) {
domUpdate(signalGraph.value);
} else {
console.log("dropped message { " + timestep + ", " + updated + ", " + duplicate + ", " + parentID + " }");
}
};
}
var renderer = A3(NS.rawLift, domUpdate, domUpdate2, signalGraph);
// must check for resize after 'renderer' is created so
// that changes show up.
if (elm.Native.Window) elm.Native.Window.values.resizeIfNeeded();
return renderer;
}
}());
ElmRuntime.Render.Element = function() {
'use strict';
var Utils = ElmRuntime.use(ElmRuntime.Render.Utils);
var newElement = Utils.newElement, colorToCss = Utils.colorToCss,
addTransform = Utils.addTransform, removeTransform = Utils.removeTransform,
fromList = Utils.fromList, eq = Utils.eq;
function setProps(elem, e) {
var props = elem.props;
var element = elem.element;
var width = props.width - (element.adjustWidth || 0);
var height = props.height - (element.adjustHeight || 0);
e.style.width = (width |0) + 'px';
e.style.height = (height|0) + 'px';
if (props.opacity !== 1) {
e.style.opacity = props.opacity;
}
if (props.color.ctor === 'Just') {
e.style.backgroundColor = colorToCss(props.color._0);
}
if (props.tag !== '') { e.id = props.tag; }
if (props.href !== '') {
var a = newElement('a');
a.href = props.href;
a.style.width = '100%';
a.style.height = '100%';
a.style.top = 0;
a.style.left = 0;
a.style.display = 'block';
a.style.position = 'absolute';
e.style.position = 'relative';
a.style.pointerEvents = 'auto';
e.appendChild(a);
}
if (props.hover.ctor !== '_Tuple0') {
addHover(e, props.hover);
}
if (props.click.ctor !== '_Tuple0') {
addClick(e, props.click);
}
return e;
}
function addClick(e, handler) {
e.style.pointerEvents = 'auto';
e.elm_click_handler = handler;
function trigger(ev) {
e.elm_click_handler(Utils.Tuple0);
ev.stopPropagation();
}
e.elm_click_trigger = trigger;
e.addEventListener('click', trigger);
}
function removeClick(e, handler) {
if (e.elm_click_trigger) {
e.removeEventListener('click', e.elm_click_trigger);
}
}
function addHover(e, handler) {
e.style.pointerEvents = 'auto';
e.elm_hover_handler = handler;
e.elm_hover_count = 0;
function over(evt) {
if (e.elm_hover_count++ > 0) return;
e.elm_hover_handler(true);
evt.stopPropagation();
}
function out(evt) {
if (e.contains(evt.toElement || evt.relatedTarget)) return;
e.elm_hover_count = 0;
e.elm_hover_handler(false);
evt.stopPropagation();
}
e.elm_hover_over = over;
e.elm_hover_out = out;
e.addEventListener('mouseover', over);
e.addEventListener('mouseout', out);
}
function removeHover(e) {
if (e.elm_hover_over) {
e.removeEventListener('mouseover', e.elm_hover_over);
}
if (e.elm_hover_out) {
e.removeEventListener('mouseout', e.elm_hover_out);
}
}
function image(props, img) {
switch (img._0.ctor) {
case 'Plain': return plainImage(img._3);
case 'Fitted': return fittedImage(props.width, props.height, img._3);
case 'Cropped': return croppedImage(img,props.width,props.height,img._3);
case 'Tiled': return tiledImage(img._3);
}
}
function plainImage(src) {
var img = newElement('img');
img.src = src;
img.name = src;
img.style.display = "block";
return img;
}
function tiledImage(src) {
var div = newElement('div');
div.style.backgroundImage = 'url(' + src + ')';
return div;
}
function fittedImage(w, h, src) {
var div = newElement('div');
div.style.background = 'url(' + src + ') no-repeat center';
div.style.webkitBackgroundSize = 'cover';
div.style.MozBackgroundSize = 'cover';
div.style.OBackgroundSize = 'cover';
div.style.backgroundSize = 'cover';
return div;
}
function croppedImage(elem, w, h, src) {
var pos = elem._0._0;
var e = newElement('div');
e.style.overflow = "hidden";
var img = newElement('img');
img.onload = function() {
var sw = w / elem._1, sh = h / elem._2;
img.style.width = ((this.width * sw)|0) + 'px';
img.style.height = ((this.height * sh)|0) + 'px';
img.style.marginLeft = ((- pos._0 * sw)|0) + 'px';
img.style.marginTop = ((- pos._1 * sh)|0) + 'px';
};
img.src = src;
img.name = src;
e.appendChild(img);
return e;
}
function goOut(e) { e.style.position = 'absolute'; return e; }
function goDown(e) { return e }
function goRight(e) { e.style.styleFloat = e.style.cssFloat = "left"; return e; }
var directionTable = {
DUp : goDown,
DDown : goDown,
DLeft : goRight,
DRight : goRight,
DIn : goOut,
DOut : goOut
};
function needsReversal(dir) {
return dir == 'DUp' || dir == 'DLeft' || dir == 'DIn';
}
function flow(dir,elist) {
var array = fromList(elist);
var container = newElement('div');
var goDir = directionTable[dir];
if (goDir == goOut) {
container.style.pointerEvents = 'none';
}
if (needsReversal(dir)) {
array.reverse();
}
var len = array.length;
for (var i = 0; i < len; ++i) {
container.appendChild(goDir(render(array[i])));
}
return container;
}
function toPos(pos) {
switch(pos.ctor) {
case "Absolute": return pos._0 + "px";
case "Relative": return (pos._0 * 100) + "%";
}
}
// must clear right, left, top, bottom, and transform
// before calling this function
function setPos(pos,elem,e) {
var element = elem.element;
var props = elem.props;
var w = props.width + (element.adjustWidth ? element.adjustWidth : 0);
var h = props.height + (element.adjustHeight ? element.adjustHeight : 0);
e.style.position = 'absolute';
e.style.margin = 'auto';
var transform = '';
switch(pos.horizontal.ctor) {
case 'P': e.style.right = toPos(pos.x); e.style.removeProperty('left'); break;
case 'Z': transform = 'translateX(' + ((-w/2)|0) + 'px) ';
case 'N': e.style.left = toPos(pos.x); e.style.removeProperty('right'); break;
}
switch(pos.vertical.ctor) {
case 'N': e.style.bottom = toPos(pos.y); e.style.removeProperty('top'); break;
case 'Z': transform += 'translateY(' + ((-h/2)|0) + 'px)';
case 'P': e.style.top = toPos(pos.y); e.style.removeProperty('bottom'); break;
}
if (transform !== '') addTransform(e.style, transform);
return e;
}
function container(pos,elem) {
var e = render(elem);
setPos(pos, elem, e);
var div = newElement('div');
div.style.position = 'relative';
div.style.overflow = 'hidden';
div.appendChild(e);
return div;
}
function rawHtml(elem) {
var html = elem.html;
var args = elem.args;
var guid = elem.guid;
var align = elem.align;
var div = newElement('div');
div.innerHTML = html;
div.style.visibility = "hidden";
if (align) div.style.textAlign = align;
document.body.appendChild(div);
for (var i = args.length; i--; ) {
var arg = args[i];
var span = document.getElementById('md-' + guid + '-' + i);
if (arg.isText) {
span.innerHTML = arg;
} else {
span.style.display = 'block';
span.style.width = arg.props.width + 'px';
span.style.height = arg.props.height + 'px';
span.appendChild(render(arg));
}
}
document.body.removeChild(div);
div.style.visibility = 'visible';
div.style.pointerEvents = 'auto';
return div;
}
function render(elem) { return setProps(elem, makeElement(elem)); }
function makeElement(e) {
var elem = e.element;
switch(elem.ctor) {
case 'Image': return image(e.props, elem);
case 'Flow': return flow(elem._0.ctor, elem._1);
case 'Container': return container(elem._0, elem._1);
case 'Spacer': return newElement('div');
case 'RawHtml': return rawHtml(elem);
case 'Custom': return elem.render(elem.model);
}
}
function update(node, curr, next) {
if (node.tagName === 'A') { node = node.firstChild; }
if (curr.props.id === next.props.id) return updateProps(node, curr, next);
if (curr.element.ctor !== next.element.ctor) {
node.parentNode.replaceChild(render(next),node);
return true;
}
var nextE = next.element, currE = curr.element;
switch(nextE.ctor) {
case "Spacer": break;
case "RawHtml":
// only markdown blocks have guids, so this must be a text block
if (nextE.guid === null) {
if(currE.html.valueOf() !== nextE.html.valueOf()) {
node.innerHTML = nextE.html;
}
break;
}
if (nextE.guid !== currE.guid) {
node.parentNode.replaceChild(render(next),node);
return true;
}
var nargs = nextE.args;
var cargs = currE.args;
for (var i = nargs.length; i--; ) {
var narg = nargs[i];
var carg = cargs[i]
if (narg == carg) continue;
var span = document.getElementById('md-' + currE.guid + '-' + i);
if (narg.isElement) {
if (carg.isElement) {
update(span, carg, narg);
} else {
span.style.display = 'block';
var e = render(narg);
span.innerHTML = '';
span.appendChild(e);
}
} else {
span.style.display = 'inline';
span.innerHTML = narg;
}
}
break;
case "Image":
if (nextE._0.ctor === 'Plain') {
if (nextE._3 !== currE._3) node.src = nextE._3;
} else if (!eq(nextE,currE) ||
next.props.width !== curr.props.width ||
next.props.height !== curr.props.height) {
node.parentNode.replaceChild(render(next),node);
return true;
}
break;
case "Flow":
var arr = fromList(nextE._1);
for (var i = arr.length; i--; ) { arr[i] = arr[i].element.ctor; }
if (nextE._0.ctor !== currE._0.ctor) {
node.parentNode.replaceChild(render(next),node);
return true;
}
var nexts = fromList(nextE._1);
var kids = node.childNodes;
if (nexts.length !== kids.length) {
node.parentNode.replaceChild(render(next),node);
return true;
}
var currs = fromList(currE._1);
var dir = nextE._0.ctor;
var goDir = directionTable[dir];
var toReverse = needsReversal(dir);
var len = kids.length;
for (var i = len; i-- ;) {
update(kids[toReverse ? len - i - 1 : i],currs[i],nexts[i]);
goDir(kids[i]);
}
break;
case "Container":
update(node.firstChild, currE._1, nextE._1);
setPos(nextE._0, nextE._1, node.firstChild);
break;
case "Custom":
if (currE.type === nextE.type) {
var done = nextE.update(node, currE.model, nextE.model);
if (done) return;
} else {
return node.parentNode.replaceChild(render(next), node);
}
}
updateProps(node, curr, next);
}
function updateProps(node, curr, next) {
var props = next.props;
var currP = curr.props;
var e = node;
var element = next.element;
var width = props.width - (element.adjustWidth || 0);
var height = props.height - (element.adjustHeight || 0);
if (width !== currP.width) {
e.style.width = (width|0) + 'px';
}
if (height !== currP.height) {
e.style.height = (height|0) + 'px';
}
if (props.opacity !== currP.opacity) {
e.style.opacity = props.opacity;
}
var nextColor = (props.color.ctor === 'Just' ?
colorToCss(props.color._0) : '');
if (e.style.backgroundColor !== nextColor) {
e.style.backgroundColor = (nextColor === '' ? 'transparent' : nextColor);
}
if (props.tag !== currP.tag) { e.id = props.tag; }
if (props.href !== currP.href) {
if (currP.href === '') {
var a = newElement('a');
a.href = props.href;
a.style.width = '100%';
a.style.height = '100%';
a.style.top = 0;
a.style.left = 0;
a.style.display = 'block';
a.style.position = 'absolute';
e.style.position = 'relative';
a.style.pointerEvents = 'auto';
e.appendChild(a);
} else {
node.lastNode.href = props.href;
}
}
// update hover handlers
if (props.hover.ctor === '_Tuple0') {
removeHover(e);
} else if (e.elm_hover_handler) {
e.elm_hover_handler = props.hover;
} else {
addHover(e, props.hover);
}
// update click handlers
if (props.click.ctor === '_Tuple0') {
removeClick(e);
} else if (e.elm_click_handler) {
e.elm_click_handler = props.click;
} else {
addClick(e, props.click);
}
}
return { render:render, update:update };
};
ElmRuntime.Render.Utils = function() {
function newElement(elementType) {
var e = document.createElement(elementType);
e.style.padding = "0";
e.style.margin = "0";
return e;
}
function addTo(container, elem) {
container.appendChild(elem);
}
function addTransform(style, trans) {
style.transform = trans;
style.msTransform = trans;
style.MozTransform = trans;
style.webkitTransform = trans;
style.OTransform = trans;
}
function removeTransform(style) {
style.transform = 'none';
style.msTransform = 'none';
style.MozTransform = 'none';
style.webkitTransform = 'none';
style.OTransform = 'none';
}
var List = Elm.Native.List.make({});
return {addTo:addTo,
newElement: newElement,
colorToCss: Elm.Native.Color.make({}).toCss,
fromList: List.toArray,
fromString: function(s) { return s; },
toString: function(s) { return s; },
eq: Elm.Native.Utils.make({}).eq,
addTransform: addTransform,
removeTransform: removeTransform};
};
ElmRuntime.Render.Collage = function() {
var Render = ElmRuntime.use(ElmRuntime.Render.Element);
var Transform = Elm.Transform2D.make({});
var Utils = ElmRuntime.use(ElmRuntime.Render.Utils);
var newElement = Utils.newElement,
colorToCss = Utils.colorToCss, fromList = Utils.fromList,
fromString = Utils.fromString, addTransform = Utils.addTransform;
function trace(ctx, path) {
var points = fromList(path);
var i = points.length - 1;
if (i <= 0) return;
ctx.moveTo(points[i]._0, points[i]._1);
while (i--) { ctx.lineTo(points[i]._0, points[i]._1); }
if (path.closed) {
i = points.length - 1;
ctx.lineTo(points[i]._0, points[i]._1);
}
}
function line(ctx,style,path) {
style.dashing.ctor === 'Nil' ? trace(ctx, path) : customLineHelp(ctx, style, path);
ctx.scale(1,-1);
ctx.stroke();
}
function customLineHelp(ctx, style, path) {
var points = fromList(path);
if (path.closed) points.push(points[0]);
var pattern = fromList(style.dashing);
var i = points.length - 1;
if (i <= 0) return;
var x0 = points[i]._0, y0 = points[i]._1;
var x1=0, y1=0, dx=0, dy=0, remaining=0, nx=0, ny=0;
var pindex = 0, plen = pattern.length;
var draw = true, segmentLength = pattern[0];
ctx.moveTo(x0,y0);
while (i--) {
x1 = points[i]._0; y1 = points[i]._1;
dx = x1 - x0; dy = y1 - y0;
remaining = Math.sqrt(dx * dx + dy * dy);
while (segmentLength <= remaining) {
x0 += dx * segmentLength / remaining;
y0 += dy * segmentLength / remaining;
ctx[draw ? 'lineTo' : 'moveTo'](x0, y0);
// update starting position
dx = x1 - x0; dy = y1 - y0;
remaining = Math.sqrt(dx * dx + dy * dy);
// update pattern
draw = !draw;
pindex = (pindex + 1) % plen;
segmentLength = pattern[pindex];
}
if (remaining > 0) {
ctx[draw ? 'lineTo' : 'moveTo'](x1, y1);
segmentLength -= remaining;
}
x0 = x1; y0 = y1;
}
}
function drawLine(ctx, style, path) {
ctx.lineWidth = style.width;
var cap = style.cap.ctor;
ctx.lineCap = cap === 'Flat' ? 'butt' :
cap === 'Round' ? 'round' : 'square';
var join = style.join.ctor;
ctx.lineJoin = join === 'Smooth' ? 'round' :
join === 'Sharp' ? 'miter' : 'bevel';
ctx.miterLimit = style.join._0 || 10;
ctx.strokeStyle = colorToCss(style.color);
return line(ctx, style, path);
}
function texture(redo, ctx, src) {
var img = new Image();
img.src = fromString(src);
img.onload = redo;
return ctx.createPattern(img, 'repeat');
}
function gradient(ctx, grad) {
var g;
var stops = [];
if (grad.ctor === 'Linear') {
var p0 = grad._0, p1 = grad._1;
g = ctx.createLinearGradient(p0._0, -p0._1, p1._0, -p1._1);
stops = fromList(grad._2);
} else {
var p0 = grad._0, p2 = grad._2;
g = ctx.createRadialGradient(p0._0, -p0._1, grad._1, p2._0, -p2._1, grad._3);
stops = fromList(grad._4);
}
var len = stops.length;
for (var i = 0; i < len; ++i) {
var stop = stops[i];
g.addColorStop(stop._0, colorToCss(stop._1));
}
return g;
}
function drawShape(redo, ctx, style, path) {
trace(ctx, path);
var sty = style.ctor;
ctx.fillStyle =
sty === 'Solid' ? colorToCss(style._0) :
sty === 'Texture' ? texture(redo, ctx, style._0) : gradient(ctx, style._0);
ctx.scale(1,-1);
ctx.fill();
}
function drawImage(redo, ctx, form) {
var img = new Image();
img.onload = redo;
img.src = fromString(form._3);
var w = form._0,
h = form._1,
pos = form._2,
srcX = pos._0,
srcY = pos._1,
srcW = w,
srcH = h,
destX = -w/2,
destY = -h/2,
destW = w,
destH = h;
ctx.scale(1,-1);
ctx.drawImage(img, srcX, srcY, srcW, srcH, destX, destY, destW, destH);
}
function renderForm(redo, ctx, form) {
ctx.save();
var x = form.x, y = form.y, theta = form.theta, scale = form.scale;
if (x !== 0 || y !== 0) ctx.translate(x, y);
if (theta !== 0) ctx.rotate(theta);
if (scale !== 1) ctx.scale(scale,scale);
if (form.alpha !== 1) ctx.globalAlpha = ctx.globalAlpha * form.alpha;
ctx.beginPath();
var f = form.form;
switch(f.ctor) {
case 'FPath' : drawLine(ctx, f._0, f._1); break;
case 'FImage': drawImage(redo, ctx, f); break;
case 'FShape':
if (f._0.ctor === 'Left') {
f._1.closed = true;
drawLine(ctx, f._0._0, f._1);
} else {
drawShape(redo, ctx, f._0._0, f._1);
}
break;
}
ctx.restore();
}
function formToMatrix(form) {
var scale = form.scale;
var matrix = A6( Transform.matrix, scale, 0, 0, scale, form.x, form.y );
var theta = form.theta
if (theta !== 0)
matrix = A2( Transform.multiply, matrix, Transform.rotation(theta) );
return matrix;
}
function str(n) {
if (n < 0.00001 && n > -0.00001) return 0;
return n;
}
function makeTransform(w, h, form, matrices) {
var props = form.form._0.props;
var m = A6( Transform.matrix, 1, 0, 0, -1,
(w - props.width ) / 2,
(h - props.height) / 2 );
var len = matrices.length;
for (var i = 0; i < len; ++i) { m = A2( Transform.multiply, m, matrices[i] ); }
m = A2( Transform.multiply, m, formToMatrix(form) );
return 'matrix(' + str( m[0]) + ', ' + str( m[3]) + ', ' +
str(-m[1]) + ', ' + str(-m[4]) + ', ' +
str( m[2]) + ', ' + str( m[5]) + ')';
}
function stepperHelp(list) {
var arr = fromList(list);
var i = 0;
function peekNext() {
return i < arr.length ? arr[i].form.ctor : '';
}
// assumes that there is a next element
function next() {
var out = arr[i];
++i;
return out;
}
return { peekNext:peekNext, next:next };
}
function formStepper(forms) {
var ps = [stepperHelp(forms)];
var matrices = [];
var alphas = [];
function peekNext() {
var len = ps.length;
var formType = '';
for (var i = 0; i < len; ++i ) {
if (formType = ps[i].peekNext()) return formType;
}
return '';
}
// assumes that there is a next element
function next(ctx) {
while (!ps[0].peekNext()) {
ps.shift();
matrices.pop();
alphas.shift();
if (ctx) { ctx.restore(); }
}
var out = ps[0].next();
var f = out.form;
if (f.ctor === 'FGroup') {
ps.unshift(stepperHelp(f._1));
var m = A2(Transform.multiply, f._0, formToMatrix(out));
ctx.save();
ctx.transform(m[0], m[3], m[1], m[4], m[2], m[5]);
matrices.push(m);
var alpha = (alphas[0] || 1) * out.alpha;
alphas.unshift(alpha);
ctx.globalAlpha = alpha;
}
return out;
}
function transforms() { return matrices; }
function alpha() { return alphas[0] || 1; }
return { peekNext:peekNext, next:next, transforms:transforms, alpha:alpha };
}
function makeCanvas(w,h) {
var canvas = newElement('canvas');
canvas.style.width = w + 'px';
canvas.style.height = h + 'px';
canvas.style.display = "block";
canvas.style.position = "absolute";
canvas.width = w;
canvas.height = h;
return canvas;
}
function render(model) {
var div = newElement('div');
div.style.overflow = 'hidden';
div.style.position = 'relative';
update(div, model, model);
return div;
}
function nodeStepper(w,h,div) {
var kids = div.childNodes;
var i = 0;
function transform(transforms, ctx) {
ctx.translate(w/2, h/2);
ctx.scale(1,-1);
var len = transforms.length;
for (var i = 0; i < len; ++i) {
var m = transforms[i];
ctx.save();
ctx.transform(m[0], m[3], m[1], m[4], m[2], m[5]);
}
return ctx;
}
function nextContext(transforms) {
while (i < kids.length) {
var node = kids[i];
if (node.getContext) {
node.width = w;
node.height = h;
node.style.width = w + 'px';
node.style.height = h + 'px';
++i;
return transform(transforms, node.getContext('2d'));
}
div.removeChild(node);
}
var canvas = makeCanvas(w,h);
div.appendChild(canvas);
// we have added a new node, so we must step our position
++i;
return transform(transforms, canvas.getContext('2d'));
}
function addElement(matrices, alpha, form) {
var kid = kids[i];
var elem = form.form._0;
var node = (!kid || kid.getContext)
? Render.render(elem)
: (Render.update(kid, kid.oldElement, elem), kids[i]);
node.style.position = 'absolute';
node.style.opacity = alpha * form.alpha;
addTransform(node.style, makeTransform(w, h, form, matrices));
node.oldElement = elem;
++i;
if (!kid) {
div.appendChild(node);
} else if (kid.getContext) {
div.insertBefore(node, kid);
}
}
function clearRest() {
while (i < kids.length) {
div.removeChild(kids[i]);
}
}
return { nextContext:nextContext, addElement:addElement, clearRest:clearRest };
}
function update(div, _, model) {
var w = model.w;
var h = model.h;
var forms = formStepper(model.forms);
var nodes = nodeStepper(w,h,div);
var ctx = null;
var formType = '';
while (formType = forms.peekNext()) {
// make sure we have context if we need it
if (ctx === null && formType !== 'FElement') {
ctx = nodes.nextContext(forms.transforms());
ctx.globalAlpha = forms.alpha();
}
var form = forms.next(ctx);
// if it is FGroup, all updates are made within formStepper when next is called.
if (formType === 'FElement') {
// update or insert an element, get a new context
nodes.addElement(forms.transforms(), forms.alpha(), form);
ctx = null;
} else if (formType !== 'FGroup') {
renderForm(function() { update(div, model, model); }, ctx, form);
}
}
nodes.clearRest();
return false;
}
return { render:render, update:update };
};
</script>
<script type="text/javascript">Elm.Main = Elm.Main || {};
Elm.Main.make = function (_elm)
{
"use strict";
_elm.Main = _elm.Main || {};
if (_elm.Main.values)
return _elm.Main.values;
var _N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_A = _N.Array.make(_elm),
_E = _N.Error.make(_elm),
$moduleName = "Main";
var Basics = Elm.Basics.make(_elm);
var Color = Elm.Color.make(_elm);
var Graphics = Graphics || {};
Graphics.Collage = Elm.Graphics.Collage.make(_elm);
var Graphics = Graphics || {};
Graphics.Element = Elm.Graphics.Element.make(_elm);
var List = Elm.List.make(_elm);
var Maybe = Elm.Maybe.make(_elm);
var Native = Native || {};
Native.Json = Elm.Native.Json.make(_elm);
var Native = Native || {};
Native.Ports = Elm.Native.Ports.make(_elm);
var Signal = Elm.Signal.make(_elm);
var String = Elm.String.make(_elm);
var Text = Elm.Text.make(_elm);
var Time = Elm.Time.make(_elm);
var _op = {};
var longList = _L.range(1,1000000);
var time = Time.fps(60);
var sumSig = A2(Signal._op["<~"],
List.sum,
Signal.sampleOn(time)(Signal.constant(longList)));
var main = A2(Signal._op["<~"],
Text.asText,
A2(Signal._op["~"],
A2(Signal._op["<~"],
F2(function (v0,v1)
{
return {ctor: "_Tuple2", _0: v0, _1: v1};
}),
time),
sumSig));
_elm.Main.values = {_op: _op, time: time, longList: longList, sumSig: sumSig, main: main};
return _elm.Main.values;
};
</script>
</head>
<body>
<script type="text/javascript">Elm.fullscreen(Elm.Main)</script>
<noscript></noscript>
</body>
</html>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment