Skip to content

Instantly share code, notes, and snippets.

@JoeyEremondi

JoeyEremondi/0_15_1.elm

Created August 21, 2015 03:01
Show Gist options
  • Save JoeyEremondi/4c7b2e03d87e2e815b02 to your computer and use it in GitHub Desktop.
Save JoeyEremondi/4c7b2e03d87e2e815b02 to your computer and use it in GitHub Desktop.
Download ZIP
Non-native Elm JS output: DCE vs no DCE
Raw
0_15_1.elm
var Elm = Elm || { Native: {} };
Elm.Array = Elm.Array || {};
Elm.Array.make = function (_elm) {
"use strict";
_elm.Array = _elm.Array || {};
if (_elm.Array.values)
return _elm.Array.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Array",
$Basics = Elm.Basics.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Array = Elm.Native.Array.make(_elm);
var append = $Native$Array.append;
var length = $Native$Array.length;
var isEmpty = function (array) {
return _U.eq(length(array),
0);
};
var slice = $Native$Array.slice;
var set = $Native$Array.set;
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 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 A3($List.map2,
F2(function (v0,v1) {
return {ctor: "_Tuple2"
,_0: v0
,_1: v1};
}),
_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
,empty: empty
,repeat: repeat
,initialize: initialize
,fromList: fromList
,isEmpty: isEmpty
,length: length
,push: push
,append: append
,get: get
,set: set
,slice: slice
,toList: toList
,toIndexedList: toIndexedList
,map: map
,indexedMap: indexedMap
,filter: filter
,foldl: foldl
,foldr: foldr};
return _elm.Array.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Basics",
$Native$Basics = Elm.Native.Basics.make(_elm),
$Native$Show = Elm.Native.Show.make(_elm),
$Native$Utils = Elm.Native.Utils.make(_elm);
var uncurry = F2(function (f,
_v0) {
return function () {
switch (_v0.ctor)
{case "_Tuple2": return A2(f,
_v0._0,
_v0._1);}
_U.badCase($moduleName,
"on line 595, column 3 to 8");
}();
});
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;}
_U.badCase($moduleName,
"on line 573, column 3 to 4");
}();
};
var fst = function (_v8) {
return function () {
switch (_v8.ctor)
{case "_Tuple2": return _v8._0;}
_U.badCase($moduleName,
"on line 567, column 3 to 4");
}();
};
var always = F2(function (a,
_v12) {
return function () {
return a;
}();
});
var identity = 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 g(f(x));
});
_op["<<"] = F3(function (g,
f,
x) {
return g(f(x));
});
_op["++"] = $Native$Utils.append;
var toString = $Native$Show.toString;
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 negate = $Native$Basics.negate;
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;
_op["%"] = $Native$Basics.mod;
var rem = $Native$Basics.rem;
_op["//"] = $Native$Basics.div;
_op["/"] = $Native$Basics.floatDiv;
_op["*"] = $Native$Basics.mul;
_op["-"] = $Native$Basics.sub;
_op["+"] = $Native$Basics.add;
var toPolar = $Native$Basics.toPolar;
var fromPolar = $Native$Basics.fromPolar;
var turns = $Native$Basics.turns;
var degrees = $Native$Basics.degrees;
var radians = function (t) {
return t;
};
_elm.Basics.values = {_op: _op
,max: max
,min: min
,compare: compare
,not: not
,xor: xor
,otherwise: otherwise
,rem: rem
,negate: negate
,abs: abs
,sqrt: sqrt
,clamp: clamp
,logBase: logBase
,e: e
,pi: pi
,cos: cos
,sin: sin
,tan: tan
,acos: acos
,asin: asin
,atan: atan
,atan2: atan2
,round: round
,floor: floor
,ceiling: ceiling
,truncate: truncate
,toFloat: toFloat
,degrees: degrees
,radians: radians
,turns: turns
,toPolar: toPolar
,fromPolar: fromPolar
,isNaN: isNaN
,isInfinite: isInfinite
,toString: toString
,fst: fst
,snd: snd
,identity: identity
,always: always
,flip: flip
,curry: curry
,uncurry: uncurry
,LT: LT
,EQ: EQ
,GT: GT};
return _elm.Basics.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Char",
$Basics = Elm.Basics.make(_elm),
$Native$Char = Elm.Native.Char.make(_elm);
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 isBetween = F3(function (low,
high,
$char) {
return function () {
var code = toCode($char);
return _U.cmp(code,
toCode(low)) > -1 && _U.cmp(code,
toCode(high)) < 1;
}();
});
var isUpper = A2(isBetween,
_U.chr("A"),
_U.chr("Z"));
var isLower = A2(isBetween,
_U.chr("a"),
_U.chr("z"));
var isDigit = A2(isBetween,
_U.chr("0"),
_U.chr("9"));
var isOctDigit = A2(isBetween,
_U.chr("0"),
_U.chr("7"));
var isHexDigit = function ($char) {
return isDigit($char) || (A3(isBetween,
_U.chr("a"),
_U.chr("f"),
$char) || A3(isBetween,
_U.chr("A"),
_U.chr("F"),
$char));
};
_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.Color = Elm.Color || {};
Elm.Color.make = function (_elm) {
"use strict";
_elm.Color = _elm.Color || {};
if (_elm.Color.values)
return _elm.Color.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Color",
$Basics = Elm.Basics.make(_elm);
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._op["%"],
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 : _U.badIf($moduleName,
"between lines 150 and 152"));
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 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};}
_U.badCase($moduleName,
"between lines 124 and 132");
}();
};
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};
}();}
_U.badCase($moduleName,
"between lines 114 and 118");
}();
};
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.turns($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 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);
}();}
_U.badCase($moduleName,
"between lines 105 and 108");
}();
};
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 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
,rgb: rgb
,rgba: rgba
,hsl: hsl
,hsla: hsla
,greyscale: greyscale
,grayscale: grayscale
,complement: complement
,linear: linear
,radial: radial
,toRgb: toRgb
,toHsl: toHsl
,red: red
,orange: orange
,yellow: yellow
,green: green
,blue: blue
,purple: purple
,brown: brown
,lightRed: lightRed
,lightOrange: lightOrange
,lightYellow: lightYellow
,lightGreen: lightGreen
,lightBlue: lightBlue
,lightPurple: lightPurple
,lightBrown: lightBrown
,darkRed: darkRed
,darkOrange: darkOrange
,darkYellow: darkYellow
,darkGreen: darkGreen
,darkBlue: darkBlue
,darkPurple: darkPurple
,darkBrown: darkBrown
,white: white
,lightGrey: lightGrey
,grey: grey
,darkGrey: darkGrey
,lightCharcoal: lightCharcoal
,charcoal: charcoal
,darkCharcoal: darkCharcoal
,black: black
,lightGray: lightGray
,gray: gray
,darkGray: darkGray};
return _elm.Color.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Debug",
$Graphics$Collage = Elm.Graphics.Collage.make(_elm),
$Native$Debug = Elm.Native.Debug.make(_elm);
var trace = $Native$Debug.tracePath;
var watchSummary = $Native$Debug.watchSummary;
var watch = $Native$Debug.watch;
var crash = $Native$Debug.crash;
var log = $Native$Debug.log;
_elm.Debug.values = {_op: _op
,log: log
,crash: crash
,watch: watch
,watchSummary: watchSummary
,trace: trace};
return _elm.Debug.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Dict",
$Basics = Elm.Basics.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Debug = Elm.Native.Debug.make(_elm),
$String = Elm.String.make(_elm);
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);}
_U.badCase($moduleName,
"between lines 417 and 421");
}();
});
var keys = function (dict) {
return A3(foldr,
F3(function (key,
value,
keyList) {
return A2($List._op["::"],
key,
keyList);
}),
_L.fromArray([]),
dict);
};
var values = function (dict) {
return A3(foldr,
F3(function (key,
value,
valueList) {
return A2($List._op["::"],
value,
valueList);
}),
_L.fromArray([]),
dict);
};
var toList = function (dict) {
return A3(foldr,
F3(function (key,value,list) {
return A2($List._op["::"],
{ctor: "_Tuple2"
,_0: key
,_1: value},
list);
}),
_L.fromArray([]),
dict);
};
var foldl = F3(function (f,
acc,
dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack": return acc;}
break;
case "RBNode": return A3(foldl,
f,
A3(f,
dict._1,
dict._2,
A3(foldl,f,acc,dict._3)),
dict._4);}
_U.badCase($moduleName,
"between lines 406 and 410");
}();
});
var isBBlack = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBBlack": return true;}
break;
case "RBNode":
switch (dict._0.ctor)
{case "BBlack": return true;}
break;}
return false;
}();
};
var showFlag = function (f) {
return function () {
switch (f.ctor)
{case "Insert": return "Insert";
case "Remove": return "Remove";
case "Same": return "Same";}
_U.badCase($moduleName,
"between lines 182 and 185");
}();
};
var Same = {ctor: "Same"};
var Remove = {ctor: "Remove"};
var Insert = {ctor: "Insert"};
var get = F2(function (targetKey,
dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack":
return $Maybe.Nothing;}
break;
case "RBNode":
return function () {
var _v29 = A2($Basics.compare,
targetKey,
dict._1);
switch (_v29.ctor)
{case "EQ":
return $Maybe.Just(dict._2);
case "GT": return A2(get,
targetKey,
dict._4);
case "LT": return A2(get,
targetKey,
dict._3);}
_U.badCase($moduleName,
"between lines 129 and 132");
}();}
_U.badCase($moduleName,
"between lines 124 and 132");
}();
});
var member = F2(function (key,
dict) {
return function () {
var _v30 = A2(get,key,dict);
switch (_v30.ctor)
{case "Just": return true;
case "Nothing": return false;}
_U.badCase($moduleName,
"between lines 138 and 140");
}();
});
var max = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
return $Native$Debug.crash("(max Empty) is not defined");
case "RBNode":
switch (dict._4.ctor)
{case "RBEmpty":
return {ctor: "_Tuple2"
,_0: dict._1
,_1: dict._2};}
return max(dict._4);}
_U.badCase($moduleName,
"between lines 100 and 108");
}();
};
var min = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack":
return $Native$Debug.crash("(min Empty) is not defined");}
break;
case "RBNode":
switch (dict._3.ctor)
{case "RBEmpty":
switch (dict._3._0.ctor)
{case "LBlack":
return {ctor: "_Tuple2"
,_0: dict._1
,_1: dict._2};}
break;}
return min(dict._3);}
_U.badCase($moduleName,
"between lines 87 and 95");
}();
};
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 showLColor = function (color) {
return function () {
switch (color.ctor)
{case "LBBlack":
return "LBBlack";
case "LBlack": return "LBlack";}
_U.badCase($moduleName,
"between lines 70 and 72");
}();
};
var LBBlack = {ctor: "LBBlack"};
var LBlack = {ctor: "LBlack"};
var empty = RBEmpty(LBlack);
var isEmpty = function (dict) {
return _U.eq(dict,empty);
};
var map = F2(function (f,dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack":
return RBEmpty(LBlack);}
break;
case "RBNode": return A5(RBNode,
dict._0,
dict._1,
A2(f,dict._1,dict._2),
A2(map,f,dict._3),
A2(map,f,dict._4));}
_U.badCase($moduleName,
"between lines 394 and 399");
}();
});
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";}
_U.badCase($moduleName,
"between lines 56 and 60");
}();
};
var reportRemBug = F4(function (msg,
c,
lgot,
rgot) {
return $Native$Debug.crash($String.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 NBlack = {ctor: "NBlack"};
var BBlack = {ctor: "BBlack"};
var Black = {ctor: "Black"};
var ensureBlackRoot = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack": return dict;}
break;
case "RBNode":
switch (dict._0.ctor)
{case "Black": return dict;
case "Red": return A5(RBNode,
Black,
dict._1,
dict._2,
dict._3,
dict._4);}
break;}
_U.badCase($moduleName,
"between lines 154 and 162");
}();
};
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);}
_U.badCase($moduleName,
"between lines 339 and 341");
}();
};
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);}
_U.badCase($moduleName,
"between lines 378 and 380");
}();
};
var Red = {ctor: "Red"};
var moreBlack = function (color) {
return function () {
switch (color.ctor)
{case "BBlack":
return $Native$Debug.crash("Can\'t make a double black node more black!");
case "Black": return BBlack;
case "NBlack": return Red;
case "Red": return Black;}
_U.badCase($moduleName,
"between lines 244 and 248");
}();
};
var lessBlack = function (color) {
return function () {
switch (color.ctor)
{case "BBlack": return Black;
case "Black": return Red;
case "NBlack":
return $Native$Debug.crash("Can\'t make a negative black node less black!");
case "Red": return NBlack;}
_U.badCase($moduleName,
"between lines 253 and 257");
}();
};
var lessBlackTree = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBBlack":
return RBEmpty(LBlack);}
break;
case "RBNode": return A5(RBNode,
lessBlack(dict._0),
dict._1,
dict._2,
dict._3,
dict._4);}
_U.badCase($moduleName,
"between lines 262 and 264");
}();
};
var redden = function (t) {
return function () {
switch (t.ctor)
{case "RBEmpty":
return $Native$Debug.crash("can\'t make a Leaf red");
case "RBNode": return A5(RBNode,
Red,
t._1,
t._2,
t._3,
t._4);}
_U.badCase($moduleName,
"between lines 386 and 388");
}();
};
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));}
_U.badCase($moduleName,
"between lines 323 and 328");
}();
});
var rem = F3(function (c,l,r) {
return function () {
var _v169 = {ctor: "_Tuple2"
,_0: l
,_1: r};
switch (_v169.ctor)
{case "_Tuple2":
switch (_v169._0.ctor)
{case "RBEmpty":
switch (_v169._1.ctor)
{case "RBEmpty":
return function () {
switch (c.ctor)
{case "Black":
return RBEmpty(LBBlack);
case "Red":
return RBEmpty(LBlack);}
_U.badCase($moduleName,
"between lines 282 and 286");
}();
case "RBNode":
return function () {
var _v191 = {ctor: "_Tuple3"
,_0: c
,_1: _v169._0._0
,_2: _v169._1._0};
switch (_v191.ctor)
{case "_Tuple3":
switch (_v191._0.ctor)
{case "Black":
switch (_v191._1.ctor)
{case "LBlack":
switch (_v191._2.ctor)
{case "Red": return A5(RBNode,
Black,
_v169._1._1,
_v169._1._2,
_v169._1._3,
_v169._1._4);}
break;}
break;}
break;}
return A4(reportRemBug,
"Black/LBlack/Red",
c,
showLColor(_v169._0._0),
showNColor(_v169._1._0));
}();}
break;
case "RBNode":
switch (_v169._1.ctor)
{case "RBEmpty":
return function () {
var _v195 = {ctor: "_Tuple3"
,_0: c
,_1: _v169._0._0
,_2: _v169._1._0};
switch (_v195.ctor)
{case "_Tuple3":
switch (_v195._0.ctor)
{case "Black":
switch (_v195._1.ctor)
{case "Red":
switch (_v195._2.ctor)
{case "LBlack":
return A5(RBNode,
Black,
_v169._0._1,
_v169._0._2,
_v169._0._3,
_v169._0._4);}
break;}
break;}
break;}
return A4(reportRemBug,
"Black/Red/LBlack",
c,
showNColor(_v169._0._0),
showLColor(_v169._1._0));
}();
case "RBNode":
return function () {
var l$ = A5(remove_max,
_v169._0._0,
_v169._0._1,
_v169._0._2,
_v169._0._3,
_v169._0._4);
var r = A5(RBNode,
_v169._1._0,
_v169._1._1,
_v169._1._2,
_v169._1._3,
_v169._1._4);
var l = A5(RBNode,
_v169._0._0,
_v169._0._1,
_v169._0._2,
_v169._0._3,
_v169._0._4);
var $ = max(l),
k = $._0,
v = $._1;
return A5(bubble,c,k,v,l$,r);
}();}
break;}
break;}
_U.badCase($moduleName,
"between lines 280 and 309");
}();
});
var update = F3(function (k,
alter,
dict) {
return function () {
var up = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack":
return function () {
var _v206 = alter($Maybe.Nothing);
switch (_v206.ctor)
{case "Just":
return {ctor: "_Tuple2"
,_0: Insert
,_1: A5(RBNode,
Red,
k,
_v206._0,
empty,
empty)};
case "Nothing":
return {ctor: "_Tuple2"
,_0: Same
,_1: empty};}
_U.badCase($moduleName,
"between lines 194 and 198");
}();}
break;
case "RBNode":
return function () {
var _v208 = A2($Basics.compare,
k,
dict._1);
switch (_v208.ctor)
{case "EQ": return function () {
var _v209 = alter($Maybe.Just(dict._2));
switch (_v209.ctor)
{case "Just":
return {ctor: "_Tuple2"
,_0: Same
,_1: A5(RBNode,
dict._0,
dict._1,
_v209._0,
dict._3,
dict._4)};
case "Nothing":
return {ctor: "_Tuple2"
,_0: Remove
,_1: A3(rem,
dict._0,
dict._3,
dict._4)};}
_U.badCase($moduleName,
"between lines 201 and 206");
}();
case "GT": return function () {
var $ = up(dict._4),
flag = $._0,
newRight = $._1;
return function () {
switch (flag.ctor)
{case "Insert":
return {ctor: "_Tuple2"
,_0: Insert
,_1: A5(balance,
dict._0,
dict._1,
dict._2,
dict._3,
newRight)};
case "Remove":
return {ctor: "_Tuple2"
,_0: Remove
,_1: A5(bubble,
dict._0,
dict._1,
dict._2,
dict._3,
newRight)};
case "Same":
return {ctor: "_Tuple2"
,_0: Same
,_1: A5(RBNode,
dict._0,
dict._1,
dict._2,
dict._3,
newRight)};}
_U.badCase($moduleName,
"between lines 215 and 220");
}();
}();
case "LT": return function () {
var $ = up(dict._3),
flag = $._0,
newLeft = $._1;
return function () {
switch (flag.ctor)
{case "Insert":
return {ctor: "_Tuple2"
,_0: Insert
,_1: A5(balance,
dict._0,
dict._1,
dict._2,
newLeft,
dict._4)};
case "Remove":
return {ctor: "_Tuple2"
,_0: Remove
,_1: A5(bubble,
dict._0,
dict._1,
dict._2,
newLeft,
dict._4)};
case "Same":
return {ctor: "_Tuple2"
,_0: Same
,_1: A5(RBNode,
dict._0,
dict._1,
dict._2,
newLeft,
dict._4)};}
_U.badCase($moduleName,
"between lines 208 and 213");
}();
}();}
_U.badCase($moduleName,
"between lines 199 and 220");
}();}
_U.badCase($moduleName,
"between lines 192 and 220");
}();
};
var $ = up(dict),
flag = $._0,
updatedDict = $._1;
return function () {
switch (flag.ctor)
{case "Insert":
return ensureBlackRoot(updatedDict);
case "Remove":
return blacken(updatedDict);
case "Same":
return updatedDict;}
_U.badCase($moduleName,
"between lines 222 and 225");
}();
}();
});
var insert = F3(function (key,
value,
dict) {
return A3(update,
key,
$Basics.always($Maybe.Just(value)),
dict);
});
var singleton = F2(function (key,
value) {
return A3(insert,
key,
value,
empty);
});
var union = F2(function (t1,
t2) {
return A3(foldl,
insert,
t2,
t1);
});
var fromList = function (assocs) {
return A3($List.foldl,
F2(function (_v214,dict) {
return function () {
switch (_v214.ctor)
{case "_Tuple2":
return A3(insert,
_v214._0,
_v214._1,
dict);}
_U.badCase($moduleName,
"on line 466, column 38 to 59");
}();
}),
empty,
assocs);
};
var filter = F2(function (predicate,
dictionary) {
return function () {
var add = F3(function (key,
value,
dict) {
return A2(predicate,
key,
value) ? A3(insert,
key,
value,
dict) : dict;
});
return A3(foldl,
add,
empty,
dictionary);
}();
});
var intersect = F2(function (t1,
t2) {
return A2(filter,
F2(function (k,_v218) {
return function () {
return A2(member,k,t2);
}();
}),
t1);
});
var partition = F2(function (predicate,
dict) {
return function () {
var add = F3(function (key,
value,
_v220) {
return function () {
switch (_v220.ctor)
{case "_Tuple2":
return A2(predicate,
key,
value) ? {ctor: "_Tuple2"
,_0: A3(insert,
key,
value,
_v220._0)
,_1: _v220._1} : {ctor: "_Tuple2"
,_0: _v220._0
,_1: A3(insert,
key,
value,
_v220._1)};}
_U.badCase($moduleName,
"between lines 487 and 489");
}();
});
return A3(foldl,
add,
{ctor: "_Tuple2"
,_0: empty
,_1: empty},
dict);
}();
});
var remove = F2(function (key,
dict) {
return A3(update,
key,
$Basics.always($Maybe.Nothing),
dict);
});
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
,isEmpty: isEmpty
,get: get
,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.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Graphics.Collage",
$Basics = Elm.Basics.make(_elm),
$Color = Elm.Color.make(_elm),
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$List = Elm.List.make(_elm),
$Native$Graphics$Collage = Elm.Native.Graphics.Collage.make(_elm),
$Text = Elm.Text.make(_elm),
$Transform2D = Elm.Transform2D.make(_elm);
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);}
_U.badCase($moduleName,
"on line 226, column 3 to 37");
}();
});
var form = function (f) {
return {_: {}
,alpha: 1
,form: f
,scale: 1
,theta: 0
,x: 0
,y: 0};
};
var Fill = function (a) {
return {ctor: "Fill",_0: a};
};
var Line = function (a) {
return {ctor: "Line",_0: a};
};
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 FText = function (a) {
return {ctor: "FText",_0: a};
};
var text = function (t) {
return form(FText(t));
};
var FOutlinedText = F2(function (a,
b) {
return {ctor: "FOutlinedText"
,_0: a
,_1: b};
});
var outlinedText = F2(function (ls,
t) {
return form(A2(FOutlinedText,
ls,
t));
});
var FShape = F2(function (a,b) {
return {ctor: "FShape"
,_0: a
,_1: b};
});
var fill = F2(function (style,
shape) {
return form(A2(FShape,
Fill(style),
shape));
});
var outlined = F2(function (style,
shape) {
return form(A2(FShape,
Line(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
,collage: collage
,toForm: toForm
,filled: filled
,textured: textured
,gradient: gradient
,outlined: outlined
,traced: traced
,text: text
,outlinedText: outlinedText
,move: move
,moveX: moveX
,moveY: moveY
,scale: scale
,rotate: rotate
,alpha: alpha
,group: group
,groupTransform: groupTransform
,rect: rect
,oval: oval
,square: square
,circle: circle
,ngon: ngon
,polygon: polygon
,segment: segment
,path: path
,solid: solid
,dashed: dashed
,dotted: dotted
,defaultLine: defaultLine
,Form: Form
,LineStyle: LineStyle
,Flat: Flat
,Round: Round
,Padded: Padded
,Smooth: Smooth
,Sharp: Sharp
,Clipped: Clipped};
return _elm.Graphics.Collage.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Graphics.Element",
$Basics = Elm.Basics.make(_elm),
$Color = Elm.Color.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Graphics$Element = Elm.Native.Graphics.Element.make(_elm),
$Text = Elm.Text.make(_elm);
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 justified = $Native$Graphics$Element.block("justify");
var centered = $Native$Graphics$Element.block("center");
var rightAligned = $Native$Graphics$Element.block("right");
var leftAligned = $Native$Graphics$Element.block("left");
var show = function (value) {
return leftAligned($Text.monospace($Text.fromString($Basics.toString(value))));
};
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 newElement = $Native$Graphics$Element.newElement;
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 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$Graphics$Element.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 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,
A2($Maybe.withDefault,
0,
$List.maximum(ws)),
A2($Maybe.withDefault,
0,
$List.maximum(hs)),
A2(Flow,DOut,es));
}();
};
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 maxOrZero = function (list) {
return A2($Maybe.withDefault,
0,
$List.maximum(list));
};
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,
maxOrZero(ws),
$List.sum(hs));
case "DIn": return A2(newFlow,
maxOrZero(ws),
maxOrZero(hs));
case "DLeft": return A2(newFlow,
$List.sum(ws),
maxOrZero(hs));
case "DOut": return A2(newFlow,
maxOrZero(ws),
maxOrZero(hs));
case "DRight":
return A2(newFlow,
$List.sum(ws),
maxOrZero(hs));
case "DUp": return A2(newFlow,
maxOrZero(ws),
$List.sum(hs));}
_U.badCase($moduleName,
"between lines 362 and 368");
}();
}();
});
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 Element = F2(function (a,
b) {
return {_: {}
,element: b
,props: a};
});
_elm.Graphics.Element.values = {_op: _op
,image: image
,fittedImage: fittedImage
,croppedImage: croppedImage
,tiledImage: tiledImage
,leftAligned: leftAligned
,rightAligned: rightAligned
,centered: centered
,justified: justified
,show: show
,width: width
,height: height
,size: size
,color: color
,opacity: opacity
,link: link
,tag: tag
,widthOf: widthOf
,heightOf: heightOf
,sizeOf: sizeOf
,flow: flow
,up: up
,down: down
,left: left
,right: right
,inward: inward
,outward: outward
,layers: layers
,above: above
,below: below
,beside: beside
,empty: empty
,spacer: spacer
,container: container
,middle: middle
,midTop: midTop
,midBottom: midBottom
,midLeft: midLeft
,midRight: midRight
,topLeft: topLeft
,topRight: topRight
,bottomLeft: bottomLeft
,bottomRight: bottomRight
,absolute: absolute
,relative: relative
,middleAt: middleAt
,midTopAt: midTopAt
,midBottomAt: midBottomAt
,midLeftAt: midLeftAt
,midRightAt: midRightAt
,topLeftAt: topLeftAt
,topRightAt: topRightAt
,bottomLeftAt: bottomLeftAt
,bottomRightAt: bottomRightAt
,Element: Element
,Position: Position};
return _elm.Graphics.Element.values;
};
Elm.Html = Elm.Html || {};
Elm.Html.make = function (_elm) {
"use strict";
_elm.Html = _elm.Html || {};
if (_elm.Html.values)
return _elm.Html.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Html",
$Basics = Elm.Basics.make(_elm),
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm),
$VirtualDom = Elm.VirtualDom.make(_elm);
var fromElement = $VirtualDom.fromElement;
var toElement = $VirtualDom.toElement;
var text = $VirtualDom.text;
var node = $VirtualDom.node;
var body = node("body");
var section = node("section");
var nav = node("nav");
var article = node("article");
var aside = node("aside");
var h1 = node("h1");
var h2 = node("h2");
var h3 = node("h3");
var h4 = node("h4");
var h5 = node("h5");
var h6 = node("h6");
var header = node("header");
var footer = node("footer");
var address = node("address");
var main$ = node("main");
var p = node("p");
var hr = node("hr");
var pre = node("pre");
var blockquote = node("blockquote");
var ol = node("ol");
var ul = node("ul");
var li = node("li");
var dl = node("dl");
var dt = node("dt");
var dd = node("dd");
var figure = node("figure");
var figcaption = node("figcaption");
var div = node("div");
var a = node("a");
var em = node("em");
var strong = node("strong");
var small = node("small");
var s = node("s");
var cite = node("cite");
var q = node("q");
var dfn = node("dfn");
var abbr = node("abbr");
var time = node("time");
var code = node("code");
var $var = node("var");
var samp = node("samp");
var kbd = node("kbd");
var sub = node("sub");
var sup = node("sup");
var i = node("i");
var b = node("b");
var u = node("u");
var mark = node("mark");
var ruby = node("ruby");
var rt = node("rt");
var rp = node("rp");
var bdi = node("bdi");
var bdo = node("bdo");
var span = node("span");
var br = node("br");
var wbr = node("wbr");
var ins = node("ins");
var del = node("del");
var img = node("img");
var iframe = node("iframe");
var embed = node("embed");
var object = node("object");
var param = node("param");
var video = node("video");
var audio = node("audio");
var source = node("source");
var track = node("track");
var canvas = node("canvas");
var svg = node("svg");
var math = node("math");
var table = node("table");
var caption = node("caption");
var colgroup = node("colgroup");
var col = node("col");
var tbody = node("tbody");
var thead = node("thead");
var tfoot = node("tfoot");
var tr = node("tr");
var td = node("td");
var th = node("th");
var form = node("form");
var fieldset = node("fieldset");
var legend = node("legend");
var label = node("label");
var input = node("input");
var button = node("button");
var select = node("select");
var datalist = node("datalist");
var optgroup = node("optgroup");
var option = node("option");
var textarea = node("textarea");
var keygen = node("keygen");
var output = node("output");
var progress = node("progress");
var meter = node("meter");
var details = node("details");
var summary = node("summary");
var menuitem = node("menuitem");
var menu = node("menu");
_elm.Html.values = {_op: _op
,node: node
,text: text
,toElement: toElement
,fromElement: fromElement
,body: body
,section: section
,nav: nav
,article: article
,aside: aside
,h1: h1
,h2: h2
,h3: h3
,h4: h4
,h5: h5
,h6: h6
,header: header
,footer: footer
,address: address
,main$: main$
,p: p
,hr: hr
,pre: pre
,blockquote: blockquote
,ol: ol
,ul: ul
,li: li
,dl: dl
,dt: dt
,dd: dd
,figure: figure
,figcaption: figcaption
,div: div
,a: a
,em: em
,strong: strong
,small: small
,s: s
,cite: cite
,q: q
,dfn: dfn
,abbr: abbr
,time: time
,code: code
,$var: $var
,samp: samp
,kbd: kbd
,sub: sub
,sup: sup
,i: i
,b: b
,u: u
,mark: mark
,ruby: ruby
,rt: rt
,rp: rp
,bdi: bdi
,bdo: bdo
,span: span
,br: br
,wbr: wbr
,ins: ins
,del: del
,img: img
,iframe: iframe
,embed: embed
,object: object
,param: param
,video: video
,audio: audio
,source: source
,track: track
,canvas: canvas
,svg: svg
,math: math
,table: table
,caption: caption
,colgroup: colgroup
,col: col
,tbody: tbody
,thead: thead
,tfoot: tfoot
,tr: tr
,td: td
,th: th
,form: form
,fieldset: fieldset
,legend: legend
,label: label
,input: input
,button: button
,select: select
,datalist: datalist
,optgroup: optgroup
,option: option
,textarea: textarea
,keygen: keygen
,output: output
,progress: progress
,meter: meter
,details: details
,summary: summary
,menuitem: menuitem
,menu: menu};
return _elm.Html.values;
};
Elm.Html = Elm.Html || {};
Elm.Html.Attributes = Elm.Html.Attributes || {};
Elm.Html.Attributes.make = function (_elm) {
"use strict";
_elm.Html = _elm.Html || {};
_elm.Html.Attributes = _elm.Html.Attributes || {};
if (_elm.Html.Attributes.values)
return _elm.Html.Attributes.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Html.Attributes",
$Basics = Elm.Basics.make(_elm),
$Html = Elm.Html.make(_elm),
$Json$Encode = Elm.Json.Encode.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm),
$String = Elm.String.make(_elm),
$VirtualDom = Elm.VirtualDom.make(_elm);
var attribute = $VirtualDom.attribute;
var property = $VirtualDom.property;
var stringProperty = F2(function (name,
string) {
return A2(property,
name,
$Json$Encode.string(string));
});
var $class = function (name) {
return A2(stringProperty,
"className",
name);
};
var id = function (name) {
return A2(stringProperty,
"id",
name);
};
var title = function (name) {
return A2(stringProperty,
"title",
name);
};
var accesskey = function ($char) {
return A2(stringProperty,
"accesskey",
$String.fromList(_L.fromArray([$char])));
};
var contextmenu = function (value) {
return A2(stringProperty,
"contextmenu",
value);
};
var dir = function (value) {
return A2(stringProperty,
"dir",
value);
};
var draggable = function (value) {
return A2(stringProperty,
"draggable",
value);
};
var dropzone = function (value) {
return A2(stringProperty,
"dropzone",
value);
};
var itemprop = function (value) {
return A2(stringProperty,
"itemprop",
value);
};
var lang = function (value) {
return A2(stringProperty,
"lang",
value);
};
var tabindex = function (n) {
return A2(stringProperty,
"tabIndex",
$Basics.toString(n));
};
var charset = function (value) {
return A2(stringProperty,
"charset",
value);
};
var content = function (value) {
return A2(stringProperty,
"content",
value);
};
var httpEquiv = function (value) {
return A2(stringProperty,
"httpEquiv",
value);
};
var language = function (value) {
return A2(stringProperty,
"language",
value);
};
var src = function (value) {
return A2(stringProperty,
"src",
value);
};
var height = function (value) {
return A2(stringProperty,
"height",
$Basics.toString(value));
};
var width = function (value) {
return A2(stringProperty,
"width",
$Basics.toString(value));
};
var alt = function (value) {
return A2(stringProperty,
"alt",
value);
};
var preload = function (value) {
return A2(stringProperty,
"preload",
value);
};
var poster = function (value) {
return A2(stringProperty,
"poster",
value);
};
var kind = function (value) {
return A2(stringProperty,
"kind",
value);
};
var srclang = function (value) {
return A2(stringProperty,
"srclang",
value);
};
var sandbox = function (value) {
return A2(stringProperty,
"sandbox",
value);
};
var srcdoc = function (value) {
return A2(stringProperty,
"srcdoc",
value);
};
var type$ = function (value) {
return A2(stringProperty,
"type",
value);
};
var value = function (value) {
return A2(stringProperty,
"value",
value);
};
var placeholder = function (value) {
return A2(stringProperty,
"placeholder",
value);
};
var accept = function (value) {
return A2(stringProperty,
"accept",
value);
};
var acceptCharset = function (value) {
return A2(stringProperty,
"acceptCharset",
value);
};
var action = function (value) {
return A2(stringProperty,
"action",
value);
};
var autocomplete = function (bool) {
return A2(stringProperty,
"autocomplete",
bool ? "on" : "off");
};
var autosave = function (value) {
return A2(stringProperty,
"autosave",
value);
};
var enctype = function (value) {
return A2(stringProperty,
"enctype",
value);
};
var formaction = function (value) {
return A2(stringProperty,
"formaction",
value);
};
var list = function (value) {
return A2(stringProperty,
"list",
value);
};
var minlength = function (n) {
return A2(stringProperty,
"minLength",
$Basics.toString(n));
};
var maxlength = function (n) {
return A2(stringProperty,
"maxLength",
$Basics.toString(n));
};
var method = function (value) {
return A2(stringProperty,
"method",
value);
};
var name = function (value) {
return A2(stringProperty,
"name",
value);
};
var pattern = function (value) {
return A2(stringProperty,
"pattern",
value);
};
var size = function (n) {
return A2(stringProperty,
"size",
$Basics.toString(n));
};
var $for = function (value) {
return A2(stringProperty,
"htmlFor",
value);
};
var form = function (value) {
return A2(stringProperty,
"form",
value);
};
var max = function (value) {
return A2(stringProperty,
"max",
value);
};
var min = function (value) {
return A2(stringProperty,
"min",
value);
};
var step = function (n) {
return A2(stringProperty,
"step",
n);
};
var cols = function (n) {
return A2(stringProperty,
"cols",
$Basics.toString(n));
};
var rows = function (n) {
return A2(stringProperty,
"rows",
$Basics.toString(n));
};
var wrap = function (value) {
return A2(stringProperty,
"wrap",
value);
};
var usemap = function (value) {
return A2(stringProperty,
"useMap",
value);
};
var shape = function (value) {
return A2(stringProperty,
"shape",
value);
};
var coords = function (value) {
return A2(stringProperty,
"coords",
value);
};
var challenge = function (value) {
return A2(stringProperty,
"challenge",
value);
};
var keytype = function (value) {
return A2(stringProperty,
"keytype",
value);
};
var align = function (value) {
return A2(stringProperty,
"align",
value);
};
var cite = function (value) {
return A2(stringProperty,
"cite",
value);
};
var href = function (value) {
return A2(stringProperty,
"href",
value);
};
var target = function (value) {
return A2(stringProperty,
"target",
value);
};
var downloadAs = function (value) {
return A2(stringProperty,
"download",
value);
};
var hreflang = function (value) {
return A2(stringProperty,
"hreflang",
value);
};
var media = function (value) {
return A2(stringProperty,
"media",
value);
};
var ping = function (value) {
return A2(stringProperty,
"ping",
value);
};
var rel = function (value) {
return A2(stringProperty,
"rel",
value);
};
var datetime = function (value) {
return A2(stringProperty,
"datetime",
value);
};
var pubdate = function (value) {
return A2(stringProperty,
"pubdate",
value);
};
var start = function (n) {
return A2(stringProperty,
"start",
$Basics.toString(n));
};
var colspan = function (n) {
return A2(stringProperty,
"colSpan",
$Basics.toString(n));
};
var headers = function (value) {
return A2(stringProperty,
"headers",
value);
};
var rowspan = function (n) {
return A2(stringProperty,
"rowSpan",
$Basics.toString(n));
};
var scope = function (value) {
return A2(stringProperty,
"scope",
value);
};
var manifest = function (value) {
return A2(stringProperty,
"manifest",
value);
};
var boolProperty = F2(function (name,
bool) {
return A2(property,
name,
$Json$Encode.bool(bool));
});
var hidden = function (bool) {
return A2(boolProperty,
"hidden",
bool);
};
var contenteditable = function (bool) {
return A2(boolProperty,
"contentEditable",
bool);
};
var spellcheck = function (bool) {
return A2(boolProperty,
"spellcheck",
bool);
};
var async = function (bool) {
return A2(boolProperty,
"async",
bool);
};
var defer = function (bool) {
return A2(boolProperty,
"defer",
bool);
};
var scoped = function (bool) {
return A2(boolProperty,
"scoped",
bool);
};
var autoplay = function (bool) {
return A2(boolProperty,
"autoplay",
bool);
};
var controls = function (bool) {
return A2(boolProperty,
"controls",
bool);
};
var loop = function (bool) {
return A2(boolProperty,
"loop",
bool);
};
var $default = function (bool) {
return A2(boolProperty,
"default",
bool);
};
var seamless = function (bool) {
return A2(boolProperty,
"seamless",
bool);
};
var checked = function (bool) {
return A2(boolProperty,
"checked",
bool);
};
var selected = function (bool) {
return A2(boolProperty,
"selected",
bool);
};
var autofocus = function (bool) {
return A2(boolProperty,
"autofocus",
bool);
};
var disabled = function (bool) {
return A2(boolProperty,
"disabled",
bool);
};
var multiple = function (bool) {
return A2(boolProperty,
"multiple",
bool);
};
var novalidate = function (bool) {
return A2(boolProperty,
"noValidate",
bool);
};
var readonly = function (bool) {
return A2(boolProperty,
"readOnly",
bool);
};
var required = function (bool) {
return A2(boolProperty,
"required",
bool);
};
var ismap = function (value) {
return A2(boolProperty,
"isMap",
value);
};
var download = function (bool) {
return A2(boolProperty,
"download",
bool);
};
var reversed = function (bool) {
return A2(boolProperty,
"reversed",
bool);
};
var classList = function (list) {
return $class($String.join(" ")($List.map($Basics.fst)($List.filter($Basics.snd)(list))));
};
var style = function (props) {
return property("style")($Json$Encode.object($List.map(function (_v0) {
return function () {
switch (_v0.ctor)
{case "_Tuple2":
return {ctor: "_Tuple2"
,_0: _v0._0
,_1: $Json$Encode.string(_v0._1)};}
_U.badCase($moduleName,
"on line 133, column 35 to 57");
}();
})(props)));
};
var key = function (k) {
return A2(stringProperty,
"key",
k);
};
_elm.Html.Attributes.values = {_op: _op
,key: key
,style: style
,classList: classList
,property: property
,stringProperty: stringProperty
,boolProperty: boolProperty
,attribute: attribute
,$class: $class
,hidden: hidden
,id: id
,title: title
,accesskey: accesskey
,contenteditable: contenteditable
,contextmenu: contextmenu
,dir: dir
,draggable: draggable
,dropzone: dropzone
,itemprop: itemprop
,lang: lang
,spellcheck: spellcheck
,tabindex: tabindex
,async: async
,charset: charset
,content: content
,defer: defer
,httpEquiv: httpEquiv
,language: language
,scoped: scoped
,src: src
,height: height
,width: width
,alt: alt
,autoplay: autoplay
,controls: controls
,loop: loop
,preload: preload
,poster: poster
,$default: $default
,kind: kind
,srclang: srclang
,sandbox: sandbox
,seamless: seamless
,srcdoc: srcdoc
,type$: type$
,value: value
,checked: checked
,placeholder: placeholder
,selected: selected
,accept: accept
,acceptCharset: acceptCharset
,action: action
,autocomplete: autocomplete
,autofocus: autofocus
,autosave: autosave
,disabled: disabled
,enctype: enctype
,formaction: formaction
,list: list
,minlength: minlength
,maxlength: maxlength
,method: method
,multiple: multiple
,name: name
,novalidate: novalidate
,pattern: pattern
,readonly: readonly
,required: required
,size: size
,$for: $for
,form: form
,max: max
,min: min
,step: step
,cols: cols
,rows: rows
,wrap: wrap
,ismap: ismap
,usemap: usemap
,shape: shape
,coords: coords
,challenge: challenge
,keytype: keytype
,align: align
,cite: cite
,href: href
,target: target
,download: download
,downloadAs: downloadAs
,hreflang: hreflang
,media: media
,ping: ping
,rel: rel
,datetime: datetime
,pubdate: pubdate
,reversed: reversed
,start: start
,colspan: colspan
,headers: headers
,rowspan: rowspan
,scope: scope
,manifest: manifest};
return _elm.Html.Attributes.values;
};
Elm.Html = Elm.Html || {};
Elm.Html.Events = Elm.Html.Events || {};
Elm.Html.Events.make = function (_elm) {
"use strict";
_elm.Html = _elm.Html || {};
_elm.Html.Events = _elm.Html.Events || {};
if (_elm.Html.Events.values)
return _elm.Html.Events.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Html.Events",
$Basics = Elm.Basics.make(_elm),
$Html = Elm.Html.make(_elm),
$Json$Decode = Elm.Json.Decode.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm),
$VirtualDom = Elm.VirtualDom.make(_elm);
var keyCode = A2($Json$Decode._op[":="],
"keyCode",
$Json$Decode.$int);
var targetChecked = A2($Json$Decode.at,
_L.fromArray(["target"
,"checked"]),
$Json$Decode.bool);
var targetValue = A2($Json$Decode.at,
_L.fromArray(["target"
,"value"]),
$Json$Decode.string);
var on = $VirtualDom.on;
var messageOn = F3(function (name,
addr,
msg) {
return A3(on,
name,
$Json$Decode.value,
function (_v0) {
return function () {
return A2($Signal.message,
addr,
msg);
}();
});
});
var onClick = messageOn("click");
var onDoubleClick = messageOn("dblclick");
var onMouseMove = messageOn("mousemove");
var onMouseDown = messageOn("mousedown");
var onMouseUp = messageOn("mouseup");
var onMouseEnter = messageOn("mouseenter");
var onMouseLeave = messageOn("mouseleave");
var onMouseOver = messageOn("mouseover");
var onMouseOut = messageOn("mouseout");
var onBlur = messageOn("blur");
var onFocus = messageOn("focus");
var onSubmit = messageOn("submit");
var onKey = F3(function (name,
addr,
handler) {
return A3(on,
name,
keyCode,
function (code) {
return A2($Signal.message,
addr,
handler(code));
});
});
var onKeyUp = onKey("keyup");
var onKeyDown = onKey("keydown");
var onKeyPress = onKey("keypress");
_elm.Html.Events.values = {_op: _op
,onBlur: onBlur
,onFocus: onFocus
,onSubmit: onSubmit
,onKeyUp: onKeyUp
,onKeyDown: onKeyDown
,onKeyPress: onKeyPress
,onClick: onClick
,onDoubleClick: onDoubleClick
,onMouseMove: onMouseMove
,onMouseDown: onMouseDown
,onMouseUp: onMouseUp
,onMouseEnter: onMouseEnter
,onMouseLeave: onMouseLeave
,onMouseOver: onMouseOver
,onMouseOut: onMouseOut
,on: on
,targetValue: targetValue
,targetChecked: targetChecked
,keyCode: keyCode};
return _elm.Html.Events.values;
};
Elm.Html = Elm.Html || {};
Elm.Html.Lazy = Elm.Html.Lazy || {};
Elm.Html.Lazy.make = function (_elm) {
"use strict";
_elm.Html = _elm.Html || {};
_elm.Html.Lazy = _elm.Html.Lazy || {};
if (_elm.Html.Lazy.values)
return _elm.Html.Lazy.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Html.Lazy",
$Basics = Elm.Basics.make(_elm),
$Html = Elm.Html.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm),
$VirtualDom = Elm.VirtualDom.make(_elm);
var lazy3 = $VirtualDom.lazy3;
var lazy2 = $VirtualDom.lazy2;
var lazy = $VirtualDom.lazy;
_elm.Html.Lazy.values = {_op: _op
,lazy: lazy
,lazy2: lazy2
,lazy3: lazy3};
return _elm.Html.Lazy.values;
};
Elm.Json = Elm.Json || {};
Elm.Json.Decode = Elm.Json.Decode || {};
Elm.Json.Decode.make = function (_elm) {
"use strict";
_elm.Json = _elm.Json || {};
_elm.Json.Decode = _elm.Json.Decode || {};
if (_elm.Json.Decode.values)
return _elm.Json.Decode.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Json.Decode",
$Array = Elm.Array.make(_elm),
$Dict = Elm.Dict.make(_elm),
$Json$Encode = Elm.Json.Encode.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Json = Elm.Native.Json.make(_elm),
$Result = Elm.Result.make(_elm);
var tuple8 = $Native$Json.decodeTuple8;
var tuple7 = $Native$Json.decodeTuple7;
var tuple6 = $Native$Json.decodeTuple6;
var tuple5 = $Native$Json.decodeTuple5;
var tuple4 = $Native$Json.decodeTuple4;
var tuple3 = $Native$Json.decodeTuple3;
var tuple2 = $Native$Json.decodeTuple2;
var tuple1 = $Native$Json.decodeTuple1;
var succeed = $Native$Json.succeed;
var fail = $Native$Json.fail;
var andThen = $Native$Json.andThen;
var customDecoder = $Native$Json.customDecoder;
var decodeValue = $Native$Json.runDecoderValue;
var value = $Native$Json.decodeValue;
var maybe = $Native$Json.decodeMaybe;
var $null = $Native$Json.decodeNull;
var array = $Native$Json.decodeArray;
var list = $Native$Json.decodeList;
var bool = $Native$Json.decodeBool;
var $int = $Native$Json.decodeInt;
var $float = $Native$Json.decodeFloat;
var string = $Native$Json.decodeString;
var oneOf = $Native$Json.oneOf;
var keyValuePairs = $Native$Json.decodeKeyValuePairs;
var object8 = $Native$Json.decodeObject8;
var object7 = $Native$Json.decodeObject7;
var object6 = $Native$Json.decodeObject6;
var object5 = $Native$Json.decodeObject5;
var object4 = $Native$Json.decodeObject4;
var object3 = $Native$Json.decodeObject3;
var object2 = $Native$Json.decodeObject2;
var object1 = $Native$Json.decodeObject1;
_op[":="] = $Native$Json.decodeField;
var at = F2(function (fields,
decoder) {
return A3($List.foldr,
F2(function (x,y) {
return A2(_op[":="],x,y);
}),
decoder,
fields);
});
var decodeString = $Native$Json.runDecoderString;
var map = $Native$Json.decodeObject1;
var dict = function (decoder) {
return A2(map,
$Dict.fromList,
keyValuePairs(decoder));
};
var Decoder = {ctor: "Decoder"};
_elm.Json.Decode.values = {_op: _op
,decodeString: decodeString
,decodeValue: decodeValue
,string: string
,$int: $int
,$float: $float
,bool: bool
,$null: $null
,list: list
,array: array
,tuple1: tuple1
,tuple2: tuple2
,tuple3: tuple3
,tuple4: tuple4
,tuple5: tuple5
,tuple6: tuple6
,tuple7: tuple7
,tuple8: tuple8
,at: at
,object1: object1
,object2: object2
,object3: object3
,object4: object4
,object5: object5
,object6: object6
,object7: object7
,object8: object8
,keyValuePairs: keyValuePairs
,dict: dict
,maybe: maybe
,oneOf: oneOf
,map: map
,fail: fail
,succeed: succeed
,andThen: andThen
,value: value
,customDecoder: customDecoder
,Decoder: Decoder};
return _elm.Json.Decode.values;
};
Elm.Json = Elm.Json || {};
Elm.Json.Encode = Elm.Json.Encode || {};
Elm.Json.Encode.make = function (_elm) {
"use strict";
_elm.Json = _elm.Json || {};
_elm.Json.Encode = _elm.Json.Encode || {};
if (_elm.Json.Encode.values)
return _elm.Json.Encode.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Json.Encode",
$Array = Elm.Array.make(_elm),
$Native$Json = Elm.Native.Json.make(_elm);
var list = $Native$Json.encodeList;
var array = $Native$Json.encodeArray;
var object = $Native$Json.encodeObject;
var $null = $Native$Json.encodeNull;
var bool = $Native$Json.identity;
var $float = $Native$Json.identity;
var $int = $Native$Json.identity;
var string = $Native$Json.identity;
var encode = $Native$Json.encode;
var Value = {ctor: "Value"};
_elm.Json.Encode.values = {_op: _op
,encode: encode
,string: string
,$int: $int
,$float: $float
,bool: bool
,$null: $null
,list: list
,array: array
,object: object
,Value: Value};
return _elm.Json.Encode.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "List",
$Basics = Elm.Basics.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$List = Elm.Native.List.make(_elm);
var sortWith = $Native$List.sortWith;
var sortBy = $Native$List.sortBy;
var sort = function (xs) {
return A2(sortBy,
$Basics.identity,
xs);
};
var repeat = $Native$List.repeat;
var drop = $Native$List.drop;
var take = $Native$List.take;
var map5 = $Native$List.map5;
var map4 = $Native$List.map4;
var map3 = $Native$List.map3;
var map2 = $Native$List.map2;
var any = $Native$List.any;
var all = F2(function (pred,
xs) {
return $Basics.not(A2(any,
function ($) {
return $Basics.not(pred($));
},
xs));
});
var foldr = $Native$List.foldr;
var foldl = $Native$List.foldl;
var length = function (xs) {
return A3(foldl,
F2(function (_v0,i) {
return function () {
return i + 1;
}();
}),
0,
xs);
};
var sum = function (numbers) {
return A3(foldl,
F2(function (x,y) {
return x + y;
}),
0,
numbers);
};
var product = function (numbers) {
return A3(foldl,
F2(function (x,y) {
return x * y;
}),
1,
numbers);
};
var maximum = function (list) {
return function () {
switch (list.ctor)
{case "::":
return $Maybe.Just(A3(foldl,
$Basics.max,
list._0,
list._1));}
return $Maybe.Nothing;
}();
};
var minimum = function (list) {
return function () {
switch (list.ctor)
{case "::":
return $Maybe.Just(A3(foldl,
$Basics.min,
list._0,
list._1));}
return $Maybe.Nothing;
}();
};
var indexedMap = F2(function (f,
xs) {
return A3(map2,
f,
_L.range(0,length(xs) - 1),
xs);
});
var member = F2(function (x,
xs) {
return A2(any,
function (a) {
return _U.eq(a,x);
},
xs);
});
var isEmpty = function (xs) {
return function () {
switch (xs.ctor)
{case "[]": return true;}
return false;
}();
};
var tail = function (list) {
return function () {
switch (list.ctor)
{case "::":
return $Maybe.Just(list._1);
case "[]":
return $Maybe.Nothing;}
_U.badCase($moduleName,
"between lines 87 and 89");
}();
};
var head = function (list) {
return function () {
switch (list.ctor)
{case "::":
return $Maybe.Just(list._0);
case "[]":
return $Maybe.Nothing;}
_U.badCase($moduleName,
"between lines 75 and 77");
}();
};
_op["::"] = $Native$List.cons;
var map = F2(function (f,xs) {
return A3(foldr,
F2(function (x,acc) {
return A2(_op["::"],
f(x),
acc);
}),
_L.fromArray([]),
xs);
});
var filter = F2(function (pred,
xs) {
return function () {
var conditionalCons = F2(function (x,
xs$) {
return pred(x) ? A2(_op["::"],
x,
xs$) : xs$;
});
return A3(foldr,
conditionalCons,
_L.fromArray([]),
xs);
}();
});
var maybeCons = F3(function (f,
mx,
xs) {
return function () {
var _v15 = f(mx);
switch (_v15.ctor)
{case "Just":
return A2(_op["::"],_v15._0,xs);
case "Nothing": return xs;}
_U.badCase($moduleName,
"between lines 179 and 181");
}();
});
var filterMap = F2(function (f,
xs) {
return A3(foldr,
maybeCons(f),
_L.fromArray([]),
xs);
});
var reverse = function (list) {
return A3(foldl,
F2(function (x,y) {
return A2(_op["::"],x,y);
}),
_L.fromArray([]),
list);
};
var scanl = F3(function (f,
b,
xs) {
return function () {
var scan1 = F2(function (x,
accAcc) {
return function () {
switch (accAcc.ctor)
{case "::": return A2(_op["::"],
A2(f,x,accAcc._0),
accAcc);
case "[]":
return _L.fromArray([]);}
_U.badCase($moduleName,
"between lines 148 and 151");
}();
});
return reverse(A3(foldl,
scan1,
_L.fromArray([b]),
xs));
}();
});
var append = F2(function (xs,
ys) {
return function () {
switch (ys.ctor)
{case "[]": return xs;}
return A3(foldr,
F2(function (x,y) {
return A2(_op["::"],x,y);
}),
ys,
xs);
}();
});
var concat = function (lists) {
return A3(foldr,
append,
_L.fromArray([]),
lists);
};
var concatMap = F2(function (f,
list) {
return concat(A2(map,
f,
list));
});
var partition = F2(function (pred,
list) {
return function () {
var step = F2(function (x,
_v21) {
return function () {
switch (_v21.ctor)
{case "_Tuple2":
return pred(x) ? {ctor: "_Tuple2"
,_0: A2(_op["::"],x,_v21._0)
,_1: _v21._1} : {ctor: "_Tuple2"
,_0: _v21._0
,_1: A2(_op["::"],
x,
_v21._1)};}
_U.badCase($moduleName,
"between lines 301 and 303");
}();
});
return A3(foldr,
step,
{ctor: "_Tuple2"
,_0: _L.fromArray([])
,_1: _L.fromArray([])},
list);
}();
});
var unzip = function (pairs) {
return function () {
var step = F2(function (_v25,
_v26) {
return function () {
switch (_v26.ctor)
{case "_Tuple2":
return function () {
switch (_v25.ctor)
{case "_Tuple2":
return {ctor: "_Tuple2"
,_0: A2(_op["::"],
_v25._0,
_v26._0)
,_1: A2(_op["::"],
_v25._1,
_v26._1)};}
_U.badCase($moduleName,
"on line 339, column 12 to 28");
}();}
_U.badCase($moduleName,
"on line 339, column 12 to 28");
}();
});
return A3(foldr,
step,
{ctor: "_Tuple2"
,_0: _L.fromArray([])
,_1: _L.fromArray([])},
pairs);
}();
};
var intersperse = F2(function (sep,
xs) {
return function () {
switch (xs.ctor)
{case "::": return function () {
var step = F2(function (x,
rest) {
return A2(_op["::"],
sep,
A2(_op["::"],x,rest));
});
var spersed = A3(foldr,
step,
_L.fromArray([]),
xs._1);
return A2(_op["::"],
xs._0,
spersed);
}();
case "[]":
return _L.fromArray([]);}
_U.badCase($moduleName,
"between lines 350 and 356");
}();
});
_elm.List.values = {_op: _op
,isEmpty: isEmpty
,length: length
,reverse: reverse
,member: member
,head: head
,tail: tail
,filter: filter
,take: take
,drop: drop
,repeat: repeat
,append: append
,concat: concat
,intersperse: intersperse
,partition: partition
,unzip: unzip
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,filterMap: filterMap
,concatMap: concatMap
,indexedMap: indexedMap
,foldr: foldr
,foldl: foldl
,sum: sum
,product: product
,maximum: maximum
,minimum: minimum
,all: all
,any: any
,scanl: scanl
,sort: sort
,sortBy: sortBy
,sortWith: sortWith};
return _elm.List.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Maybe";
var withDefault = F2(function ($default,
maybe) {
return function () {
switch (maybe.ctor)
{case "Just": return maybe._0;
case "Nothing":
return $default;}
_U.badCase($moduleName,
"between lines 45 and 47");
}();
});
var Nothing = {ctor: "Nothing"};
var oneOf = function (maybes) {
return function () {
switch (maybes.ctor)
{case "::": return function () {
switch (maybes._0.ctor)
{case "Just": return maybes._0;
case "Nothing":
return oneOf(maybes._1);}
_U.badCase($moduleName,
"between lines 64 and 66");
}();
case "[]": return Nothing;}
_U.badCase($moduleName,
"between lines 59 and 66");
}();
};
var andThen = F2(function (maybeValue,
callback) {
return function () {
switch (maybeValue.ctor)
{case "Just":
return callback(maybeValue._0);
case "Nothing": return Nothing;}
_U.badCase($moduleName,
"between lines 110 and 112");
}();
});
var Just = function (a) {
return {ctor: "Just",_0: a};
};
var map = F2(function (f,
maybe) {
return function () {
switch (maybe.ctor)
{case "Just":
return Just(f(maybe._0));
case "Nothing": return Nothing;}
_U.badCase($moduleName,
"between lines 76 and 78");
}();
});
_elm.Maybe.values = {_op: _op
,andThen: andThen
,map: map
,withDefault: withDefault
,oneOf: oneOf
,Just: Just
,Nothing: Nothing};
return _elm.Maybe.values;
};
Elm.Result = Elm.Result || {};
Elm.Result.make = function (_elm) {
"use strict";
_elm.Result = _elm.Result || {};
if (_elm.Result.values)
return _elm.Result.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Result",
$Maybe = Elm.Maybe.make(_elm);
var toMaybe = function (result) {
return function () {
switch (result.ctor)
{case "Err":
return $Maybe.Nothing;
case "Ok":
return $Maybe.Just(result._0);}
_U.badCase($moduleName,
"between lines 164 and 166");
}();
};
var Err = function (a) {
return {ctor: "Err",_0: a};
};
var andThen = F2(function (result,
callback) {
return function () {
switch (result.ctor)
{case "Err":
return Err(result._0);
case "Ok":
return callback(result._0);}
_U.badCase($moduleName,
"between lines 126 and 128");
}();
});
var Ok = function (a) {
return {ctor: "Ok",_0: a};
};
var map = F2(function (func,
ra) {
return function () {
switch (ra.ctor)
{case "Err": return Err(ra._0);
case "Ok":
return Ok(func(ra._0));}
_U.badCase($moduleName,
"between lines 41 and 43");
}();
});
var map2 = F3(function (func,
ra,
rb) {
return function () {
var _v9 = {ctor: "_Tuple2"
,_0: ra
,_1: rb};
switch (_v9.ctor)
{case "_Tuple2":
switch (_v9._0.ctor)
{case "Err":
return Err(_v9._0._0);
case "Ok": switch (_v9._1.ctor)
{case "Ok": return Ok(A2(func,
_v9._0._0,
_v9._1._0));}
break;}
switch (_v9._1.ctor)
{case "Err":
return Err(_v9._1._0);}
break;}
_U.badCase($moduleName,
"between lines 55 and 58");
}();
});
var map3 = F4(function (func,
ra,
rb,
rc) {
return function () {
var _v16 = {ctor: "_Tuple3"
,_0: ra
,_1: rb
,_2: rc};
switch (_v16.ctor)
{case "_Tuple3":
switch (_v16._0.ctor)
{case "Err":
return Err(_v16._0._0);
case "Ok": switch (_v16._1.ctor)
{case "Ok":
switch (_v16._2.ctor)
{case "Ok": return Ok(A3(func,
_v16._0._0,
_v16._1._0,
_v16._2._0));}
break;}
break;}
switch (_v16._1.ctor)
{case "Err":
return Err(_v16._1._0);}
switch (_v16._2.ctor)
{case "Err":
return Err(_v16._2._0);}
break;}
_U.badCase($moduleName,
"between lines 63 and 67");
}();
});
var map4 = F5(function (func,
ra,
rb,
rc,
rd) {
return function () {
var _v26 = {ctor: "_Tuple4"
,_0: ra
,_1: rb
,_2: rc
,_3: rd};
switch (_v26.ctor)
{case "_Tuple4":
switch (_v26._0.ctor)
{case "Err":
return Err(_v26._0._0);
case "Ok": switch (_v26._1.ctor)
{case "Ok":
switch (_v26._2.ctor)
{case "Ok":
switch (_v26._3.ctor)
{case "Ok": return Ok(A4(func,
_v26._0._0,
_v26._1._0,
_v26._2._0,
_v26._3._0));}
break;}
break;}
break;}
switch (_v26._1.ctor)
{case "Err":
return Err(_v26._1._0);}
switch (_v26._2.ctor)
{case "Err":
return Err(_v26._2._0);}
switch (_v26._3.ctor)
{case "Err":
return Err(_v26._3._0);}
break;}
_U.badCase($moduleName,
"between lines 72 and 77");
}();
});
var map5 = F6(function (func,
ra,
rb,
rc,
rd,
re) {
return function () {
var _v39 = {ctor: "_Tuple5"
,_0: ra
,_1: rb
,_2: rc
,_3: rd
,_4: re};
switch (_v39.ctor)
{case "_Tuple5":
switch (_v39._0.ctor)
{case "Err":
return Err(_v39._0._0);
case "Ok": switch (_v39._1.ctor)
{case "Ok":
switch (_v39._2.ctor)
{case "Ok":
switch (_v39._3.ctor)
{case "Ok":
switch (_v39._4.ctor)
{case "Ok": return Ok(A5(func,
_v39._0._0,
_v39._1._0,
_v39._2._0,
_v39._3._0,
_v39._4._0));}
break;}
break;}
break;}
break;}
switch (_v39._1.ctor)
{case "Err":
return Err(_v39._1._0);}
switch (_v39._2.ctor)
{case "Err":
return Err(_v39._2._0);}
switch (_v39._3.ctor)
{case "Err":
return Err(_v39._3._0);}
switch (_v39._4.ctor)
{case "Err":
return Err(_v39._4._0);}
break;}
_U.badCase($moduleName,
"between lines 82 and 88");
}();
});
var formatError = F2(function (f,
result) {
return function () {
switch (result.ctor)
{case "Err":
return Err(f(result._0));
case "Ok":
return Ok(result._0);}
_U.badCase($moduleName,
"between lines 148 and 150");
}();
});
var fromMaybe = F2(function (err,
maybe) {
return function () {
switch (maybe.ctor)
{case "Just":
return Ok(maybe._0);
case "Nothing":
return Err(err);}
_U.badCase($moduleName,
"between lines 180 and 182");
}();
});
_elm.Result.values = {_op: _op
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,andThen: andThen
,toMaybe: toMaybe
,fromMaybe: fromMaybe
,formatError: formatError
,Ok: Ok
,Err: Err};
return _elm.Result.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Signal",
$Basics = Elm.Basics.make(_elm),
$Debug = Elm.Debug.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Signal = Elm.Native.Signal.make(_elm),
$Task = Elm.Task.make(_elm);
var send = F2(function (_v0,
value) {
return function () {
switch (_v0.ctor)
{case "Address":
return A2($Task.onError,
_v0._0(value),
function (_v3) {
return function () {
return $Task.succeed({ctor: "_Tuple0"});
}();
});}
_U.badCase($moduleName,
"between lines 370 and 371");
}();
});
var Message = function (a) {
return {ctor: "Message"
,_0: a};
};
var message = F2(function (_v5,
value) {
return function () {
switch (_v5.ctor)
{case "Address":
return Message(_v5._0(value));}
_U.badCase($moduleName,
"on line 352, column 5 to 24");
}();
});
var mailbox = $Native$Signal.mailbox;
var Address = function (a) {
return {ctor: "Address"
,_0: a};
};
var forwardTo = F2(function (_v8,
f) {
return function () {
switch (_v8.ctor)
{case "Address":
return Address(function (x) {
return _v8._0(f(x));
});}
_U.badCase($moduleName,
"on line 339, column 5 to 29");
}();
});
var Mailbox = F2(function (a,
b) {
return {_: {}
,address: a
,signal: b};
});
var sampleOn = $Native$Signal.sampleOn;
var dropRepeats = $Native$Signal.dropRepeats;
var filterMap = $Native$Signal.filterMap;
var filter = F3(function (isOk,
base,
signal) {
return A3(filterMap,
function (value) {
return isOk(value) ? $Maybe.Just(value) : $Maybe.Nothing;
},
base,
signal);
});
var merge = F2(function (left,
right) {
return A3($Native$Signal.genericMerge,
$Basics.always,
left,
right);
});
var mergeMany = function (signalList) {
return function () {
var _v11 = $List.reverse(signalList);
switch (_v11.ctor)
{case "::":
return A3($List.foldl,
merge,
_v11._0,
_v11._1);
case "[]":
return $Debug.crash("mergeMany was given an empty list!");}
_U.badCase($moduleName,
"between lines 177 and 182");
}();
};
var foldp = $Native$Signal.foldp;
var map5 = $Native$Signal.map5;
var map4 = $Native$Signal.map4;
var map3 = $Native$Signal.map3;
var map2 = $Native$Signal.map2;
_op["~"] = F2(function (funcs,
args) {
return A3(map2,
F2(function (f,v) {
return f(v);
}),
funcs,
args);
});
var map = $Native$Signal.map;
_op["<~"] = map;
var constant = $Native$Signal.constant;
var Signal = {ctor: "Signal"};
_elm.Signal.values = {_op: _op
,merge: merge
,mergeMany: mergeMany
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,constant: constant
,dropRepeats: dropRepeats
,filter: filter
,filterMap: filterMap
,sampleOn: sampleOn
,foldp: foldp
,mailbox: mailbox
,send: send
,message: message
,forwardTo: forwardTo
,Mailbox: Mailbox};
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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "String",
$Maybe = Elm.Maybe.make(_elm),
$Native$String = Elm.Native.String.make(_elm),
$Result = Elm.Result.make(_elm);
var fromList = $Native$String.fromList;
var toList = $Native$String.toList;
var toFloat = $Native$String.toFloat;
var toInt = $Native$String.toInt;
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 fromChar = function ($char) {
return A2(cons,$char,"");
};
var isEmpty = $Native$String.isEmpty;
_elm.String.values = {_op: _op
,isEmpty: isEmpty
,length: length
,reverse: reverse
,repeat: repeat
,cons: cons
,uncons: uncons
,fromChar: fromChar
,append: append
,concat: concat
,split: split
,join: join
,words: words
,lines: lines
,slice: slice
,left: left
,right: right
,dropLeft: dropLeft
,dropRight: dropRight
,contains: contains
,startsWith: startsWith
,endsWith: endsWith
,indexes: indexes
,indices: indices
,toInt: toInt
,toFloat: toFloat
,toList: toList
,fromList: fromList
,toUpper: toUpper
,toLower: toLower
,pad: pad
,padLeft: padLeft
,padRight: padRight
,trim: trim
,trimLeft: trimLeft
,trimRight: trimRight
,map: map
,filter: filter
,foldl: foldl
,foldr: foldr
,any: any
,all: all};
return _elm.String.values;
};
Elm.Task = Elm.Task || {};
Elm.Task.make = function (_elm) {
"use strict";
_elm.Task = _elm.Task || {};
if (_elm.Task.values)
return _elm.Task.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Task",
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Task = Elm.Native.Task.make(_elm),
$Result = Elm.Result.make(_elm);
var sleep = $Native$Task.sleep;
var spawn = $Native$Task.spawn;
var ThreadID = function (a) {
return {ctor: "ThreadID"
,_0: a};
};
var onError = $Native$Task.catch_;
var andThen = $Native$Task.andThen;
var fail = $Native$Task.fail;
var mapError = F2(function (f,
promise) {
return A2(onError,
promise,
function (err) {
return fail(f(err));
});
});
var succeed = $Native$Task.succeed;
var map = F2(function (func,
promiseA) {
return A2(andThen,
promiseA,
function (a) {
return succeed(func(a));
});
});
var map2 = F3(function (func,
promiseA,
promiseB) {
return A2(andThen,
promiseA,
function (a) {
return A2(andThen,
promiseB,
function (b) {
return succeed(A2(func,a,b));
});
});
});
var map3 = F4(function (func,
promiseA,
promiseB,
promiseC) {
return A2(andThen,
promiseA,
function (a) {
return A2(andThen,
promiseB,
function (b) {
return A2(andThen,
promiseC,
function (c) {
return succeed(A3(func,
a,
b,
c));
});
});
});
});
var map4 = F5(function (func,
promiseA,
promiseB,
promiseC,
promiseD) {
return A2(andThen,
promiseA,
function (a) {
return A2(andThen,
promiseB,
function (b) {
return A2(andThen,
promiseC,
function (c) {
return A2(andThen,
promiseD,
function (d) {
return succeed(A4(func,
a,
b,
c,
d));
});
});
});
});
});
var map5 = F6(function (func,
promiseA,
promiseB,
promiseC,
promiseD,
promiseE) {
return A2(andThen,
promiseA,
function (a) {
return A2(andThen,
promiseB,
function (b) {
return A2(andThen,
promiseC,
function (c) {
return A2(andThen,
promiseD,
function (d) {
return A2(andThen,
promiseE,
function (e) {
return succeed(A5(func,
a,
b,
c,
d,
e));
});
});
});
});
});
});
var andMap = F2(function (promiseFunc,
promiseValue) {
return A2(andThen,
promiseFunc,
function (func) {
return A2(andThen,
promiseValue,
function (value) {
return succeed(func(value));
});
});
});
var sequence = function (promises) {
return function () {
switch (promises.ctor)
{case "::": return A3(map2,
F2(function (x,y) {
return A2($List._op["::"],
x,
y);
}),
promises._0,
sequence(promises._1));
case "[]":
return succeed(_L.fromArray([]));}
_U.badCase($moduleName,
"between lines 101 and 106");
}();
};
var toMaybe = function (task) {
return A2(onError,
A2(map,$Maybe.Just,task),
function (_v3) {
return function () {
return succeed($Maybe.Nothing);
}();
});
};
var fromMaybe = F2(function ($default,
maybe) {
return function () {
switch (maybe.ctor)
{case "Just":
return succeed(maybe._0);
case "Nothing":
return fail($default);}
_U.badCase($moduleName,
"between lines 139 and 141");
}();
});
var toResult = function (task) {
return A2(onError,
A2(map,$Result.Ok,task),
function (msg) {
return succeed($Result.Err(msg));
});
};
var fromResult = function (result) {
return function () {
switch (result.ctor)
{case "Err":
return fail(result._0);
case "Ok":
return succeed(result._0);}
_U.badCase($moduleName,
"between lines 151 and 153");
}();
};
var Task = {ctor: "Task"};
_elm.Task.values = {_op: _op
,succeed: succeed
,fail: fail
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,andMap: andMap
,sequence: sequence
,andThen: andThen
,onError: onError
,mapError: mapError
,toMaybe: toMaybe
,fromMaybe: fromMaybe
,toResult: toResult
,fromResult: fromResult
,spawn: spawn
,sleep: sleep};
return _elm.Task.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Text",
$Color = Elm.Color.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Text = Elm.Native.Text.make(_elm);
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 append = $Native$Text.append;
var fromString = $Native$Text.fromString;
var empty = fromString("");
var concat = function (texts) {
return A3($List.foldr,
append,
empty,
texts);
};
var join = F2(function (seperator,
texts) {
return concat(A2($List.intersperse,
seperator,
texts));
});
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
,fromString: fromString
,empty: empty
,append: append
,concat: concat
,join: join
,link: link
,style: style
,defaultStyle: defaultStyle
,typeface: typeface
,monospace: monospace
,height: height
,color: color
,bold: bold
,italic: italic
,line: line
,Style: Style
,Under: Under
,Over: Over
,Through: Through};
return _elm.Text.values;
};
Elm.Todo = Elm.Todo || {};
Elm.Todo.make = function (_elm) {
"use strict";
_elm.Todo = _elm.Todo || {};
if (_elm.Todo.values)
return _elm.Todo.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Todo",
$Basics = Elm.Basics.make(_elm),
$Html = Elm.Html.make(_elm),
$Html$Attributes = Elm.Html.Attributes.make(_elm),
$Html$Events = Elm.Html.Events.make(_elm),
$Html$Lazy = Elm.Html.Lazy.make(_elm),
$Json$Decode = Elm.Json.Decode.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm),
$String = Elm.String.make(_elm);
var getStorage = Elm.Native.Port.make(_elm).inbound("getStorage",
"Maybe.Maybe Todo.Model",
function (v) {
return v === null ? Elm.Maybe.make(_elm).Nothing : Elm.Maybe.make(_elm).Just(typeof v === "object" && "tasks" in v && "field" in v && "uid" in v && "visibility" in v ? {_: {}
,tasks: typeof v.tasks === "object" && v.tasks instanceof Array ? Elm.Native.List.make(_elm).fromArray(v.tasks.map(function (v) {
return typeof v === "object" && "description" in v && "completed" in v && "editing" in v && "id" in v ? {_: {}
,description: typeof v.description === "string" || typeof v.description === "object" && v.description instanceof String ? v.description : _U.badPort("a string",
v.description)
,completed: typeof v.completed === "boolean" ? v.completed : _U.badPort("a boolean (true or false)",
v.completed)
,editing: typeof v.editing === "boolean" ? v.editing : _U.badPort("a boolean (true or false)",
v.editing)
,id: typeof v.id === "number" ? v.id : _U.badPort("a number",
v.id)} : _U.badPort("an object with fields `description`, `completed`, `editing`, `id`",
v);
})) : _U.badPort("an array",
v.tasks)
,field: typeof v.field === "string" || typeof v.field === "object" && v.field instanceof String ? v.field : _U.badPort("a string",
v.field)
,uid: typeof v.uid === "number" ? v.uid : _U.badPort("a number",
v.uid)
,visibility: typeof v.visibility === "string" || typeof v.visibility === "object" && v.visibility instanceof String ? v.visibility : _U.badPort("a string",
v.visibility)} : _U.badPort("an object with fields `tasks`, `field`, `uid`, `visibility`",
v));
});
var infoFooter = A2($Html.footer,
_L.fromArray([$Html$Attributes.id("info")]),
_L.fromArray([A2($Html.p,
_L.fromArray([]),
_L.fromArray([$Html.text("Double-click to edit a todo")]))
,A2($Html.p,
_L.fromArray([]),
_L.fromArray([$Html.text("Written by ")
,A2($Html.a,
_L.fromArray([$Html$Attributes.href("https://github.com/evancz")]),
_L.fromArray([$Html.text("Evan Czaplicki")]))]))
,A2($Html.p,
_L.fromArray([]),
_L.fromArray([$Html.text("Part of ")
,A2($Html.a,
_L.fromArray([$Html$Attributes.href("http://todomvc.com")]),
_L.fromArray([$Html.text("TodoMVC")]))]))]));
var is13 = function (code) {
return _U.eq(code,
13) ? $Result.Ok({ctor: "_Tuple0"}) : $Result.Err("not the right key code");
};
var onEnter = F2(function (address,
value) {
return A3($Html$Events.on,
"keydown",
A2($Json$Decode.customDecoder,
$Html$Events.keyCode,
is13),
function (_v0) {
return function () {
return A2($Signal.message,
address,
value);
}();
});
});
var ChangeVisibility = function (a) {
return {ctor: "ChangeVisibility"
,_0: a};
};
var visibilitySwap = F4(function (address,
uri,
visibility,
actualVisibility) {
return A2($Html.li,
_L.fromArray([A2($Html$Events.onClick,
address,
ChangeVisibility(visibility))]),
_L.fromArray([A2($Html.a,
_L.fromArray([$Html$Attributes.href(uri)
,$Html$Attributes.classList(_L.fromArray([{ctor: "_Tuple2"
,_0: "selected"
,_1: _U.eq(visibility,
actualVisibility)}]))]),
_L.fromArray([$Html.text(visibility)]))]));
});
var CheckAll = function (a) {
return {ctor: "CheckAll"
,_0: a};
};
var Check = F2(function (a,b) {
return {ctor: "Check"
,_0: a
,_1: b};
});
var DeleteComplete = {ctor: "DeleteComplete"};
var controls = F3(function (address,
visibility,
tasks) {
return function () {
var tasksCompleted = $List.length(A2($List.filter,
function (_) {
return _.completed;
},
tasks));
var tasksLeft = $List.length(tasks) - tasksCompleted;
var item_ = _U.eq(tasksLeft,
1) ? " item" : " items";
return A2($Html.footer,
_L.fromArray([$Html$Attributes.id("footer")
,$Html$Attributes.hidden($List.isEmpty(tasks))]),
_L.fromArray([A2($Html.span,
_L.fromArray([$Html$Attributes.id("todo-count")]),
_L.fromArray([A2($Html.strong,
_L.fromArray([]),
_L.fromArray([$Html.text($Basics.toString(tasksLeft))]))
,$Html.text(A2($Basics._op["++"],
item_,
" left"))]))
,A2($Html.ul,
_L.fromArray([$Html$Attributes.id("filters")]),
_L.fromArray([A4(visibilitySwap,
address,
"#/",
"All",
visibility)
,$Html.text(" ")
,A4(visibilitySwap,
address,
"#/active",
"Active",
visibility)
,$Html.text(" ")
,A4(visibilitySwap,
address,
"#/completed",
"Completed",
visibility)]))
,A2($Html.button,
_L.fromArray([$Html$Attributes.$class("clear-completed")
,$Html$Attributes.id("clear-completed")
,$Html$Attributes.hidden(_U.eq(tasksCompleted,
0))
,A2($Html$Events.onClick,
address,
DeleteComplete)]),
_L.fromArray([$Html.text(A2($Basics._op["++"],
"Clear completed (",
A2($Basics._op["++"],
$Basics.toString(tasksCompleted),
")")))]))]));
}();
});
var Delete = function (a) {
return {ctor: "Delete"
,_0: a};
};
var Add = {ctor: "Add"};
var UpdateTask = F2(function (a,
b) {
return {ctor: "UpdateTask"
,_0: a
,_1: b};
});
var EditingTask = F2(function (a,
b) {
return {ctor: "EditingTask"
,_0: a
,_1: b};
});
var todoItem = F2(function (address,
todo) {
return A2($Html.li,
_L.fromArray([$Html$Attributes.classList(_L.fromArray([{ctor: "_Tuple2"
,_0: "completed"
,_1: todo.completed}
,{ctor: "_Tuple2"
,_0: "editing"
,_1: todo.editing}]))]),
_L.fromArray([A2($Html.div,
_L.fromArray([$Html$Attributes.$class("view")]),
_L.fromArray([A2($Html.input,
_L.fromArray([$Html$Attributes.$class("toggle")
,$Html$Attributes.type$("checkbox")
,$Html$Attributes.checked(todo.completed)
,A2($Html$Events.onClick,
address,
A2(Check,
todo.id,
$Basics.not(todo.completed)))]),
_L.fromArray([]))
,A2($Html.label,
_L.fromArray([A2($Html$Events.onDoubleClick,
address,
A2(EditingTask,todo.id,true))]),
_L.fromArray([$Html.text(todo.description)]))
,A2($Html.button,
_L.fromArray([$Html$Attributes.$class("destroy")
,A2($Html$Events.onClick,
address,
Delete(todo.id))]),
_L.fromArray([]))]))
,A2($Html.input,
_L.fromArray([$Html$Attributes.$class("edit")
,$Html$Attributes.value(todo.description)
,$Html$Attributes.name("title")
,$Html$Attributes.id(A2($Basics._op["++"],
"todo-",
$Basics.toString(todo.id)))
,A3($Html$Events.on,
"input",
$Html$Events.targetValue,
function ($) {
return $Signal.message(address)(UpdateTask(todo.id)($));
})
,A2($Html$Events.onBlur,
address,
A2(EditingTask,todo.id,false))
,A2(onEnter,
address,
A2(EditingTask,
todo.id,
false))]),
_L.fromArray([]))]));
});
var taskList = F3(function (address,
visibility,
tasks) {
return function () {
var cssVisibility = $List.isEmpty(tasks) ? "hidden" : "visible";
var allCompleted = A2($List.all,
function (_) {
return _.completed;
},
tasks);
var isVisible = function (todo) {
return function () {
switch (visibility)
{case "Active":
return $Basics.not(todo.completed);
case "All": return true;
case "Completed":
return todo.completed;}
_U.badCase($moduleName,
"between lines 184 and 189");
}();
};
return A2($Html.section,
_L.fromArray([$Html$Attributes.id("main")
,$Html$Attributes.style(_L.fromArray([{ctor: "_Tuple2"
,_0: "visibility"
,_1: cssVisibility}]))]),
_L.fromArray([A2($Html.input,
_L.fromArray([$Html$Attributes.id("toggle-all")
,$Html$Attributes.type$("checkbox")
,$Html$Attributes.name("toggle")
,$Html$Attributes.checked(allCompleted)
,A2($Html$Events.onClick,
address,
CheckAll($Basics.not(allCompleted)))]),
_L.fromArray([]))
,A2($Html.label,
_L.fromArray([$Html$Attributes.$for("toggle-all")]),
_L.fromArray([$Html.text("Mark all as complete")]))
,A2($Html.ul,
_L.fromArray([$Html$Attributes.id("todo-list")]),
A2($List.map,
todoItem(address),
A2($List.filter,
isVisible,
tasks)))]));
}();
});
var UpdateField = function (a) {
return {ctor: "UpdateField"
,_0: a};
};
var taskEntry = F2(function (address,
task) {
return A2($Html.header,
_L.fromArray([$Html$Attributes.id("header")]),
_L.fromArray([A2($Html.h1,
_L.fromArray([]),
_L.fromArray([$Html.text("todos")]))
,A2($Html.input,
_L.fromArray([$Html$Attributes.id("new-todo")
,$Html$Attributes.placeholder("What needs to be done?")
,$Html$Attributes.autofocus(true)
,$Html$Attributes.value(task)
,$Html$Attributes.name("newTodo")
,A3($Html$Events.on,
"input",
$Html$Events.targetValue,
function ($) {
return $Signal.message(address)(UpdateField($));
})
,A2(onEnter,address,Add)]),
_L.fromArray([]))]));
});
var view = F2(function (address,
model) {
return A2($Html.div,
_L.fromArray([$Html$Attributes.$class("todomvc-wrapper")
,$Html$Attributes.style(_L.fromArray([{ctor: "_Tuple2"
,_0: "visibility"
,_1: "hidden"}]))]),
_L.fromArray([A2($Html.section,
_L.fromArray([$Html$Attributes.id("todoapp")]),
_L.fromArray([A3($Html$Lazy.lazy2,
taskEntry,
address,
model.field)
,A4($Html$Lazy.lazy3,
taskList,
address,
model.visibility,
model.tasks)
,A4($Html$Lazy.lazy3,
controls,
address,
model.visibility,
model.tasks)]))
,infoFooter]));
});
var NoOp = {ctor: "NoOp"};
var actions = $Signal.mailbox(NoOp);
var focus = Elm.Native.Port.make(_elm).outboundSignal("focus",
function (v) {
return v;
},
function () {
var toSelector = function (_v3) {
return function () {
switch (_v3.ctor)
{case "EditingTask":
return A2($Basics._op["++"],
"#todo-",
$Basics.toString(_v3._0));}
_U.badCase($moduleName,
"on line 336, column 42 to 65");
}();
};
var needsFocus = function (act) {
return function () {
switch (act.ctor)
{case "EditingTask":
return act._1;}
return false;
}();
};
return $Signal.map(toSelector)(A2($Signal.filter,
needsFocus,
A2(EditingTask,
0,
true))(actions.signal));
}());
var emptyModel = {_: {}
,field: ""
,tasks: _L.fromArray([])
,uid: 0
,visibility: "All"};
var initialModel = A2($Maybe.withDefault,
emptyModel,
getStorage);
var newTask = F2(function (desc,
id) {
return {_: {}
,completed: false
,description: desc
,editing: false
,id: id};
});
var update = F2(function (action,
model) {
return function () {
switch (action.ctor)
{case "Add":
return _U.replace([["uid"
,model.uid + 1]
,["field",""]
,["tasks"
,$String.isEmpty(model.field) ? model.tasks : A2($Basics._op["++"],
model.tasks,
_L.fromArray([A2(newTask,
model.field,
model.uid)]))]],
model);
case "ChangeVisibility":
return _U.replace([["visibility"
,action._0]],
model);
case "Check":
return function () {
var updateTask = function (t) {
return _U.eq(t.id,
action._0) ? _U.replace([["completed"
,action._1]],
t) : t;
};
return _U.replace([["tasks"
,A2($List.map,
updateTask,
model.tasks)]],
model);
}();
case "CheckAll":
return function () {
var updateTask = function (t) {
return _U.replace([["completed"
,action._0]],
t);
};
return _U.replace([["tasks"
,A2($List.map,
updateTask,
model.tasks)]],
model);
}();
case "Delete":
return _U.replace([["tasks"
,A2($List.filter,
function (t) {
return !_U.eq(t.id,
action._0);
},
model.tasks)]],
model);
case "DeleteComplete":
return _U.replace([["tasks"
,A2($List.filter,
function ($) {
return $Basics.not(function (_) {
return _.completed;
}($));
},
model.tasks)]],
model);
case "EditingTask":
return function () {
var updateTask = function (t) {
return _U.eq(t.id,
action._0) ? _U.replace([["editing"
,action._1]],
t) : t;
};
return _U.replace([["tasks"
,A2($List.map,
updateTask,
model.tasks)]],
model);
}();
case "NoOp": return model;
case "UpdateField":
return _U.replace([["field"
,action._0]],
model);
case "UpdateTask":
return function () {
var updateTask = function (t) {
return _U.eq(t.id,
action._0) ? _U.replace([["description"
,action._1]],
t) : t;
};
return _U.replace([["tasks"
,A2($List.map,
updateTask,
model.tasks)]],
model);
}();}
_U.badCase($moduleName,
"between lines 87 and 130");
}();
});
var model = A3($Signal.foldp,
update,
initialModel,
actions.signal);
var main = A2($Signal.map,
view(actions.address),
model);
var setStorage = Elm.Native.Port.make(_elm).outboundSignal("setStorage",
function (v) {
return {tasks: Elm.Native.List.make(_elm).toArray(v.tasks).map(function (v) {
return {description: v.description
,completed: v.completed
,editing: v.editing
,id: v.id};
})
,field: v.field
,uid: v.uid
,visibility: v.visibility};
},
model);
var Task = F4(function (a,
b,
c,
d) {
return {_: {}
,completed: b
,description: a
,editing: c
,id: d};
});
var Model = F4(function (a,
b,
c,
d) {
return {_: {}
,field: b
,tasks: a
,uid: c
,visibility: d};
});
_elm.Todo.values = {_op: _op
,Model: Model
,Task: Task
,newTask: newTask
,emptyModel: emptyModel
,NoOp: NoOp
,UpdateField: UpdateField
,EditingTask: EditingTask
,UpdateTask: UpdateTask
,Add: Add
,Delete: Delete
,DeleteComplete: DeleteComplete
,Check: Check
,CheckAll: CheckAll
,ChangeVisibility: ChangeVisibility
,update: update
,view: view
,onEnter: onEnter
,is13: is13
,taskEntry: taskEntry
,taskList: taskList
,todoItem: todoItem
,controls: controls
,visibilitySwap: visibilitySwap
,infoFooter: infoFooter
,main: main
,model: model
,initialModel: initialModel
,actions: actions};
return _elm.Todo.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Transform2D",
$Native$Transform2D = Elm.Native.Transform2D.make(_elm);
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
,multiply: multiply
,rotation: rotation
,translation: translation
,scale: scale
,scaleX: scaleX
,scaleY: scaleY};
return _elm.Transform2D.values;
};
Elm.VirtualDom = Elm.VirtualDom || {};
Elm.VirtualDom.make = function (_elm) {
"use strict";
_elm.VirtualDom = _elm.VirtualDom || {};
if (_elm.VirtualDom.values)
return _elm.VirtualDom.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "VirtualDom",
$Basics = Elm.Basics.make(_elm),
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$Json$Decode = Elm.Json.Decode.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$VirtualDom = Elm.Native.VirtualDom.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm);
var lazy3 = $Native$VirtualDom.lazy3;
var lazy2 = $Native$VirtualDom.lazy2;
var lazy = $Native$VirtualDom.lazy;
var on = $Native$VirtualDom.on;
var attribute = $Native$VirtualDom.attribute;
var property = $Native$VirtualDom.property;
var Property = {ctor: "Property"};
var fromElement = $Native$VirtualDom.fromElement;
var toElement = $Native$VirtualDom.toElement;
var text = $Native$VirtualDom.text;
var node = $Native$VirtualDom.node;
var Node = {ctor: "Node"};
_elm.VirtualDom.values = {_op: _op
,Node: Node
,node: node
,text: text
,toElement: toElement
,fromElement: fromElement
,Property: Property
,property: property
,attribute: attribute
,on: on
,lazy: lazy
,lazy2: lazy2
,lazy3: lazy3};
return _elm.VirtualDom.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Window",
$Basics = Elm.Basics.make(_elm),
$Native$Window = Elm.Native.Window.make(_elm),
$Signal = Elm.Signal.make(_elm);
var dimensions = $Native$Window.dimensions;
var width = A2($Signal.map,
$Basics.fst,
dimensions);
var height = A2($Signal.map,
$Basics.snd,
dimensions);
_elm.Window.values = {_op: _op
,dimensions: dimensions
,width: width
,height: height};
return _elm.Window.values;
};
Raw
DCE
Elm.Array = Elm.Array || {};
Elm.Array.make = function(_elm){
"use strict";
_elm.Array = _elm.Array || {};
if (_elm.Array.values)
return _elm.Array.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Array",
$Basics = Elm.Basics.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Array = Elm.Native.Array.make(_elm);var toList = $Native$Array.toList;_elm.Array.values = { _op : _op,
toList : toList};
return _elm.Array.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Basics",
$Native$Basics = Elm.Native.Basics.make(_elm),
$Native$Show = Elm.Native.Show.make(_elm),
$Native$Utils = Elm.Native.Utils.make(_elm);var snd = function (_v1) {
var _ = _v1;
var b = function () {
switch (_.ctor)
{case "_Tuple2": return _._1;}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
}();
return b;
};
var fst = function (_v5) {
var _ = _v5;
var a = function () {
switch (_.ctor)
{case "_Tuple2": return _._0;}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
}();
return a;
};
_op["<|"] = F2(function (f,x) {
return f(x);
});
_op["|>"] = F2(function (x,f) {
return f(x);
});
_op["<<"] = F3(function (g,
f,
x) {
return g(f(x));
});
_op["++"] = $Native$Utils.append;
var toString = $Native$Show.toString;
var not = $Native$Basics.not;
_op["||"] = $Native$Basics.or;
_op["&&"] = $Native$Basics.and;
var compare = $Native$Basics.compare;
_op[">="] = $Native$Basics.ge;
_op["<="] = $Native$Basics.le;
_op["/="] = $Native$Basics.neq;
_op["=="] = $Native$Basics.eq;
_op["-"] = $Native$Basics.sub;
_op["+"] = $Native$Basics.add;_elm.Basics.values = { _op : _op,
compare : compare,
not : not,
toString : toString,
fst : fst,
snd : snd};
return _elm.Basics.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Char",
$Basics = Elm.Basics.make(_elm),
$Native$Char = Elm.Native.Char.make(_elm);var toCode = $Native$Char.toCode;
var isBetween = F3(function (low,
high,
$char) {
var code = toCode($char);
return _U.cmp(code,
toCode(low)) > -1 && _U.cmp(code,
toCode(high)) < 1;
});
var isDigit = A2(isBetween,
_U.chr("0"),
_U.chr("9"));_elm.Char.values = { _op : _op,
isDigit : isDigit,
toCode : toCode};
return _elm.Char.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Color",
$Basics = Elm.Basics.make(_elm);_elm.Color.values = { _op : _op};
return _elm.Color.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Debug",
$Graphics$Collage = Elm.Graphics.Collage.make(_elm),
$Native$Debug = Elm.Native.Debug.make(_elm);_elm.Debug.values = { _op : _op};
return _elm.Debug.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Dict",
$Basics = Elm.Basics.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Debug = Elm.Native.Debug.make(_elm),
$String = Elm.String.make(_elm);var foldr = F3(function (f,
acc,
t) {
_v0: while (true) {
switch (t.ctor)
{case "RBEmpty":
switch (t._0.ctor)
{case "LBlack": return acc;}
break;
case "RBNode": var _v8 = f,
_v9 = A3(f,
t._1,
t._2,
A3(foldr,f,acc,t._4)),
_v10 = t._3;
f = _v8;
acc = _v9;
t = _v10;
continue _v0;}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
}
});
var toList = function (dict) {
return A3(foldr,
F3(function (key,value,list) {
return A2($List._op["::"],
{ctor: "_Tuple2"
,_0: key
,_1: value},
list);
}),
_L.fromArray([]),
dict);
};
var isBBlack = function (dict) {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBBlack": return true;}
break;
case "RBNode":
switch (dict._0.ctor)
{case "BBlack": return true;}
break;}
return false;
};
var Same = {ctor: "Same"};
var Remove = {ctor: "Remove"};
var Insert = {ctor: "Insert"};
var max = function (dict) {
_v45: while (true) {
switch (dict.ctor)
{case "RBEmpty":
return $Native$Debug.crash("(max Empty) is not defined");
case "RBNode":
switch (dict._4.ctor)
{case "RBEmpty":
return {ctor: "_Tuple2"
,_0: dict._1
,_1: dict._2};}
var _v54 = dict._4;
dict = _v54;
continue _v45;}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
}
};
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 showLColor = function (color) {
switch (color.ctor)
{case "LBBlack":
return "LBBlack";
case "LBlack": return "LBlack";}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
};
var LBBlack = {ctor: "LBBlack"};
var LBlack = {ctor: "LBlack"};
var empty = RBEmpty(LBlack);
var showNColor = function (c) {
switch (c.ctor)
{case "BBlack": return "BBlack";
case "Black": return "Black";
case "NBlack": return "NBlack";
case "Red": return "Red";}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
};
var reportRemBug = F4(function (msg,
c,
lgot,
rgot) {
return $Native$Debug.crash($String.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 NBlack = {ctor: "NBlack"};
var BBlack = {ctor: "BBlack"};
var Black = {ctor: "Black"};
var ensureBlackRoot = function (dict) {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack": return dict;}
break;
case "RBNode":
switch (dict._0.ctor)
{case "Black": return dict;
case "Red": return A5(RBNode,
Black,
dict._1,
dict._2,
dict._3,
dict._4);}
break;}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
};
var blackish = function (t) {
switch (t.ctor)
{case "RBEmpty": return true;
case "RBNode":
return _U.eq(t._0,
Black) || _U.eq(t._0,BBlack);}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
};
var blacken = function (t) {
switch (t.ctor)
{case "RBEmpty":
return RBEmpty(LBlack);
case "RBNode": return A5(RBNode,
Black,
t._1,
t._2,
t._3,
t._4);}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
};
var Red = {ctor: "Red"};
var moreBlack = function (color) {
switch (color.ctor)
{case "BBlack":
return $Native$Debug.crash("Can\'t make a double black node more black!");
case "Black": return BBlack;
case "NBlack": return Red;
case "Red": return Black;}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
};
var lessBlack = function (color) {
switch (color.ctor)
{case "BBlack": return Black;
case "Black": return Red;
case "NBlack":
return $Native$Debug.crash("Can\'t make a negative black node less black!");
case "Red": return NBlack;}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
};
var lessBlackTree = function (dict) {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBBlack":
return RBEmpty(LBlack);}
break;
case "RBNode": return A5(RBNode,
lessBlack(dict._0),
dict._1,
dict._2,
dict._3,
dict._4);}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
};
var redden = function (t) {
switch (t.ctor)
{case "RBEmpty":
return $Native$Debug.crash("can\'t make a Leaf red");
case "RBNode": return A5(RBNode,
Red,
t._1,
t._2,
t._3,
t._4);}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
};
var balance_node = function (t) {
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));
};
};
};
};
};
};
};
};
};
};
};
if (blackish(t)) {
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":
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":
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;
} else return 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) {
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));}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
});
var rem = F3(function (c,l,r) {
var _v186 = {ctor: "_Tuple2"
,_0: l
,_1: r};
switch (_v186.ctor)
{case "_Tuple2":
switch (_v186._0.ctor)
{case "RBEmpty":
switch (_v186._1.ctor)
{case "RBEmpty": switch (c.ctor)
{case "Black":
return RBEmpty(LBBlack);
case "Red":
return RBEmpty(LBlack);}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
case "RBNode":
var _v208 = {ctor: "_Tuple3"
,_0: c
,_1: _v186._0._0
,_2: _v186._1._0};
switch (_v208.ctor)
{case "_Tuple3":
switch (_v208._0.ctor)
{case "Black":
switch (_v208._1.ctor)
{case "LBlack":
switch (_v208._2.ctor)
{case "Red": return A5(RBNode,
Black,
_v186._1._1,
_v186._1._2,
_v186._1._3,
_v186._1._4);}
break;}
break;}
break;}
return A4(reportRemBug,
"Black/LBlack/Red",
c,
showLColor(_v186._0._0),
showNColor(_v186._1._0));}
break;
case "RBNode":
switch (_v186._1.ctor)
{case "RBEmpty":
var _v212 = {ctor: "_Tuple3"
,_0: c
,_1: _v186._0._0
,_2: _v186._1._0};
switch (_v212.ctor)
{case "_Tuple3":
switch (_v212._0.ctor)
{case "Black":
switch (_v212._1.ctor)
{case "Red":
switch (_v212._2.ctor)
{case "LBlack":
return A5(RBNode,
Black,
_v186._0._1,
_v186._0._2,
_v186._0._3,
_v186._0._4);}
break;}
break;}
break;}
return A4(reportRemBug,
"Black/Red/LBlack",
c,
showNColor(_v186._0._0),
showLColor(_v186._1._0));
case "RBNode":
var l$ = A5(remove_max,
_v186._0._0,
_v186._0._1,
_v186._0._2,
_v186._0._3,
_v186._0._4);
var r = A5(RBNode,
_v186._1._0,
_v186._1._1,
_v186._1._2,
_v186._1._3,
_v186._1._4);
var l = A5(RBNode,
_v186._0._0,
_v186._0._1,
_v186._0._2,
_v186._0._3,
_v186._0._4);
var $ = max(l),
k = $._0,
v = $._1;
return A5(bubble,c,k,v,l$,r);}
break;}
break;}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
});
var update = F3(function (k,
alter,
dict) {
var up = function (dict) {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack":
var _v223 = alter($Maybe.Nothing);
switch (_v223.ctor)
{case "Just":
return {ctor: "_Tuple2"
,_0: Insert
,_1: A5(RBNode,
Red,
k,
_v223._0,
empty,
empty)};
case "Nothing":
return {ctor: "_Tuple2"
,_0: Same
,_1: empty};}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");}
break;
case "RBNode":
var _v225 = A2($Basics.compare,
k,
dict._1);
switch (_v225.ctor)
{case "EQ":
var _v226 = alter($Maybe.Just(dict._2));
switch (_v226.ctor)
{case "Just":
return {ctor: "_Tuple2"
,_0: Same
,_1: A5(RBNode,
dict._0,
dict._1,
_v226._0,
dict._3,
dict._4)};
case "Nothing":
return {ctor: "_Tuple2"
,_0: Remove
,_1: A3(rem,
dict._0,
dict._3,
dict._4)};}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
case "GT": var $ = up(dict._4),
flag = $._0,
newRight = $._1;
switch (flag.ctor)
{case "Insert":
return {ctor: "_Tuple2"
,_0: Insert
,_1: A5(balance,
dict._0,
dict._1,
dict._2,
dict._3,
newRight)};
case "Remove":
return {ctor: "_Tuple2"
,_0: Remove
,_1: A5(bubble,
dict._0,
dict._1,
dict._2,
dict._3,
newRight)};
case "Same":
return {ctor: "_Tuple2"
,_0: Same
,_1: A5(RBNode,
dict._0,
dict._1,
dict._2,
dict._3,
newRight)};}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
case "LT": var $ = up(dict._3),
flag = $._0,
newLeft = $._1;
switch (flag.ctor)
{case "Insert":
return {ctor: "_Tuple2"
,_0: Insert
,_1: A5(balance,
dict._0,
dict._1,
dict._2,
newLeft,
dict._4)};
case "Remove":
return {ctor: "_Tuple2"
,_0: Remove
,_1: A5(bubble,
dict._0,
dict._1,
dict._2,
newLeft,
dict._4)};
case "Same":
return {ctor: "_Tuple2"
,_0: Same
,_1: A5(RBNode,
dict._0,
dict._1,
dict._2,
newLeft,
dict._4)};}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
};
var $ = up(dict),
flag = $._0,
updatedDict = $._1;
switch (flag.ctor)
{case "Insert":
return ensureBlackRoot(updatedDict);
case "Remove":
return blacken(updatedDict);
case "Same":
return updatedDict;}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
});_elm.Dict.values = { _op : _op,
empty : empty,
update : update,
foldr : foldr,
toList : toList};
return _elm.Dict.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Graphics.Collage",
$Basics = Elm.Basics.make(_elm),
$Color = Elm.Color.make(_elm),
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$List = Elm.List.make(_elm),
$Native$Graphics$Collage = Elm.Native.Graphics.Collage.make(_elm),
$Text = Elm.Text.make(_elm),
$Transform2D = Elm.Transform2D.make(_elm);_elm.Graphics.Collage.values = { _op : _op};
return _elm.Graphics.Collage.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Graphics.Element",
$Basics = Elm.Basics.make(_elm),
$Color = Elm.Color.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Graphics$Element = Elm.Native.Graphics.Element.make(_elm),
$Text = Elm.Text.make(_elm);_elm.Graphics.Element.values = { _op : _op};
return _elm.Graphics.Element.values;};Elm.Html = Elm.Html || {};
Elm.Html.make = function(_elm){
"use strict";
_elm.Html = _elm.Html || {};
if (_elm.Html.values)
return _elm.Html.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Html",
$Basics = Elm.Basics.make(_elm),
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm),
$VirtualDom = Elm.VirtualDom.make(_elm);var text = $VirtualDom.text;
var node = $VirtualDom.node;
var section = node("section");
var h1 = node("h1");
var header = node("header");
var footer = node("footer");
var p = node("p");
var ul = node("ul");
var li = node("li");
var div = node("div");
var a = node("a");
var strong = node("strong");
var span = node("span");
var label = node("label");
var input = node("input");
var button = node("button");_elm.Html.values = { _op : _op,
node : node,
text : text,
section : section,
h1 : h1,
header : header,
footer : footer,
p : p,
ul : ul,
li : li,
div : div,
a : a,
strong : strong,
span : span,
label : label,
input : input,
button : button};
return _elm.Html.values;};Elm.Html = Elm.Html || {};
Elm.Html.Attributes = Elm.Html.Attributes || {};
Elm.Html.Attributes.make = function(_elm){
"use strict";
_elm.Html = _elm.Html || {};
_elm.Html.Attributes = _elm.Html.Attributes || {};
if (_elm.Html.Attributes.values)
return _elm.Html.Attributes.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Html.Attributes",
$Basics = Elm.Basics.make(_elm),
$Html = Elm.Html.make(_elm),
$Json$Encode = Elm.Json.Encode.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm),
$String = Elm.String.make(_elm),
$VirtualDom = Elm.VirtualDom.make(_elm);var property = $VirtualDom.property;
var stringProperty = F2(function (name,
string) {
return A2(property,
name,
$Json$Encode.string(string));
});
var $class = function (name) {
return A2(stringProperty,
"className",
name);
};
var id = function (name) {
return A2(stringProperty,
"id",
name);
};
var type$ = function (value) {
return A2(stringProperty,
"type",
value);
};
var value = function (value) {
return A2(stringProperty,
"value",
value);
};
var placeholder = function (value) {
return A2(stringProperty,
"placeholder",
value);
};
var name = function (value) {
return A2(stringProperty,
"name",
value);
};
var $for = function (value) {
return A2(stringProperty,
"htmlFor",
value);
};
var href = function (value) {
return A2(stringProperty,
"href",
value);
};
var boolProperty = F2(function (name,
bool) {
return A2(property,
name,
$Json$Encode.bool(bool));
});
var hidden = function (bool) {
return A2(boolProperty,
"hidden",
bool);
};
var checked = function (bool) {
return A2(boolProperty,
"checked",
bool);
};
var autofocus = function (bool) {
return A2(boolProperty,
"autofocus",
bool);
};
var classList = function (list) {
return $class($String.join(" ")($List.map($Basics.fst)($List.filter($Basics.snd)(list))));
};
var style = function (props) {
return property("style")($Json$Encode.object($List.map(function (_v0) {
var $ = _v0,
key = $._0,
value = $._1;
return {ctor: "_Tuple2"
,_0: key
,_1: $Json$Encode.string(value)};
})(props)));
};_elm.Html.Attributes.values = { _op : _op,
style : style,
classList : classList,
property : property,
stringProperty : stringProperty,
boolProperty : boolProperty,
$class : $class,
hidden : hidden,
id : id,
type$ : type$,
value : value,
checked : checked,
placeholder : placeholder,
autofocus : autofocus,
name : name,
$for : $for,
href : href};
return _elm.Html.Attributes.values;};Elm.Html = Elm.Html || {};
Elm.Html.Events = Elm.Html.Events || {};
Elm.Html.Events.make = function(_elm){
"use strict";
_elm.Html = _elm.Html || {};
_elm.Html.Events = _elm.Html.Events || {};
if (_elm.Html.Events.values)
return _elm.Html.Events.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Html.Events",
$Basics = Elm.Basics.make(_elm),
$Html = Elm.Html.make(_elm),
$Json$Decode = Elm.Json.Decode.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm),
$VirtualDom = Elm.VirtualDom.make(_elm);var keyCode = A2($Json$Decode._op[":="],
"keyCode",
$Json$Decode.$int);
var targetValue = A2($Json$Decode.at,
_L.fromArray(["target"
,"value"]),
$Json$Decode.string);
var on = $VirtualDom.on;
var messageOn = F3(function (name,
addr,
msg) {
return A3(on,
name,
$Json$Decode.value,
function (_v0) {
var _ = _v0;
return A2($Signal.message,
addr,
msg);
});
});
var onClick = messageOn("click");
var onDoubleClick = messageOn("dblclick");
var onBlur = messageOn("blur");_elm.Html.Events.values = { _op : _op,
onBlur : onBlur,
onClick : onClick,
onDoubleClick : onDoubleClick,
on : on,
targetValue : targetValue,
keyCode : keyCode};
return _elm.Html.Events.values;};Elm.Html = Elm.Html || {};
Elm.Html.Lazy = Elm.Html.Lazy || {};
Elm.Html.Lazy.make = function(_elm){
"use strict";
_elm.Html = _elm.Html || {};
_elm.Html.Lazy = _elm.Html.Lazy || {};
if (_elm.Html.Lazy.values)
return _elm.Html.Lazy.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Html.Lazy",
$Basics = Elm.Basics.make(_elm),
$Html = Elm.Html.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm),
$VirtualDom = Elm.VirtualDom.make(_elm);var lazy3 = $VirtualDom.lazy3;
var lazy2 = $VirtualDom.lazy2;_elm.Html.Lazy.values = { _op : _op,
lazy2 : lazy2,
lazy3 : lazy3};
return _elm.Html.Lazy.values;};Elm.Json = Elm.Json || {};
Elm.Json.Decode = Elm.Json.Decode || {};
Elm.Json.Decode.make = function(_elm){
"use strict";
_elm.Json = _elm.Json || {};
_elm.Json.Decode = _elm.Json.Decode || {};
if (_elm.Json.Decode.values)
return _elm.Json.Decode.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Json.Decode",
$Array = Elm.Array.make(_elm),
$Dict = Elm.Dict.make(_elm),
$Json$Encode = Elm.Json.Encode.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Json = Elm.Native.Json.make(_elm),
$Result = Elm.Result.make(_elm);var customDecoder = $Native$Json.customDecoder;
var value = $Native$Json.decodeValue;
var $int = $Native$Json.decodeInt;
var string = $Native$Json.decodeString;
_op[":="] = $Native$Json.decodeField;
var at = F2(function (fields,
decoder) {
return A3($List.foldr,
F2(function (x,y) {
return A2(_op[":="],x,y);
}),
decoder,
fields);
});_elm.Json.Decode.values = { _op : _op,
string : string,
$int : $int,
at : at,
value : value,
customDecoder : customDecoder};
return _elm.Json.Decode.values;};Elm.Json = Elm.Json || {};
Elm.Json.Encode = Elm.Json.Encode || {};
Elm.Json.Encode.make = function(_elm){
"use strict";
_elm.Json = _elm.Json || {};
_elm.Json.Encode = _elm.Json.Encode || {};
if (_elm.Json.Encode.values)
return _elm.Json.Encode.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Json.Encode",
$Array = Elm.Array.make(_elm),
$Native$Json = Elm.Native.Json.make(_elm);var object = $Native$Json.encodeObject;
var bool = $Native$Json.identity;
var string = $Native$Json.identity;_elm.Json.Encode.values = { _op : _op,
string : string,
bool : bool,
object : object};
return _elm.Json.Encode.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "List",
$Basics = Elm.Basics.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$List = Elm.Native.List.make(_elm);var any = $Native$List.any;
var all = F2(function (pred,
xs) {
return $Basics.not(A2(any,
function ($) {
return $Basics.not(pred($));
},
xs));
});
var foldr = $Native$List.foldr;
var foldl = $Native$List.foldl;
var length = function (xs) {
return A3(foldl,
F2(function (_v0,i) {
var _ = _v0;
return i + 1;
}),
0,
xs);
};
var isEmpty = function (xs) {
switch (xs.ctor)
{case "[]": return true;}
return false;
};
_op["::"] = $Native$List.cons;
var map = F2(function (f,xs) {
return A3(foldr,
F2(function (x,acc) {
return A2(_op["::"],
f(x),
acc);
}),
_L.fromArray([]),
xs);
});
var filter = F2(function (pred,
xs) {
var conditionalCons = F2(function (x,
xs$) {
return pred(x) ? A2(_op["::"],
x,
xs$) : xs$;
});
return A3(foldr,
conditionalCons,
_L.fromArray([]),
xs);
});_elm.List.values = { _op : _op,
isEmpty : isEmpty,
length : length,
filter : filter,
map : map,
foldr : foldr,
foldl : foldl,
all : all,
any : any};
return _elm.List.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Maybe";var withDefault = F2(function ($default,
maybe) {
switch (maybe.ctor)
{case "Just": return maybe._0;
case "Nothing":
return $default;}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
});
var Nothing = {ctor: "Nothing"};
var Just = function (a) {
return {ctor: "Just",_0: a};
};_elm.Maybe.values = { _op : _op,
withDefault : withDefault,
Just : Just,
Nothing : Nothing};
return _elm.Maybe.values;};Elm.Result = Elm.Result || {};
Elm.Result.make = function(_elm){
"use strict";
_elm.Result = _elm.Result || {};
if (_elm.Result.values)
return _elm.Result.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Result",
$Maybe = Elm.Maybe.make(_elm);var Err = function (a) {
return {ctor: "Err",_0: a};
};
var Ok = function (a) {
return {ctor: "Ok",_0: a};
};_elm.Result.values = { _op : _op,
Ok : Ok,
Err : Err};
return _elm.Result.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Signal",
$Basics = Elm.Basics.make(_elm),
$Debug = Elm.Debug.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Signal = Elm.Native.Signal.make(_elm),
$Task = Elm.Task.make(_elm);var Message = function (a) {
return {ctor: "Message"
,_0: a};
};
var message = F2(function (_v2,
value) {
var _raw = _v2,
$ = _raw.ctor === "Address" ? _raw : _U.badCase($moduleName,
"bugs in reporting the exact location right now"),
send = $._0;
return Message(send(value));
});
var mailbox = $Native$Signal.mailbox;
var filterMap = $Native$Signal.filterMap;
var filter = F3(function (isOk,
base,
signal) {
return A3(filterMap,
function (value) {
return isOk(value) ? $Maybe.Just(value) : $Maybe.Nothing;
},
base,
signal);
});
var foldp = $Native$Signal.foldp;
var map2 = $Native$Signal.map2;
var map = $Native$Signal.map;
var constant = $Native$Signal.constant;_elm.Signal.values = { _op : _op,
map : map,
map2 : map2,
constant : constant,
filter : filter,
filterMap : filterMap,
foldp : foldp,
mailbox : mailbox,
message : message};
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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "String",
$Maybe = Elm.Maybe.make(_elm),
$Native$String = Elm.Native.String.make(_elm),
$Result = Elm.Result.make(_elm);var join = $Native$String.join;
var concat = $Native$String.concat;
var isEmpty = $Native$String.isEmpty;_elm.String.values = { _op : _op,
isEmpty : isEmpty,
concat : concat,
join : join};
return _elm.String.values;};Elm.Task = Elm.Task || {};
Elm.Task.make = function(_elm){
"use strict";
_elm.Task = _elm.Task || {};
if (_elm.Task.values)
return _elm.Task.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Task",
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Task = Elm.Native.Task.make(_elm),
$Result = Elm.Result.make(_elm);_elm.Task.values = { _op : _op};
return _elm.Task.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Text",
$Color = Elm.Color.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Text = Elm.Native.Text.make(_elm);_elm.Text.values = { _op : _op};
return _elm.Text.values;};Elm.Todo = Elm.Todo || {};
Elm.Todo.make = function(_elm){
"use strict";
_elm.Todo = _elm.Todo || {};
if (_elm.Todo.values)
return _elm.Todo.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Todo",
$Basics = Elm.Basics.make(_elm),
$Html = Elm.Html.make(_elm),
$Html$Attributes = Elm.Html.Attributes.make(_elm),
$Html$Events = Elm.Html.Events.make(_elm),
$Html$Lazy = Elm.Html.Lazy.make(_elm),
$Json$Decode = Elm.Json.Decode.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm),
$String = Elm.String.make(_elm);var getStorage = Elm.Native.Port.make(_elm).inbound("getStorage",
"Maybe.Maybe Todo.Model",
function (v) {
return v === null ? Elm.Maybe.make(_elm).Nothing : Elm.Maybe.make(_elm).Just(typeof v === "object" && "tasks" in v && "field" in v && "uid" in v && "visibility" in v ? {_: {}
,tasks: typeof v.tasks === "object" && v.tasks instanceof Array ? Elm.Native.List.make(_elm).fromArray(v.tasks.map(function (v) {
return typeof v === "object" && "description" in v && "completed" in v && "editing" in v && "id" in v ? {_: {}
,description: typeof v.description === "string" || typeof v.description === "object" && v.description instanceof String ? v.description : _U.badPort("a string",
v.description)
,completed: typeof v.completed === "boolean" ? v.completed : _U.badPort("a boolean (true or false)",
v.completed)
,editing: typeof v.editing === "boolean" ? v.editing : _U.badPort("a boolean (true or false)",
v.editing)
,id: typeof v.id === "number" ? v.id : _U.badPort("a number",
v.id)} : _U.badPort("an object with fields `description`, `completed`, `editing`, `id`",
v);
})) : _U.badPort("an array",
v.tasks)
,field: typeof v.field === "string" || typeof v.field === "object" && v.field instanceof String ? v.field : _U.badPort("a string",
v.field)
,uid: typeof v.uid === "number" ? v.uid : _U.badPort("a number",
v.uid)
,visibility: typeof v.visibility === "string" || typeof v.visibility === "object" && v.visibility instanceof String ? v.visibility : _U.badPort("a string",
v.visibility)} : _U.badPort("an object with fields `tasks`, `field`, `uid`, `visibility`",
v));
});
var infoFooter = A2($Html.footer,
_L.fromArray([$Html$Attributes.id("info")]),
_L.fromArray([A2($Html.p,
_L.fromArray([]),
_L.fromArray([$Html.text("Double-click to edit a todo")]))
,A2($Html.p,
_L.fromArray([]),
_L.fromArray([$Html.text("Written by ")
,A2($Html.a,
_L.fromArray([$Html$Attributes.href("https://github.com/evancz")]),
_L.fromArray([$Html.text("Evan Czaplicki")]))]))
,A2($Html.p,
_L.fromArray([]),
_L.fromArray([$Html.text("Part of ")
,A2($Html.a,
_L.fromArray([$Html$Attributes.href("http://todomvc.com")]),
_L.fromArray([$Html.text("TodoMVC")]))]))]));
var is13 = function (code) {
return _U.eq(code,
13) ? $Result.Ok({ctor: "_Tuple0"}) : $Result.Err("not the right key code");
};
var onEnter = F2(function (address,
value) {
return A3($Html$Events.on,
"keydown",
A2($Json$Decode.customDecoder,
$Html$Events.keyCode,
is13),
function (_v0) {
var _ = _v0;
return A2($Signal.message,
address,
value);
});
});
var ChangeVisibility = function (a) {
return {ctor: "ChangeVisibility"
,_0: a};
};
var visibilitySwap = F4(function (address,
uri,
visibility,
actualVisibility) {
return A2($Html.li,
_L.fromArray([A2($Html$Events.onClick,
address,
ChangeVisibility(visibility))]),
_L.fromArray([A2($Html.a,
_L.fromArray([$Html$Attributes.href(uri)
,$Html$Attributes.classList(_L.fromArray([{ctor: "_Tuple2"
,_0: "selected"
,_1: _U.eq(visibility,
actualVisibility)}]))]),
_L.fromArray([$Html.text(visibility)]))]));
});
var CheckAll = function (a) {
return {ctor: "CheckAll"
,_0: a};
};
var Check = F2(function (a,b) {
return {ctor: "Check"
,_0: a
,_1: b};
});
var DeleteComplete = {ctor: "DeleteComplete"};
var controls = F3(function (address,
visibility,
tasks) {
var tasksCompleted = $List.length(A2($List.filter,
function (_) {
return _.completed;
},
tasks));
var tasksLeft = $List.length(tasks) - tasksCompleted;
var item_ = _U.eq(tasksLeft,
1) ? " item" : " items";
return A2($Html.footer,
_L.fromArray([$Html$Attributes.id("footer")
,$Html$Attributes.hidden($List.isEmpty(tasks))]),
_L.fromArray([A2($Html.span,
_L.fromArray([$Html$Attributes.id("todo-count")]),
_L.fromArray([A2($Html.strong,
_L.fromArray([]),
_L.fromArray([$Html.text($Basics.toString(tasksLeft))]))
,$Html.text(A2($Basics._op["++"],
item_,
" left"))]))
,A2($Html.ul,
_L.fromArray([$Html$Attributes.id("filters")]),
_L.fromArray([A4(visibilitySwap,
address,
"#/",
"All",
visibility)
,$Html.text(" ")
,A4(visibilitySwap,
address,
"#/active",
"Active",
visibility)
,$Html.text(" ")
,A4(visibilitySwap,
address,
"#/completed",
"Completed",
visibility)]))
,A2($Html.button,
_L.fromArray([$Html$Attributes.$class("clear-completed")
,$Html$Attributes.id("clear-completed")
,$Html$Attributes.hidden(_U.eq(tasksCompleted,
0))
,A2($Html$Events.onClick,
address,
DeleteComplete)]),
_L.fromArray([$Html.text(A2($Basics._op["++"],
"Clear completed (",
A2($Basics._op["++"],
$Basics.toString(tasksCompleted),
")")))]))]));
});
var Delete = function (a) {
return {ctor: "Delete"
,_0: a};
};
var Add = {ctor: "Add"};
var UpdateTask = F2(function (a,
b) {
return {ctor: "UpdateTask"
,_0: a
,_1: b};
});
var EditingTask = F2(function (a,
b) {
return {ctor: "EditingTask"
,_0: a
,_1: b};
});
var todoItem = F2(function (address,
todo) {
return A2($Html.li,
_L.fromArray([$Html$Attributes.classList(_L.fromArray([{ctor: "_Tuple2"
,_0: "completed"
,_1: todo.completed}
,{ctor: "_Tuple2"
,_0: "editing"
,_1: todo.editing}]))]),
_L.fromArray([A2($Html.div,
_L.fromArray([$Html$Attributes.$class("view")]),
_L.fromArray([A2($Html.input,
_L.fromArray([$Html$Attributes.$class("toggle")
,$Html$Attributes.type$("checkbox")
,$Html$Attributes.checked(todo.completed)
,A2($Html$Events.onClick,
address,
A2(Check,
todo.id,
$Basics.not(todo.completed)))]),
_L.fromArray([]))
,A2($Html.label,
_L.fromArray([A2($Html$Events.onDoubleClick,
address,
A2(EditingTask,todo.id,true))]),
_L.fromArray([$Html.text(todo.description)]))
,A2($Html.button,
_L.fromArray([$Html$Attributes.$class("destroy")
,A2($Html$Events.onClick,
address,
Delete(todo.id))]),
_L.fromArray([]))]))
,A2($Html.input,
_L.fromArray([$Html$Attributes.$class("edit")
,$Html$Attributes.value(todo.description)
,$Html$Attributes.name("title")
,$Html$Attributes.id(A2($Basics._op["++"],
"todo-",
$Basics.toString(todo.id)))
,A3($Html$Events.on,
"input",
$Html$Events.targetValue,
function ($) {
return $Signal.message(address)(UpdateTask(todo.id)($));
})
,A2($Html$Events.onBlur,
address,
A2(EditingTask,todo.id,false))
,A2(onEnter,
address,
A2(EditingTask,
todo.id,
false))]),
_L.fromArray([]))]));
});
var taskList = F3(function (address,
visibility,
tasks) {
var cssVisibility = $List.isEmpty(tasks) ? "hidden" : "visible";
var allCompleted = A2($List.all,
function (_) {
return _.completed;
},
tasks);
var isVisible = function (todo) {
switch (visibility)
{case "Active":
return $Basics.not(todo.completed);
case "All": return true;
case "Completed":
return todo.completed;}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
};
return A2($Html.section,
_L.fromArray([$Html$Attributes.id("main")
,$Html$Attributes.style(_L.fromArray([{ctor: "_Tuple2"
,_0: "visibility"
,_1: cssVisibility}]))]),
_L.fromArray([A2($Html.input,
_L.fromArray([$Html$Attributes.id("toggle-all")
,$Html$Attributes.type$("checkbox")
,$Html$Attributes.name("toggle")
,$Html$Attributes.checked(allCompleted)
,A2($Html$Events.onClick,
address,
CheckAll($Basics.not(allCompleted)))]),
_L.fromArray([]))
,A2($Html.label,
_L.fromArray([$Html$Attributes.$for("toggle-all")]),
_L.fromArray([$Html.text("Mark all as complete")]))
,A2($Html.ul,
_L.fromArray([$Html$Attributes.id("todo-list")]),
A2($List.map,
todoItem(address),
A2($List.filter,
isVisible,
tasks)))]));
});
var UpdateField = function (a) {
return {ctor: "UpdateField"
,_0: a};
};
var taskEntry = F2(function (address,
task) {
return A2($Html.header,
_L.fromArray([$Html$Attributes.id("header")]),
_L.fromArray([A2($Html.h1,
_L.fromArray([]),
_L.fromArray([$Html.text("todos")]))
,A2($Html.input,
_L.fromArray([$Html$Attributes.id("new-todo")
,$Html$Attributes.placeholder("What needs to be done?")
,$Html$Attributes.autofocus(true)
,$Html$Attributes.value(task)
,$Html$Attributes.name("newTodo")
,A3($Html$Events.on,
"input",
$Html$Events.targetValue,
function ($) {
return $Signal.message(address)(UpdateField($));
})
,A2(onEnter,address,Add)]),
_L.fromArray([]))]));
});
var view = F2(function (address,
model) {
return A2($Html.div,
_L.fromArray([$Html$Attributes.$class("todomvc-wrapper")
,$Html$Attributes.style(_L.fromArray([{ctor: "_Tuple2"
,_0: "visibility"
,_1: "hidden"}]))]),
_L.fromArray([A2($Html.section,
_L.fromArray([$Html$Attributes.id("todoapp")]),
_L.fromArray([A3($Html$Lazy.lazy2,
taskEntry,
address,
model.field)
,A4($Html$Lazy.lazy3,
taskList,
address,
model.visibility,
model.tasks)
,A4($Html$Lazy.lazy3,
controls,
address,
model.visibility,
model.tasks)]))
,infoFooter]));
});
var NoOp = {ctor: "NoOp"};
var actions = $Signal.mailbox(NoOp);
var emptyModel = {_: {}
,field: ""
,tasks: _L.fromArray([])
,uid: 0
,visibility: "All"};
var initialModel = A2($Maybe.withDefault,
emptyModel,
getStorage);
var newTask = F2(function (desc,
id) {
return {_: {}
,completed: false
,description: desc
,editing: false
,id: id};
});
var update = F2(function (action,
model) {
switch (action.ctor)
{case "Add":
return _U.replace([["uid"
,model.uid + 1]
,["field",""]
,["tasks"
,$String.isEmpty(model.field) ? model.tasks : A2($Basics._op["++"],
model.tasks,
_L.fromArray([A2(newTask,
model.field,
model.uid)]))]],
model);
case "ChangeVisibility":
return _U.replace([["visibility"
,action._0]],
model);
case "Check":
var updateTask = function (t) {
return _U.eq(t.id,
action._0) ? _U.replace([["completed"
,action._1]],
t) : t;
};
return _U.replace([["tasks"
,A2($List.map,
updateTask,
model.tasks)]],
model);
case "CheckAll":
var updateTask = function (t) {
return _U.replace([["completed"
,action._0]],
t);
};
return _U.replace([["tasks"
,A2($List.map,
updateTask,
model.tasks)]],
model);
case "Delete":
return _U.replace([["tasks"
,A2($List.filter,
function (t) {
return !_U.eq(t.id,
action._0);
},
model.tasks)]],
model);
case "DeleteComplete":
return _U.replace([["tasks"
,A2($List.filter,
function ($) {
return $Basics.not(function (_) {
return _.completed;
}($));
},
model.tasks)]],
model);
case "EditingTask":
var updateTask = function (t) {
return _U.eq(t.id,
action._0) ? _U.replace([["editing"
,action._1]],
t) : t;
};
return _U.replace([["tasks"
,A2($List.map,
updateTask,
model.tasks)]],
model);
case "NoOp": return model;
case "UpdateField":
return _U.replace([["field"
,action._0]],
model);
case "UpdateTask":
var updateTask = function (t) {
return _U.eq(t.id,
action._0) ? _U.replace([["description"
,action._1]],
t) : t;
};
return _U.replace([["tasks"
,A2($List.map,
updateTask,
model.tasks)]],
model);}
_U.badCase($moduleName,
"bugs in reporting the exact location right now");
});
var model = A3($Signal.foldp,
update,
initialModel,
actions.signal);
var main = A2($Signal.map,
view(actions.address),
model);
var Task = F4(function (a,
b,
c,
d) {
return {_: {}
,completed: b
,description: a
,editing: c
,id: d};
});
var Model = F4(function (a,
b,
c,
d) {
return {_: {}
,field: b
,tasks: a
,uid: c
,visibility: d};
});_elm.Todo.values = { _op : _op,
Model : Model,
Task : Task,
newTask : newTask,
emptyModel : emptyModel,
NoOp : NoOp,
UpdateField : UpdateField,
EditingTask : EditingTask,
UpdateTask : UpdateTask,
Add : Add,
Delete : Delete,
DeleteComplete : DeleteComplete,
Check : Check,
CheckAll : CheckAll,
ChangeVisibility : ChangeVisibility,
update : update,
view : view,
onEnter : onEnter,
is13 : is13,
taskEntry : taskEntry,
taskList : taskList,
todoItem : todoItem,
controls : controls,
visibilitySwap : visibilitySwap,
infoFooter : infoFooter,
main : main,
model : model,
initialModel : initialModel,
actions : actions};
return _elm.Todo.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Transform2D",
$Native$Transform2D = Elm.Native.Transform2D.make(_elm);_elm.Transform2D.values = { _op : _op};
return _elm.Transform2D.values;};Elm.VirtualDom = Elm.VirtualDom || {};
Elm.VirtualDom.make = function(_elm){
"use strict";
_elm.VirtualDom = _elm.VirtualDom || {};
if (_elm.VirtualDom.values)
return _elm.VirtualDom.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "VirtualDom",
$Basics = Elm.Basics.make(_elm),
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$Json$Decode = Elm.Json.Decode.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$VirtualDom = Elm.Native.VirtualDom.make(_elm),
$Result = Elm.Result.make(_elm),
$Signal = Elm.Signal.make(_elm);var lazy3 = $Native$VirtualDom.lazy3;
var lazy2 = $Native$VirtualDom.lazy2;
var on = $Native$VirtualDom.on;
var property = $Native$VirtualDom.property;
var text = $Native$VirtualDom.text;
var node = $Native$VirtualDom.node;_elm.VirtualDom.values = { _op : _op,
node : node,
text : text,
property : property,
on : on,
lazy2 : lazy2,
lazy3 : lazy3};
return _elm.VirtualDom.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 _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Window",
$Basics = Elm.Basics.make(_elm),
$Native$Window = Elm.Native.Window.make(_elm),
$Signal = Elm.Signal.make(_elm);_elm.Window.values = { _op : _op};
return _elm.Window.values;};
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment