Navigation Menu

Skip to content

Instantly share code, notes, and snippets.

@jameshfisher

jameshfisher/gist:77799ca0d96f5d475f1e

Created December 22, 2014 17:20
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save jameshfisher/77799ca0d96f5d475f1e to your computer and use it in GitHub Desktop.
Save jameshfisher/77799ca0d96f5d475f1e to your computer and use it in GitHub Desktop.
Download ZIP
Elm: Wrong HTML element disappears in state transition
Raw
gistfile1.html
<!DOCTYPE HTML>
<html><head><meta charset="UTF-8"><title>Compiled Elm</title><style>html,head,body { padding:0; margin:0; }
body { font-family: 'Lucida Grande','Trebuchet MS','Bitstream Vera Sans',Verdana,Helvetica,sans-serif; }
a {
color: #1184CE;
text-decoration: none;
}
a:hover {
text-decoration: underline;
color: rgb(234,21,122);
}
h1,h2,h3,h4 { font-weight:normal; font-family: futura, 'century gothic', 'twentieth century', calibri, verdana, helvetica, arial; }
p, li {
font-size: 14px !important;
line-height: 1.5em !important;
}
pre {
margin: 0;
padding: 10px;
background-color: rgb(254,254,254);
border-style: solid;
border-width: 1px;
border-color: rgb(245,245,245);
border-radius: 6px;
}
</style></head><body><script>var Elm = Elm || { Native: {} };
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),
_P = _N.Ports.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 461, column 19 to 24");
}();
});
var curry = F3(function (f,
a,
b) {
return f({ctor: "_Tuple2"
,_0: a
,_1: b});
});
var flip = F3(function (f,b,a) {
return A2(f,a,b);
});
var snd = function (_v4) {
return function () {
switch (_v4.ctor)
{case "_Tuple2": return _v4._1;}
_U.badCase($moduleName,
"on line 445, column 13 to 14");
}();
};
var fst = function (_v8) {
return function () {
switch (_v8.ctor)
{case "_Tuple2": return _v8._0;}
_U.badCase($moduleName,
"on line 441, column 13 to 14");
}();
};
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
,radians: radians
,degrees: degrees
,turns: turns
,fromPolar: fromPolar
,toPolar: toPolar
,rem: rem
,cos: cos
,sin: sin
,tan: tan
,acos: acos
,asin: asin
,atan: atan
,atan2: atan2
,sqrt: sqrt
,negate: negate
,abs: abs
,logBase: logBase
,clamp: clamp
,pi: pi
,e: e
,compare: compare
,LT: LT
,EQ: EQ
,GT: GT
,min: min
,max: max
,xor: xor
,not: not
,otherwise: otherwise
,round: round
,truncate: truncate
,floor: floor
,ceiling: ceiling
,toFloat: toFloat
,isNaN: isNaN
,isInfinite: isInfinite
,toString: toString
,identity: identity
,always: always
,fst: fst
,snd: snd
,flip: flip
,curry: curry
,uncurry: uncurry};
return _elm.Basics.values;
};
Elm.Color = Elm.Color || {};
Elm.Color.make = function (_elm) {
"use strict";
_elm.Color = _elm.Color || {};
if (_elm.Color.values)
return _elm.Color.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_P = _N.Ports.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 141 and 143"));
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 115 and 123");
}();
};
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 105 and 112");
}();
};
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 96 and 102");
}();
};
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
,RGBA: RGBA
,HSLA: HSLA
,rgba: rgba
,rgb: rgb
,hsla: hsla
,hsl: hsl
,grayscale: grayscale
,greyscale: greyscale
,complement: complement
,toHsl: toHsl
,toRgb: toRgb
,fmod: fmod
,rgbToHsl: rgbToHsl
,hslToRgb: hslToRgb
,Linear: Linear
,Radial: Radial
,linear: linear
,radial: radial
,lightRed: lightRed
,red: red
,darkRed: darkRed
,lightOrange: lightOrange
,orange: orange
,darkOrange: darkOrange
,lightYellow: lightYellow
,yellow: yellow
,darkYellow: darkYellow
,lightGreen: lightGreen
,green: green
,darkGreen: darkGreen
,lightBlue: lightBlue
,blue: blue
,darkBlue: darkBlue
,lightPurple: lightPurple
,purple: purple
,darkPurple: darkPurple
,lightBrown: lightBrown
,brown: brown
,darkBrown: darkBrown
,black: black
,white: white
,lightGrey: lightGrey
,grey: grey
,darkGrey: darkGrey
,lightGray: lightGray
,gray: gray
,darkGray: darkGray
,lightCharcoal: lightCharcoal
,charcoal: charcoal
,darkCharcoal: darkCharcoal};
return _elm.Color.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),
_P = _N.Ports.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),
$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 174, column 20 to 48");
}();
});
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 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
,Form: Form
,Solid: Solid
,Texture: Texture
,Grad: Grad
,Flat: Flat
,Round: Round
,Padded: Padded
,Smooth: Smooth
,Sharp: Sharp
,Clipped: Clipped
,LineStyle: LineStyle
,defaultLine: defaultLine
,solid: solid
,dashed: dashed
,dotted: dotted
,FPath: FPath
,FShape: FShape
,FImage: FImage
,FElement: FElement
,FGroup: FGroup
,Line: Line
,Fill: Fill
,form: form
,fill: fill
,filled: filled
,textured: textured
,gradient: gradient
,outlined: outlined
,traced: traced
,sprite: sprite
,toForm: toForm
,group: group
,groupTransform: groupTransform
,move: move
,moveX: moveX
,moveY: moveY
,scale: scale
,rotate: rotate
,alpha: alpha
,collage: collage
,path: path
,segment: segment
,polygon: polygon
,rect: rect
,square: square
,oval: oval
,circle: circle
,ngon: ngon};
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),
_P = _N.Ports.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);
var DOut = {ctor: "DOut"};
var outward = DOut;
var DIn = {ctor: "DIn"};
var inward = DIn;
var DRight = {ctor: "DRight"};
var right = DRight;
var DLeft = {ctor: "DLeft"};
var left = DLeft;
var DDown = {ctor: "DDown"};
var down = DDown;
var DUp = {ctor: "DUp"};
var up = DUp;
var Position = F4(function (a,
b,
c,
d) {
return {_: {}
,horizontal: a
,vertical: b
,x: c
,y: d};
});
var Relative = function (a) {
return {ctor: "Relative"
,_0: a};
};
var relative = Relative;
var Absolute = function (a) {
return {ctor: "Absolute"
,_0: a};
};
var absolute = Absolute;
var N = {ctor: "N"};
var bottomLeftAt = F2(function (x,
y) {
return {_: {}
,horizontal: N
,vertical: N
,x: x
,y: y};
});
var Z = {ctor: "Z"};
var middle = {_: {}
,horizontal: Z
,vertical: Z
,x: Relative(0.5)
,y: Relative(0.5)};
var midLeft = _U.replace([["horizontal"
,N]
,["x",Absolute(0)]],
middle);
var middleAt = F2(function (x,
y) {
return {_: {}
,horizontal: Z
,vertical: Z
,x: x
,y: y};
});
var midLeftAt = F2(function (x,
y) {
return {_: {}
,horizontal: N
,vertical: Z
,x: x
,y: y};
});
var midBottomAt = F2(function (x,
y) {
return {_: {}
,horizontal: Z
,vertical: N
,x: x
,y: y};
});
var P = {ctor: "P"};
var topLeft = {_: {}
,horizontal: N
,vertical: P
,x: Absolute(0)
,y: Absolute(0)};
var bottomLeft = _U.replace([["vertical"
,N]],
topLeft);
var topRight = _U.replace([["horizontal"
,P]],
topLeft);
var bottomRight = _U.replace([["horizontal"
,P]],
bottomLeft);
var midRight = _U.replace([["horizontal"
,P]],
midLeft);
var midTop = _U.replace([["vertical"
,P]
,["y",Absolute(0)]],
middle);
var midBottom = _U.replace([["vertical"
,N]],
midTop);
var topLeftAt = F2(function (x,
y) {
return {_: {}
,horizontal: N
,vertical: P
,x: x
,y: y};
});
var topRightAt = F2(function (x,
y) {
return {_: {}
,horizontal: P
,vertical: P
,x: x
,y: y};
});
var bottomRightAt = F2(function (x,
y) {
return {_: {}
,horizontal: P
,vertical: N
,x: x
,y: y};
});
var midRightAt = F2(function (x,
y) {
return {_: {}
,horizontal: P
,vertical: Z
,x: x
,y: y};
});
var midTopAt = F2(function (x,
y) {
return {_: {}
,horizontal: Z
,vertical: P
,x: x
,y: y};
});
var Tiled = {ctor: "Tiled"};
var Cropped = function (a) {
return {ctor: "Cropped"
,_0: a};
};
var Fitted = {ctor: "Fitted"};
var Plain = {ctor: "Plain"};
var Custom = {ctor: "Custom"};
var RawHtml = {ctor: "RawHtml"};
var Spacer = {ctor: "Spacer"};
var Flow = F2(function (a,b) {
return {ctor: "Flow"
,_0: a
,_1: b};
});
var Container = F2(function (a,
b) {
return {ctor: "Container"
,_0: a
,_1: b};
});
var Image = F4(function (a,
b,
c,
d) {
return {ctor: "Image"
,_0: a
,_1: b
,_2: c
,_3: d};
});
var link = F2(function (href,
e) {
return function () {
var p = e.props;
return {_: {}
,element: e.element
,props: _U.replace([["href"
,href]],
p)};
}();
});
var tag = F2(function (name,e) {
return function () {
var p = e.props;
return {_: {}
,element: e.element
,props: _U.replace([["tag"
,name]],
p)};
}();
});
var color = F2(function (c,e) {
return function () {
var p = e.props;
return {_: {}
,element: e.element
,props: _U.replace([["color"
,$Maybe.Just(c)]],
p)};
}();
});
var opacity = F2(function (o,
e) {
return function () {
var p = e.props;
return {_: {}
,element: e.element
,props: _U.replace([["opacity"
,o]],
p)};
}();
});
var height = F2(function (nh,
e) {
return function () {
var p = e.props;
var props = function () {
var _v0 = e.element;
switch (_v0.ctor)
{case "Image":
return _U.replace([["width"
,$Basics.round($Basics.toFloat(_v0._1) / $Basics.toFloat(_v0._2) * $Basics.toFloat(nh))]],
p);}
return p;
}();
return {_: {}
,element: e.element
,props: _U.replace([["height"
,nh]],
p)};
}();
});
var width = F2(function (nw,e) {
return function () {
var p = e.props;
var props = function () {
var _v5 = e.element;
switch (_v5.ctor)
{case "Image":
return _U.replace([["height"
,$Basics.round($Basics.toFloat(_v5._2) / $Basics.toFloat(_v5._1) * $Basics.toFloat(nw))]],
p);
case "RawHtml":
return _U.replace([["height"
,$Basics.snd(A2($Native$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 Element = F2(function (a,
b) {
return {_: {}
,element: b
,props: a};
});
var Properties = F9(function (a,
b,
c,
d,
e,
f,
g,
h,
i) {
return {_: {}
,click: i
,color: e
,height: c
,hover: h
,href: f
,id: a
,opacity: d
,tag: g
,width: b};
});
var newElement = F3(function (w,
h,
e) {
return {_: {}
,element: e
,props: A9(Properties,
$Native$Graphics$Element.guid({ctor: "_Tuple0"}),
w,
h,
1,
$Maybe.Nothing,
"",
"",
{ctor: "_Tuple0"},
{ctor: "_Tuple0"})};
});
var image = F3(function (w,
h,
src) {
return A3(newElement,
w,
h,
A4(Image,Plain,w,h,src));
});
var fittedImage = F3(function (w,
h,
src) {
return A3(newElement,
w,
h,
A4(Image,Fitted,w,h,src));
});
var croppedImage = F4(function (pos,
w,
h,
src) {
return A3(newElement,
w,
h,
A4(Image,Cropped(pos),w,h,src));
});
var tiledImage = F3(function (w,
h,
src) {
return A3(newElement,
w,
h,
A4(Image,Tiled,w,h,src));
});
var container = F4(function (w,
h,
pos,
e) {
return A3(newElement,
w,
h,
A2(Container,pos,e));
});
var spacer = F2(function (w,h) {
return A3(newElement,
w,
h,
Spacer);
});
var empty = A2(spacer,0,0);
var flow = F2(function (dir,
es) {
return function () {
var newFlow = F2(function (w,
h) {
return A3(newElement,
w,
h,
A2(Flow,dir,es));
});
var hs = A2($List.map,
heightOf,
es);
var ws = A2($List.map,
widthOf,
es);
return _U.eq(es,
_L.fromArray([])) ? empty : function () {
switch (dir.ctor)
{case "DDown":
return A2(newFlow,
$List.maximum(ws),
$List.sum(hs));
case "DIn": return A2(newFlow,
$List.maximum(ws),
$List.maximum(hs));
case "DLeft": return A2(newFlow,
$List.sum(ws),
$List.maximum(hs));
case "DOut": return A2(newFlow,
$List.maximum(ws),
$List.maximum(hs));
case "DRight":
return A2(newFlow,
$List.sum(ws),
$List.maximum(hs));
case "DUp": return A2(newFlow,
$List.maximum(ws),
$List.sum(hs));}
_U.badCase($moduleName,
"between lines 280 and 291");
}();
}();
});
var above = F2(function (hi,
lo) {
return A3(newElement,
A2($Basics.max,
widthOf(hi),
widthOf(lo)),
heightOf(hi) + heightOf(lo),
A2(Flow,
DDown,
_L.fromArray([hi,lo])));
});
var below = F2(function (lo,
hi) {
return A3(newElement,
A2($Basics.max,
widthOf(hi),
widthOf(lo)),
heightOf(hi) + heightOf(lo),
A2(Flow,
DDown,
_L.fromArray([hi,lo])));
});
var beside = F2(function (lft,
rht) {
return A3(newElement,
widthOf(lft) + widthOf(rht),
A2($Basics.max,
heightOf(lft),
heightOf(rht)),
A2(Flow,
right,
_L.fromArray([lft,rht])));
});
var layers = function (es) {
return function () {
var hs = A2($List.map,
heightOf,
es);
var ws = A2($List.map,
widthOf,
es);
return A3(newElement,
$List.maximum(ws),
$List.maximum(hs),
A2(Flow,DOut,es));
}();
};
_elm.Graphics.Element.values = {_op: _op
,Properties: Properties
,Element: Element
,empty: empty
,widthOf: widthOf
,heightOf: heightOf
,sizeOf: sizeOf
,width: width
,height: height
,size: size
,opacity: opacity
,color: color
,tag: tag
,link: link
,newElement: newElement
,Image: Image
,Container: Container
,Flow: Flow
,Spacer: Spacer
,RawHtml: RawHtml
,Custom: Custom
,Plain: Plain
,Fitted: Fitted
,Cropped: Cropped
,Tiled: Tiled
,image: image
,fittedImage: fittedImage
,croppedImage: croppedImage
,tiledImage: tiledImage
,P: P
,Z: Z
,N: N
,Absolute: Absolute
,Relative: Relative
,Position: Position
,container: container
,spacer: spacer
,DUp: DUp
,DDown: DDown
,DLeft: DLeft
,DRight: DRight
,DIn: DIn
,DOut: DOut
,flow: flow
,above: above
,below: below
,beside: beside
,layers: layers
,absolute: absolute
,relative: relative
,middle: middle
,topLeft: topLeft
,topRight: topRight
,bottomLeft: bottomLeft
,bottomRight: bottomRight
,midLeft: midLeft
,midRight: midRight
,midTop: midTop
,midBottom: midBottom
,middleAt: middleAt
,topLeftAt: topLeftAt
,topRightAt: topRightAt
,bottomLeftAt: bottomLeftAt
,bottomRightAt: bottomRightAt
,midLeftAt: midLeftAt
,midRightAt: midRightAt
,midTopAt: midTopAt
,midBottomAt: midBottomAt
,up: up
,down: down
,left: left
,right: right
,inward: inward
,outward: outward};
return _elm.Graphics.Element.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),
_P = _N.Ports.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 = $Native$List.sort;
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 append = $Native$List.append;
var any = $Native$List.any;
var all = $Native$List.all;
var reverse = $Native$List.reverse;
var length = $Native$List.length;
var filter = $Native$List.filter;
var scanl1 = $Native$List.scanl1;
var scanl = $Native$List.scanl;
var foldr1 = $Native$List.foldr1;
var foldl1 = $Native$List.foldl1;
var maximum = foldl1($Basics.max);
var minimum = foldl1($Basics.min);
var foldr = $Native$List.foldr;
var concat = function (lists) {
return A3(foldr,
append,
_L.fromArray([]),
lists);
};
var foldl = $Native$List.foldl;
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 indexedMap = F2(function (f,
xs) {
return A3(map2,
f,
_L.range(0,length(xs) - 1),
xs);
});
var map = $Native$List.map;
var concatMap = F2(function (f,
list) {
return concat(A2(map,
f,
list));
});
var member = $Native$List.member;
var isEmpty = function (xs) {
return function () {
switch (xs.ctor)
{case "[]": return true;}
return false;
}();
};
var tail = $Native$List.tail;
var head = $Native$List.head;
_op["::"] = $Native$List.cons;
var maybeCons = F3(function (f,
mx,
xs) {
return function () {
var _v1 = f(mx);
switch (_v1.ctor)
{case "Just":
return A2(_op["::"],_v1._0,xs);
case "Nothing": return xs;}
_U.badCase($moduleName,
"between lines 162 and 169");
}();
});
var filterMap = F2(function (f,
xs) {
return A3(foldr,
maybeCons(f),
_L.fromArray([]),
xs);
});
var partition = F2(function (pred,
list) {
return function () {
var step = F2(function (x,
_v3) {
return function () {
switch (_v3.ctor)
{case "_Tuple2":
return pred(x) ? {ctor: "_Tuple2"
,_0: A2(_op["::"],x,_v3._0)
,_1: _v3._1} : {ctor: "_Tuple2"
,_0: _v3._0
,_1: A2(_op["::"],x,_v3._1)};}
_U.badCase($moduleName,
"between lines 270 and 272");
}();
});
return A3(foldr,
step,
{ctor: "_Tuple2"
,_0: _L.fromArray([])
,_1: _L.fromArray([])},
list);
}();
});
var unzip = function (pairs) {
return function () {
var step = F2(function (_v7,
_v8) {
return function () {
switch (_v8.ctor)
{case "_Tuple2":
return function () {
switch (_v7.ctor)
{case "_Tuple2":
return {ctor: "_Tuple2"
,_0: A2(_op["::"],_v7._0,_v8._0)
,_1: A2(_op["::"],
_v7._1,
_v8._1)};}
_U.badCase($moduleName,
"on line 308, column 12 to 28");
}();}
_U.badCase($moduleName,
"on line 308, 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 319 and 330");
}();
});
_elm.List.values = {_op: _op
,head: head
,tail: tail
,isEmpty: isEmpty
,member: member
,map: map
,indexedMap: indexedMap
,foldl: foldl
,foldr: foldr
,foldl1: foldl1
,foldr1: foldr1
,scanl: scanl
,scanl1: scanl1
,filter: filter
,filterMap: filterMap
,maybeCons: maybeCons
,length: length
,reverse: reverse
,all: all
,any: any
,append: append
,concat: concat
,concatMap: concatMap
,sum: sum
,product: product
,maximum: maximum
,minimum: minimum
,partition: partition
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,unzip: unzip
,intersperse: intersperse
,take: take
,drop: drop
,repeat: repeat
,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),
_P = _N.Ports.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 56");
}();
});
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 73");
}();
case "[]": return Nothing;}
_U.badCase($moduleName,
"between lines 59 and 73");
}();
};
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 107");
}();
});
_elm.Maybe.values = {_op: _op
,andThen: andThen
,map: map
,withDefault: withDefault
,oneOf: oneOf
,Just: Just
,Nothing: Nothing};
return _elm.Maybe.values;
};
Elm.Mouse = Elm.Mouse || {};
Elm.Mouse.make = function (_elm) {
"use strict";
_elm.Mouse = _elm.Mouse || {};
if (_elm.Mouse.values)
return _elm.Mouse.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_P = _N.Ports.make(_elm),
$moduleName = "Mouse",
$Native$Mouse = Elm.Native.Mouse.make(_elm),
$Signal = Elm.Signal.make(_elm);
var clicks = $Native$Mouse.clicks;
var isDown = $Native$Mouse.isDown;
var y = $Native$Mouse.y;
var x = $Native$Mouse.x;
var position = $Native$Mouse.position;
_elm.Mouse.values = {_op: _op
,position: position
,x: x
,y: y
,isDown: isDown
,clicks: clicks};
return _elm.Mouse.values;
};
Elm.Native.Basics = {};
Elm.Native.Basics.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Basics = elm.Native.Basics || {};
if (elm.Native.Basics.values) return elm.Native.Basics.values;
var Utils = Elm.Native.Utils.make(elm);
function div(a, b) {
return (a/b)|0;
}
function rem(a, b) {
return a % b;
}
function mod(a, b) {
if (b === 0) {
throw new Error("Cannot perform mod 0. Division by zero error.");
}
var r = a % b;
var m = a === 0 ? 0 : (b > 0 ? (a >= 0 ? r : r+b) : -mod(-a,-b));
return m === b ? 0 : m;
}
function logBase(base, n) {
return Math.log(n) / Math.log(base);
}
function negate(n) {
return -n;
}
function abs(n) {
return n < 0 ? -n : n;
}
function min(a, b) {
return Utils.cmp(a,b) < 0 ? a : b;
}
function max(a, b) {
return Utils.cmp(a,b) > 0 ? a : b;
}
function clamp(lo, hi, n) {
return Utils.cmp(n,lo) < 0 ? lo : Utils.cmp(n,hi) > 0 ? hi : n;
}
function xor(a, b) {
return a !== b;
}
function not(b) {
return !b;
}
function isInfinite(n) {
return n === Infinity || n === -Infinity
}
function truncate(n) {
return n|0;
}
function degrees(d) {
return d * Math.PI / 180;
}
function turns(t) {
return 2 * Math.PI * t;
}
function fromPolar(point) {
var r = point._0;
var t = point._1;
return Utils.Tuple2(r * Math.cos(t), r * Math.sin(t));
}
function toPolar(point) {
var x = point._0;
var y = point._1;
return Utils.Tuple2(Math.sqrt(x * x + y * y), Math.atan2(y,x));
}
var basics = {
div: F2(div),
rem: F2(rem),
mod: F2(mod),
pi: Math.PI,
e: Math.E,
cos: Math.cos,
sin: Math.sin,
tan: Math.tan,
acos: Math.acos,
asin: Math.asin,
atan: Math.atan,
atan2: F2(Math.atan2),
degrees: degrees,
turns: turns,
fromPolar: fromPolar,
toPolar: toPolar,
sqrt: Math.sqrt,
logBase: F2(logBase),
negate: negate,
abs: abs,
min: F2(min),
max: F2(max),
clamp: F3(clamp),
compare: Utils.compare,
xor: F2(xor),
not: not,
truncate: truncate,
ceiling: Math.ceil,
floor: Math.floor,
round: Math.round,
toFloat: function(x) { return x; },
isNaN: isNaN,
isInfinite: isInfinite
};
return elm.Native.Basics.values = basics;
};
Elm.Native.Color = {};
Elm.Native.Color.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Color = elm.Native.Color || {};
if (elm.Native.Color.values) return elm.Native.Color.values;
function toCss(c) {
var format = '';
var colors = '';
if (c.ctor === 'RGBA') {
format = 'rgb';
colors = c._0 + ', ' + c._1 + ', ' + c._2;
} else {
format = 'hsl';
colors = (c._0 * 180 / Math.PI) + ', ' +
(c._1 * 100) + '%, ' +
(c._2 * 100) + '%';
}
if (c._3 === 1) {
return format + '(' + colors + ')';
} else {
return format + 'a(' + colors + ', ' + c._3 + ')';
}
}
return elm.Native.Color.values = {
toCss:toCss
};
};
// setup
Elm.Native = Elm.Native || {};
Elm.Native.Graphics = Elm.Native.Graphics || {};
Elm.Native.Graphics.Collage = Elm.Native.Graphics.Collage || {};
// definition
Elm.Native.Graphics.Collage.make = function(localRuntime) {
'use strict';
// attempt to short-circuit
if ('values' in Elm.Native.Graphics.Collage) {
return Elm.Native.Graphics.Collage.values;
}
// okay, we cannot short-ciruit, so now we define everything
var Color = Elm.Native.Color.make(localRuntime);
var List = Elm.Native.List.make(localRuntime);
var Transform = Elm.Transform2D.make(localRuntime);
var Element = Elm.Graphics.Element.make(localRuntime);
var NativeElement = Elm.Native.Graphics.Element.make(localRuntime);
function trace(ctx, path) {
var points = List.toArray(path);
var i = points.length - 1;
if (i <= 0) {
return;
}
ctx.moveTo(points[i]._0, points[i]._1);
while (i--) {
ctx.lineTo(points[i]._0, points[i]._1);
}
if (path.closed) {
i = points.length - 1;
ctx.lineTo(points[i]._0, points[i]._1);
}
}
function line(ctx,style,path) {
(style.dashing.ctor === '[]')
? trace(ctx, path)
: customLineHelp(ctx, style, path);
ctx.scale(1,-1);
ctx.stroke();
}
function customLineHelp(ctx, style, path) {
var points = List.toArray(path);
if (path.closed) {
points.push(points[0]);
}
var pattern = List.toArray(style.dashing);
var i = points.length - 1;
if (i <= 0) {
return;
}
var x0 = points[i]._0, y0 = points[i]._1;
var x1=0, y1=0, dx=0, dy=0, remaining=0, nx=0, ny=0;
var pindex = 0, plen = pattern.length;
var draw = true, segmentLength = pattern[0];
ctx.moveTo(x0,y0);
while (i--) {
x1 = points[i]._0; y1 = points[i]._1;
dx = x1 - x0; dy = y1 - y0;
remaining = Math.sqrt(dx * dx + dy * dy);
while (segmentLength <= remaining) {
x0 += dx * segmentLength / remaining;
y0 += dy * segmentLength / remaining;
ctx[draw ? 'lineTo' : 'moveTo'](x0, y0);
// update starting position
dx = x1 - x0; dy = y1 - y0;
remaining = Math.sqrt(dx * dx + dy * dy);
// update pattern
draw = !draw;
pindex = (pindex + 1) % plen;
segmentLength = pattern[pindex];
}
if (remaining > 0) {
ctx[draw ? 'lineTo' : 'moveTo'](x1, y1);
segmentLength -= remaining;
}
x0 = x1; y0 = y1;
}
}
function drawLine(ctx, style, path) {
ctx.lineWidth = style.width;
var cap = style.cap.ctor;
ctx.lineCap = cap === 'Flat'
? 'butt'
: cap === 'Round'
? 'round'
: 'square';
var join = style.join.ctor;
ctx.lineJoin = join === 'Smooth'
? 'round'
: join === 'Sharp'
? 'miter'
: 'bevel';
ctx.miterLimit = style.join._0 || 10;
ctx.strokeStyle = Color.toCss(style.color);
return line(ctx, style, path);
}
function texture(redo, ctx, src) {
var img = new Image();
img.src = src;
img.onload = redo;
return ctx.createPattern(img, 'repeat');
}
function gradient(ctx, grad) {
var g;
var stops = [];
if (grad.ctor === 'Linear') {
var p0 = grad._0, p1 = grad._1;
g = ctx.createLinearGradient(p0._0, -p0._1, p1._0, -p1._1);
stops = List.toArray(grad._2);
} else {
var p0 = grad._0, p2 = grad._2;
g = ctx.createRadialGradient(p0._0, -p0._1, grad._1, p2._0, -p2._1, grad._3);
stops = List.toArray(grad._4);
}
var len = stops.length;
for (var i = 0; i < len; ++i) {
var stop = stops[i];
g.addColorStop(stop._0, Color.toCss(stop._1));
}
return g;
}
function drawShape(redo, ctx, style, path) {
trace(ctx, path);
var sty = style.ctor;
ctx.fillStyle = sty === 'Solid'
? Color.toCss(style._0)
: sty === 'Texture'
? texture(redo, ctx, style._0)
: gradient(ctx, style._0);
ctx.scale(1,-1);
ctx.fill();
}
function drawImage(redo, ctx, form) {
var img = new Image();
img.onload = redo;
img.src = form._3;
var w = form._0,
h = form._1,
pos = form._2,
srcX = pos._0,
srcY = pos._1,
srcW = w,
srcH = h,
destX = -w/2,
destY = -h/2,
destW = w,
destH = h;
ctx.scale(1,-1);
ctx.drawImage(img, srcX, srcY, srcW, srcH, destX, destY, destW, destH);
}
function renderForm(redo, ctx, form) {
ctx.save();
var x = form.x, y = form.y, theta = form.theta, scale = form.scale;
if (x !== 0 || y !== 0) ctx.translate(x, y);
if (theta !== 0) ctx.rotate(theta);
if (scale !== 1) ctx.scale(scale,scale);
if (form.alpha !== 1) ctx.globalAlpha = ctx.globalAlpha * form.alpha;
ctx.beginPath();
var f = form.form;
switch(f.ctor) {
case 'FPath' : drawLine(ctx, f._0, f._1); break;
case 'FImage': drawImage(redo, ctx, f); break;
case 'FShape':
if (f._0.ctor === 'Line') {
f._1.closed = true;
drawLine(ctx, f._0._0, f._1);
} else {
drawShape(redo, ctx, f._0._0, f._1);
}
break;
}
ctx.restore();
}
function formToMatrix(form) {
var scale = form.scale;
var matrix = A6( Transform.matrix, scale, 0, 0, scale, form.x, form.y );
var theta = form.theta
if (theta !== 0) {
matrix = A2( Transform.multiply, matrix, Transform.rotation(theta) );
}
return matrix;
}
function str(n) {
if (n < 0.00001 && n > -0.00001) return 0;
return n;
}
function makeTransform(w, h, form, matrices) {
var props = form.form._0.props;
var m = A6( Transform.matrix, 1, 0, 0, -1,
(w - props.width ) / 2,
(h - props.height) / 2 );
var len = matrices.length;
for (var i = 0; i < len; ++i) {
m = A2( Transform.multiply, m, matrices[i] );
}
m = A2( Transform.multiply, m, formToMatrix(form) );
return 'matrix(' + str( m[0]) + ', ' + str( m[3]) + ', ' +
str(-m[1]) + ', ' + str(-m[4]) + ', ' +
str( m[2]) + ', ' + str( m[5]) + ')';
}
function stepperHelp(list) {
var arr = List.toArray(list);
var i = 0;
function peekNext() {
return i < arr.length ? arr[i].form.ctor : '';
}
// assumes that there is a next element
function next() {
var out = arr[i];
++i;
return out;
}
return {
peekNext:peekNext,
next:next
};
}
function formStepper(forms) {
var ps = [stepperHelp(forms)];
var matrices = [];
var alphas = [];
function peekNext() {
var len = ps.length;
var formType = '';
for (var i = 0; i < len; ++i ) {
if (formType = ps[i].peekNext()) return formType;
}
return '';
}
// assumes that there is a next element
function next(ctx) {
while (!ps[0].peekNext()) {
ps.shift();
matrices.pop();
alphas.shift();
if (ctx) { ctx.restore(); }
}
var out = ps[0].next();
var f = out.form;
if (f.ctor === 'FGroup') {
ps.unshift(stepperHelp(f._1));
var m = A2(Transform.multiply, f._0, formToMatrix(out));
ctx.save();
ctx.transform(m[0], m[3], m[1], m[4], m[2], m[5]);
matrices.push(m);
var alpha = (alphas[0] || 1) * out.alpha;
alphas.unshift(alpha);
ctx.globalAlpha = alpha;
}
return out;
}
function transforms() { return matrices; }
function alpha() { return alphas[0] || 1; }
return {
peekNext:peekNext,
next:next,
transforms:transforms,
alpha:alpha
};
}
function makeCanvas(w,h) {
var canvas = NativeElement.createNode('canvas');
canvas.style.width = w + 'px';
canvas.style.height = h + 'px';
canvas.style.display = "block";
canvas.style.position = "absolute";
canvas.width = w;
canvas.height = h;
return canvas;
}
function render(model) {
var div = NativeElement.createNode('div');
div.style.overflow = 'hidden';
div.style.position = 'relative';
update(div, model, model);
return div;
}
function nodeStepper(w,h,div) {
var kids = div.childNodes;
var i = 0;
function transform(transforms, ctx) {
ctx.translate(w/2, h/2);
ctx.scale(1,-1);
var len = transforms.length;
for (var i = 0; i < len; ++i) {
var m = transforms[i];
ctx.save();
ctx.transform(m[0], m[3], m[1], m[4], m[2], m[5]);
}
return ctx;
}
function nextContext(transforms) {
while (i < kids.length) {
var node = kids[i];
if (node.getContext) {
node.width = w;
node.height = h;
node.style.width = w + 'px';
node.style.height = h + 'px';
++i;
return transform(transforms, node.getContext('2d'));
}
div.removeChild(node);
}
var canvas = makeCanvas(w,h);
div.appendChild(canvas);
// we have added a new node, so we must step our position
++i;
return transform(transforms, canvas.getContext('2d'));
}
function addElement(matrices, alpha, form) {
var kid = kids[i];
var elem = form.form._0;
var node = (!kid || kid.getContext)
? NativeElement.render(elem)
: NativeElement.update(kid, kid.oldElement, elem);
node.style.position = 'absolute';
node.style.opacity = alpha * form.alpha * elem.props.opacity;
NativeElement.addTransform(node.style, makeTransform(w, h, form, matrices));
node.oldElement = elem;
++i;
if (!kid) {
div.appendChild(node);
} else if (kid.getContext) {
div.insertBefore(node, kid);
}
}
function clearRest() {
while (i < kids.length) {
div.removeChild(kids[i]);
}
}
return { nextContext:nextContext, addElement:addElement, clearRest:clearRest };
}
function update(div, _, model) {
var w = model.w;
var h = model.h;
var forms = formStepper(model.forms);
var nodes = nodeStepper(w,h,div);
var ctx = null;
var formType = '';
while (formType = forms.peekNext()) {
// make sure we have context if we need it
if (ctx === null && formType !== 'FElement') {
ctx = nodes.nextContext(forms.transforms());
ctx.globalAlpha = forms.alpha();
}
var form = forms.next(ctx);
// if it is FGroup, all updates are made within formStepper when next is called.
if (formType === 'FElement') {
// update or insert an element, get a new context
nodes.addElement(forms.transforms(), forms.alpha(), form);
ctx = null;
} else if (formType !== 'FGroup') {
renderForm(function() { update(div, model, model); }, ctx, form);
}
}
nodes.clearRest();
return div;
}
function collage(w,h,forms) {
return A3(Element.newElement, w, h, {
ctor: 'Custom',
type: 'Collage',
render: render,
update: update,
model: {w:w, h:h, forms:forms}
});
}
return Elm.Native.Graphics.Collage.values = {
collage:F3(collage)
};
};
// setup
Elm.Native = Elm.Native || {};
Elm.Native.Graphics = Elm.Native.Graphics || {};
Elm.Native.Graphics.Element = Elm.Native.Graphics.Element || {};
// definition
Elm.Native.Graphics.Element.make = function(localRuntime) {
'use strict';
// attempt to short-circuit
if ('values' in Elm.Native.Graphics.Element) {
return Elm.Native.Graphics.Element.values;
}
var Color = Elm.Native.Color.make(localRuntime);
var List = Elm.Native.List.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
function createNode(elementType) {
var node = document.createElement(elementType);
node.style.padding = "0";
node.style.margin = "0";
return node;
}
function setProps(elem, node) {
var props = elem.props;
var element = elem.element;
var width = props.width - (element.adjustWidth || 0);
var height = props.height - (element.adjustHeight || 0);
node.style.width = (width |0) + 'px';
node.style.height = (height|0) + 'px';
if (props.opacity !== 1) {
node.style.opacity = props.opacity;
}
if (props.color.ctor === 'Just') {
node.style.backgroundColor = Color.toCss(props.color._0);
}
if (props.tag !== '') {
node.id = props.tag;
}
if (props.hover.ctor !== '_Tuple0') {
addHover(node, props.hover);
}
if (props.click.ctor !== '_Tuple0') {
addClick(node, props.click);
}
if (props.href !== '') {
var anchor = createNode('a');
anchor.href = props.href;
anchor.style.display = 'block';
anchor.style.pointerEvents = 'auto';
anchor.appendChild(node);
node = anchor;
}
return node;
}
function addClick(e, handler) {
e.style.pointerEvents = 'auto';
e.elm_click_handler = handler;
function trigger(ev) {
e.elm_click_handler(Utils.Tuple0);
ev.stopPropagation();
}
e.elm_click_trigger = trigger;
e.addEventListener('click', trigger);
}
function removeClick(e, handler) {
if (e.elm_click_trigger) {
e.removeEventListener('click', e.elm_click_trigger);
e.elm_click_trigger = null;
e.elm_click_handler = null;
}
}
function addHover(e, handler) {
e.style.pointerEvents = 'auto';
e.elm_hover_handler = handler;
e.elm_hover_count = 0;
function over(evt) {
if (e.elm_hover_count++ > 0) return;
e.elm_hover_handler(true);
evt.stopPropagation();
}
function out(evt) {
if (e.contains(evt.toElement || evt.relatedTarget)) return;
e.elm_hover_count = 0;
e.elm_hover_handler(false);
evt.stopPropagation();
}
e.elm_hover_over = over;
e.elm_hover_out = out;
e.addEventListener('mouseover', over);
e.addEventListener('mouseout', out);
}
function removeHover(e) {
e.elm_hover_handler = null;
if (e.elm_hover_over) {
e.removeEventListener('mouseover', e.elm_hover_over);
e.elm_hover_over = null;
}
if (e.elm_hover_out) {
e.removeEventListener('mouseout', e.elm_hover_out);
e.elm_hover_out = null;
}
}
function image(props, img) {
switch (img._0.ctor) {
case 'Plain': return plainImage(img._3);
case 'Fitted': return fittedImage(props.width, props.height, img._3);
case 'Cropped': return croppedImage(img,props.width,props.height,img._3);
case 'Tiled': return tiledImage(img._3);
}
}
function plainImage(src) {
var img = createNode('img');
img.src = src;
img.name = src;
img.style.display = "block";
return img;
}
function tiledImage(src) {
var div = createNode('div');
div.style.backgroundImage = 'url(' + src + ')';
return div;
}
function fittedImage(w, h, src) {
var div = createNode('div');
div.style.background = 'url(' + src + ') no-repeat center';
div.style.webkitBackgroundSize = 'cover';
div.style.MozBackgroundSize = 'cover';
div.style.OBackgroundSize = 'cover';
div.style.backgroundSize = 'cover';
return div;
}
function croppedImage(elem, w, h, src) {
var pos = elem._0._0;
var e = createNode('div');
e.style.overflow = "hidden";
var img = createNode('img');
img.onload = function() {
var sw = w / elem._1, sh = h / elem._2;
img.style.width = ((this.width * sw)|0) + 'px';
img.style.height = ((this.height * sh)|0) + 'px';
img.style.marginLeft = ((- pos._0 * sw)|0) + 'px';
img.style.marginTop = ((- pos._1 * sh)|0) + 'px';
};
img.src = src;
img.name = src;
e.appendChild(img);
return e;
}
function goOut(node) {
node.style.position = 'absolute';
return node;
}
function goDown(node) {
return node;
}
function goRight(node) {
node.style.styleFloat = 'left';
node.style.cssFloat = 'left';
return node;
}
var directionTable = {
DUp : goDown,
DDown : goDown,
DLeft : goRight,
DRight : goRight,
DIn : goOut,
DOut : goOut
};
function needsReversal(dir) {
return dir == 'DUp' || dir == 'DLeft' || dir == 'DIn';
}
function flow(dir,elist) {
var array = List.toArray(elist);
var container = createNode('div');
var goDir = directionTable[dir];
if (goDir == goOut) {
container.style.pointerEvents = 'none';
}
if (needsReversal(dir)) {
array.reverse();
}
var len = array.length;
for (var i = 0; i < len; ++i) {
container.appendChild(goDir(render(array[i])));
}
return container;
}
function toPos(pos) {
switch(pos.ctor) {
case "Absolute": return pos._0 + "px";
case "Relative": return (pos._0 * 100) + "%";
}
}
// must clear right, left, top, bottom, and transform
// before calling this function
function setPos(pos,elem,e) {
var element = elem.element;
var props = elem.props;
var w = props.width + (element.adjustWidth ? element.adjustWidth : 0);
var h = props.height + (element.adjustHeight ? element.adjustHeight : 0);
e.style.position = 'absolute';
e.style.margin = 'auto';
var transform = '';
switch(pos.horizontal.ctor) {
case 'P': e.style.right = toPos(pos.x); e.style.removeProperty('left'); break;
case 'Z': transform = 'translateX(' + ((-w/2)|0) + 'px) ';
case 'N': e.style.left = toPos(pos.x); e.style.removeProperty('right'); break;
}
switch(pos.vertical.ctor) {
case 'N': e.style.bottom = toPos(pos.y); e.style.removeProperty('top'); break;
case 'Z': transform += 'translateY(' + ((-h/2)|0) + 'px)';
case 'P': e.style.top = toPos(pos.y); e.style.removeProperty('bottom'); break;
}
if (transform !== '') {
addTransform(e.style, transform);
}
return e;
}
function addTransform(style, transform) {
style.transform = transform;
style.msTransform = transform;
style.MozTransform = transform;
style.webkitTransform = transform;
style.OTransform = transform;
}
function container(pos,elem) {
var e = render(elem);
setPos(pos, elem, e);
var div = createNode('div');
div.style.position = 'relative';
div.style.overflow = 'hidden';
div.appendChild(e);
return div;
}
function rawHtml(elem) {
var html = elem.html;
var guid = elem.guid;
var align = elem.align;
var div = createNode('div');
div.innerHTML = html;
div.style.visibility = "hidden";
if (align) {
div.style.textAlign = align;
}
div.style.visibility = 'visible';
div.style.pointerEvents = 'auto';
return div;
}
function render(elem) {
return setProps(elem, makeElement(elem));
}
function makeElement(e) {
var elem = e.element;
switch(elem.ctor) {
case 'Image': return image(e.props, elem);
case 'Flow': return flow(elem._0.ctor, elem._1);
case 'Container': return container(elem._0, elem._1);
case 'Spacer': return createNode('div');
case 'RawHtml': return rawHtml(elem);
case 'Custom': return elem.render(elem.model);
}
}
function updateAndReplace(node, curr, next) {
var newNode = update(node, curr, next);
if (newNode !== node) {
node.parentNode.replaceChild(newNode, node);
}
return newNode;
}
function update(node, curr, next) {
var rootNode = node;
if (node.tagName === 'A') {
node = node.firstChild;
}
if (curr.props.id === next.props.id) {
updateProps(node, curr, next);
return rootNode;
}
if (curr.element.ctor !== next.element.ctor) {
return render(next);
}
var nextE = next.element;
var currE = curr.element;
switch(nextE.ctor) {
case "Spacer":
updateProps(node, curr, next);
return rootNode;
case "RawHtml":
// only markdown blocks have guids, so this must be a text block
if (nextE.guid === null) {
if(currE.html.valueOf() !== nextE.html.valueOf()) {
node.innerHTML = nextE.html;
}
updateProps(node, curr, next);
return rootNode;
}
if (nextE.guid !== currE.guid) {
return render(next);
}
updateProps(node, curr, next);
return rootNode;
case "Image":
if (nextE._0.ctor === 'Plain') {
if (nextE._3 !== currE._3) {
node.src = nextE._3;
}
} else if (!Utils.eq(nextE,currE) ||
next.props.width !== curr.props.width ||
next.props.height !== curr.props.height) {
return render(next);
}
updateProps(node, curr, next);
return rootNode;
case "Flow":
var arr = List.toArray(nextE._1);
for (var i = arr.length; i--; ) {
arr[i] = arr[i].element.ctor;
}
if (nextE._0.ctor !== currE._0.ctor) {
return render(next);
}
var nexts = List.toArray(nextE._1);
var kids = node.childNodes;
if (nexts.length !== kids.length) {
return render(next);
}
var currs = List.toArray(currE._1);
var dir = nextE._0.ctor;
var goDir = directionTable[dir];
var toReverse = needsReversal(dir);
var len = kids.length;
for (var i = len; i-- ;) {
var subNode = kids[toReverse ? len - i - 1 : i];
goDir(updateAndReplace(subNode, currs[i], nexts[i]));
}
updateProps(node, curr, next);
return rootNode;
case "Container":
var subNode = node.firstChild;
var newSubNode = updateAndReplace(subNode, currE._1, nextE._1);
setPos(nextE._0, nextE._1, newSubNode);
updateProps(node, curr, next);
return rootNode;
case "Custom":
if (currE.type === nextE.type) {
var updatedNode = nextE.update(node, currE.model, nextE.model);
updateProps(updatedNode, curr, next);
return updatedNode;
} else {
return render(next);
}
}
}
function updateProps(node, curr, next) {
var nextProps = next.props;
var currProps = curr.props;
var element = next.element;
var width = nextProps.width - (element.adjustWidth || 0);
var height = nextProps.height - (element.adjustHeight || 0);
if (width !== currProps.width) {
node.style.width = (width|0) + 'px';
}
if (height !== currProps.height) {
node.style.height = (height|0) + 'px';
}
if (nextProps.opacity !== currProps.opacity) {
node.style.opacity = nextProps.opacity;
}
var nextColor = nextProps.color.ctor === 'Just'
? Color.toCss(nextProps.color._0)
: '';
if (node.style.backgroundColor !== nextColor) {
node.style.backgroundColor = nextColor;
}
if (nextProps.tag !== currProps.tag) {
node.id = nextProps.tag;
}
if (nextProps.href !== currProps.href) {
if (currProps.href === '') {
// add a surrounding href
var anchor = createNode('a');
anchor.href = nextProps.href;
anchor.style.display = 'block';
anchor.style.pointerEvents = 'auto';
node.parentNode.replaceChild(anchor, node);
anchor.appendChild(node);
} else if (nextProps.href === '') {
// remove the surrounding href
var anchor = node.parentNode;
anchor.parentNode.replaceChild(node, anchor);
} else {
// just update the link
node.parentNode.href = nextProps.href;
}
}
// update click and hover handlers
var removed = false;
// update hover handlers
if (currProps.hover.ctor === '_Tuple0') {
if (nextProps.hover.ctor !== '_Tuple0') {
addHover(node, nextProps.hover);
}
}
else {
if (nextProps.hover.ctor === '_Tuple0') {
removed = true;
removeHover(node);
}
else {
node.elm_hover_handler = nextProps.hover;
}
}
// update click handlers
if (currProps.click.ctor === '_Tuple0') {
if (nextProps.click.ctor !== '_Tuple0') {
addClick(node, nextProps.click);
}
}
else {
if (nextProps.click.ctor === '_Tuple0') {
removed = true;
removeClick(node);
} else {
node.elm_click_handler = nextProps.click;
}
}
// stop capturing clicks if
if (removed
&& nextProps.hover.ctor === '_Tuple0'
&& nextProps.click.ctor === '_Tuple0')
{
node.style.pointerEvents = 'none';
}
}
function htmlHeight(width, rawHtml) {
// create dummy node
var temp = document.createElement('div');
temp.innerHTML = rawHtml.html;
if (width > 0) {
temp.style.width = width + "px";
}
temp.style.visibility = "hidden";
temp.style.styleFloat = "left";
temp.style.cssFloat = "left";
document.body.appendChild(temp);
// get dimensions
var style = window.getComputedStyle(temp, null);
var w = Math.ceil(style.getPropertyValue("width").slice(0,-2) - 0);
var h = Math.ceil(style.getPropertyValue("height").slice(0,-2) - 0);
document.body.removeChild(temp);
return Utils.Tuple2(w,h);
}
return Elm.Native.Graphics.Element.values = {
render: render,
update: update,
updateAndReplace: updateAndReplace,
createNode: createNode,
addTransform: addTransform,
htmlHeight: F2(htmlHeight),
guid: Utils.guid
};
};
Elm.Native.List = {};
Elm.Native.List.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.List = elm.Native.List || {};
if (elm.Native.List.values) return elm.Native.List.values;
if ('values' in Elm.Native.List)
return elm.Native.List.values = Elm.Native.List.values;
var Utils = Elm.Native.Utils.make(elm);
var Nil = Utils.Nil;
var Cons = Utils.Cons;
function throwError(f) {
throw new Error("Function '" + f + "' expects a non-empty list!");
}
function toArray(xs) {
var out = [];
while (xs.ctor !== '[]') {
out.push(xs._0);
xs = xs._1;
}
return out;
}
function fromArray(arr) {
var out = Nil;
for (var i = arr.length; i--; ) {
out = Cons(arr[i], out);
}
return out;
}
function range(lo,hi) {
var lst = Nil;
if (lo <= hi) {
do { lst = Cons(hi,lst) } while (hi-->lo);
}
return lst
}
function head(v) {
return v.ctor === '[]' ? throwError('head') : v._0;
}
function tail(v) {
return v.ctor === '[]' ? throwError('tail') : v._1;
}
function last(xs) {
if (xs.ctor === '[]') { throwError('last'); }
var out = xs._0;
while (xs.ctor !== '[]') {
out = xs._0;
xs = xs._1;
}
return out;
}
function map(f, xs) {
var arr = [];
while (xs.ctor !== '[]') {
arr.push(f(xs._0));
xs = xs._1;
}
return fromArray(arr);
}
// f defined similarly for both foldl and foldr (NB: different from Haskell)
// ie, foldl : (a -> b -> b) -> b -> [a] -> b
function foldl(f, b, xs) {
var acc = b;
while (xs.ctor !== '[]') {
acc = A2(f, xs._0, acc);
xs = xs._1;
}
return acc;
}
function foldr(f, b, xs) {
var arr = toArray(xs);
var acc = b;
for (var i = arr.length; i--; ) {
acc = A2(f, arr[i], acc);
}
return acc;
}
function foldl1(f, xs) {
return xs.ctor === '[]' ? throwError('foldl1') : foldl(f, xs._0, xs._1);
}
function foldr1(f, xs) {
if (xs.ctor === '[]') { throwError('foldr1'); }
var arr = toArray(xs);
var acc = arr.pop();
for (var i = arr.length; i--; ) {
acc = A2(f, arr[i], acc);
}
return acc;
}
function scanl(f, b, xs) {
var arr = toArray(xs);
arr.unshift(b);
var len = arr.length;
for (var i = 1; i < len; ++i) {
arr[i] = A2(f, arr[i], arr[i-1]);
}
return fromArray(arr);
}
function scanl1(f, xs) {
return xs.ctor === '[]' ? throwError('scanl1') : scanl(f, xs._0, xs._1);
}
function filter(pred, xs) {
var arr = [];
while (xs.ctor !== '[]') {
if (pred(xs._0)) { arr.push(xs._0); }
xs = xs._1;
}
return fromArray(arr);
}
function length(xs) {
var out = 0;
while (xs.ctor !== '[]') {
out += 1;
xs = xs._1;
}
return out;
}
function member(x, xs) {
while (xs.ctor !== '[]') {
if (Utils.eq(x,xs._0)) return true;
xs = xs._1;
}
return false;
}
function reverse(xs) {
return fromArray(toArray(xs).reverse());
}
function append(xs, ys) {
if (xs.ctor === '[]') {
return ys;
}
var root = Cons(xs._0, Nil);
var curr = root;
xs = xs._1;
while (xs.ctor !== '[]') {
curr._1 = Cons(xs._0, Nil);
xs = xs._1;
curr = curr._1;
}
curr._1 = ys;
return root;
}
function all(pred, xs) {
while (xs.ctor !== '[]') {
if (!pred(xs._0)) return false;
xs = xs._1;
}
return true;
}
function any(pred, xs) {
while (xs.ctor !== '[]') {
if (pred(xs._0)) return true;
xs = xs._1;
}
return false;
}
function map2(f, xs, ys) {
var arr = [];
while (xs.ctor !== '[]' && ys.ctor !== '[]') {
arr.push(A2(f, xs._0, ys._0));
xs = xs._1;
ys = ys._1;
}
return fromArray(arr);
}
function map3(f, xs, ys, zs) {
var arr = [];
while (xs.ctor !== '[]' && ys.ctor !== '[]' && zs.ctor !== '[]') {
arr.push(A3(f, xs._0, ys._0, zs._0));
xs = xs._1;
ys = ys._1;
zs = zs._1;
}
return fromArray(arr);
}
function map4(f, ws, xs, ys, zs) {
var arr = [];
while ( ws.ctor !== '[]'
&& xs.ctor !== '[]'
&& ys.ctor !== '[]'
&& zs.ctor !== '[]')
{
arr.push(A4(f, ws._0, xs._0, ys._0, zs._0));
ws = ws._1;
xs = xs._1;
ys = ys._1;
zs = zs._1;
}
return fromArray(arr);
}
function map5(f, vs, ws, xs, ys, zs) {
var arr = [];
while ( vs.ctor !== '[]'
&& ws.ctor !== '[]'
&& xs.ctor !== '[]'
&& ys.ctor !== '[]'
&& zs.ctor !== '[]')
{
arr.push(A5(f, vs._0, ws._0, xs._0, ys._0, zs._0));
vs = vs._1;
ws = ws._1;
xs = xs._1;
ys = ys._1;
zs = zs._1;
}
return fromArray(arr);
}
function sort(xs) {
return fromArray(toArray(xs).sort(Utils.cmp));
}
function sortBy(f, xs) {
return fromArray(toArray(xs).sort(function(a,b){
return Utils.cmp(f(a), f(b));
}));
}
function sortWith(f, xs) {
return fromArray(toArray(xs).sort(function(a,b){
var ord = f(a)(b).ctor;
return ord === 'EQ' ? 0 : ord === 'LT' ? -1 : 1;
}));
}
function nth(xs, n) {
return toArray(xs)[n];
}
function take(n, xs) {
var arr = [];
while (xs.ctor !== '[]' && n > 0) {
arr.push(xs._0);
xs = xs._1;
--n;
}
return fromArray(arr);
}
function drop(n, xs) {
while (xs.ctor !== '[]' && n > 0) {
xs = xs._1;
--n;
}
return xs;
}
function repeat(n, x) {
var arr = [];
var pattern = [x];
while (n > 0) {
if (n & 1) arr = arr.concat(pattern);
n >>= 1, pattern = pattern.concat(pattern);
}
return fromArray(arr);
}
Elm.Native.List.values = {
Nil:Nil,
Cons:Cons,
cons:F2(Cons),
toArray:toArray,
fromArray:fromArray,
range:range,
append: F2(append),
head:head,
tail:tail,
last:last,
map:F2(map),
foldl:F3(foldl),
foldr:F3(foldr),
foldl1:F2(foldl1),
foldr1:F2(foldr1),
scanl:F3(scanl),
scanl1:F2(scanl1),
filter:F2(filter),
length:length,
member:F2(member),
reverse:reverse,
all:F2(all),
any:F2(any),
map2:F3(map2),
map3:F4(map3),
map4:F5(map4),
map5:F6(map5),
sort:sort,
sortBy:F2(sortBy),
sortWith:F2(sortWith),
nth:F2(nth),
take:F2(take),
drop:F2(drop),
repeat:F2(repeat)
};
return elm.Native.List.values = Elm.Native.List.values;
};
Elm.Native = Elm.Native || {};
Elm.Native.Mouse = {};
Elm.Native.Mouse.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Mouse = localRuntime.Native.Mouse || {};
if (localRuntime.Native.Mouse.values) {
return localRuntime.Native.Mouse.values;
}
var Signal = Elm.Signal.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
var position = Signal.constant(Utils.Tuple2(0,0));
position.defaultNumberOfKids = 2;
// do not move x and y into Elm. By setting their default number
// of kids, it is possible to detatch the mouse listeners if
// they are not needed.
function fst(pair) {
return pair._0;
}
function snd(pair) {
return pair._0;
}
var x = A2( Signal.map, fst, position );
x.defaultNumberOfKids = 0;
var y = A2( Signal.map, snd, position );
y.defaultNumberOfKids = 0;
var isDown = Signal.constant(false);
var clicks = Signal.constant(Utils.Tuple0);
var node = localRuntime.isFullscreen()
? document
: localRuntime.node;
localRuntime.addListener([clicks.id], node, 'click', function click() {
localRuntime.notify(clicks.id, Utils.Tuple0);
});
localRuntime.addListener([isDown.id], node, 'mousedown', function down() {
localRuntime.notify(isDown.id, true);
});
localRuntime.addListener([isDown.id], node, 'mouseup', function up() {
localRuntime.notify(isDown.id, false);
});
localRuntime.addListener([position.id], node, 'mousemove', function move(e) {
localRuntime.notify(position.id, Utils.getXY(e));
});
return localRuntime.Native.Mouse.values = {
position: position,
x: x,
y: y,
isDown: isDown,
clicks: clicks
};
};
Elm.Native.Ports = {};
Elm.Native.Ports.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Ports = localRuntime.Native.Ports || {};
if (localRuntime.Native.Ports.values) {
return localRuntime.Native.Ports.values;
}
var Signal;
function incomingSignal(converter) {
converter.isSignal = true;
return converter;
}
function outgoingSignal(converter) {
if (!Signal) {
Signal = Elm.Signal.make(localRuntime);
}
return function(signal) {
var subscribers = []
function subscribe(handler) {
subscribers.push(handler);
}
function unsubscribe(handler) {
subscribers.pop(subscribers.indexOf(handler));
}
A2( Signal.map, function(value) {
var val = converter(value);
var len = subscribers.length;
for (var i = 0; i < len; ++i) {
subscribers[i](val);
}
}, signal);
return { subscribe:subscribe, unsubscribe:unsubscribe };
}
}
function portIn(name, converter) {
var jsValue = localRuntime.ports.incoming[name];
if (jsValue === undefined) {
throw new Error("Initialization Error: port '" + name +
"' was not given an input!");
}
localRuntime.ports.uses[name] += 1;
try {
var elmValue = converter(jsValue);
} catch(e) {
throw new Error("Initialization Error on port '" + name + "': \n" + e.message);
}
// just return a static value if it is not a signal
if (!converter.isSignal) {
return elmValue;
}
// create a signal if necessary
if (!Signal) {
Signal = Elm.Signal.make(localRuntime);
}
var signal = Signal.constant(elmValue);
function send(jsValue) {
try {
var elmValue = converter(jsValue);
} catch(e) {
throw new Error("Error sending to port '" + name + "': \n" + e.message);
}
setTimeout(function() {
localRuntime.notify(signal.id, elmValue);
}, 0);
}
localRuntime.ports.outgoing[name] = { send:send };
return signal;
}
function portOut(name, converter, value) {
try {
localRuntime.ports.outgoing[name] = converter(value);
} catch(e) {
throw new Error("Initialization Error on port '" + name + "': \n" + e.message);
}
return value;
}
return localRuntime.Native.Ports.values = {
incomingSignal: incomingSignal,
outgoingSignal: outgoingSignal,
portOut: portOut,
portIn: portIn
};
};
if (!Elm.fullscreen) {
(function() {
'use strict';
var Display = { FULLSCREEN: 0, COMPONENT: 1, NONE: 2 };
Elm.fullscreen = function(module, ports) {
var container = document.createElement('div');
document.body.appendChild(container);
return init(Display.FULLSCREEN, container, module, ports || {});
};
Elm.embed = function(module, container, ports) {
var tag = container.tagName;
if (tag !== 'DIV') {
throw new Error('Elm.node must be given a DIV, not a ' + tag + '.');
} else if (container.hasChildNodes()) {
throw new Error('Elm.node must be given an empty DIV. No children allowed!');
}
return init(Display.COMPONENT, container, module, ports || {});
};
Elm.worker = function(module, ports) {
return init(Display.NONE, {}, module, ports || {});
};
function init(display, container, module, ports, moduleToReplace) {
// defining state needed for an instance of the Elm RTS
var inputs = [];
/* OFFSET
* Elm's time traveling debugger lets you interrupt the smooth flow of time
* by pausing and continuing program execution. To ensure the user sees a
* program that moves smoothly through the pause/continue time gap,
* we need to adjsut the value of Date.now().
*/
var timer = function() {
var inducedDelay = 0;
var now = function() {
return Date.now() - inducedDelay;
};
var addDelay = function(d) {
inducedDelay += d;
return inducedDelay;
};
return {
now : now,
addDelay : addDelay
}
}();
var updateInProgress = false;
function notify(id, v) {
if (updateInProgress) {
throw new Error(
'The notify function has been called synchronously!\n' +
'This can lead to frames being dropped.\n' +
'Definitely report this to <https://github.com/elm-lang/Elm/issues>\n');
}
updateInProgress = true;
var timestep = timer.now();
for (var i = inputs.length; i--; ) {
inputs[i].recv(timestep, id, v);
}
updateInProgress = false;
}
function setTimeout(func, delay) {
window.setTimeout(func, delay);
}
var listeners = [];
function addListener(relevantInputs, domNode, eventName, func) {
domNode.addEventListener(eventName, func);
var listener = {
relevantInputs: relevantInputs,
domNode: domNode,
eventName: eventName,
func: func
};
listeners.push(listener);
}
var portUses = {}
for (var key in ports) {
portUses[key] = 0;
}
// create the actual RTS. Any impure modules will attach themselves to this
// object. This permits many Elm programs to be embedded per document.
var elm = {
notify: notify,
setTimeout: setTimeout,
node: container,
addListener: addListener,
inputs: inputs,
timer: timer,
ports: { incoming:ports, outgoing:{}, uses:portUses },
isFullscreen: function() { return display === Display.FULLSCREEN; },
isEmbed: function() { return display === Display.COMPONENT; },
isWorker: function() { return display === Display.NONE; }
};
function swap(newModule) {
removeListeners(listeners);
var div = document.createElement('div');
var newElm = init(display, div, newModule, ports, elm);
inputs = [];
// elm.swap = newElm.swap;
return newElm;
}
function dispose() {
removeListeners(listeners);
inputs = [];
}
var Module = {};
try {
Module = module.make(elm);
checkPorts(elm);
} catch(e) {
var code = document.createElement('code');
var lines = e.message.split('\n');
code.appendChild(document.createTextNode(lines[0]));
code.appendChild(document.createElement('br'));
code.appendChild(document.createElement('br'));
for (var i = 1; i < lines.length; ++i) {
code.appendChild(document.createTextNode('\u00A0 \u00A0 ' + lines[i]));
code.appendChild(document.createElement('br'));
}
code.appendChild(document.createElement('br'));
code.appendChild(document.createTextNode("Open the developer console for more details."));
container.appendChild(code);
throw e;
}
inputs = filterDeadInputs(inputs);
filterListeners(inputs, listeners);
addReceivers(elm.ports.outgoing);
if (display !== Display.NONE) {
var graphicsNode = initGraphics(elm, Module);
}
if (typeof moduleToReplace !== 'undefined') {
hotSwap(moduleToReplace, elm);
// rerender scene if graphics are enabled.
if (typeof graphicsNode !== 'undefined') {
graphicsNode.recv(0, true, 0);
}
}
return {
swap:swap,
ports:elm.ports.outgoing,
dispose:dispose
};
};
function checkPorts(elm) {
var portUses = elm.ports.uses;
for (var key in portUses) {
var uses = portUses[key]
if (uses === 0) {
throw new Error(
"Initialization Error: provided port '" + key +
"' to a module that does not take it as in input.\n" +
"Remove '" + key + "' from the module initialization code.");
} else if (uses > 1) {
throw new Error(
"Initialization Error: port '" + key +
"' has been declared multiple times in the Elm code.\n" +
"Remove declarations until there is exactly one.");
}
}
}
//// FILTER SIGNALS ////
// TODO: move this code into the signal module and create a function
// Signal.initializeGraph that actually instantiates everything.
function filterListeners(inputs, listeners) {
loop:
for (var i = listeners.length; i--; ) {
var listener = listeners[i];
for (var j = inputs.length; j--; ) {
if (listener.relevantInputs.indexOf(inputs[j].id) >= 0) {
continue loop;
}
}
listener.domNode.removeEventListener(listener.eventName, listener.func);
}
}
function removeListeners(listeners) {
for (var i = listeners.length; i--; ) {
var listener = listeners[i];
listener.domNode.removeEventListener(listener.eventName, listener.func);
}
}
// add receivers for built-in ports if they are defined
function addReceivers(ports) {
if ('log' in ports) {
ports.log.subscribe(function(v) { console.log(v) });
}
if ('stdout' in ports) {
var process = process || {};
var handler = process.stdout
? function(v) { process.stdout.write(v); }
: function(v) { console.log(v); };
ports.stdout.subscribe(handler);
}
if ('stderr' in ports) {
var process = process || {};
var handler = process.stderr
? function(v) { process.stderr.write(v); }
: function(v) { console.log('Error:' + v); };
ports.stderr.subscribe(handler);
}
if ('title' in ports) {
if (typeof ports.title === 'string') {
document.title = ports.title;
} else {
ports.title.subscribe(function(v) { document.title = v; });
}
}
if ('redirect' in ports) {
ports.redirect.subscribe(function(v) {
if (v.length > 0) window.location = v;
});
}
if ('favicon' in ports) {
if (typeof ports.favicon === 'string') {
changeFavicon(ports.favicon);
} else {
ports.favicon.subscribe(changeFavicon);
}
}
function changeFavicon(src) {
var link = document.createElement('link');
var oldLink = document.getElementById('elm-favicon');
link.id = 'elm-favicon';
link.rel = 'shortcut icon';
link.href = src;
if (oldLink) {
document.head.removeChild(oldLink);
}
document.head.appendChild(link);
}
}
function filterDeadInputs(inputs) {
var temp = [];
for (var i = inputs.length; i--; ) {
if (isAlive(inputs[i])) temp.push(inputs[i]);
}
return temp;
}
function isAlive(input) {
if (!('defaultNumberOfKids' in input)) return true;
var len = input.kids.length;
if (len === 0) return false;
if (len > input.defaultNumberOfKids) return true;
var alive = false;
for (var i = len; i--; ) {
alive = alive || isAlive(input.kids[i]);
}
return alive;
}
//// RENDERING ////
function initGraphics(elm, Module) {
if (!('main' in Module)) {
throw new Error("'main' is missing! What do I display?!");
}
var signalGraph = Module.main;
// make sure the signal graph is actually a signal & extract the visual model
var Signal = Elm.Signal.make(elm);
if (!('recv' in signalGraph)) {
signalGraph = Signal.constant(signalGraph);
}
var initialScene = signalGraph.value;
// Add the initialScene to the DOM
var Element = Elm.Native.Graphics.Element.make(elm);
elm.node.appendChild(Element.render(initialScene));
var _requestAnimationFrame =
typeof requestAnimationFrame !== 'undefined'
? requestAnimationFrame
: function(cb) { setTimeout(cb, 1000/60); }
;
// domUpdate is called whenever the main Signal changes.
//
// domUpdate and drawCallback implement a small state machine in order
// to schedule only 1 draw per animation frame. This enforces that
// once draw has been called, it will not be called again until the
// next frame.
//
// drawCallback is scheduled whenever
// 1. The state transitions from PENDING_REQUEST to EXTRA_REQUEST, or
// 2. The state transitions from NO_REQUEST to PENDING_REQUEST
//
// Invariants:
// 1. In the NO_REQUEST state, there is never a scheduled drawCallback.
// 2. In the PENDING_REQUEST and EXTRA_REQUEST states, there is always exactly 1
// scheduled drawCallback.
var NO_REQUEST = 0;
var PENDING_REQUEST = 1;
var EXTRA_REQUEST = 2;
var state = NO_REQUEST;
var savedScene = initialScene;
var scheduledScene = initialScene;
function domUpdate(newScene) {
scheduledScene = newScene;
switch (state) {
case NO_REQUEST:
_requestAnimationFrame(drawCallback);
state = PENDING_REQUEST;
return;
case PENDING_REQUEST:
state = PENDING_REQUEST;
return;
case EXTRA_REQUEST:
state = PENDING_REQUEST;
return;
}
}
function drawCallback() {
switch (state) {
case NO_REQUEST:
// This state should not be possible. How can there be no
// request, yet somehow we are actively fulfilling a
// request?
throw new Error(
"Unexpected draw callback.\n" +
"Please report this to <https://github.com/elm-lang/core/issues>."
);
case PENDING_REQUEST:
// At this point, we do not *know* that another frame is
// needed, but we make an extra request to rAF just in
// case. It's possible to drop a frame if rAF is called
// too late, so we just do it preemptively.
_requestAnimationFrame(drawCallback);
state = EXTRA_REQUEST;
// There's also stuff we definitely need to draw.
draw();
return;
case EXTRA_REQUEST:
// Turns out the extra request was not needed, so we will
// stop calling rAF. No reason to call it all the time if
// no one needs it.
state = NO_REQUEST;
return;
}
}
function draw() {
Element.updateAndReplace(elm.node.firstChild, savedScene, scheduledScene);
if (elm.Native.Window) {
elm.Native.Window.values.resizeIfNeeded();
}
savedScene = scheduledScene;
}
var renderer = A2(Signal.map, domUpdate, signalGraph);
// must check for resize after 'renderer' is created so
// that changes show up.
if (elm.Native.Window) {
elm.Native.Window.values.resizeIfNeeded();
}
return renderer;
}
//// HOT SWAPPING ////
// Returns boolean indicating if the swap was successful.
// Requires that the two signal graphs have exactly the same
// structure.
function hotSwap(from, to) {
function similar(nodeOld,nodeNew) {
var idOkay = nodeOld.id === nodeNew.id;
var lengthOkay = nodeOld.kids.length === nodeNew.kids.length;
return idOkay && lengthOkay;
}
function swap(nodeOld,nodeNew) {
nodeNew.value = nodeOld.value;
return true;
}
var canSwap = depthFirstTraversals(similar, from.inputs, to.inputs);
if (canSwap) {
depthFirstTraversals(swap, from.inputs, to.inputs);
}
from.node.parentNode.replaceChild(to.node, from.node);
return canSwap;
}
// Returns false if the node operation f ever fails.
function depthFirstTraversals(f, queueOld, queueNew) {
if (queueOld.length !== queueNew.length) return false;
queueOld = queueOld.slice(0);
queueNew = queueNew.slice(0);
var seen = [];
while (queueOld.length > 0 && queueNew.length > 0) {
var nodeOld = queueOld.pop();
var nodeNew = queueNew.pop();
if (seen.indexOf(nodeOld.id) < 0) {
if (!f(nodeOld, nodeNew)) return false;
queueOld = queueOld.concat(nodeOld.kids);
queueNew = queueNew.concat(nodeNew.kids);
seen.push(nodeOld.id);
}
}
return true;
}
}());
function F2(fun) {
function wrapper(a) { return function(b) { return fun(a,b) } }
wrapper.arity = 2;
wrapper.func = fun;
return wrapper;
}
function F3(fun) {
function wrapper(a) {
return function(b) { return function(c) { return fun(a,b,c) }}
}
wrapper.arity = 3;
wrapper.func = fun;
return wrapper;
}
function F4(fun) {
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return fun(a,b,c,d) }}}
}
wrapper.arity = 4;
wrapper.func = fun;
return wrapper;
}
function F5(fun) {
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return function(e) { return fun(a,b,c,d,e) }}}}
}
wrapper.arity = 5;
wrapper.func = fun;
return wrapper;
}
function F6(fun) {
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return function(e) { return function(f) {
return fun(a,b,c,d,e,f) }}}}}
}
wrapper.arity = 6;
wrapper.func = fun;
return wrapper;
}
function F7(fun) {
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return function(e) { return function(f) {
return function(g) { return fun(a,b,c,d,e,f,g) }}}}}}
}
wrapper.arity = 7;
wrapper.func = fun;
return wrapper;
}
function F8(fun) {
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return function(e) { return function(f) {
return function(g) { return function(h) {
return fun(a,b,c,d,e,f,g,h)}}}}}}}
}
wrapper.arity = 8;
wrapper.func = fun;
return wrapper;
}
function F9(fun) {
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return function(e) { return function(f) {
return function(g) { return function(h) { return function(i) {
return fun(a,b,c,d,e,f,g,h,i) }}}}}}}}
}
wrapper.arity = 9;
wrapper.func = fun;
return wrapper;
}
function A2(fun,a,b) {
return fun.arity === 2
? fun.func(a,b)
: fun(a)(b);
}
function A3(fun,a,b,c) {
return fun.arity === 3
? fun.func(a,b,c)
: fun(a)(b)(c);
}
function A4(fun,a,b,c,d) {
return fun.arity === 4
? fun.func(a,b,c,d)
: fun(a)(b)(c)(d);
}
function A5(fun,a,b,c,d,e) {
return fun.arity === 5
? fun.func(a,b,c,d,e)
: fun(a)(b)(c)(d)(e);
}
function A6(fun,a,b,c,d,e,f) {
return fun.arity === 6
? fun.func(a,b,c,d,e,f)
: fun(a)(b)(c)(d)(e)(f);
}
function A7(fun,a,b,c,d,e,f,g) {
return fun.arity === 7
? fun.func(a,b,c,d,e,f,g)
: fun(a)(b)(c)(d)(e)(f)(g);
}
function A8(fun,a,b,c,d,e,f,g,h) {
return fun.arity === 8
? fun.func(a,b,c,d,e,f,g,h)
: fun(a)(b)(c)(d)(e)(f)(g)(h);
}
function A9(fun,a,b,c,d,e,f,g,h,i) {
return fun.arity === 9
? fun.func(a,b,c,d,e,f,g,h,i)
: fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
}
}
Elm.Native.Show = {};
Elm.Native.Show.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Show = elm.Native.Show || {};
if (elm.Native.Show.values) return elm.Native.Show.values;
var _Array;
var Dict;
var List;
var Utils = Elm.Native.Utils.make(elm);
var toString = function(v) {
var type = typeof v;
if (type === "function") {
var name = v.func ? v.func.name : v.name;
return '<function' + (name === '' ? '' : ': ') + name + '>';
}
else if (type === "boolean") {
return v ? "True" : "False";
}
else if (type === "number") {
return v + "";
}
else if ((v instanceof String) && v.isChar) {
return "'" + addSlashes(v) + "'";
}
else if (type === "string") {
return '"' + addSlashes(v) + '"';
}
else if (type === "object" && '_' in v && probablyPublic(v)) {
var output = [];
for (var k in v._) {
for (var i = v._[k].length; i--; ) {
output.push(k + " = " + toString(v._[k][i]));
}
}
for (var k in v) {
if (k === '_') continue;
output.push(k + " = " + toString(v[k]));
}
if (output.length === 0) {
return "{}";
}
return "{ " + output.join(", ") + " }";
}
else if (type === "object" && 'ctor' in v) {
if (v.ctor.substring(0,6) === "_Tuple") {
var output = [];
for (var k in v) {
if (k === 'ctor') continue;
output.push(toString(v[k]));
}
return "(" + output.join(",") + ")";
}
else if (v.ctor === "_Array") {
if (!_Array) {
_Array = Elm.Array.make(elm);
}
var list = _Array.toList(v);
return "Array.fromList " + toString(list);
}
else if (v.ctor === "::") {
var output = '[' + toString(v._0);
v = v._1;
while (v.ctor === "::") {
output += "," + toString(v._0);
v = v._1;
}
return output + ']';
}
else if (v.ctor === "[]") {
return "[]";
}
else if (v.ctor === "RBNode" || v.ctor === "RBEmpty") {
if (!Dict) {
Dict = Elm.Dict.make(elm);
}
if (!List) {
List = Elm.List.make(elm);
}
var list = Dict.toList(v);
var name = "Dict";
if (list.ctor === "::" && list._0._1.ctor === "_Tuple0") {
name = "Set";
list = A2(List.map, function(x){return x._0}, list);
}
return name + ".fromList " + toString(list);
}
else {
var output = "";
for (var i in v) {
if (i === 'ctor') continue;
var str = toString(v[i]);
var parenless = str[0] === '{' || str[0] === '<' || str.indexOf(' ') < 0;
output += ' ' + (parenless ? str : '(' + str + ')');
}
return v.ctor + output;
}
}
if (type === 'object' && 'recv' in v) {
return '<signal>';
}
return "<internal structure>";
};
function addSlashes(str) {
return str.replace(/\\/g, '\\\\')
.replace(/\n/g, '\\n')
.replace(/\t/g, '\\t')
.replace(/\r/g, '\\r')
.replace(/\v/g, '\\v')
.replace(/\0/g, '\\0')
.replace(/\'/g, "\\'")
.replace(/\"/g, '\\"');
}
function probablyPublic(v) {
var keys = Object.keys(v);
var len = keys.length;
if (len === 3
&& 'props' in v
&& 'element' in v)
{
return false;
}
else if (len === 5
&& 'horizontal' in v
&& 'vertical' in v
&& 'x' in v
&& 'y' in v)
{
return false;
}
else if (len === 7
&& 'theta' in v
&& 'scale' in v
&& 'x' in v
&& 'y' in v
&& 'alpha' in v
&& 'form' in v)
{
return false;
}
return true;
}
return elm.Native.Show.values = {
toString: toString
};
};
Elm.Native.Signal = {};
Elm.Native.Signal.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Signal = localRuntime.Native.Signal || {};
if (localRuntime.Native.Signal.values) {
return localRuntime.Native.Signal.values;
}
var Utils = Elm.Native.Utils.make(localRuntime);
function broadcastToKids(node, timestep, changed) {
var kids = node.kids;
for (var i = kids.length; i--; ) {
kids[i].recv(timestep, changed, node.id);
}
}
function Input(base) {
this.id = Utils.guid();
this.value = base;
this.kids = [];
this.defaultNumberOfKids = 0;
this.recv = function(timestep, eid, v) {
var changed = eid === this.id;
if (changed) {
this.value = v;
}
broadcastToKids(this, timestep, changed);
return changed;
};
localRuntime.inputs.push(this);
}
function LiftN(update, args) {
this.id = Utils.guid();
this.value = update();
this.kids = [];
var n = args.length;
var count = 0;
var isChanged = false;
this.recv = function(timestep, changed, parentID) {
++count;
if (changed) { isChanged = true; }
if (count == n) {
if (isChanged) { this.value = update(); }
broadcastToKids(this, timestep, isChanged);
isChanged = false;
count = 0;
}
};
for (var i = n; i--; ) { args[i].kids.push(this); }
}
function map(func, a) {
function update() { return func(a.value); }
return new LiftN(update, [a]);
}
function map2(func, a, b) {
function update() { return A2( func, a.value, b.value ); }
return new LiftN(update, [a,b]);
}
function map3(func, a, b, c) {
function update() { return A3( func, a.value, b.value, c.value ); }
return new LiftN(update, [a,b,c]);
}
function map4(func, a, b, c, d) {
function update() { return A4( func, a.value, b.value, c.value, d.value ); }
return new LiftN(update, [a,b,c,d]);
}
function map5(func, a, b, c, d, e) {
function update() { return A5( func, a.value, b.value, c.value, d.value, e.value ); }
return new LiftN(update, [a,b,c,d,e]);
}
function Foldp(step, state, input) {
this.id = Utils.guid();
this.value = state;
this.kids = [];
this.recv = function(timestep, changed, parentID) {
if (changed) {
this.value = A2( step, input.value, this.value );
}
broadcastToKids(this, timestep, changed);
};
input.kids.push(this);
}
function foldp(step, state, input) {
return new Foldp(step, state, input);
}
function DropIf(pred,base,input) {
this.id = Utils.guid();
this.value = pred(input.value) ? base : input.value;
this.kids = [];
this.recv = function(timestep, changed, parentID) {
var chng = changed && !pred(input.value);
if (chng) { this.value = input.value; }
broadcastToKids(this, timestep, chng);
};
input.kids.push(this);
}
function DropRepeats(input) {
this.id = Utils.guid();
this.value = input.value;
this.kids = [];
this.recv = function(timestep, changed, parentID) {
var chng = changed && !Utils.eq(this.value,input.value);
if (chng) { this.value = input.value; }
broadcastToKids(this, timestep, chng);
};
input.kids.push(this);
}
function timestamp(a) {
function update() { return Utils.Tuple2(localRuntime.timer.now(), a.value); }
return new LiftN(update, [a]);
}
function SampleOn(s1,s2) {
this.id = Utils.guid();
this.value = s2.value;
this.kids = [];
var count = 0;
var isChanged = false;
this.recv = function(timestep, changed, parentID) {
if (parentID === s1.id) isChanged = changed;
++count;
if (count == 2) {
if (isChanged) { this.value = s2.value; }
broadcastToKids(this, timestep, isChanged);
count = 0;
isChanged = false;
}
};
s1.kids.push(this);
s2.kids.push(this);
}
function sampleOn(s1,s2) { return new SampleOn(s1,s2); }
function delay(t,s) {
var delayed = new Input(s.value);
var firstEvent = true;
function update(v) {
if (firstEvent) {
firstEvent = false; return;
}
setTimeout(function() {
localRuntime.notify(delayed.id, v);
}, t);
}
function first(a,b) { return a; }
return new SampleOn(delayed, map2(F2(first), delayed, map(update,s)));
}
function Merge(s1,s2) {
this.id = Utils.guid();
this.value = s1.value;
this.kids = [];
var next = null;
var count = 0;
var isChanged = false;
this.recv = function(timestep, changed, parentID) {
++count;
if (changed) {
isChanged = true;
if (parentID == s2.id && next === null) { next = s2.value; }
if (parentID == s1.id) { next = s1.value; }
}
if (count == 2) {
if (isChanged) { this.value = next; next = null; }
broadcastToKids(this, timestep, isChanged);
isChanged = false;
count = 0;
}
};
s1.kids.push(this);
s2.kids.push(this);
}
function merge(s1,s2) {
return new Merge(s1,s2);
}
// SIGNAL INPUTS
function input(initialValue) {
return new Input(initialValue);
}
function send(input, value) {
return function() {
localRuntime.notify(input.id, value);
};
}
function subscribe(input) {
return input;
}
return localRuntime.Native.Signal.values = {
constant : function(v) { return new Input(v); },
map : F2(map ),
map2 : F3(map2),
map3 : F4(map3),
map4 : F5(map4),
map5 : F6(map5),
foldp : F3(foldp),
delay : F2(delay),
merge : F2(merge),
keepIf : F3(function(pred,base,sig) {
return new DropIf(function(x) {return !pred(x);},base,sig); }),
dropIf : F3(function(pred,base,sig) { return new DropIf(pred,base,sig); }),
dropRepeats : function(s) { return new DropRepeats(s);},
sampleOn : F2(sampleOn),
timestamp : timestamp,
input: input,
send: F2(send),
subscribe: subscribe
};
};
Elm.Native.Transform2D = {};
Elm.Native.Transform2D.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Transform2D = elm.Native.Transform2D || {};
if (elm.Native.Transform2D.values) return elm.Native.Transform2D.values;
var A;
if (typeof Float32Array === 'undefined') {
A = function(arr) {
this.length = arr.length;
this[0] = arr[0];
this[1] = arr[1];
this[2] = arr[2];
this[3] = arr[3];
this[4] = arr[4];
this[5] = arr[5];
};
} else {
A = Float32Array;
}
// layout of matrix in an array is
//
// | m11 m12 dx |
// | m21 m22 dy |
// | 0 0 1 |
//
// new A([ m11, m12, dx, m21, m22, dy ])
var identity = new A([1,0,0,0,1,0]);
function matrix(m11, m12, m21, m22, dx, dy) {
return new A([m11, m12, dx, m21, m22, dy]);
}
function rotation(t) {
var c = Math.cos(t);
var s = Math.sin(t);
return new A([c, -s, 0, s, c, 0]);
}
function rotate(t,m) {
var c = Math.cos(t);
var s = Math.sin(t);
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];
return new A([m11*c + m12*s, -m11*s + m12*c, m[2],
m21*c + m22*s, -m21*s + m22*c, m[5]]);
}
/*
function move(xy,m) {
var x = xy._0;
var y = xy._1;
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];
return new A([m11, m12, m11*x + m12*y + m[2],
m21, m22, m21*x + m22*y + m[5]]);
}
function scale(s,m) { return new A([m[0]*s, m[1]*s, m[2], m[3]*s, m[4]*s, m[5]]); }
function scaleX(x,m) { return new A([m[0]*x, m[1], m[2], m[3]*x, m[4], m[5]]); }
function scaleY(y,m) { return new A([m[0], m[1]*y, m[2], m[3], m[4]*y, m[5]]); }
function reflectX(m) { return new A([-m[0], m[1], m[2], -m[3], m[4], m[5]]); }
function reflectY(m) { return new A([m[0], -m[1], m[2], m[3], -m[4], m[5]]); }
function transform(m11, m21, m12, m22, mdx, mdy, n) {
var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5];
return new A([m11*n11 + m12*n21,
m11*n12 + m12*n22,
m11*ndx + m12*ndy + mdx,
m21*n11 + m22*n21,
m21*n12 + m22*n22,
m21*ndx + m22*ndy + mdy]);
}
*/
function multiply(m, n) {
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4], mdx = m[2], mdy = m[5];
var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5];
return new A([m11*n11 + m12*n21,
m11*n12 + m12*n22,
m11*ndx + m12*ndy + mdx,
m21*n11 + m22*n21,
m21*n12 + m22*n22,
m21*ndx + m22*ndy + mdy]);
}
return elm.Native.Transform2D.values = {
identity:identity,
matrix:F6(matrix),
rotation:rotation,
multiply:F2(multiply)
/*
transform:F7(transform),
rotate:F2(rotate),
move:F2(move),
scale:F2(scale),
scaleX:F2(scaleX),
scaleY:F2(scaleY),
reflectX:reflectX,
reflectY:reflectY
*/
};
};
Elm.Native = Elm.Native || {};
Elm.Native.Utils = {};
Elm.Native.Utils.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Utils = localRuntime.Native.Utils || {};
if (localRuntime.Native.Utils.values) {
return localRuntime.Native.Utils.values;
}
function eq(l,r) {
var stack = [{'x': l, 'y': r}]
while (stack.length > 0) {
var front = stack.pop();
var x = front.x;
var y = front.y;
if (x === y) continue;
if (typeof x === "object") {
var c = 0;
for (var i in x) {
++c;
if (i in y) {
if (i !== 'ctor') {
stack.push({ 'x': x[i], 'y': y[i] });
}
} else {
return false;
}
}
if ('ctor' in x) {
stack.push({'x': x.ctor, 'y': y.ctor});
}
if (c !== Object.keys(y).length) {
return false;
};
} else if (typeof x === 'function') {
throw new Error('Equality error: general function equality is ' +
'undecidable, and therefore, unsupported');
} else {
return false;
}
}
return true;
}
// code in Generate/JavaScript.hs depends on the particular
// integer values assigned to LT, EQ, and GT
var LT = -1, EQ = 0, GT = 1, ord = ['LT','EQ','GT'];
function compare(x,y) { return { ctor: ord[cmp(x,y)+1] } }
function cmp(x,y) {
var ord;
if (typeof x !== 'object'){
return x === y ? EQ : x < y ? LT : GT;
}
else if (x.isChar){
var a = x.toString();
var b = y.toString();
return a === b ? EQ : a < b ? LT : GT;
}
else if (x.ctor === "::" || x.ctor === "[]") {
while (true) {
if (x.ctor === "[]" && y.ctor === "[]") return EQ;
if (x.ctor !== y.ctor) return x.ctor === '[]' ? LT : GT;
ord = cmp(x._0, y._0);
if (ord !== EQ) return ord;
x = x._1;
y = y._1;
}
}
else if (x.ctor.slice(0,6) === '_Tuple') {
var n = x.ctor.slice(6) - 0;
var err = 'cannot compare tuples with more than 6 elements.';
if (n === 0) return EQ;
if (n >= 1) { ord = cmp(x._0, y._0); if (ord !== EQ) return ord;
if (n >= 2) { ord = cmp(x._1, y._1); if (ord !== EQ) return ord;
if (n >= 3) { ord = cmp(x._2, y._2); if (ord !== EQ) return ord;
if (n >= 4) { ord = cmp(x._3, y._3); if (ord !== EQ) return ord;
if (n >= 5) { ord = cmp(x._4, y._4); if (ord !== EQ) return ord;
if (n >= 6) { ord = cmp(x._5, y._5); if (ord !== EQ) return ord;
if (n >= 7) throw new Error('Comparison error: ' + err); } } } } } }
return EQ;
}
else {
throw new Error('Comparison error: comparison is only defined on ints, ' +
'floats, times, chars, strings, lists of comparable values, ' +
'and tuples of comparable values.');
}
}
var Tuple0 = { ctor: "_Tuple0" };
function Tuple2(x,y) {
return {
ctor: "_Tuple2",
_0: x,
_1: y
};
}
function chr(c) {
var x = new String(c);
x.isChar = true;
return x;
}
function txt(str) {
var t = new String(str);
t.text = true;
return t;
}
function makeText(text) {
var style = '';
var href = '';
while (true) {
if (text.style) {
style += text.style;
text = text.text;
continue;
}
if (text.href) {
href = text.href;
text = text.text;
continue;
}
if (href) {
text = '<a href="' + href + '">' + text + '</a>';
}
if (style) {
text = '<span style="' + style + '">' + text + '</span>';
}
return text;
}
}
var count = 0;
function guid(_) {
return count++
}
function copy(oldRecord) {
var newRecord = {};
for (var key in oldRecord) {
var value = key === '_'
? copy(oldRecord._)
: oldRecord[key]
;
newRecord[key] = value;
}
return newRecord;
}
function remove(key, oldRecord) {
var record = copy(oldRecord);
if (key in record._) {
record[key] = record._[key][0];
record._[key] = record._[key].slice(1);
if (record._[key].length === 0) {
delete record._[key];
}
} else {
delete record[key];
}
return record;
}
function replace(keyValuePairs, oldRecord) {
var record = copy(oldRecord);
for (var i = keyValuePairs.length; i--; ) {
var pair = keyValuePairs[i];
record[pair[0]] = pair[1];
}
return record;
}
function insert(key, value, oldRecord) {
var newRecord = copy(oldRecord);
if (key in newRecord) {
var values = newRecord._[key];
var copiedValues = values ? values.slice(0) : [];
newRecord._[key] = [newRecord[key]].concat(copiedValues);
}
newRecord[key] = value;
return newRecord;
}
function getXY(e) {
var posx = 0;
var posy = 0;
if (e.pageX || e.pageY) {
posx = e.pageX;
posy = e.pageY;
} else if (e.clientX || e.clientY) {
posx = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
posy = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;
}
if (localRuntime.isEmbed()) {
var rect = localRuntime.node.getBoundingClientRect();
var relx = rect.left + document.body.scrollLeft + document.documentElement.scrollLeft;
var rely = rect.top + document.body.scrollTop + document.documentElement.scrollTop;
// TODO: figure out if there is a way to avoid rounding here
posx = posx - Math.round(relx) - localRuntime.node.clientLeft;
posy = posy - Math.round(rely) - localRuntime.node.clientTop;
}
return Tuple2(posx, posy);
}
//// LIST STUFF ////
var Nil = { ctor:'[]' };
function Cons(hd,tl) {
return {
ctor: "::",
_0: hd,
_1: tl
};
}
function append(xs,ys) {
// append Text
if (xs.text || ys.text) {
return txt(makeText(xs) + makeText(ys));
}
// append Strings
if (typeof xs === "string") {
return xs + ys;
}
// append Lists
if (xs.ctor === '[]') {
return ys;
}
var root = Cons(xs._0, Nil);
var curr = root;
xs = xs._1;
while (xs.ctor !== '[]') {
curr._1 = Cons(xs._0, Nil);
xs = xs._1;
curr = curr._1;
}
curr._1 = ys;
return root;
}
//// RUNTIME ERRORS ////
function indent(lines) {
return '\n' + lines.join('\n');
}
function badCase(moduleName, span) {
var msg = indent([
'Non-exhaustive pattern match in case-expression.',
'Make sure your patterns cover every case!'
]);
throw new Error('Runtime error in module ' + moduleName + ' (' + span + ')' + msg);
}
function badIf(moduleName, span) {
var msg = indent([
'Non-exhaustive pattern match in multi-way-if expression.',
'It is best to use \'otherwise\' as the last branch of multi-way-if.'
]);
throw new Error('Runtime error in module ' + moduleName + ' (' + span + ')' + msg);
}
function badPort(expected, received) {
var msg = indent([
'Expecting ' + expected + ' but was given ',
JSON.stringify(received)
]);
throw new Error('Runtime error when sending values through a port.' + msg);
}
return localRuntime.Native.Utils.values = {
eq:eq,
cmp:cmp,
compare:F2(compare),
Tuple0:Tuple0,
Tuple2:Tuple2,
chr:chr,
txt:txt,
makeText:makeText,
copy: copy,
remove: remove,
replace: replace,
insert: insert,
guid: guid,
getXY: getXY,
Nil: Nil,
Cons: Cons,
append: F2(append),
badCase: badCase,
badIf: badIf,
badPort: badPort
};
};
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),
_P = _N.Ports.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 110 and 123");
}();
};
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 72 and 91");
}();
});
var Ok = function (a) {
return {ctor: "Ok",_0: a};
};
var map = F2(function (f,
result) {
return function () {
switch (result.ctor)
{case "Err":
return Err(result._0);
case "Ok":
return Ok(f(result._0));}
_U.badCase($moduleName,
"between lines 32 and 69");
}();
});
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 94 and 107");
}();
});
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 126 and 128");
}();
});
_elm.Result.values = {_op: _op
,Ok: Ok
,Err: Err
,map: map
,andThen: andThen
,formatError: formatError
,toMaybe: toMaybe
,fromMaybe: fromMaybe};
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),
_P = _N.Ports.make(_elm),
$moduleName = "Signal",
$Basics = Elm.Basics.make(_elm),
$List = Elm.List.make(_elm),
$Native$Signal = Elm.Native.Signal.make(_elm);
var subscribe = $Native$Signal.subscribe;
var send = $Native$Signal.send;
var channel = $Native$Signal.input;
var Message = {ctor: "Message"};
var Channel = {ctor: "Channel"};
_op["~"] = F2(function (sf,s) {
return A3($Native$Signal.map2,
F2(function (f,x) {
return f(x);
}),
sf,
s);
});
_op["<~"] = F2(function (f,s) {
return A2($Native$Signal.map,
f,
s);
});
var sampleOn = $Native$Signal.sampleOn;
var dropRepeats = $Native$Signal.dropRepeats;
var dropIf = $Native$Signal.dropIf;
var keepIf = $Native$Signal.keepIf;
var keepWhen = F3(function (bs,
def,
sig) {
return A2(_op["<~"],
$Basics.snd,
A3(keepIf,
$Basics.fst,
{ctor: "_Tuple2"
,_0: false
,_1: def},
A2(_op["~"],
A2(_op["<~"],
F2(function (v0,v1) {
return {ctor: "_Tuple2"
,_0: v0
,_1: v1};
}),
A2(sampleOn,sig,bs)),
sig)));
});
var dropWhen = function (bs) {
return keepWhen(A2(_op["<~"],
$Basics.not,
bs));
};
var merge = $Native$Signal.merge;
var mergeMany = function (signals) {
return A2($List.foldr1,
merge,
signals);
};
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;
var map = $Native$Signal.map;
var constant = $Native$Signal.constant;
var Signal = {ctor: "Signal"};
_elm.Signal.values = {_op: _op
,Signal: Signal
,constant: constant
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,foldp: foldp
,merge: merge
,mergeMany: mergeMany
,keepIf: keepIf
,dropIf: dropIf
,keepWhen: keepWhen
,dropWhen: dropWhen
,dropRepeats: dropRepeats
,sampleOn: sampleOn
,Channel: Channel
,Message: Message
,channel: channel
,send: send
,subscribe: subscribe};
return _elm.Signal.values;
};
Elm.Temp22095 = Elm.Temp22095 || {};
Elm.Temp22095.make = function (_elm) {
"use strict";
_elm.Temp22095 = _elm.Temp22095 || {};
if (_elm.Temp22095.values)
return _elm.Temp22095.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
_P = _N.Ports.make(_elm),
$moduleName = "Temp22095",
$Basics = Elm.Basics.make(_elm),
$Color = Elm.Color.make(_elm),
$Graphics$Collage = Elm.Graphics.Collage.make(_elm),
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$Mouse = Elm.Mouse.make(_elm),
$Signal = Elm.Signal.make(_elm);
var b = A2($Graphics$Element.color,
$Color.blue,
A2($Graphics$Element.spacer,
20,
20));
var bb = $Graphics$Collage.toForm(A2($Graphics$Element.beside,
b,
b));
var main = A2($Signal.map,
function (s) {
return A3($Graphics$Collage.collage,
200,
200,
s ? _L.fromArray([A2($Graphics$Collage.move,
{ctor: "_Tuple2",_0: 0,_1: 50},
$Graphics$Collage.toForm(b))
,bb]) : _L.fromArray([bb]));
},
A3($Signal.foldp,
$Basics.always($Basics.not),
true,
$Mouse.clicks));
_elm.Temp22095.values = {_op: _op
,b: b
,bb: bb
,main: main};
return _elm.Temp22095.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),
_P = _N.Ports.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;
};
</script><script>var runningElmModule = Elm.fullscreen(Elm.Temp22095)</script></body></html>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment