yogsototh/her.esy.fun
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
her.esy.fun/src/YPassword/elm.js

16184 lines
413 KiB
JavaScript
Raw Normal View History

support raw HTML and merged old blog
2021-04-18 10:23:24 +00:00
var Elm = Elm || { Native: {} };
Elm.Array = Elm.Array || {};
Elm.Array.make = function (_elm) {
"use strict";
_elm.Array = _elm.Array || {};
if (_elm.Array.values)
return _elm.Array.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Array",
$Basics = Elm.Basics.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Array = Elm.Native.Array.make(_elm);
var append = $Native$Array.append;
var length = $Native$Array.length;
var slice = $Native$Array.slice;
var set = $Native$Array.set;
var get = F2(function (i,
array) {
return _U.cmp(0,
i) < 1 && _U.cmp(i,
$Native$Array.length(array)) < 0 ? $Maybe.Just(A2($Native$Array.get,
i,
array)) : $Maybe.Nothing;
});
var push = $Native$Array.push;
var empty = $Native$Array.empty;
var filter = F2(function (isOkay,
arr) {
return function () {
var update = F2(function (x,
xs) {
return isOkay(x) ? A2($Native$Array.push,
x,
xs) : xs;
});
return A3($Native$Array.foldl,
update,
$Native$Array.empty,
arr);
}();
});
var foldr = $Native$Array.foldr;
var foldl = $Native$Array.foldl;
var indexedMap = $Native$Array.indexedMap;
var map = $Native$Array.map;
var toIndexedList = function (array) {
return A3($List.map2,
F2(function (v0,v1) {
return {ctor: "_Tuple2"
,_0: v0
,_1: v1};
}),
_L.range(0,
$Native$Array.length(array) - 1),
$Native$Array.toList(array));
};
var toList = $Native$Array.toList;
var fromList = $Native$Array.fromList;
var initialize = $Native$Array.initialize;
var repeat = F2(function (n,e) {
return A2(initialize,
n,
$Basics.always(e));
});
var Array = {ctor: "Array"};
_elm.Array.values = {_op: _op
,empty: empty
,repeat: repeat
,initialize: initialize
,fromList: fromList
,length: length
,push: push
,append: append
,get: get
,set: set
,slice: slice
,toList: toList
,toIndexedList: toIndexedList
,map: map
,indexedMap: indexedMap
,filter: filter
,foldl: foldl
,foldr: foldr};
return _elm.Array.values;
};
Elm.Basics = Elm.Basics || {};
Elm.Basics.make = function (_elm) {
"use strict";
_elm.Basics = _elm.Basics || {};
if (_elm.Basics.values)
return _elm.Basics.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Basics",
$Native$Basics = Elm.Native.Basics.make(_elm),
$Native$Show = Elm.Native.Show.make(_elm),
$Native$Utils = Elm.Native.Utils.make(_elm);
var uncurry = F2(function (f,
_v0) {
return function () {
switch (_v0.ctor)
{case "_Tuple2": return A2(f,
_v0._0,
_v0._1);}
_U.badCase($moduleName,
"on line 595, column 3 to 8");
}();
});
var curry = F3(function (f,
a,
b) {
return f({ctor: "_Tuple2"
,_0: a
,_1: b});
});
var flip = F3(function (f,b,a) {
return A2(f,a,b);
});
var snd = function (_v4) {
return function () {
switch (_v4.ctor)
{case "_Tuple2": return _v4._1;}
_U.badCase($moduleName,
"on line 573, column 3 to 4");
}();
};
var fst = function (_v8) {
return function () {
switch (_v8.ctor)
{case "_Tuple2": return _v8._0;}
_U.badCase($moduleName,
"on line 567, column 3 to 4");
}();
};
var always = F2(function (a,
_v12) {
return function () {
return a;
}();
});
var identity = function (x) {
return x;
};
_op["<|"] = F2(function (f,x) {
return f(x);
});
_op["|>"] = F2(function (x,f) {
return f(x);
});
_op[">>"] = F3(function (f,
g,
x) {
return g(f(x));
});
_op["<<"] = F3(function (g,
f,
x) {
return g(f(x));
});
_op["++"] = $Native$Utils.append;
var toString = $Native$Show.toString;
var isInfinite = $Native$Basics.isInfinite;
var isNaN = $Native$Basics.isNaN;
var toFloat = $Native$Basics.toFloat;
var ceiling = $Native$Basics.ceiling;
var floor = $Native$Basics.floor;
var truncate = $Native$Basics.truncate;
var round = $Native$Basics.round;
var otherwise = true;
var not = $Native$Basics.not;
var xor = $Native$Basics.xor;
_op["||"] = $Native$Basics.or;
_op["&&"] = $Native$Basics.and;
var max = $Native$Basics.max;
var min = $Native$Basics.min;
var GT = {ctor: "GT"};
var EQ = {ctor: "EQ"};
var LT = {ctor: "LT"};
var compare = $Native$Basics.compare;
_op[">="] = $Native$Basics.ge;
_op["<="] = $Native$Basics.le;
_op[">"] = $Native$Basics.gt;
_op["<"] = $Native$Basics.lt;
_op["/="] = $Native$Basics.neq;
_op["=="] = $Native$Basics.eq;
var e = $Native$Basics.e;
var pi = $Native$Basics.pi;
var clamp = $Native$Basics.clamp;
var logBase = $Native$Basics.logBase;
var abs = $Native$Basics.abs;
var negate = $Native$Basics.negate;
var sqrt = $Native$Basics.sqrt;
var atan2 = $Native$Basics.atan2;
var atan = $Native$Basics.atan;
var asin = $Native$Basics.asin;
var acos = $Native$Basics.acos;
var tan = $Native$Basics.tan;
var sin = $Native$Basics.sin;
var cos = $Native$Basics.cos;
_op["^"] = $Native$Basics.exp;
_op["%"] = $Native$Basics.mod;
var rem = $Native$Basics.rem;
_op["//"] = $Native$Basics.div;
_op["/"] = $Native$Basics.floatDiv;
_op["*"] = $Native$Basics.mul;
_op["-"] = $Native$Basics.sub;
_op["+"] = $Native$Basics.add;
var toPolar = $Native$Basics.toPolar;
var fromPolar = $Native$Basics.fromPolar;
var turns = $Native$Basics.turns;
var degrees = $Native$Basics.degrees;
var radians = function (t) {
return t;
};
_elm.Basics.values = {_op: _op
,max: max
,min: min
,compare: compare
,not: not
,xor: xor
,otherwise: otherwise
,rem: rem
,negate: negate
,abs: abs
,sqrt: sqrt
,clamp: clamp
,logBase: logBase
,e: e
,pi: pi
,cos: cos
,sin: sin
,tan: tan
,acos: acos
,asin: asin
,atan: atan
,atan2: atan2
,round: round
,floor: floor
,ceiling: ceiling
,truncate: truncate
,toFloat: toFloat
,degrees: degrees
,radians: radians
,turns: turns
,toPolar: toPolar
,fromPolar: fromPolar
,isNaN: isNaN
,isInfinite: isInfinite
,toString: toString
,fst: fst
,snd: snd
,identity: identity
,always: always
,flip: flip
,curry: curry
,uncurry: uncurry
,LT: LT
,EQ: EQ
,GT: GT};
return _elm.Basics.values;
};
Elm.Char = Elm.Char || {};
Elm.Char.make = function (_elm) {
"use strict";
_elm.Char = _elm.Char || {};
if (_elm.Char.values)
return _elm.Char.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Char",
$Basics = Elm.Basics.make(_elm),
$Native$Char = Elm.Native.Char.make(_elm);
var fromCode = $Native$Char.fromCode;
var toCode = $Native$Char.toCode;
var toLocaleLower = $Native$Char.toLocaleLower;
var toLocaleUpper = $Native$Char.toLocaleUpper;
var toLower = $Native$Char.toLower;
var toUpper = $Native$Char.toUpper;
var isBetween = F3(function (low,
high,
$char) {
return function () {
var code = toCode($char);
return _U.cmp(code,
toCode(low)) > -1 && _U.cmp(code,
toCode(high)) < 1;
}();
});
var isUpper = A2(isBetween,
_U.chr("A"),
_U.chr("Z"));
var isLower = A2(isBetween,
_U.chr("a"),
_U.chr("z"));
var isDigit = A2(isBetween,
_U.chr("0"),
_U.chr("9"));
var isOctDigit = A2(isBetween,
_U.chr("0"),
_U.chr("7"));
var isHexDigit = function ($char) {
return isDigit($char) || (A3(isBetween,
_U.chr("a"),
_U.chr("f"),
$char) || A3(isBetween,
_U.chr("A"),
_U.chr("F"),
$char));
};
_elm.Char.values = {_op: _op
,isUpper: isUpper
,isLower: isLower
,isDigit: isDigit
,isOctDigit: isOctDigit
,isHexDigit: isHexDigit
,toUpper: toUpper
,toLower: toLower
,toLocaleUpper: toLocaleUpper
,toLocaleLower: toLocaleLower
,toCode: toCode
,fromCode: fromCode};
return _elm.Char.values;
};
Elm.Color = Elm.Color || {};
Elm.Color.make = function (_elm) {
"use strict";
_elm.Color = _elm.Color || {};
if (_elm.Color.values)
return _elm.Color.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Color",
$Basics = Elm.Basics.make(_elm);
var Radial = F5(function (a,
b,
c,
d,
e) {
return {ctor: "Radial"
,_0: a
,_1: b
,_2: c
,_3: d
,_4: e};
});
var radial = Radial;
var Linear = F3(function (a,
b,
c) {
return {ctor: "Linear"
,_0: a
,_1: b
,_2: c};
});
var linear = Linear;
var fmod = F2(function (f,n) {
return function () {
var integer = $Basics.floor(f);
return $Basics.toFloat(A2($Basics._op["%"],
integer,
n)) + f - $Basics.toFloat(integer);
}();
});
var rgbToHsl = F3(function (red,
green,
blue) {
return function () {
var b = $Basics.toFloat(blue) / 255;
var g = $Basics.toFloat(green) / 255;
var r = $Basics.toFloat(red) / 255;
var cMax = A2($Basics.max,
A2($Basics.max,r,g),
b);
var cMin = A2($Basics.min,
A2($Basics.min,r,g),
b);
var c = cMax - cMin;
var lightness = (cMax + cMin) / 2;
var saturation = _U.eq(lightness,
0) ? 0 : c / (1 - $Basics.abs(2 * lightness - 1));
var hue = $Basics.degrees(60) * (_U.eq(cMax,
r) ? A2(fmod,
(g - b) / c,
6) : _U.eq(cMax,
g) ? (b - r) / c + 2 : _U.eq(cMax,
b) ? (r - g) / c + 4 : _U.badIf($moduleName,
"between lines 150 and 152"));
return {ctor: "_Tuple3"
,_0: hue
,_1: saturation
,_2: lightness};
}();
});
var hslToRgb = F3(function (hue,
saturation,
lightness) {
return function () {
var hue$ = hue / $Basics.degrees(60);
var chroma = (1 - $Basics.abs(2 * lightness - 1)) * saturation;
var x = chroma * (1 - $Basics.abs(A2(fmod,
hue$,
2) - 1));
var $ = _U.cmp(hue$,
0) < 0 ? {ctor: "_Tuple3"
,_0: 0
,_1: 0
,_2: 0} : _U.cmp(hue$,
1) < 0 ? {ctor: "_Tuple3"
,_0: chroma
,_1: x
,_2: 0} : _U.cmp(hue$,
2) < 0 ? {ctor: "_Tuple3"
,_0: x
,_1: chroma
,_2: 0} : _U.cmp(hue$,
3) < 0 ? {ctor: "_Tuple3"
,_0: 0
,_1: chroma
,_2: x} : _U.cmp(hue$,
4) < 0 ? {ctor: "_Tuple3"
,_0: 0
,_1: x
,_2: chroma} : _U.cmp(hue$,
5) < 0 ? {ctor: "_Tuple3"
,_0: x
,_1: 0
,_2: chroma} : _U.cmp(hue$,
6) < 0 ? {ctor: "_Tuple3"
,_0: chroma
,_1: 0
,_2: x} : {ctor: "_Tuple3"
,_0: 0
,_1: 0
,_2: 0},
r = $._0,
g = $._1,
b = $._2;
var m = lightness - chroma / 2;
return {ctor: "_Tuple3"
,_0: r + m
,_1: g + m
,_2: b + m};
}();
});
var toRgb = function (color) {
return function () {
switch (color.ctor)
{case "HSLA":
return function () {
var $ = A3(hslToRgb,
color._0,
color._1,
color._2),
r = $._0,
g = $._1,
b = $._2;
return {_: {}
,alpha: color._3
,blue: $Basics.round(255 * b)
,green: $Basics.round(255 * g)
,red: $Basics.round(255 * r)};
}();
case "RGBA": return {_: {}
,alpha: color._3
,blue: color._2
,green: color._1
,red: color._0};}
_U.badCase($moduleName,
"between lines 124 and 132");
}();
};
var toHsl = function (color) {
return function () {
switch (color.ctor)
{case "HSLA": return {_: {}
,alpha: color._3
,hue: color._0
,lightness: color._2
,saturation: color._1};
case "RGBA":
return function () {
var $ = A3(rgbToHsl,
color._0,
color._1,
color._2),
h = $._0,
s = $._1,
l = $._2;
return {_: {}
,alpha: color._3
,hue: h
,lightness: l
,saturation: s};
}();}
_U.badCase($moduleName,
"between lines 114 and 121");
}();
};
var HSLA = F4(function (a,
b,
c,
d) {
return {ctor: "HSLA"
,_0: a
,_1: b
,_2: c
,_3: d};
});
var hsla = F4(function (hue,
saturation,
lightness,
alpha) {
return A4(HSLA,
hue - $Basics.turns($Basics.toFloat($Basics.floor(hue / (2 * $Basics.pi)))),
saturation,
lightness,
alpha);
});
var hsl = F3(function (hue,
saturation,
lightness) {
return A4(hsla,
hue,
saturation,
lightness,
1);
});
var complement = function (color) {
return function () {
switch (color.ctor)
{case "HSLA": return A4(hsla,
color._0 + $Basics.degrees(180),
color._1,
color._2,
color._3);
case "RGBA":
return function () {
var $ = A3(rgbToHsl,
color._0,
color._1,
color._2),
h = $._0,
s = $._1,
l = $._2;
return A4(hsla,
h + $Basics.degrees(180),
s,
l,
color._3);
}();}
_U.badCase($moduleName,
"between lines 105 and 111");
}();
};
var grayscale = function (p) {
return A4(HSLA,0,0,1 - p,1);
};
var greyscale = function (p) {
return A4(HSLA,0,0,1 - p,1);
};
var RGBA = F4(function (a,
b,
c,
d) {
return {ctor: "RGBA"
,_0: a
,_1: b
,_2: c
,_3: d};
});
var rgba = RGBA;
var rgb = F3(function (r,g,b) {
return A4(RGBA,r,g,b,1);
});
var lightRed = A4(RGBA,
239,
41,
41,
1);
var red = A4(RGBA,204,0,0,1);
var darkRed = A4(RGBA,
164,
0,
0,
1);
var lightOrange = A4(RGBA,
252,
175,
62,
1);
var orange = A4(RGBA,
245,
121,
0,
1);
var darkOrange = A4(RGBA,
206,
92,
0,
1);
var lightYellow = A4(RGBA,
255,
233,
79,
1);
var yellow = A4(RGBA,
237,
212,
0,
1);
var darkYellow = A4(RGBA,
196,
160,
0,
1);
var lightGreen = A4(RGBA,
138,
226,
52,
1);
var green = A4(RGBA,
115,
210,
22,
1);
var darkGreen = A4(RGBA,
78,
154,
6,
1);
var lightBlue = A4(RGBA,
114,
159,
207,
1);
var blue = A4(RGBA,
52,
101,
164,
1);
var darkBlue = A4(RGBA,
32,
74,
135,
1);
var lightPurple = A4(RGBA,
173,
127,
168,
1);
var purple = A4(RGBA,
117,
80,
123,
1);
var darkPurple = A4(RGBA,
92,
53,
102,
1);
var lightBrown = A4(RGBA,
233,
185,
110,
1);
var brown = A4(RGBA,
193,
125,
17,
1);
var darkBrown = A4(RGBA,
143,
89,
2,
1);
var black = A4(RGBA,0,0,0,1);
var white = A4(RGBA,
255,
255,
255,
1);
var lightGrey = A4(RGBA,
238,
238,
236,
1);
var grey = A4(RGBA,
211,
215,
207,
1);
var darkGrey = A4(RGBA,
186,
189,
182,
1);
var lightGray = A4(RGBA,
238,
238,
236,
1);
var gray = A4(RGBA,
211,
215,
207,
1);
var darkGray = A4(RGBA,
186,
189,
182,
1);
var lightCharcoal = A4(RGBA,
136,
138,
133,
1);
var charcoal = A4(RGBA,
85,
87,
83,
1);
var darkCharcoal = A4(RGBA,
46,
52,
54,
1);
_elm.Color.values = {_op: _op
,rgb: rgb
,rgba: rgba
,hsl: hsl
,hsla: hsla
,greyscale: greyscale
,grayscale: grayscale
,complement: complement
,linear: linear
,radial: radial
,toRgb: toRgb
,toHsl: toHsl
,red: red
,orange: orange
,yellow: yellow
,green: green
,blue: blue
,purple: purple
,brown: brown
,lightRed: lightRed
,lightOrange: lightOrange
,lightYellow: lightYellow
,lightGreen: lightGreen
,lightBlue: lightBlue
,lightPurple: lightPurple
,lightBrown: lightBrown
,darkRed: darkRed
,darkOrange: darkOrange
,darkYellow: darkYellow
,darkGreen: darkGreen
,darkBlue: darkBlue
,darkPurple: darkPurple
,darkBrown: darkBrown
,white: white
,lightGrey: lightGrey
,grey: grey
,darkGrey: darkGrey
,lightCharcoal: lightCharcoal
,charcoal: charcoal
,darkCharcoal: darkCharcoal
,black: black
,lightGray: lightGray
,gray: gray
,darkGray: darkGray};
return _elm.Color.values;
};
Elm.Debug = Elm.Debug || {};
Elm.Debug.make = function (_elm) {
"use strict";
_elm.Debug = _elm.Debug || {};
if (_elm.Debug.values)
return _elm.Debug.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Debug",
$Graphics$Collage = Elm.Graphics.Collage.make(_elm),
$Native$Debug = Elm.Native.Debug.make(_elm);
var trace = $Native$Debug.tracePath;
var watchSummary = $Native$Debug.watchSummary;
var watch = $Native$Debug.watch;
var crash = $Native$Debug.crash;
var log = $Native$Debug.log;
_elm.Debug.values = {_op: _op
,log: log
,crash: crash
,watch: watch
,watchSummary: watchSummary
,trace: trace};
return _elm.Debug.values;
};
Elm.Dict = Elm.Dict || {};
Elm.Dict.make = function (_elm) {
"use strict";
_elm.Dict = _elm.Dict || {};
if (_elm.Dict.values)
return _elm.Dict.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Dict",
$Basics = Elm.Basics.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Debug = Elm.Native.Debug.make(_elm),
$String = Elm.String.make(_elm);
var foldr = F3(function (f,
acc,
t) {
return function () {
switch (t.ctor)
{case "RBEmpty":
switch (t._0.ctor)
{case "LBlack": return acc;}
break;
case "RBNode": return A3(foldr,
f,
A3(f,
t._1,
t._2,
A3(foldr,f,acc,t._4)),
t._3);}
_U.badCase($moduleName,
"between lines 408 and 416");
}();
});
var keys = function (dict) {
return A3(foldr,
F3(function (key,
value,
keyList) {
return A2($List._op["::"],
key,
keyList);
}),
_L.fromArray([]),
dict);
};
var values = function (dict) {
return A3(foldr,
F3(function (key,
value,
valueList) {
return A2($List._op["::"],
value,
valueList);
}),
_L.fromArray([]),
dict);
};
var toList = function (dict) {
return A3(foldr,
F3(function (key,value,list) {
return A2($List._op["::"],
{ctor: "_Tuple2"
,_0: key
,_1: value},
list);
}),
_L.fromArray([]),
dict);
};
var foldl = F3(function (f,
acc,
dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack": return acc;}
break;
case "RBNode": return A3(foldl,
f,
A3(f,
dict._1,
dict._2,
A3(foldl,f,acc,dict._3)),
dict._4);}
_U.badCase($moduleName,
"between lines 397 and 405");
}();
});
var isBBlack = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBBlack": return true;}
break;
case "RBNode":
switch (dict._0.ctor)
{case "BBlack": return true;}
break;}
return false;
}();
};
var showFlag = function (f) {
return function () {
switch (f.ctor)
{case "Insert": return "Insert";
case "Remove": return "Remove";
case "Same": return "Same";}
_U.badCase($moduleName,
"between lines 173 and 179");
}();
};
var Same = {ctor: "Same"};
var Remove = {ctor: "Remove"};
var Insert = {ctor: "Insert"};
var get = F2(function (targetKey,
dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack":
return $Maybe.Nothing;}
break;
case "RBNode":
return function () {
var _v29 = A2($Basics.compare,
targetKey,
dict._1);
switch (_v29.ctor)
{case "EQ":
return $Maybe.Just(dict._2);
case "GT": return A2(get,
targetKey,
dict._4);
case "LT": return A2(get,
targetKey,
dict._3);}
_U.badCase($moduleName,
"between lines 129 and 135");
}();}
_U.badCase($moduleName,
"between lines 124 and 135");
}();
});
var member = F2(function (key,
dict) {
return function () {
var _v30 = A2(get,key,dict);
switch (_v30.ctor)
{case "Just": return true;
case "Nothing": return false;}
_U.badCase($moduleName,
"between lines 138 and 140");
}();
});
var max = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
return $Native$Debug.crash("(max Empty) is not defined");
case "RBNode":
switch (dict._4.ctor)
{case "RBEmpty":
return {ctor: "_Tuple2"
,_0: dict._1
,_1: dict._2};}
return max(dict._4);}
_U.badCase($moduleName,
"between lines 100 and 121");
}();
};
var min = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack":
return $Native$Debug.crash("(min Empty) is not defined");}
break;
case "RBNode":
switch (dict._3.ctor)
{case "RBEmpty":
switch (dict._3._0.ctor)
{case "LBlack":
return {ctor: "_Tuple2"
,_0: dict._1
,_1: dict._2};}
break;}
return min(dict._3);}
_U.badCase($moduleName,
"between lines 87 and 95");
}();
};
var RBEmpty = function (a) {
return {ctor: "RBEmpty"
,_0: a};
};
var RBNode = F5(function (a,
b,
c,
d,
e) {
return {ctor: "RBNode"
,_0: a
,_1: b
,_2: c
,_3: d
,_4: e};
});
var showLColor = function (color) {
return function () {
switch (color.ctor)
{case "LBBlack":
return "LBBlack";
case "LBlack": return "LBlack";}
_U.badCase($moduleName,
"between lines 70 and 72");
}();
};
var LBBlack = {ctor: "LBBlack"};
var LBlack = {ctor: "LBlack"};
var empty = RBEmpty(LBlack);
var map = F2(function (f,dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack":
return RBEmpty(LBlack);}
break;
case "RBNode": return A5(RBNode,
dict._0,
dict._1,
A2(f,dict._1,dict._2),
A2(map,f,dict._3),
A2(map,f,dict._4));}
_U.badCase($moduleName,
"between lines 385 and 394");
}();
});
var showNColor = function (c) {
return function () {
switch (c.ctor)
{case "BBlack": return "BBlack";
case "Black": return "Black";
case "NBlack": return "NBlack";
case "Red": return "Red";}
_U.badCase($moduleName,
"between lines 56 and 60");
}();
};
var reportRemBug = F4(function (msg,
c,
lgot,
rgot) {
return $Native$Debug.crash($String.concat(_L.fromArray(["Internal red-black tree invariant violated, expected "
,msg
," and got "
,showNColor(c)
,"/"
,lgot
,"/"
,rgot
,"\nPlease report this bug to <https://github.com/elm-lang/Elm/issues>"])));
});
var NBlack = {ctor: "NBlack"};
var BBlack = {ctor: "BBlack"};
var Black = {ctor: "Black"};
var ensureBlackRoot = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack": return dict;}
break;
case "RBNode":
switch (dict._0.ctor)
{case "Black": return dict;
case "Red": return A5(RBNode,
Black,
dict._1,
dict._2,
dict._3,
dict._4);}
break;}
_U.badCase($moduleName,
"between lines 145 and 157");
}();
};
var blackish = function (t) {
return function () {
switch (t.ctor)
{case "RBEmpty": return true;
case "RBNode":
return _U.eq(t._0,
Black) || _U.eq(t._0,BBlack);}
_U.badCase($moduleName,
"between lines 330 and 332");
}();
};
var blacken = function (t) {
return function () {
switch (t.ctor)
{case "RBEmpty":
return RBEmpty(LBlack);
case "RBNode": return A5(RBNode,
Black,
t._1,
t._2,
t._3,
t._4);}
_U.badCase($moduleName,
"between lines 369 and 371");
}();
};
var Red = {ctor: "Red"};
var moreBlack = function (color) {
return function () {
switch (color.ctor)
{case "BBlack":
return $Native$Debug.crash("Can\'t make a double black node more black!");
case "Black": return BBlack;
case "NBlack": return Red;
case "Red": return Black;}
_U.badCase($moduleName,
"between lines 235 and 239");
}();
};
var lessBlack = function (color) {
return function () {
switch (color.ctor)
{case "BBlack": return Black;
case "Black": return Red;
case "NBlack":
return $Native$Debug.crash("Can\'t make a negative black node less black!");
case "Red": return NBlack;}
_U.badCase($moduleName,
"between lines 244 and 248");
}();
};
var lessBlackTree = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBBlack":
return RBEmpty(LBlack);}
break;
case "RBNode": return A5(RBNode,
lessBlack(dict._0),
dict._1,
dict._2,
dict._3,
dict._4);}
_U.badCase($moduleName,
"between lines 253 and 255");
}();
};
var redden = function (t) {
return function () {
switch (t.ctor)
{case "RBEmpty":
return $Native$Debug.crash("can\'t make a Leaf red");
case "RBNode": return A5(RBNode,
Red,
t._1,
t._2,
t._3,
t._4);}
_U.badCase($moduleName,
"between lines 377 and 382");
}();
};
var balance_node = function (t) {
return function () {
var assemble = function (col) {
return function (xk) {
return function (xv) {
return function (yk) {
return function (yv) {
return function (zk) {
return function (zv) {
return function (a) {
return function (b) {
return function (c) {
return function (d) {
return A5(RBNode,
lessBlack(col),
yk,
yv,
A5(RBNode,Black,xk,xv,a,b),
A5(RBNode,Black,zk,zv,c,d));
};
};
};
};
};
};
};
};
};
};
};
return blackish(t) ? function () {
switch (t.ctor)
{case "RBNode":
switch (t._3.ctor)
{case "RBNode":
switch (t._3._0.ctor)
{case "Red":
switch (t._3._3.ctor)
{case "RBNode":
switch (t._3._3._0.ctor)
{case "Red":
return assemble(t._0)(t._3._3._1)(t._3._3._2)(t._3._1)(t._3._2)(t._1)(t._2)(t._3._3._3)(t._3._3._4)(t._3._4)(t._4);}
break;}
switch (t._3._4.ctor)
{case "RBNode":
switch (t._3._4._0.ctor)
{case "Red":
return assemble(t._0)(t._3._1)(t._3._2)(t._3._4._1)(t._3._4._2)(t._1)(t._2)(t._3._3)(t._3._4._3)(t._3._4._4)(t._4);}
break;}
break;}
break;}
switch (t._4.ctor)
{case "RBNode":
switch (t._4._0.ctor)
{case "Red":
switch (t._4._3.ctor)
{case "RBNode":
switch (t._4._3._0.ctor)
{case "Red":
return assemble(t._0)(t._1)(t._2)(t._4._3._1)(t._4._3._2)(t._4._1)(t._4._2)(t._3)(t._4._3._3)(t._4._3._4)(t._4._4);}
break;}
switch (t._4._4.ctor)
{case "RBNode":
switch (t._4._4._0.ctor)
{case "Red":
return assemble(t._0)(t._1)(t._2)(t._4._1)(t._4._2)(t._4._4._1)(t._4._4._2)(t._3)(t._4._3)(t._4._4._3)(t._4._4._4);}
break;}
break;}
break;}
switch (t._0.ctor)
{case "BBlack":
switch (t._4.ctor)
{case "RBNode":
switch (t._4._0.ctor)
{case "NBlack":
switch (t._4._3.ctor)
{case "RBNode":
switch (t._4._3._0.ctor)
{case "Black":
return function () {
switch (t._4._4.ctor)
{case "RBNode":
switch (t._4._4._0.ctor)
{case "Black":
return A5(RBNode,
Black,
t._4._3._1,
t._4._3._2,
A5(RBNode,
Black,
t._1,
t._2,
t._3,
t._4._3._3),
A5(balance,
Black,
t._4._1,
t._4._2,
t._4._3._4,
redden(t._4._4)));}
break;}
return t;
}();}
break;}
break;}
break;}
switch (t._3.ctor)
{case "RBNode":
switch (t._3._0.ctor)
{case "NBlack":
switch (t._3._4.ctor)
{case "RBNode":
switch (t._3._4._0.ctor)
{case "Black":
return function () {
switch (t._3._3.ctor)
{case "RBNode":
switch (t._3._3._0.ctor)
{case "Black":
return A5(RBNode,
Black,
t._3._4._1,
t._3._4._2,
A5(balance,
Black,
t._3._1,
t._3._2,
redden(t._3._3),
t._3._4._3),
A5(RBNode,
Black,
t._1,
t._2,
t._3._4._4,
t._4));}
break;}
return t;
}();}
break;}
break;}
break;}
break;}
break;}
return t;
}() : t;
}();
};
var balance = F5(function (c,
k,
v,
l,
r) {
return balance_node(A5(RBNode,
c,
k,
v,
l,
r));
});
var bubble = F5(function (c,
k,
v,
l,
r) {
return isBBlack(l) || isBBlack(r) ? A5(balance,
moreBlack(c),
k,
v,
lessBlackTree(l),
lessBlackTree(r)) : A5(RBNode,
c,
k,
v,
l,
r);
});
var remove_max = F5(function (c,
k,
v,
l,
r) {
return function () {
switch (r.ctor)
{case "RBEmpty": return A3(rem,
c,
l,
r);
case "RBNode": return A5(bubble,
c,
k,
v,
l,
A5(remove_max,
r._0,
r._1,
r._2,
r._3,
r._4));}
_U.badCase($moduleName,
"between lines 314 and 319");
}();
});
var rem = F3(function (c,l,r) {
return function () {
var _v169 = {ctor: "_Tuple2"
,_0: l
,_1: r};
switch (_v169.ctor)
{case "_Tuple2":
switch (_v169._0.ctor)
{case "RBEmpty":
switch (_v169._1.ctor)
{case "RBEmpty":
return function () {
switch (c.ctor)
{case "Black":
return RBEmpty(LBBlack);
case "Red":
return RBEmpty(LBlack);}
_U.badCase($moduleName,
"between lines 273 and 277");
}();
case "RBNode":
return function () {
var _v191 = {ctor: "_Tuple3"
,_0: c
,_1: _v169._0._0
,_2: _v169._1._0};
switch (_v191.ctor)
{case "_Tuple3":
switch (_v191._0.ctor)
{case "Black":
switch (_v191._1.ctor)
{case "LBlack":
switch (_v191._2.ctor)
{case "Red": return A5(RBNode,
Black,
_v169._1._1,
_v169._1._2,
_v169._1._3,
_v169._1._4);}
break;}
break;}
break;}
return A4(reportRemBug,
"Black/LBlack/Red",
c,
showLColor(_v169._0._0),
showNColor(_v169._1._0));
}();}
break;
case "RBNode":
switch (_v169._1.ctor)
{case "RBEmpty":
return function () {
var _v195 = {ctor: "_Tuple3"
,_0: c
,_1: _v169._0._0
,_2: _v169._1._0};
switch (_v195.ctor)
{case "_Tuple3":
switch (_v195._0.ctor)
{case "Black":
switch (_v195._1.ctor)
{case "Red":
switch (_v195._2.ctor)
{case "LBlack":
return A5(RBNode,
Black,
_v169._0._1,
_v169._0._2,
_v169._0._3,
_v169._0._4);}
break;}
break;}
break;}
return A4(reportRemBug,
"Black/Red/LBlack",
c,
showNColor(_v169._0._0),
showLColor(_v169._1._0));
}();
case "RBNode":
return function () {
var l$ = A5(remove_max,
_v169._0._0,
_v169._0._1,
_v169._0._2,
_v169._0._3,
_v169._0._4);
var r = A5(RBNode,
_v169._1._0,
_v169._1._1,
_v169._1._2,
_v169._1._3,
_v169._1._4);
var l = A5(RBNode,
_v169._0._0,
_v169._0._1,
_v169._0._2,
_v169._0._3,
_v169._0._4);
var $ = max(l),
k = $._0,
v = $._1;
return A5(bubble,c,k,v,l$,r);
}();}
break;}
break;}
_U.badCase($moduleName,
"between lines 271 and 300");
}();
});
var update = F3(function (k,
alter,
dict) {
return function () {
var up = function (dict) {
return function () {
switch (dict.ctor)
{case "RBEmpty":
switch (dict._0.ctor)
{case "LBlack":
return function () {
var _v206 = alter($Maybe.Nothing);
switch (_v206.ctor)
{case "Just":
return {ctor: "_Tuple2"
,_0: Insert
,_1: A5(RBNode,
Red,
k,
_v206._0,
empty,
empty)};
case "Nothing":
return {ctor: "_Tuple2"
,_0: Same
,_1: empty};}
_U.badCase($moduleName,
"between lines 185 and 189");
}();}
break;
case "RBNode":
return function () {
var _v208 = A2($Basics.compare,
k,
dict._1);
switch (_v208.ctor)
{case "EQ": return function () {
var _v209 = alter($Maybe.Just(dict._2));
switch (_v209.ctor)
{case "Just":
return {ctor: "_Tuple2"
,_0: Same
,_1: A5(RBNode,
dict._0,
dict._1,
_v209._0,
dict._3,
dict._4)};
case "Nothing":
return {ctor: "_Tuple2"
,_0: Remove
,_1: A3(rem,
dict._0,
dict._3,
dict._4)};}
_U.badCase($moduleName,
"between lines 192 and 197");
}();
case "GT": return function () {
var $ = up(dict._4),
flag = $._0,
newRight = $._1;
return function () {
switch (flag.ctor)
{case "Insert":
return {ctor: "_Tuple2"
,_0: Insert
,_1: A5(balance,
dict._0,
dict._1,
dict._2,
dict._3,
newRight)};
case "Remove":
return {ctor: "_Tuple2"
,_0: Remove
,_1: A5(bubble,
dict._0,
dict._1,
dict._2,
dict._3,
newRight)};
case "Same":
return {ctor: "_Tuple2"
,_0: Same
,_1: A5(RBNode,
dict._0,
dict._1,
dict._2,
dict._3,
newRight)};}
_U.badCase($moduleName,
"between lines 206 and 211");
}();
}();
case "LT": return function () {
var $ = up(dict._3),
flag = $._0,
newLeft = $._1;
return function () {
switch (flag.ctor)
{case "Insert":
return {ctor: "_Tuple2"
,_0: Insert
,_1: A5(balance,
dict._0,
dict._1,
dict._2,
newLeft,
dict._4)};
case "Remove":
return {ctor: "_Tuple2"
,_0: Remove
,_1: A5(bubble,
dict._0,
dict._1,
dict._2,
newLeft,
dict._4)};
case "Same":
return {ctor: "_Tuple2"
,_0: Same
,_1: A5(RBNode,
dict._0,
dict._1,
dict._2,
newLeft,
dict._4)};}
_U.badCase($moduleName,
"between lines 199 and 204");
}();
}();}
_U.badCase($moduleName,
"between lines 190 and 211");
}();}
_U.badCase($moduleName,
"between lines 183 and 211");
}();
};
var $ = up(dict),
flag = $._0,
updatedDict = $._1;
return function () {
switch (flag.ctor)
{case "Insert":
return ensureBlackRoot(updatedDict);
case "Remove":
return blacken(updatedDict);
case "Same":
return updatedDict;}
_U.badCase($moduleName,
"between lines 213 and 219");
}();
}();
});
var insert = F3(function (key,
value,
dict) {
return A3(update,
key,
$Basics.always($Maybe.Just(value)),
dict);
});
var singleton = F2(function (key,
value) {
return A3(insert,
key,
value,
RBEmpty(LBlack));
});
var union = F2(function (t1,
t2) {
return A3(foldl,
insert,
t2,
t1);
});
var fromList = function (assocs) {
return A3($List.foldl,
F2(function (_v214,dict) {
return function () {
switch (_v214.ctor)
{case "_Tuple2":
return A3(insert,
_v214._0,
_v214._1,
dict);}
_U.badCase($moduleName,
"on line 457, column 38 to 59");
}();
}),
empty,
assocs);
};
var filter = F2(function (predicate,
dictionary) {
return function () {
var add = F3(function (key,
value,
dict) {
return A2(predicate,
key,
value) ? A3(insert,
key,
value,
dict) : dict;
});
return A3(foldl,
add,
empty,
dictionary);
}();
});
var intersect = F2(function (t1,
t2) {
return A2(filter,
F2(function (k,_v218) {
return function () {
return A2(member,k,t2);
}();
}),
t1);
});
var partition = F2(function (predicate,
dict) {
return function () {
var add = F3(function (key,
value,
_v220) {
return function () {
switch (_v220.ctor)
{case "_Tuple2":
return A2(predicate,
key,
value) ? {ctor: "_Tuple2"
,_0: A3(insert,
key,
value,
_v220._0)
,_1: _v220._1} : {ctor: "_Tuple2"
,_0: _v220._0
,_1: A3(insert,
key,
value,
_v220._1)};}
_U.badCase($moduleName,
"between lines 478 and 480");
}();
});
return A3(foldl,
add,
{ctor: "_Tuple2"
,_0: empty
,_1: empty},
dict);
}();
});
var remove = F2(function (key,
dict) {
return A3(update,
key,
$Basics.always($Maybe.Nothing),
dict);
});
var diff = F2(function (t1,t2) {
return A3(foldl,
F3(function (k,v,t) {
return A2(remove,k,t);
}),
t1,
t2);
});
_elm.Dict.values = {_op: _op
,empty: empty
,singleton: singleton
,insert: insert
,update: update
,get: get
,remove: remove
,member: member
,filter: filter
,partition: partition
,foldl: foldl
,foldr: foldr
,map: map
,union: union
,intersect: intersect
,diff: diff
,keys: keys
,values: values
,toList: toList
,fromList: fromList};
return _elm.Dict.values;
};
Elm.Graphics = Elm.Graphics || {};
Elm.Graphics.Collage = Elm.Graphics.Collage || {};
Elm.Graphics.Collage.make = function (_elm) {
"use strict";
_elm.Graphics = _elm.Graphics || {};
_elm.Graphics.Collage = _elm.Graphics.Collage || {};
if (_elm.Graphics.Collage.values)
return _elm.Graphics.Collage.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Graphics.Collage",
$Basics = Elm.Basics.make(_elm),
$Color = Elm.Color.make(_elm),
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$List = Elm.List.make(_elm),
$Native$Graphics$Collage = Elm.Native.Graphics.Collage.make(_elm),
$Text = Elm.Text.make(_elm),
$Transform2D = Elm.Transform2D.make(_elm);
var ngon = F2(function (n,r) {
return function () {
var m = $Basics.toFloat(n);
var t = 2 * $Basics.pi / m;
var f = function (i) {
return {ctor: "_Tuple2"
,_0: r * $Basics.cos(t * i)
,_1: r * $Basics.sin(t * i)};
};
return A2($List.map,
f,
_L.range(0,m - 1));
}();
});
var oval = F2(function (w,h) {
return function () {
var hh = h / 2;
var hw = w / 2;
var n = 50;
var t = 2 * $Basics.pi / n;
var f = function (i) {
return {ctor: "_Tuple2"
,_0: hw * $Basics.cos(t * i)
,_1: hh * $Basics.sin(t * i)};
};
return A2($List.map,
f,
_L.range(0,n - 1));
}();
});
var circle = function (r) {
return A2(oval,2 * r,2 * r);
};
var rect = F2(function (w,h) {
return function () {
var hh = h / 2;
var hw = w / 2;
return _L.fromArray([{ctor: "_Tuple2"
,_0: 0 - hw
,_1: 0 - hh}
,{ctor: "_Tuple2"
,_0: 0 - hw
,_1: hh}
,{ctor: "_Tuple2",_0: hw,_1: hh}
,{ctor: "_Tuple2"
,_0: hw
,_1: 0 - hh}]);
}();
});
var square = function (n) {
return A2(rect,n,n);
};
var polygon = function (points) {
return points;
};
var segment = F2(function (p1,
p2) {
return _L.fromArray([p1,p2]);
});
var path = function (ps) {
return ps;
};
var collage = $Native$Graphics$Collage.collage;
var alpha = F2(function (a,f) {
return _U.replace([["alpha"
,a]],
f);
});
var rotate = F2(function (t,f) {
return _U.replace([["theta"
,f.theta + t]],
f);
});
var scale = F2(function (s,f) {
return _U.replace([["scale"
,f.scale * s]],
f);
});
var moveY = F2(function (y,f) {
return _U.replace([["y"
,f.y + y]],
f);
});
var moveX = F2(function (x,f) {
return _U.replace([["x"
,f.x + x]],
f);
});
var move = F2(function (_v0,f) {
return function () {
switch (_v0.ctor)
{case "_Tuple2":
return _U.replace([["x"
,f.x + _v0._0]
,["y",f.y + _v0._1]],
f);}
_U.badCase($moduleName,
"on line 226, column 7 to 35");
}();
});
var form = function (f) {
return {_: {}
,alpha: 1
,form: f
,scale: 1
,theta: 0
,x: 0
,y: 0};
};
var Fill = function (a) {
return {ctor: "Fill",_0: a};
};
var Line = function (a) {
return {ctor: "Line",_0: a};
};
var FGroup = F2(function (a,b) {
return {ctor: "FGroup"
,_0: a
,_1: b};
});
var group = function (fs) {
return form(A2(FGroup,
$Transform2D.identity,
fs));
};
var groupTransform = F2(function (matrix,
fs) {
return form(A2(FGroup,
matrix,
fs));
});
var FElement = function (a) {
return {ctor: "FElement"
,_0: a};
};
var toForm = function (e) {
return form(FElement(e));
};
var FImage = F4(function (a,
b,
c,
d) {
return {ctor: "FImage"
,_0: a
,_1: b
,_2: c
,_3: d};
});
var sprite = F4(function (w,
h,
pos,
src) {
return form(A4(FImage,
w,
h,
pos,
src));
});
var FText = function (a) {
return {ctor: "FText",_0: a};
};
var text = function (t) {
return form(FText(t));
};
var FOutlinedText = F2(function (a,
b) {
return {ctor: "FOutlinedText"
,_0: a
,_1: b};
});
var outlinedText = F2(function (ls,
t) {
return form(A2(FOutlinedText,
ls,
t));
});
var FShape = F2(function (a,b) {
return {ctor: "FShape"
,_0: a
,_1: b};
});
var fill = F2(function (style,
shape) {
return form(A2(FShape,
Fill(style),
shape));
});
var outlined = F2(function (style,
shape) {
return form(A2(FShape,
Line(style),
shape));
});
var FPath = F2(function (a,b) {
return {ctor: "FPath"
,_0: a
,_1: b};
});
var traced = F2(function (style,
path) {
return form(A2(FPath,
style,
path));
});
var LineStyle = F6(function (a,
b,
c,
d,
e,
f) {
return {_: {}
,cap: c
,color: a
,dashOffset: f
,dashing: e
,join: d
,width: b};
});
var Clipped = {ctor: "Clipped"};
var Sharp = function (a) {
return {ctor: "Sharp",_0: a};
};
var Smooth = {ctor: "Smooth"};
var Padded = {ctor: "Padded"};
var Round = {ctor: "Round"};
var Flat = {ctor: "Flat"};
var defaultLine = {_: {}
,cap: Flat
,color: $Color.black
,dashOffset: 0
,dashing: _L.fromArray([])
,join: Sharp(10)
,width: 1};
var solid = function (clr) {
return _U.replace([["color"
,clr]],
defaultLine);
};
var dashed = function (clr) {
return _U.replace([["color"
,clr]
,["dashing"
,_L.fromArray([8,4])]],
defaultLine);
};
var dotted = function (clr) {
return _U.replace([["color"
,clr]
,["dashing"
,_L.fromArray([3,3])]],
defaultLine);
};
var Grad = function (a) {
return {ctor: "Grad",_0: a};
};
var gradient = F2(function (grad,
shape) {
return A2(fill,
Grad(grad),
shape);
});
var Texture = function (a) {
return {ctor: "Texture"
,_0: a};
};
var textured = F2(function (src,
shape) {
return A2(fill,
Texture(src),
shape);
});
var Solid = function (a) {
return {ctor: "Solid",_0: a};
};
var filled = F2(function (color,
shape) {
return A2(fill,
Solid(color),
shape);
});
var Form = F6(function (a,
b,
c,
d,
e,
f) {
return {_: {}
,alpha: e
,form: f
,scale: b
,theta: a
,x: c
,y: d};
});
_elm.Graphics.Collage.values = {_op: _op
,collage: collage
,toForm: toForm
,filled: filled
,textured: textured
,gradient: gradient
,outlined: outlined
,traced: traced
,text: text
,outlinedText: outlinedText
,move: move
,moveX: moveX
,moveY: moveY
,scale: scale
,rotate: rotate
,alpha: alpha
,group: group
,groupTransform: groupTransform
,rect: rect
,oval: oval
,square: square
,circle: circle
,ngon: ngon
,polygon: polygon
,segment: segment
,path: path
,solid: solid
,dashed: dashed
,dotted: dotted
,defaultLine: defaultLine
,Form: Form
,LineStyle: LineStyle
,Flat: Flat
,Round: Round
,Padded: Padded
,Smooth: Smooth
,Sharp: Sharp
,Clipped: Clipped};
return _elm.Graphics.Collage.values;
};
Elm.Graphics = Elm.Graphics || {};
Elm.Graphics.Element = Elm.Graphics.Element || {};
Elm.Graphics.Element.make = function (_elm) {
"use strict";
_elm.Graphics = _elm.Graphics || {};
_elm.Graphics.Element = _elm.Graphics.Element || {};
if (_elm.Graphics.Element.values)
return _elm.Graphics.Element.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Graphics.Element",
$Basics = Elm.Basics.make(_elm),
$Color = Elm.Color.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Graphics$Element = Elm.Native.Graphics.Element.make(_elm),
$Text = Elm.Text.make(_elm);
var DOut = {ctor: "DOut"};
var outward = DOut;
var DIn = {ctor: "DIn"};
var inward = DIn;
var DRight = {ctor: "DRight"};
var right = DRight;
var DLeft = {ctor: "DLeft"};
var left = DLeft;
var DDown = {ctor: "DDown"};
var down = DDown;
var DUp = {ctor: "DUp"};
var up = DUp;
var Position = F4(function (a,
b,
c,
d) {
return {_: {}
,horizontal: a
,vertical: b
,x: c
,y: d};
});
var Relative = function (a) {
return {ctor: "Relative"
,_0: a};
};
var relative = Relative;
var Absolute = function (a) {
return {ctor: "Absolute"
,_0: a};
};
var absolute = Absolute;
var N = {ctor: "N"};
var bottomLeftAt = F2(function (x,
y) {
return {_: {}
,horizontal: N
,vertical: N
,x: x
,y: y};
});
var Z = {ctor: "Z"};
var middle = {_: {}
,horizontal: Z
,vertical: Z
,x: Relative(0.5)
,y: Relative(0.5)};
var midLeft = _U.replace([["horizontal"
,N]
,["x",Absolute(0)]],
middle);
var middleAt = F2(function (x,
y) {
return {_: {}
,horizontal: Z
,vertical: Z
,x: x
,y: y};
});
var midLeftAt = F2(function (x,
y) {
return {_: {}
,horizontal: N
,vertical: Z
,x: x
,y: y};
});
var midBottomAt = F2(function (x,
y) {
return {_: {}
,horizontal: Z
,vertical: N
,x: x
,y: y};
});
var P = {ctor: "P"};
var topLeft = {_: {}
,horizontal: N
,vertical: P
,x: Absolute(0)
,y: Absolute(0)};
var bottomLeft = _U.replace([["vertical"
,N]],
topLeft);
var topRight = _U.replace([["horizontal"
,P]],
topLeft);
var bottomRight = _U.replace([["horizontal"
,P]],
bottomLeft);
var midRight = _U.replace([["horizontal"
,P]],
midLeft);
var midTop = _U.replace([["vertical"
,P]
,["y",Absolute(0)]],
middle);
var midBottom = _U.replace([["vertical"
,N]],
midTop);
var topLeftAt = F2(function (x,
y) {
return {_: {}
,horizontal: N
,vertical: P
,x: x
,y: y};
});
var topRightAt = F2(function (x,
y) {
return {_: {}
,horizontal: P
,vertical: P
,x: x
,y: y};
});
var bottomRightAt = F2(function (x,
y) {
return {_: {}
,horizontal: P
,vertical: N
,x: x
,y: y};
});
var midRightAt = F2(function (x,
y) {
return {_: {}
,horizontal: P
,vertical: Z
,x: x
,y: y};
});
var midTopAt = F2(function (x,
y) {
return {_: {}
,horizontal: Z
,vertical: P
,x: x
,y: y};
});
var justified = $Native$Graphics$Element.block("justify");
var centered = $Native$Graphics$Element.block("center");
var rightAligned = $Native$Graphics$Element.block("right");
var leftAligned = $Native$Graphics$Element.block("left");
var show = function (value) {
return leftAligned($Text.monospace($Text.fromString($Basics.toString(value))));
};
var Tiled = {ctor: "Tiled"};
var Cropped = function (a) {
return {ctor: "Cropped"
,_0: a};
};
var Fitted = {ctor: "Fitted"};
var Plain = {ctor: "Plain"};
var Custom = {ctor: "Custom"};
var RawHtml = {ctor: "RawHtml"};
var Spacer = {ctor: "Spacer"};
var Flow = F2(function (a,b) {
return {ctor: "Flow"
,_0: a
,_1: b};
});
var Container = F2(function (a,
b) {
return {ctor: "Container"
,_0: a
,_1: b};
});
var Image = F4(function (a,
b,
c,
d) {
return {ctor: "Image"
,_0: a
,_1: b
,_2: c
,_3: d};
});
var newElement = $Native$Graphics$Element.newElement;
var image = F3(function (w,
h,
src) {
return A3(newElement,
w,
h,
A4(Image,Plain,w,h,src));
});
var fittedImage = F3(function (w,
h,
src) {
return A3(newElement,
w,
h,
A4(Image,Fitted,w,h,src));
});
var croppedImage = F4(function (pos,
w,
h,
src) {
return A3(newElement,
w,
h,
A4(Image,Cropped(pos),w,h,src));
});
var tiledImage = F3(function (w,
h,
src) {
return A3(newElement,
w,
h,
A4(Image,Tiled,w,h,src));
});
var container = F4(function (w,
h,
pos,
e) {
return A3(newElement,
w,
h,
A2(Container,pos,e));
});
var spacer = F2(function (w,h) {
return A3(newElement,
w,
h,
Spacer);
});
var link = F2(function (href,
e) {
return function () {
var p = e.props;
return {_: {}
,element: e.element
,props: _U.replace([["href"
,href]],
p)};
}();
});
var tag = F2(function (name,e) {
return function () {
var p = e.props;
return {_: {}
,element: e.element
,props: _U.replace([["tag"
,name]],
p)};
}();
});
var color = F2(function (c,e) {
return function () {
var p = e.props;
return {_: {}
,element: e.element
,props: _U.replace([["color"
,$Maybe.Just(c)]],
p)};
}();
});
var opacity = F2(function (o,
e) {
return function () {
var p = e.props;
return {_: {}
,element: e.element
,props: _U.replace([["opacity"
,o]],
p)};
}();
});
var height = F2(function (nh,
e) {
return function () {
var p = e.props;
var props = function () {
var _v0 = e.element;
switch (_v0.ctor)
{case "Image":
return _U.replace([["width"
,$Basics.round($Basics.toFloat(_v0._1) / $Basics.toFloat(_v0._2) * $Basics.toFloat(nh))]],
p);}
return p;
}();
return {_: {}
,element: e.element
,props: _U.replace([["height"
,nh]],
p)};
}();
});
var width = F2(function (nw,e) {
return function () {
var p = e.props;
var props = function () {
var _v5 = e.element;
switch (_v5.ctor)
{case "Image":
return _U.replace([["height"
,$Basics.round($Basics.toFloat(_v5._2) / $Basics.toFloat(_v5._1) * $Basics.toFloat(nw))]],
p);
case "RawHtml":
return _U.replace([["height"
,$Basics.snd(A2($Native$Graphics$Element.htmlHeight,
nw,
e.element))]],
p);}
return p;
}();
return {_: {}
,element: e.element
,props: _U.replace([["width"
,nw]],
props)};
}();
});
var size = F3(function (w,h,e) {
return A2(height,
h,
A2(width,w,e));
});
var sizeOf = function (e) {
return {ctor: "_Tuple2"
,_0: e.props.width
,_1: e.props.height};
};
var heightOf = function (e) {
return e.props.height;
};
var widthOf = function (e) {
return e.props.width;
};
var above = F2(function (hi,
lo) {
return A3(newElement,
A2($Basics.max,
widthOf(hi),
widthOf(lo)),
heightOf(hi) + heightOf(lo),
A2(Flow,
DDown,
_L.fromArray([hi,lo])));
});
var below = F2(function (lo,
hi) {
return A3(newElement,
A2($Basics.max,
widthOf(hi),
widthOf(lo)),
heightOf(hi) + heightOf(lo),
A2(Flow,
DDown,
_L.fromArray([hi,lo])));
});
var beside = F2(function (lft,
rht) {
return A3(newElement,
widthOf(lft) + widthOf(rht),
A2($Basics.max,
heightOf(lft),
heightOf(rht)),
A2(Flow,
right,
_L.fromArray([lft,rht])));
});
var layers = function (es) {
return function () {
var hs = A2($List.map,
heightOf,
es);
var ws = A2($List.map,
widthOf,
es);
return A3(newElement,
A2($Maybe.withDefault,
0,
$List.maximum(ws)),
A2($Maybe.withDefault,
0,
$List.maximum(hs)),
A2(Flow,DOut,es));
}();
};
var empty = A2(spacer,0,0);
var flow = F2(function (dir,
es) {
return function () {
var newFlow = F2(function (w,
h) {
return A3(newElement,
w,
h,
A2(Flow,dir,es));
});
var maxOrZero = function (list) {
return A2($Maybe.withDefault,
0,
$List.maximum(list));
};
var hs = A2($List.map,
heightOf,
es);
var ws = A2($List.map,
widthOf,
es);
return _U.eq(es,
_L.fromArray([])) ? empty : function () {
switch (dir.ctor)
{case "DDown":
return A2(newFlow,
maxOrZero(ws),
$List.sum(hs));
case "DIn": return A2(newFlow,
maxOrZero(ws),
maxOrZero(hs));
case "DLeft": return A2(newFlow,
$List.sum(ws),
maxOrZero(hs));
case "DOut": return A2(newFlow,
maxOrZero(ws),
maxOrZero(hs));
case "DRight":
return A2(newFlow,
$List.sum(ws),
maxOrZero(hs));
case "DUp": return A2(newFlow,
maxOrZero(ws),
$List.sum(hs));}
_U.badCase($moduleName,
"between lines 362 and 373");
}();
}();
});
var Properties = F9(function (a,
b,
c,
d,
e,
f,
g,
h,
i) {
return {_: {}
,click: i
,color: e
,height: c
,hover: h
,href: f
,id: a
,opacity: d
,tag: g
,width: b};
});
var Element = F2(function (a,
b) {
return {_: {}
,element: b
,props: a};
});
_elm.Graphics.Element.values = {_op: _op
,image: image
,fittedImage: fittedImage
,croppedImage: croppedImage
,tiledImage: tiledImage
,leftAligned: leftAligned
,rightAligned: rightAligned
,centered: centered
,justified: justified
,show: show
,width: width
,height: height
,size: size
,color: color
,opacity: opacity
,link: link
,tag: tag
,widthOf: widthOf
,heightOf: heightOf
,sizeOf: sizeOf
,flow: flow
,up: up
,down: down
,left: left
,right: right
,inward: inward
,outward: outward
,layers: layers
,above: above
,below: below
,beside: beside
,empty: empty
,spacer: spacer
,container: container
,middle: middle
,midTop: midTop
,midBottom: midBottom
,midLeft: midLeft
,midRight: midRight
,topLeft: topLeft
,topRight: topRight
,bottomLeft: bottomLeft
,bottomRight: bottomRight
,absolute: absolute
,relative: relative
,middleAt: middleAt
,midTopAt: midTopAt
,midBottomAt: midBottomAt
,midLeftAt: midLeftAt
,midRightAt: midRightAt
,topLeftAt: topLeftAt
,topRightAt: topRightAt
,bottomLeftAt: bottomLeftAt
,bottomRightAt: bottomRightAt
,Element: Element
,Position: Position};
return _elm.Graphics.Element.values;
};
Elm.Graphics = Elm.Graphics || {};
Elm.Graphics.Input = Elm.Graphics.Input || {};
Elm.Graphics.Input.make = function (_elm) {
"use strict";
_elm.Graphics = _elm.Graphics || {};
_elm.Graphics.Input = _elm.Graphics.Input || {};
if (_elm.Graphics.Input.values)
return _elm.Graphics.Input.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Graphics.Input",
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$Native$Graphics$Input = Elm.Native.Graphics.Input.make(_elm),
$Signal = Elm.Signal.make(_elm);
var clickable = $Native$Graphics$Input.clickable;
var hoverable = $Native$Graphics$Input.hoverable;
var dropDown = $Native$Graphics$Input.dropDown;
var checkbox = $Native$Graphics$Input.checkbox;
var customButton = $Native$Graphics$Input.customButton;
var button = $Native$Graphics$Input.button;
_elm.Graphics.Input.values = {_op: _op
,button: button
,customButton: customButton
,checkbox: checkbox
,dropDown: dropDown
,hoverable: hoverable
,clickable: clickable};
return _elm.Graphics.Input.values;
};
Elm.Graphics = Elm.Graphics || {};
Elm.Graphics.Input = Elm.Graphics.Input || {};
Elm.Graphics.Input.Field = Elm.Graphics.Input.Field || {};
Elm.Graphics.Input.Field.make = function (_elm) {
"use strict";
_elm.Graphics = _elm.Graphics || {};
_elm.Graphics.Input = _elm.Graphics.Input || {};
_elm.Graphics.Input.Field = _elm.Graphics.Input.Field || {};
if (_elm.Graphics.Input.Field.values)
return _elm.Graphics.Input.Field.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Graphics.Input.Field",
$Color = Elm.Color.make(_elm),
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$Native$Graphics$Input = Elm.Native.Graphics.Input.make(_elm),
$Signal = Elm.Signal.make(_elm),
$Text = Elm.Text.make(_elm);
var email = $Native$Graphics$Input.email;
var password = $Native$Graphics$Input.password;
var field = $Native$Graphics$Input.field;
var Backward = {ctor: "Backward"};
var Forward = {ctor: "Forward"};
var Selection = F3(function (a,
b,
c) {
return {_: {}
,direction: c
,end: b
,start: a};
});
var Content = F2(function (a,
b) {
return {_: {}
,selection: b
,string: a};
});
var noContent = A2(Content,
"",
A3(Selection,0,0,Forward));
var Style = F4(function (a,
b,
c,
d) {
return {_: {}
,highlight: c
,outline: b
,padding: a
,style: d};
});
var Highlight = F2(function (a,
b) {
return {_: {}
,color: a
,width: b};
});
var noHighlight = A2(Highlight,
$Color.blue,
0);
var Outline = F3(function (a,
b,
c) {
return {_: {}
,color: a
,radius: c
,width: b};
});
var Dimensions = F4(function (a,
b,
c,
d) {
return {_: {}
,bottom: d
,left: a
,right: b
,top: c};
});
var uniformly = function (n) {
return A4(Dimensions,
n,
n,
n,
n);
};
var noOutline = A3(Outline,
$Color.grey,
uniformly(0),
0);
var defaultStyle = {_: {}
,highlight: A2(Highlight,
$Color.blue,
1)
,outline: A3(Outline,
$Color.grey,
uniformly(1),
2)
,padding: uniformly(4)
,style: $Text.defaultStyle};
_elm.Graphics.Input.Field.values = {_op: _op
,uniformly: uniformly
,Dimensions: Dimensions
,Outline: Outline
,noOutline: noOutline
,Highlight: Highlight
,noHighlight: noHighlight
,Style: Style
,defaultStyle: defaultStyle
,Content: Content
,Selection: Selection
,Forward: Forward
,Backward: Backward
,noContent: noContent
,field: field
,password: password
,email: email};
return _elm.Graphics.Input.Field.values;
};
Elm.Html = Elm.Html || {};
Elm.Html.make = function (_elm) {
"use strict";
_elm.Html = _elm.Html || {};
if (_elm.Html.values)
return _elm.Html.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Html",
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$VirtualDom = Elm.VirtualDom.make(_elm);
var fromElement = $VirtualDom.fromElement;
var toElement = $VirtualDom.toElement;
var text = $VirtualDom.text;
var node = $VirtualDom.node;
var body = node("body");
var section = node("section");
var nav = node("nav");
var article = node("article");
var aside = node("aside");
var h1 = node("h1");
var h2 = node("h2");
var h3 = node("h3");
var h4 = node("h4");
var h5 = node("h5");
var h6 = node("h6");
var header = node("header");
var footer = node("footer");
var address = node("address");
var main$ = node("main");
var p = node("p");
var hr = node("hr");
var pre = node("pre");
var blockquote = node("blockquote");
var ol = node("ol");
var ul = node("ul");
var li = node("li");
var dl = node("dl");
var dt = node("dt");
var dd = node("dd");
var figure = node("figure");
var figcaption = node("figcaption");
var div = node("div");
var a = node("a");
var em = node("em");
var strong = node("strong");
var small = node("small");
var s = node("s");
var cite = node("cite");
var q = node("q");
var dfn = node("dfn");
var abbr = node("abbr");
var time = node("time");
var code = node("code");
var $var = node("var");
var samp = node("samp");
var kbd = node("kbd");
var sub = node("sub");
var sup = node("sup");
var i = node("i");
var b = node("b");
var u = node("u");
var mark = node("mark");
var ruby = node("ruby");
var rt = node("rt");
var rp = node("rp");
var bdi = node("bdi");
var bdo = node("bdo");
var span = node("span");
var br = node("br");
var wbr = node("wbr");
var ins = node("ins");
var del = node("del");
var img = node("img");
var iframe = node("iframe");
var embed = node("embed");
var object = node("object");
var param = node("param");
var video = node("video");
var audio = node("audio");
var source = node("source");
var track = node("track");
var canvas = node("canvas");
var svg = node("svg");
var math = node("math");
var table = node("table");
var caption = node("caption");
var colgroup = node("colgroup");
var col = node("col");
var tbody = node("tbody");
var thead = node("thead");
var tfoot = node("tfoot");
var tr = node("tr");
var td = node("td");
var th = node("th");
var form = node("form");
var fieldset = node("fieldset");
var legend = node("legend");
var label = node("label");
var input = node("input");
var button = node("button");
var select = node("select");
var datalist = node("datalist");
var optgroup = node("optgroup");
var option = node("option");
var textarea = node("textarea");
var keygen = node("keygen");
var output = node("output");
var progress = node("progress");
var meter = node("meter");
var details = node("details");
var summary = node("summary");
var menuitem = node("menuitem");
var menu = node("menu");
_elm.Html.values = {_op: _op
,node: node
,text: text
,toElement: toElement
,fromElement: fromElement
,body: body
,section: section
,nav: nav
,article: article
,aside: aside
,h1: h1
,h2: h2
,h3: h3
,h4: h4
,h5: h5
,h6: h6
,header: header
,footer: footer
,address: address
,main$: main$
,p: p
,hr: hr
,pre: pre
,blockquote: blockquote
,ol: ol
,ul: ul
,li: li
,dl: dl
,dt: dt
,dd: dd
,figure: figure
,figcaption: figcaption
,div: div
,a: a
,em: em
,strong: strong
,small: small
,s: s
,cite: cite
,q: q
,dfn: dfn
,abbr: abbr
,time: time
,code: code
,$var: $var
,samp: samp
,kbd: kbd
,sub: sub
,sup: sup
,i: i
,b: b
,u: u
,mark: mark
,ruby: ruby
,rt: rt
,rp: rp
,bdi: bdi
,bdo: bdo
,span: span
,br: br
,wbr: wbr
,ins: ins
,del: del
,img: img
,iframe: iframe
,embed: embed
,object: object
,param: param
,video: video
,audio: audio
,source: source
,track: track
,canvas: canvas
,svg: svg
,math: math
,table: table
,caption: caption
,colgroup: colgroup
,col: col
,tbody: tbody
,thead: thead
,tfoot: tfoot
,tr: tr
,td: td
,th: th
,form: form
,fieldset: fieldset
,legend: legend
,label: label
,input: input
,button: button
,select: select
,datalist: datalist
,optgroup: optgroup
,option: option
,textarea: textarea
,keygen: keygen
,output: output
,progress: progress
,meter: meter
,details: details
,summary: summary
,menuitem: menuitem
,menu: menu};
return _elm.Html.values;
};
Elm.Json = Elm.Json || {};
Elm.Json.Decode = Elm.Json.Decode || {};
Elm.Json.Decode.make = function (_elm) {
"use strict";
_elm.Json = _elm.Json || {};
_elm.Json.Decode = _elm.Json.Decode || {};
if (_elm.Json.Decode.values)
return _elm.Json.Decode.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Json.Decode",
$Array = Elm.Array.make(_elm),
$Dict = Elm.Dict.make(_elm),
$Json$Encode = Elm.Json.Encode.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Json = Elm.Native.Json.make(_elm),
$Result = Elm.Result.make(_elm);
var tuple8 = $Native$Json.decodeTuple8;
var tuple7 = $Native$Json.decodeTuple7;
var tuple6 = $Native$Json.decodeTuple6;
var tuple5 = $Native$Json.decodeTuple5;
var tuple4 = $Native$Json.decodeTuple4;
var tuple3 = $Native$Json.decodeTuple3;
var tuple2 = $Native$Json.decodeTuple2;
var tuple1 = $Native$Json.decodeTuple1;
var succeed = $Native$Json.succeed;
var fail = $Native$Json.fail;
var andThen = $Native$Json.andThen;
var customDecoder = $Native$Json.customDecoder;
var decodeValue = $Native$Json.runDecoderValue;
var value = $Native$Json.decodeValue;
var maybe = $Native$Json.decodeMaybe;
var $null = $Native$Json.decodeNull;
var array = $Native$Json.decodeArray;
var list = $Native$Json.decodeList;
var bool = $Native$Json.decodeBool;
var $int = $Native$Json.decodeInt;
var $float = $Native$Json.decodeFloat;
var string = $Native$Json.decodeString;
var oneOf = $Native$Json.oneOf;
var keyValuePairs = $Native$Json.decodeKeyValuePairs;
var object8 = $Native$Json.decodeObject8;
var object7 = $Native$Json.decodeObject7;
var object6 = $Native$Json.decodeObject6;
var object5 = $Native$Json.decodeObject5;
var object4 = $Native$Json.decodeObject4;
var object3 = $Native$Json.decodeObject3;
var object2 = $Native$Json.decodeObject2;
var object1 = $Native$Json.decodeObject1;
_op[":="] = $Native$Json.decodeField;
var at = F2(function (fields,
decoder) {
return A3($List.foldr,
F2(function (x,y) {
return A2(_op[":="],x,y);
}),
decoder,
fields);
});
var decodeString = $Native$Json.runDecoderString;
var map = $Native$Json.decodeObject1;
var dict = function (decoder) {
return A2(map,
$Dict.fromList,
keyValuePairs(decoder));
};
var Decoder = {ctor: "Decoder"};
_elm.Json.Decode.values = {_op: _op
,Decoder: Decoder
,map: map
,decodeString: decodeString
,at: at
,object1: object1
,object2: object2
,object3: object3
,object4: object4
,object5: object5
,object6: object6
,object7: object7
,object8: object8
,keyValuePairs: keyValuePairs
,dict: dict
,oneOf: oneOf
,string: string
,$float: $float
,$int: $int
,bool: bool
,list: list
,array: array
,$null: $null
,maybe: maybe
,value: value
,decodeValue: decodeValue
,customDecoder: customDecoder
,andThen: andThen
,fail: fail
,succeed: succeed
,tuple1: tuple1
,tuple2: tuple2
,tuple3: tuple3
,tuple4: tuple4
,tuple5: tuple5
,tuple6: tuple6
,tuple7: tuple7
,tuple8: tuple8};
return _elm.Json.Decode.values;
};
Elm.Json = Elm.Json || {};
Elm.Json.Encode = Elm.Json.Encode || {};
Elm.Json.Encode.make = function (_elm) {
"use strict";
_elm.Json = _elm.Json || {};
_elm.Json.Encode = _elm.Json.Encode || {};
if (_elm.Json.Encode.values)
return _elm.Json.Encode.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Json.Encode",
$Array = Elm.Array.make(_elm),
$Native$Json = Elm.Native.Json.make(_elm);
var list = $Native$Json.encodeList;
var array = $Native$Json.encodeArray;
var object = $Native$Json.encodeObject;
var $null = $Native$Json.encodeNull;
var bool = $Native$Json.identity;
var $float = $Native$Json.identity;
var $int = $Native$Json.identity;
var string = $Native$Json.identity;
var encode = $Native$Json.encode;
var Value = {ctor: "Value"};
_elm.Json.Encode.values = {_op: _op
,Value: Value
,encode: encode
,string: string
,$int: $int
,$float: $float
,bool: bool
,$null: $null
,object: object
,array: array
,list: list};
return _elm.Json.Encode.values;
};
Elm.List = Elm.List || {};
Elm.List.make = function (_elm) {
"use strict";
_elm.List = _elm.List || {};
if (_elm.List.values)
return _elm.List.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "List",
$Basics = Elm.Basics.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$List = Elm.Native.List.make(_elm);
var sortWith = $Native$List.sortWith;
var sortBy = $Native$List.sortBy;
var sort = function (xs) {
return A2(sortBy,
$Basics.identity,
xs);
};
var repeat = $Native$List.repeat;
var drop = $Native$List.drop;
var take = $Native$List.take;
var map5 = $Native$List.map5;
var map4 = $Native$List.map4;
var map3 = $Native$List.map3;
var map2 = $Native$List.map2;
var any = $Native$List.any;
var all = F2(function (pred,
xs) {
return $Basics.not(A2(any,
function ($) {
return $Basics.not(pred($));
},
xs));
});
var foldr = $Native$List.foldr;
var foldl = $Native$List.foldl;
var length = function (xs) {
return A3(foldl,
F2(function (_v0,i) {
return function () {
return i + 1;
}();
}),
0,
xs);
};
var sum = function (numbers) {
return A3(foldl,
F2(function (x,y) {
return x + y;
}),
0,
numbers);
};
var product = function (numbers) {
return A3(foldl,
F2(function (x,y) {
return x * y;
}),
1,
numbers);
};
var maximum = function (list) {
return function () {
switch (list.ctor)
{case "::":
return $Maybe.Just(A3(foldl,
$Basics.max,
list._0,
list._1));}
return $Maybe.Nothing;
}();
};
var minimum = function (list) {
return function () {
switch (list.ctor)
{case "::":
return $Maybe.Just(A3(foldl,
$Basics.min,
list._0,
list._1));}
return $Maybe.Nothing;
}();
};
var indexedMap = F2(function (f,
xs) {
return A3(map2,
f,
_L.range(0,length(xs) - 1),
xs);
});
var member = F2(function (x,
xs) {
return A2(any,
function (a) {
return _U.eq(a,x);
},
xs);
});
var isEmpty = function (xs) {
return function () {
switch (xs.ctor)
{case "[]": return true;}
return false;
}();
};
var tail = function (list) {
return function () {
switch (list.ctor)
{case "::":
return $Maybe.Just(list._1);
case "[]":
return $Maybe.Nothing;}
_U.badCase($moduleName,
"between lines 87 and 95");
}();
};
var head = function (list) {
return function () {
switch (list.ctor)
{case "::":
return $Maybe.Just(list._0);
case "[]":
return $Maybe.Nothing;}
_U.badCase($moduleName,
"between lines 75 and 84");
}();
};
_op["::"] = $Native$List.cons;
var map = F2(function (f,xs) {
return A3(foldr,
F2(function (x,acc) {
return A2(_op["::"],
f(x),
acc);
}),
_L.fromArray([]),
xs);
});
var filter = F2(function (pred,
xs) {
return function () {
var conditionalCons = F2(function (x,
xs$) {
return pred(x) ? A2(_op["::"],
x,
xs$) : xs$;
});
return A3(foldr,
conditionalCons,
_L.fromArray([]),
xs);
}();
});
var maybeCons = F3(function (f,
mx,
xs) {
return function () {
var _v15 = f(mx);
switch (_v15.ctor)
{case "Just":
return A2(_op["::"],_v15._0,xs);
case "Nothing": return xs;}
_U.badCase($moduleName,
"between lines 179 and 186");
}();
});
var filterMap = F2(function (f,
xs) {
return A3(foldr,
maybeCons(f),
_L.fromArray([]),
xs);
});
var reverse = function (list) {
return A3(foldl,
F2(function (x,y) {
return A2(_op["::"],x,y);
}),
_L.fromArray([]),
list);
};
var scanl = F3(function (f,
b,
xs) {
return function () {
var scan1 = F2(function (x,
accAcc) {
return function () {
switch (accAcc.ctor)
{case "::": return A2(_op["::"],
A2(f,x,accAcc._0),
accAcc);
case "[]":
return _L.fromArray([]);}
_U.badCase($moduleName,
"between lines 148 and 151");
}();
});
return reverse(A3(foldl,
scan1,
_L.fromArray([b]),
xs));
}();
});
var append = F2(function (xs,
ys) {
return function () {
switch (ys.ctor)
{case "[]": return xs;}
return A3(foldr,
F2(function (x,y) {
return A2(_op["::"],x,y);
}),
ys,
xs);
}();
});
var concat = function (lists) {
return A3(foldr,
append,
_L.fromArray([]),
lists);
};
var concatMap = F2(function (f,
list) {
return concat(A2(map,
f,
list));
});
var partition = F2(function (pred,
list) {
return function () {
var step = F2(function (x,
_v21) {
return function () {
switch (_v21.ctor)
{case "_Tuple2":
return pred(x) ? {ctor: "_Tuple2"
,_0: A2(_op["::"],x,_v21._0)
,_1: _v21._1} : {ctor: "_Tuple2"
,_0: _v21._0
,_1: A2(_op["::"],
x,
_v21._1)};}
_U.badCase($moduleName,
"between lines 301 and 303");
}();
});
return A3(foldr,
step,
{ctor: "_Tuple2"
,_0: _L.fromArray([])
,_1: _L.fromArray([])},
list);
}();
});
var unzip = function (pairs) {
return function () {
var step = F2(function (_v25,
_v26) {
return function () {
switch (_v26.ctor)
{case "_Tuple2":
return function () {
switch (_v25.ctor)
{case "_Tuple2":
return {ctor: "_Tuple2"
,_0: A2(_op["::"],
_v25._0,
_v26._0)
,_1: A2(_op["::"],
_v25._1,
_v26._1)};}
_U.badCase($moduleName,
"on line 339, column 12 to 28");
}();}
_U.badCase($moduleName,
"on line 339, column 12 to 28");
}();
});
return A3(foldr,
step,
{ctor: "_Tuple2"
,_0: _L.fromArray([])
,_1: _L.fromArray([])},
pairs);
}();
};
var intersperse = F2(function (sep,
xs) {
return function () {
switch (xs.ctor)
{case "::": return function () {
var step = F2(function (x,
rest) {
return A2(_op["::"],
sep,
A2(_op["::"],x,rest));
});
var spersed = A3(foldr,
step,
_L.fromArray([]),
xs._1);
return A2(_op["::"],
xs._0,
spersed);
}();
case "[]":
return _L.fromArray([]);}
_U.badCase($moduleName,
"between lines 350 and 361");
}();
});
_elm.List.values = {_op: _op
,isEmpty: isEmpty
,length: length
,reverse: reverse
,member: member
,head: head
,tail: tail
,filter: filter
,take: take
,drop: drop
,repeat: repeat
,append: append
,concat: concat
,intersperse: intersperse
,partition: partition
,unzip: unzip
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,filterMap: filterMap
,concatMap: concatMap
,indexedMap: indexedMap
,foldr: foldr
,foldl: foldl
,sum: sum
,product: product
,maximum: maximum
,minimum: minimum
,all: all
,any: any
,scanl: scanl
,sort: sort
,sortBy: sortBy
,sortWith: sortWith};
return _elm.List.values;
};
Elm.Markdown = Elm.Markdown || {};
Elm.Markdown.make = function (_elm) {
"use strict";
_elm.Markdown = _elm.Markdown || {};
if (_elm.Markdown.values)
return _elm.Markdown.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Markdown",
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$Html = Elm.Html.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Markdown = Elm.Native.Markdown.make(_elm);
var toElementWith = $Native$Markdown.toElementWith;
var toHtmlWith = $Native$Markdown.toHtmlWith;
var defaultOptions = {_: {}
,githubFlavored: $Maybe.Just({_: {}
,breaks: false
,tables: false})
,sanitize: false
,smartypants: false};
var Options = F3(function (a,
b,
c) {
return {_: {}
,githubFlavored: a
,sanitize: b
,smartypants: c};
});
var toElement = function (string) {
return A2($Native$Markdown.toElementWith,
defaultOptions,
string);
};
var toHtml = function (string) {
return A2($Native$Markdown.toHtmlWith,
defaultOptions,
string);
};
_elm.Markdown.values = {_op: _op
,toHtml: toHtml
,toElement: toElement
,Options: Options
,defaultOptions: defaultOptions
,toHtmlWith: toHtmlWith
,toElementWith: toElementWith};
return _elm.Markdown.values;
};
Elm.Maybe = Elm.Maybe || {};
Elm.Maybe.make = function (_elm) {
"use strict";
_elm.Maybe = _elm.Maybe || {};
if (_elm.Maybe.values)
return _elm.Maybe.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Maybe";
var withDefault = F2(function ($default,
maybe) {
return function () {
switch (maybe.ctor)
{case "Just": return maybe._0;
case "Nothing":
return $default;}
_U.badCase($moduleName,
"between lines 45 and 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.Native.Array = {};
Elm.Native.Array.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Array = localRuntime.Native.Array || {};
if (localRuntime.Native.Array.values)
{
return localRuntime.Native.Array.values;
}
if ('values' in Elm.Native.Array)
{
return localRuntime.Native.Array.values = Elm.Native.Array.values;
}
var List = Elm.Native.List.make(localRuntime);
// A RRB-Tree has two distinct data types.
// Leaf -> "height" is always 0
// "table" is an array of elements
// Node -> "height" is always greater than 0
// "table" is an array of child nodes
// "lengths" is an array of accumulated lengths of the child nodes
// M is the maximal table size. 32 seems fast. E is the allowed increase
// of search steps when concatting to find an index. Lower values will
// decrease balancing, but will increase search steps.
var M = 32;
var E = 2;
// An empty array.
var empty = {
ctor: "_Array",
height: 0,
table: new Array()
};
function get(i, array)
{
if (i < 0 || i >= length(array))
{
throw new Error(
"Index " + i + " is out of range. Check the length of " +
"your array first or use getMaybe or getWithDefault.");
}
return unsafeGet(i, array);
}
function unsafeGet(i, array)
{
for (var x = array.height; x > 0; x--)
{
var slot = i >> (x * 5);
while (array.lengths[slot] <= i)
{
slot++;
}
if (slot > 0)
{
i -= array.lengths[slot - 1];
}
array = array.table[slot];
}
return array.table[i];
}
// Sets the value at the index i. Only the nodes leading to i will get
// copied and updated.
function set(i, item, array)
{
if (i < 0 || length(array) <= i)
{
return array;
}
return unsafeSet(i, item, array);
}
function unsafeSet(i, item, array)
{
array = nodeCopy(array);
if (array.height == 0)
{
array.table[i] = item;
}
else
{
var slot = getSlot(i, array);
if (slot > 0)
{
i -= array.lengths[slot - 1];
}
array.table[slot] = unsafeSet(i, item, array.table[slot]);
}
return array;
}
function initialize(len, f)
{
if (len == 0)
{
return empty;
}
var h = Math.floor( Math.log(len) / Math.log(M) );
return initialize_(f, h, 0, len);
}
function initialize_(f, h, from, to)
{
if (h == 0)
{
var table = new Array((to - from) % (M + 1));
for (var i = 0; i < table.length; i++)
{
table[i] = f(from + i);
}
return {
ctor: "_Array",
height: 0,
table: table
};
}
var step = Math.pow(M, h);
var table = new Array(Math.ceil((to - from) / step));
var lengths = new Array(table.length);
for (var i = 0; i < table.length; i++)
{
table[i] = initialize_(f, h - 1, from + (i * step), Math.min(from + ((i + 1) * step), to));
lengths[i] = length(table[i]) + (i > 0 ? lengths[i-1] : 0);
}
return {
ctor: "_Array",
height: h,
table: table,
lengths: lengths
};
}
function fromList(list)
{
if (list == List.Nil)
{
return empty;
}
// Allocate M sized blocks (table) and write list elements to it.
var table = new Array(M);
var nodes = new Array();
var i = 0;
while (list.ctor !== '[]')
{
table[i] = list._0;
list = list._1;
i++;
// table is full, so we can push a leaf containing it into the
// next node.
if (i == M)
{
var leaf = {
ctor: "_Array",
height: 0,
table: table
};
fromListPush(leaf, nodes);
table = new Array(M);
i = 0;
}
}
// Maybe there is something left on the table.
if (i > 0)
{
var leaf = {
ctor: "_Array",
height: 0,
table: table.splice(0,i)
};
fromListPush(leaf, nodes);
}
// Go through all of the nodes and eventually push them into higher nodes.
for (var h = 0; h < nodes.length - 1; h++)
{
if (nodes[h].table.length > 0)
{
fromListPush(nodes[h], nodes);
}
}
var head = nodes[nodes.length - 1];
if (head.height > 0 && head.table.length == 1)
{
return head.table[0];
}
else
{
return head;
}
}
// Push a node into a higher node as a child.
function fromListPush(toPush, nodes)
{
var h = toPush.height;
// Maybe the node on this height does not exist.
if (nodes.length == h)
{
var node = {
ctor: "_Array",
height: h + 1,
table: new Array(),
lengths: new Array()
};
nodes.push(node);
}
nodes[h].table.push(toPush);
var len = length(toPush);
if (nodes[h].lengths.length > 0)
{
len += nodes[h].lengths[nodes[h].lengths.length - 1];
}
nodes[h].lengths.push(len);
if (nodes[h].table.length == M)
{
fromListPush(nodes[h], nodes);
nodes[h] = {
ctor: "_Array",
height: h + 1,
table: new Array(),
lengths: new Array()
};
}
}
// Pushes an item via push_ to the bottom right of a tree.
function push(item, a)
{
var pushed = push_(item, a);
if (pushed !== null)
{
return pushed;
}
var newTree = create(item, a.height);
return siblise(a, newTree);
}
// Recursively tries to push an item to the bottom-right most
// tree possible. If there is no space left for the item,
// null will be returned.
function push_(item, a)
{
// Handle resursion stop at leaf level.
if (a.height == 0)
{
if (a.table.length < M)
{
var newA = {
ctor: "_Array",
height: 0,
table: a.table.slice()
};
newA.table.push(item);
return newA;
}
else
{
return null;
}
}
// Recursively push
var pushed = push_(item, botRight(a));
// There was space in the bottom right tree, so the slot will
// be updated.
if (pushed != null)
{
var newA = nodeCopy(a);
newA.table[newA.table.length - 1] = pushed;
newA.lengths[newA.lengths.length - 1]++;
return newA;
}
// When there was no space left, check if there is space left
// for a new slot with a tree which contains only the item
// at the bottom.
if (a.table.length < M)
{
var newSlot = create(item, a.height - 1);
var newA = nodeCopy(a);
newA.table.push(newSlot);
newA.lengths.push(newA.lengths[newA.lengths.length - 1] + length(newSlot));
return newA;
}
else
{
return null;
}
}
// Converts an array into a list of elements.
function toList(a)
{
return toList_(List.Nil, a);
}
function toList_(list, a)
{
for (var i = a.table.length - 1; i >= 0; i--)
{
list =
a.height == 0
? List.Cons(a.table[i], list)
: toList_(list, a.table[i]);
}
return list;
}
// Maps a function over the elements of an array.
function map(f, a)
{
var newA = {
ctor: "_Array",
height: a.height,
table: new Array(a.table.length)
};
if (a.height > 0)
{
newA.lengths = a.lengths;
}
for (var i = 0; i < a.table.length; i++)
{
newA.table[i] =
a.height == 0
? f(a.table[i])
: map(f, a.table[i]);
}
return newA;
}
// Maps a function over the elements with their index as first argument.
function indexedMap(f, a)
{
return indexedMap_(f, a, 0);
}
function indexedMap_(f, a, from)
{
var newA = {
ctor: "_Array",
height: a.height,
table: new Array(a.table.length)
};
if (a.height > 0)
{
newA.lengths = a.lengths;
}
for (var i = 0; i < a.table.length; i++)
{
newA.table[i] =
a.height == 0
? A2(f, from + i, a.table[i])
: indexedMap_(f, a.table[i], i == 0 ? 0 : a.lengths[i - 1]);
}
return newA;
}
function foldl(f, b, a)
{
if (a.height == 0)
{
for (var i = 0; i < a.table.length; i++)
{
b = A2(f, a.table[i], b);
}
}
else
{
for (var i = 0; i < a.table.length; i++)
{
b = foldl(f, b, a.table[i]);
}
}
return b;
}
function foldr(f, b, a)
{
if (a.height == 0)
{
for (var i = a.table.length; i--; )
{
b = A2(f, a.table[i], b);
}
}
else
{
for (var i = a.table.length; i--; )
{
b = foldr(f, b, a.table[i]);
}
}
return b;
}
// TODO: currently, it slices the right, then the left. This can be
// optimized.
function slice(from, to, a)
{
if (from < 0)
{
from += length(a);
}
if (to < 0)
{
to += length(a);
}
return sliceLeft(from, sliceRight(to, a));
}
function sliceRight(to, a)
{
if (to == length(a))
{
return a;
}
// Handle leaf level.
if (a.height == 0)
{
var newA = { ctor:"_Array", height:0 };
newA.table = a.table.slice(0, to);
return newA;
}
// Slice the right recursively.
var right = getSlot(to, a);
var sliced = sliceRight(to - (right > 0 ? a.lengths[right - 1] : 0), a.table[right]);
// Maybe the a node is not even needed, as sliced contains the whole slice.
if (right == 0)
{
return sliced;
}
// Create new node.
var newA = {
ctor: "_Array",
height: a.height,
table: a.table.slice(0, right),
lengths: a.lengths.slice(0, right)
};
if (sliced.table.length > 0)
{
newA.table[right] = sliced;
newA.lengths[right] = length(sliced) + (right > 0 ? newA.lengths[right - 1] : 0);
}
return newA;
}
function sliceLeft(from, a)
{
if (from == 0)
{
return a;
}
// Handle leaf level.
if (a.height == 0)
{
var newA = { ctor:"_Array", height:0 };
newA.table = a.table.slice(from, a.table.length + 1);
return newA;
}
// Slice the left recursively.
var left = getSlot(from, a);
var sliced = sliceLeft(from - (left > 0 ? a.lengths[left - 1] : 0), a.table[left]);
// Maybe the a node is not even needed, as sliced contains the whole slice.
if (left == a.table.length - 1)
{
return sliced;
}
// Create new node.
var newA = {
ctor: "_Array",
height: a.height,
table: a.table.slice(left, a.table.length + 1),
lengths: new Array(a.table.length - left)
};
newA.table[0] = sliced;
var len = 0;
for (var i = 0; i < newA.table.length; i++)
{
len += length(newA.table[i]);
newA.lengths[i] = len;
}
return newA;
}
// Appends two trees.
function append(a,b)
{
if (a.table.length === 0)
{
return b;
}
if (b.table.length === 0)
{
return a;
}
var c = append_(a, b);
// Check if both nodes can be crunshed together.
if (c[0].table.length + c[1].table.length <= M)
{
if (c[0].table.length === 0)
{
return c[1];
}
if (c[1].table.length === 0)
{
return c[0];
}
// Adjust .table and .lengths
c[0].table = c[0].table.concat(c[1].table);
if (c[0].height > 0)
{
var len = length(c[0]);
for (var i = 0; i < c[1].lengths.length; i++)
{
c[1].lengths[i] += len;
}
c[0].lengths = c[0].lengths.concat(c[1].lengths);
}
return c[0];
}
if (c[0].height > 0)
{
var toRemove = calcToRemove(a, b);
if (toRemove > E)
{
c = shuffle(c[0], c[1], toRemove);
}
}
return siblise(c[0], c[1]);
}
// Returns an array of two nodes; right and left. One node _may_ be empty.
function append_(a, b)
{
if (a.height === 0 && b.height === 0)
{
return [a, b];
}
if (a.height !== 1 || b.height !== 1)
{
if (a.height === b.height)
{
a = nodeCopy(a);
b = nodeCopy(b);
var appended = append_(botRight(a), botLeft(b));
insertRight(a, appended[1]);
insertLeft(b, appended[0]);
}
else if (a.height > b.height)
{
a = nodeCopy(a);
var appended = append_(botRight(a), b);
insertRight(a, appended[0]);
b = parentise(appended[1], appended[1].height + 1);
}
else
{
b = nodeCopy(b);
var appended = append_(a, botLeft(b));
var left = appended[0].table.length === 0 ? 0 : 1;
var right = left === 0 ? 1 : 0;
insertLeft(b, appended[left]);
a = parentise(appended[right], appended[right].height + 1);
}
}
// Check if balancing is needed and return based on that.
if (a.table.length === 0 || b.table.length === 0)
{
return [a,b];
}
var toRemove = calcToRemove(a, b);
if (toRemove <= E)
{
return [a,b];
}
return shuffle(a, b, toRemove);
}
// Helperfunctions for append_. Replaces a child node at the side of the parent.
function insertRight(parent, node)
{
var index = parent.table.length - 1;
parent.table[index] = node;
parent.lengths[index] = length(node)
parent.lengths[index] += index > 0 ? parent.lengths[index - 1] : 0;
}
function insertLeft(parent, node)
{
if (node.table.length > 0)
{
parent.table[0] = node;
parent.lengths[0] = length(node);
var len = length(parent.table[0]);
for (var i = 1; i < parent.lengths.length; i++)
{
len += length(parent.table[i]);
parent.lengths[i] = len;
}
}
else
{
parent.table.shift();
for (var i = 1; i < parent.lengths.length; i++)
{
parent.lengths[i] = parent.lengths[i] - parent.lengths[0];
}
parent.lengths.shift();
}
}
// Returns the extra search steps for E. Refer to the paper.
function calcToRemove(a, b)
{
var subLengths = 0;
for (var i = 0; i < a.table.length; i++)
{
subLengths += a.table[i].table.length;
}
for (var i = 0; i < b.table.length; i++)
{
subLengths += b.table[i].table.length;
}
var toRemove = a.table.length + b.table.length
return toRemove - (Math.floor((subLengths - 1) / M) + 1);
}
// get2, set2 and saveSlot are helpers for accessing elements over two arrays.
function get2(a, b, index)
{
return index < a.length
? a[index]
: b[index - a.length];
}
function set2(a, b, index, value)
{
if (index < a.length)
{
a[index] = value;
}
else
{
b[index - a.length] = value;
}
}
function saveSlot(a, b, index, slot)
{
set2(a.table, b.table, index, slot);
var l = (index == 0 || index == a.lengths.length)
? 0
: get2(a.lengths, a.lengths, index - 1);
set2(a.lengths, b.lengths, index, l + length(slot));
}
// Creates a node or leaf with a given length at their arrays for perfomance.
// Is only used by shuffle.
function createNode(h, length)
{
if (length < 0)
{
length = 0;
}
var a = {
ctor: "_Array",
height: h,
table: new Array(length)
};
if (h > 0)
{
a.lengths = new Array(length);
}
return a;
}
// Returns an array of two balanced nodes.
function shuffle(a, b, toRemove)
{
var newA = createNode(a.height, Math.min(M, a.table.length + b.table.length - toRemove));
var newB = createNode(a.height, newA.table.length - (a.table.length + b.table.length - toRemove));
// Skip the slots with size M. More precise: copy the slot references
// to the new node
var read = 0;
while (get2(a.table, b.table, read).table.length % M == 0)
{
set2(newA.table, newB.table, read, get2(a.table, b.table, read));
set2(newA.lengths, newB.lengths, read, get2(a.lengths, b.lengths, read));
read++;
}
// Pulling items from left to right, caching in a slot before writing
// it into the new nodes.
var write = read;
var slot = new createNode(a.height - 1, 0);
var from = 0;
// If the current slot is still containing data, then there will be at
// least one more write, so we do not break this loop yet.
while (read - write - (slot.table.length > 0 ? 1 : 0) < toRemove)
{
// Find out the max possible items for copying.
var source = get2(a.table, b.table, read);
var to = Math.min(M - slot.table.length, source.table.length)
// Copy and adjust size table.
slot.table = slot.table.concat(source.table.slice(from, to));
if (slot.height > 0)
{
var len = slot.lengths.length;
for (var i = len; i < len + to - from; i++)
{
slot.lengths[i] = length(slot.table[i]);
slot.lengths[i] += (i > 0 ? slot.lengths[i - 1] : 0);
}
}
from += to;
// Only proceed to next slots[i] if the current one was
// fully copied.
if (source.table.length <= to)
{
read++; from = 0;
}
// Only create a new slot if the current one is filled up.
if (slot.table.length == M)
{
saveSlot(newA, newB, write, slot);
slot = createNode(a.height - 1,0);
write++;
}
}
// Cleanup after the loop. Copy the last slot into the new nodes.
if (slot.table.length > 0)
{
saveSlot(newA, newB, write, slot);
write++;
}
// Shift the untouched slots to the left
while (read < a.table.length + b.table.length )
{
saveSlot(newA, newB, write, get2(a.table, b.table, read));
read++;
write++;
}
return [newA, newB];
}
// Navigation functions
function botRight(a)
{
return a.table[a.table.length - 1];
}
function botLeft(a)
{
return a.table[0];
}
// Copies a node for updating. Note that you should not use this if
// only updating only one of "table" or "lengths" for performance reasons.
function nodeCopy(a)
{
var newA = {
ctor: "_Array",
height: a.height,
table: a.table.slice()
};
if (a.height > 0)
{
newA.lengths = a.lengths.slice();
}
return newA;
}
// Returns how many items are in the tree.
function length(array)
{
if (array.height == 0)
{
return array.table.length;
}
else
{
return array.lengths[array.lengths.length - 1];
}
}
// Calculates in which slot of "table" the item probably is, then
// find the exact slot via forward searching in "lengths". Returns the index.
function getSlot(i, a)
{
var slot = i >> (5 * a.height);
while (a.lengths[slot] <= i)
{
slot++;
}
return slot;
}
// Recursively creates a tree with a given height containing
// only the given item.
function create(item, h)
{
if (h == 0)
{
return {
ctor: "_Array",
height: 0,
table: [item]
};
}
return {
ctor: "_Array",
height: h,
table: [create(item, h - 1)],
lengths: [1]
};
}
// Recursively creates a tree that contains the given tree.
function parentise(tree, h)
{
if (h == tree.height)
{
return tree;
}
return {
ctor: "_Array",
height: h,
table: [parentise(tree, h - 1)],
lengths: [length(tree)]
};
}
// Emphasizes blood brotherhood beneath two trees.
function siblise(a, b)
{
return {
ctor: "_Array",
height: a.height + 1,
table: [a, b],
lengths: [length(a), length(a) + length(b)]
};
}
function toJSArray(a)
{
var jsArray = new Array(length(a));
toJSArray_(jsArray, 0, a);
return jsArray;
}
function toJSArray_(jsArray, i, a)
{
for (var t = 0; t < a.table.length; t++)
{
if (a.height == 0)
{
jsArray[i + t] = a.table[t];
}
else
{
var inc = t == 0 ? 0 : a.lengths[t - 1];
toJSArray_(jsArray, i + inc, a.table[t]);
}
}
}
function fromJSArray(jsArray)
{
if (jsArray.length == 0)
{
return empty;
}
var h = Math.floor(Math.log(jsArray.length) / Math.log(M));
return fromJSArray_(jsArray, h, 0, jsArray.length);
}
function fromJSArray_(jsArray, h, from, to)
{
if (h == 0)
{
return {
ctor: "_Array",
height: 0,
table: jsArray.slice(from, to)
};
}
var step = Math.pow(M, h);
var table = new Array(Math.ceil((to - from) / step));
var lengths = new Array(table.length);
for (var i = 0; i < table.length; i++)
{
table[i] = fromJSArray_(jsArray, h - 1, from + (i * step), Math.min(from + ((i + 1) * step), to));
lengths[i] = length(table[i]) + (i > 0 ? lengths[i-1] : 0);
}
return {
ctor: "_Array",
height: h,
table: table,
lengths: lengths
};
}
Elm.Native.Array.values = {
empty: empty,
fromList: fromList,
toList: toList,
initialize: F2(initialize),
append: F2(append),
push: F2(push),
slice: F3(slice),
get: F2(get),
set: F3(set),
map: F2(map),
indexedMap: F2(indexedMap),
foldl: F3(foldl),
foldr: F3(foldr),
length: length,
toJSArray:toJSArray,
fromJSArray:fromJSArray
};
return localRuntime.Native.Array.values = Elm.Native.Array.values;
}
Elm.Native.Basics = {};
Elm.Native.Basics.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Basics = localRuntime.Native.Basics || {};
if (localRuntime.Native.Basics.values)
{
return localRuntime.Native.Basics.values;
}
var Utils = Elm.Native.Utils.make(localRuntime);
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));
}
return localRuntime.Native.Basics.values = {
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
};
};
Elm.Native.Char = {};
Elm.Native.Char.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Char = localRuntime.Native.Char || {};
if (localRuntime.Native.Char.values)
{
return localRuntime.Native.Char.values;
}
var Utils = Elm.Native.Utils.make(localRuntime);
return localRuntime.Native.Char.values = {
fromCode : function(c) { return Utils.chr(String.fromCharCode(c)); },
toCode : function(c) { return c.charCodeAt(0); },
toUpper : function(c) { return Utils.chr(c.toUpperCase()); },
toLower : function(c) { return Utils.chr(c.toLowerCase()); },
toLocaleUpper : function(c) { return Utils.chr(c.toLocaleUpperCase()); },
toLocaleLower : function(c) { return Utils.chr(c.toLocaleLowerCase()); },
};
};
Elm.Native.Color = {};
Elm.Native.Color.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Color = localRuntime.Native.Color || {};
if (localRuntime.Native.Color.values)
{
return localRuntime.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 localRuntime.Native.Color.values = {
toCss: toCss
};
};
Elm.Native.Debug = {};
Elm.Native.Debug.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Debug = localRuntime.Native.Debug || {};
if (localRuntime.Native.Debug.values)
{
return localRuntime.Native.Debug.values;
}
var toString = Elm.Native.Show.make(localRuntime).toString;
function log(tag, value)
{
var msg = tag + ': ' + toString(value);
var process = process || {};
if (process.stdout)
{
process.stdout.write(msg);
}
else
{
console.log(msg);
}
return value;
}
function crash(message)
{
throw new Error(message);
}
function tracePath(tag, form)
{
if (localRuntime.debug)
{
return localRuntime.debug.trace(tag, form);
}
return form;
}
function watch(tag, value)
{
if (localRuntime.debug)
{
localRuntime.debug.watch(tag, value);
}
return value;
}
function watchSummary(tag, summarize, value)
{
if (localRuntime.debug)
{
localRuntime.debug.watch(tag, summarize(value));
}
return value;
}
return localRuntime.Native.Debug.values = {
crash: crash,
tracePath: F2(tracePath),
log: F2(log),
watch: F2(watch),
watchSummary:F3(watchSummary),
};
};
// 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
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Graphics = localRuntime.Native.Graphics || {};
localRuntime.Native.Graphics.Collage = localRuntime.Native.Graphics.Collage || {};
if ('values' in localRuntime.Native.Graphics.Collage)
{
return localRuntime.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 NativeElement = Elm.Native.Graphics.Element.make(localRuntime);
var Transform = Elm.Transform2D.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
function setStrokeStyle(ctx, style)
{
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);
}
function setFillStyle(ctx, style)
{
var sty = style.ctor;
ctx.fillStyle = sty === 'Solid'
? Color.toCss(style._0)
: sty === 'Texture'
? texture(redo, ctx, style._0)
: gradient(ctx, style._0);
}
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)
{
setStrokeStyle(ctx, style);
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);
setFillStyle(ctx, style);
ctx.scale(1,-1);
ctx.fill();
}
// TEXT RENDERING
function fillText(redo, ctx, text)
{
drawText(ctx, text, ctx.fillText);
}
function strokeText(redo, ctx, style, text)
{
setStrokeStyle(ctx, style);
// Use native canvas API for dashes only for text for now
// Degrades to non-dashed on IE 9 + 10
if (style.dashing.ctor !== '[]' && ctx.setLineDash)
{
var pattern = List.toArray(style.dashing);
ctx.setLineDash(pattern);
}
drawText(ctx, text, ctx.strokeText);
}
function drawText(ctx, text, canvasDrawFn)
{
var textChunks = chunkText(defaultContext, text);
var totalWidth = 0;
var maxHeight = 0;
var numChunks = textChunks.length;
ctx.scale(1,-1);
for (var i = numChunks; i--; )
{
var chunk = textChunks[i];
ctx.font = chunk.font;
var metrics = ctx.measureText(chunk.text);
chunk.width = metrics.width;
totalWidth += chunk.width;
if (chunk.height > maxHeight)
{
maxHeight = chunk.height;
}
}
var x = -totalWidth / 2.0;
for (var i = 0; i < numChunks; ++i)
{
var chunk = textChunks[i];
ctx.font = chunk.font;
ctx.fillStyle = chunk.color;
canvasDrawFn.call(ctx, chunk.text, x, maxHeight / 2);
x += chunk.width;
}
}
function toFont(props)
{
return [
props['font-style'],
props['font-variant'],
props['font-weight'],
props['font-size'],
props['font-family']
].join(' ');
}
// Convert the object returned by the text module
// into something we can use for styling canvas text
function chunkText(context, text)
{
var tag = text.ctor;
if (tag === 'Text:Append')
{
var leftChunks = chunkText(context, text._0);
var rightChunks = chunkText(context, text._1);
return leftChunks.concat(rightChunks);
}
if (tag === 'Text:Text')
{
return [{
text: text._0,
color: context.color,
height: context['font-size'].slice(0,-2) | 0,
font: toFont(context)
}];
}
if (tag === 'Text:Meta')
{
var newContext = freshContext(text._0, context);
return chunkText(newContext, text._1);
}
}
function freshContext(props, ctx)
{
return {
'font-style': props['font-style'] || ctx['font-style'],
'font-variant': props['font-variant'] || ctx['font-variant'],
'font-weight': props['font-weight'] || ctx['font-weight'],
'font-size': props['font-size'] || ctx['font-size'],
'font-family': props['font-family'] || ctx['font-family'],
'color': props['color'] || ctx['color']
};
}
var defaultContext = {
'font-style': 'normal',
'font-variant': 'normal',
'font-weight': 'normal',
'font-size': '12px',
'font-family': 'sans-serif',
'color': 'black'
};
// IMAGES
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;
case 'FText':
fillText(redo, ctx, f._0);
break;
case 'FOutlinedText':
strokeText(redo, ctx, f._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";
var ratio = window.devicePixelRatio || 1;
canvas.width = w * ratio;
canvas.height = h * ratio;
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;
var ratio = window.devicePixelRatio || 1;
function transform(transforms, ctx)
{
ctx.translate( w / 2 * ratio, h / 2 * ratio );
ctx.scale( ratio, -ratio );
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 * ratio;
node.height = h * ratio;
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
{
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(NativeElement.newElement, w, h, {
ctor: 'Custom',
type: 'Collage',
render: render,
update: update,
model: {w:w, h:h, forms:forms}
});
}
return localRuntime.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
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Graphics = localRuntime.Native.Graphics || {};
localRuntime.Native.Graphics.Element = localRuntime.Native.Graphics.Element || {};
if ('values' in localRuntime.Native.Graphics.Element)
{
return localRuntime.Native.Graphics.Element.values;
}
var Color = Elm.Native.Color.make(localRuntime);
var List = Elm.Native.List.make(localRuntime);
var Maybe = Elm.Maybe.make(localRuntime);
var Text = Elm.Native.Text.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
// CREATION
function createNode(elementType)
{
var node = document.createElement(elementType);
node.style.padding = "0";
node.style.margin = "0";
return node;
}
function newElement(width, height, elementPrim)
{
return {
_: {},
element: elementPrim,
props: {
_: {},
id: Utils.guid(),
width: width,
height: height,
opacity: 1,
color: Maybe.Nothing,
href: "",
tag: "",
hover: Utils.Tuple0,
click: Utils.Tuple0
}
};
}
// PROPERTIES
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;
}
}
// IMAGES
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;
}
// FLOW
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;
}
// CONTAINER
function toPos(pos)
{
return pos.ctor === "Absolute"
? pos._0 + "px"
: (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;
}
// RENDER
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;
}
// UPDATE
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":
if(currE.html.valueOf() !== nextE.html.valueOf())
{
node.innerHTML = nextE.html;
}
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;
}
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';
}
}
// TEXT
function block(align)
{
return function(text)
{
var raw = {
ctor :'RawHtml',
html : Text.renderHtml(text),
align: align
};
var pos = htmlHeight(0, raw);
return newElement(pos._0, pos._1, raw);
}
}
function markdown(text)
{
var raw = {
ctor:'RawHtml',
html: text,
align: null
};
var pos = htmlHeight(0, raw);
return newElement(pos._0, pos._1, raw);
}
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 localRuntime.Native.Graphics.Element.values = {
render: render,
update: update,
updateAndReplace: updateAndReplace,
createNode: createNode,
newElement: F3(newElement),
addTransform: addTransform,
htmlHeight: F2(htmlHeight),
guid: Utils.guid,
block: block,
markdown: markdown
};
};
// setup
Elm.Native = Elm.Native || {};
Elm.Native.Graphics = Elm.Native.Graphics || {};
Elm.Native.Graphics.Input = Elm.Native.Graphics.Input || {};
// definition
Elm.Native.Graphics.Input.make = function(localRuntime) {
'use strict';
// attempt to short-circuit
if ('values' in Elm.Native.Graphics.Input) {
return Elm.Native.Graphics.Input.values;
}
var Color = Elm.Native.Color.make(localRuntime);
var List = Elm.Native.List.make(localRuntime);
var Signal = Elm.Native.Signal.make(localRuntime);
var Text = Elm.Native.Text.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
var Element = Elm.Native.Graphics.Element.make(localRuntime);
function renderDropDown(model)
{
var drop = Element.createNode('select');
drop.style.border = '0 solid';
drop.style.pointerEvents = 'auto';
drop.style.display = 'block';
drop.elm_values = List.toArray(model.values);
drop.elm_handler = model.handler;
var values = drop.elm_values;
for (var i = 0; i < values.length; ++i)
{
var option = Element.createNode('option');
var name = values[i]._0;
option.value = name;
option.innerHTML = name;
drop.appendChild(option);
}
drop.addEventListener('change', function() {
Signal.sendMessage(drop.elm_handler(drop.elm_values[drop.selectedIndex]._1));
});
return drop;
}
function updateDropDown(node, oldModel, newModel)
{
node.elm_values = List.toArray(newModel.values);
node.elm_handler = newModel.handler;
var values = node.elm_values;
var kids = node.childNodes;
var kidsLength = kids.length;
var i = 0;
for (; i < kidsLength && i < values.length; ++i)
{
var option = kids[i];
var name = values[i]._0;
option.value = name;
option.innerHTML = name;
}
for (; i < kidsLength; ++i)
{
node.removeChild(node.lastChild);
}
for (; i < values.length; ++i)
{
var option = Element.createNode('option');
var name = values[i]._0;
option.value = name;
option.innerHTML = name;
node.appendChild(option);
}
return node;
}
function dropDown(handler, values)
{
return A3(Element.newElement, 100, 24, {
ctor: 'Custom',
type: 'DropDown',
render: renderDropDown,
update: updateDropDown,
model: {
values: values,
handler: handler
}
});
}
function renderButton(model)
{
var node = Element.createNode('button');
node.style.display = 'block';
node.style.pointerEvents = 'auto';
node.elm_message = model.message;
function click()
{
Signal.sendMessage(node.elm_message);
}
node.addEventListener('click', click);
node.innerHTML = model.text;
return node;
}
function updateButton(node, oldModel, newModel)
{
node.elm_message = newModel.message;
var txt = newModel.text;
if (oldModel.text !== txt)
{
node.innerHTML = txt;
}
return node;
}
function button(message, text)
{
return A3(Element.newElement, 100, 40, {
ctor: 'Custom',
type: 'Button',
render: renderButton,
update: updateButton,
model: {
message: message,
text:text
}
});
}
function renderCustomButton(model)
{
var btn = Element.createNode('div');
btn.style.pointerEvents = 'auto';
btn.elm_message = model.message;
btn.elm_up = Element.render(model.up);
btn.elm_hover = Element.render(model.hover);
btn.elm_down = Element.render(model.down);
btn.elm_up.style.display = 'block';
btn.elm_hover.style.display = 'none';
btn.elm_down.style.display = 'none';
btn.appendChild(btn.elm_up);
btn.appendChild(btn.elm_hover);
btn.appendChild(btn.elm_down);
function swap(visibleNode, hiddenNode1, hiddenNode2)
{
visibleNode.style.display = 'block';
hiddenNode1.style.display = 'none';
hiddenNode2.style.display = 'none';
}
var overCount = 0;
function over(e)
{
if (overCount++ > 0) return;
swap(btn.elm_hover, btn.elm_down, btn.elm_up);
}
function out(e)
{
if (btn.contains(e.toElement || e.relatedTarget)) return;
overCount = 0;
swap(btn.elm_up, btn.elm_down, btn.elm_hover);
}
function up()
{
swap(btn.elm_hover, btn.elm_down, btn.elm_up);
Signal.sendMessage(btn.elm_message);
}
function down()
{
swap(btn.elm_down, btn.elm_hover, btn.elm_up);
}
btn.addEventListener('mouseover', over);
btn.addEventListener('mouseout' , out);
btn.addEventListener('mousedown', down);
btn.addEventListener('mouseup' , up);
return btn;
}
function updateCustomButton(node, oldModel, newModel)
{
node.elm_message = newModel.message;
var kids = node.childNodes;
var styleUp = kids[0].style.display;
var styleHover = kids[1].style.display;
var styleDown = kids[2].style.display;
Element.updateAndReplace(kids[0], oldModel.up, newModel.up);
Element.updateAndReplace(kids[1], oldModel.hover, newModel.hover);
Element.updateAndReplace(kids[2], oldModel.down, newModel.down);
var kids = node.childNodes;
kids[0].style.display = styleUp;
kids[1].style.display = styleHover;
kids[2].style.display = styleDown;
return node;
}
function max3(a,b,c)
{
var ab = a > b ? a : b;
return ab > c ? ab : c;
}
function customButton(message, up, hover, down)
{
return A3(Element.newElement,
max3(up.props.width, hover.props.width, down.props.width),
max3(up.props.height, hover.props.height, down.props.height),
{ ctor: 'Custom',
type: 'CustomButton',
render: renderCustomButton,
update: updateCustomButton,
model: {
message: message,
up: up,
hover: hover,
down: down
}
});
}
function renderCheckbox(model)
{
var node = Element.createNode('input');
node.type = 'checkbox';
node.checked = model.checked;
node.style.display = 'block';
node.style.pointerEvents = 'auto';
node.elm_handler = model.handler;
function change()
{
Signal.sendMessage(node.elm_handler(node.checked));
}
node.addEventListener('change', change);
return node;
}
function updateCheckbox(node, oldModel, newModel)
{
node.elm_handler = newModel.handler;
node.checked = newModel.checked;
return node;
}
function checkbox(handler, checked)
{
return A3(Element.newElement, 13, 13, {
ctor: 'Custom',
type: 'CheckBox',
render: renderCheckbox,
update: updateCheckbox,
model: { handler:handler, checked:checked }
});
}
function setRange(node, start, end, dir)
{
if (node.parentNode)
{
node.setSelectionRange(start, end, dir);
}
else
{
setTimeout(function(){node.setSelectionRange(start, end, dir);}, 0);
}
}
function updateIfNeeded(css, attribute, latestAttribute)
{
if (css[attribute] !== latestAttribute)
{
css[attribute] = latestAttribute;
}
}
function cssDimensions(dimensions)
{
return dimensions.top + 'px ' +
dimensions.right + 'px ' +
dimensions.bottom + 'px ' +
dimensions.left + 'px';
}
function updateFieldStyle(css, style)
{
updateIfNeeded(css, 'padding', cssDimensions(style.padding));
var outline = style.outline;
updateIfNeeded(css, 'border-width', cssDimensions(outline.width));
updateIfNeeded(css, 'border-color', Color.toCss(outline.color));
updateIfNeeded(css, 'border-radius', outline.radius + 'px');
var highlight = style.highlight;
if (highlight.width === 0)
{
css.outline = 'none';
}
else
{
updateIfNeeded(css, 'outline-width', highlight.width + 'px');
updateIfNeeded(css, 'outline-color', Color.toCss(highlight.color));
}
var textStyle = style.style;
updateIfNeeded(css, 'color', Color.toCss(textStyle.color));
if (textStyle.typeface.ctor !== '[]')
{
updateIfNeeded(css, 'font-family', Text.toTypefaces(textStyle.typeface));
}
if (textStyle.height.ctor !== "Nothing")
{
updateIfNeeded(css, 'font-size', textStyle.height._0 + 'px');
}
updateIfNeeded(css, 'font-weight', textStyle.bold ? 'bold' : 'normal');
updateIfNeeded(css, 'font-style', textStyle.italic ? 'italic' : 'normal');
if (textStyle.line.ctor !== 'Nothing')
{
updateIfNeeded(css, 'text-decoration', Text.toLine(textStyle.line._0));
}
}
function renderField(model)
{
var field = Element.createNode('input');
updateFieldStyle(field.style, model.style);
field.style.borderStyle = 'solid';
field.style.pointerEvents = 'auto';
field.type = model.type;
field.placeholder = model.placeHolder;
field.value = model.content.string;
field.elm_handler = model.handler;
field.elm_old_value = field.value;
function inputUpdate(event)
{
var curr = field.elm_old_value;
var next = field.value;
if (curr === next)
{
return;
}
var direction = field.selectionDirection === 'forward' ? 'Forward' : 'Backward';
var start = field.selectionStart;
var end = field.selectionEnd;
field.value = field.elm_old_value;
Signal.sendMessage(field.elm_handler({
_:{},
string: next,
selection: {
_:{},
start: start,
end: end,
direction: { ctor: direction }
}
}));
}
field.addEventListener('input', inputUpdate);
field.addEventListener('focus', function() {
field.elm_hasFocus = true;
});
field.addEventListener('blur', function() {
field.elm_hasFocus = false;
});
return field;
}
function updateField(field, oldModel, newModel)
{
if (oldModel.style !== newModel.style)
{
updateFieldStyle(field.style, newModel.style);
}
field.elm_handler = newModel.handler;
field.type = newModel.type;
field.placeholder = newModel.placeHolder;
var value = newModel.content.string;
field.value = value;
field.elm_old_value = value;
if (field.elm_hasFocus)
{
var selection = newModel.content.selection;
var direction = selection.direction.ctor === 'Forward' ? 'forward' : 'backward';
setRange(field, selection.start, selection.end, direction);
}
return field;
}
function mkField(type)
{
function field(style, handler, placeHolder, content)
{
var padding = style.padding;
var outline = style.outline.width;
var adjustWidth = padding.left + padding.right + outline.left + outline.right;
var adjustHeight = padding.top + padding.bottom + outline.top + outline.bottom;
return A3(Element.newElement, 200, 30, {
ctor: 'Custom',
type: type + 'Field',
adjustWidth: adjustWidth,
adjustHeight: adjustHeight,
render: renderField,
update: updateField,
model: {
handler:handler,
placeHolder:placeHolder,
content:content,
style:style,
type:type
}
});
}
return F4(field);
}
function hoverable(handler, elem)
{
function onHover(bool)
{
Signal.sendMessage(handler(bool));
}
var props = Utils.replace([['hover',onHover]], elem.props);
return {
props: props,
element: elem.element
};
}
function clickable(message, elem)
{
function onClick()
{
Signal.sendMessage(message);
}
var props = Utils.replace([['click',onClick]], elem.props);
return {
props: props,
element: elem.element
};
}
return Elm.Native.Graphics.Input.values = {
button: F2(button),
customButton: F4(customButton),
checkbox: F2(checkbox),
dropDown: F2(dropDown),
field: mkField('text'),
email: mkField('email'),
password: mkField('password'),
hoverable: F2(hoverable),
clickable: F2(clickable)
};
};
Elm.Native.Json = {};
Elm.Native.Json.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Json = localRuntime.Native.Json || {};
if (localRuntime.Native.Json.values) {
return localRuntime.Native.Json.values;
}
var ElmArray = Elm.Native.Array.make(localRuntime);
var List = Elm.Native.List.make(localRuntime);
var Maybe = Elm.Maybe.make(localRuntime);
var Result = Elm.Result.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
function crash(expected, actual) {
throw new Error(
'expecting ' + expected + ' but got ' + JSON.stringify(actual)
);
}
// PRIMITIVE VALUES
function decodeNull(successValue) {
return function(value) {
if (value === null) {
return successValue;
}
crash('null', value);
};
}
function decodeString(value) {
if (typeof value === 'string' || value instanceof String) {
return value;
}
crash('a String', value);
}
function decodeFloat(value) {
if (typeof value === 'number') {
return value;
}
crash('a Float', value);
}
function decodeInt(value) {
if (typeof value === 'number' && (value|0) === value) {
return value;
}
crash('an Int', value);
}
function decodeBool(value) {
if (typeof value === 'boolean') {
return value;
}
crash('a Bool', value);
}
// ARRAY
function decodeArray(decoder) {
return function(value) {
if (value instanceof Array) {
var len = value.length;
var array = new Array(len);
for (var i = len; i-- ; ) {
array[i] = decoder(value[i]);
}
return ElmArray.fromJSArray(array);
}
crash('an Array', value);
};
}
// LIST
function decodeList(decoder) {
return function(value) {
if (value instanceof Array) {
var len = value.length;
var list = List.Nil;
for (var i = len; i-- ; ) {
list = List.Cons( decoder(value[i]), list );
}
return list;
}
crash('a List', value);
};
}
// MAYBE
function decodeMaybe(decoder) {
return function(value) {
try {
return Maybe.Just(decoder(value));
} catch(e) {
return Maybe.Nothing;
}
};
}
// FIELDS
function decodeField(field, decoder) {
return function(value) {
var subValue = value[field];
if (subValue !== undefined) {
return decoder(subValue);
}
crash("an object with field '" + field + "'", value);
};
}
// OBJECTS
function decodeKeyValuePairs(decoder) {
return function(value) {
var isObject =
typeof value === 'object'
&& value !== null
&& !(value instanceof Array);
if (isObject) {
var keyValuePairs = List.Nil;
for (var key in value) {
var elmValue = decoder(value[key]);
var pair = Utils.Tuple2(key, elmValue);
keyValuePairs = List.Cons(pair, keyValuePairs);
}
return keyValuePairs;
}
crash("an object", value);
};
}
function decodeObject1(f, d1) {
return function(value) {
return f(d1(value));
};
}
function decodeObject2(f, d1, d2) {
return function(value) {
return A2( f, d1(value), d2(value) );
};
}
function decodeObject3(f, d1, d2, d3) {
return function(value) {
return A3( f, d1(value), d2(value), d3(value) );
};
}
function decodeObject4(f, d1, d2, d3, d4) {
return function(value) {
return A4( f, d1(value), d2(value), d3(value), d4(value) );
};
}
function decodeObject5(f, d1, d2, d3, d4, d5) {
return function(value) {
return A5( f, d1(value), d2(value), d3(value), d4(value), d5(value) );
};
}
function decodeObject6(f, d1, d2, d3, d4, d5, d6) {
return function(value) {
return A6( f,
d1(value),
d2(value),
d3(value),
d4(value),
d5(value),
d6(value)
);
};
}
function decodeObject7(f, d1, d2, d3, d4, d5, d6, d7) {
return function(value) {
return A7( f,
d1(value),
d2(value),
d3(value),
d4(value),
d5(value),
d6(value),
d7(value)
);
};
}
function decodeObject8(f, d1, d2, d3, d4, d5, d6, d7, d8) {
return function(value) {
return A8( f,
d1(value),
d2(value),
d3(value),
d4(value),
d5(value),
d6(value),
d7(value),
d8(value)
);
};
}
// TUPLES
function decodeTuple1(f, d1) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 1 ) {
crash('a Tuple of length 1', value);
}
return f( d1(value[0]) );
};
}
function decodeTuple2(f, d1, d2) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 2 ) {
crash('a Tuple of length 2', value);
}
return A2( f, d1(value[0]), d2(value[1]) );
};
}
function decodeTuple3(f, d1, d2, d3) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 3 ) {
crash('a Tuple of length 3', value);
}
return A3( f, d1(value[0]), d2(value[1]), d3(value[2]) );
};
}
function decodeTuple4(f, d1, d2, d3, d4) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 4 ) {
crash('a Tuple of length 4', value);
}
return A4( f, d1(value[0]), d2(value[1]), d3(value[2]), d4(value[3]) );
};
}
function decodeTuple5(f, d1, d2, d3, d4, d5) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 5 ) {
crash('a Tuple of length 5', value);
}
return A5( f,
d1(value[0]),
d2(value[1]),
d3(value[2]),
d4(value[3]),
d5(value[4])
);
};
}
function decodeTuple6(f, d1, d2, d3, d4, d5, d6) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 6 ) {
crash('a Tuple of length 6', value);
}
return A6( f,
d1(value[0]),
d2(value[1]),
d3(value[2]),
d4(value[3]),
d5(value[4]),
d6(value[5])
);
};
}
function decodeTuple7(f, d1, d2, d3, d4, d5, d6, d7) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 7 ) {
crash('a Tuple of length 7', value);
}
return A7( f,
d1(value[0]),
d2(value[1]),
d3(value[2]),
d4(value[3]),
d5(value[4]),
d6(value[5]),
d7(value[6])
);
};
}
function decodeTuple8(f, d1, d2, d3, d4, d5, d6, d7, d8) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 8 ) {
crash('a Tuple of length 8', value);
}
return A8( f,
d1(value[0]),
d2(value[1]),
d3(value[2]),
d4(value[3]),
d5(value[4]),
d6(value[5]),
d7(value[6]),
d8(value[7])
);
};
}
// CUSTOM DECODERS
function decodeValue(value) {
return value;
}
function runDecoderValue(decoder, value) {
try {
return Result.Ok(decoder(value));
} catch(e) {
return Result.Err(e.message);
}
}
function customDecoder(decoder, callback) {
return function(value) {
var result = callback(decoder(value));
if (result.ctor === 'Err') {
throw new Error('custom decoder failed: ' + result._0);
}
return result._0;
}
}
function andThen(decode, callback) {
return function(value) {
var result = decode(value);
return callback(result)(value);
}
}
function fail(msg) {
return function(value) {
throw new Error(msg);
}
}
function succeed(successValue) {
return function(value) {
return successValue;
}
}
// ONE OF MANY
function oneOf(decoders) {
return function(value) {
var errors = [];
var temp = decoders;
while (temp.ctor !== '[]') {
try {
return temp._0(value);
} catch(e) {
errors.push(e.message);
}
temp = temp._1;
}
throw new Error('expecting one of the following:\n ' + errors.join('\n '));
}
}
function get(decoder, value) {
try {
return Result.Ok(decoder(value));
} catch(e) {
return Result.Err(e.message);
}
}
// ENCODE / DECODE
function runDecoderString(decoder, string) {
try {
return Result.Ok(decoder(JSON.parse(string)));
} catch(e) {
return Result.Err(e.message);
}
}
function encode(indentLevel, value) {
return JSON.stringify(value, null, indentLevel);
}
function identity(value) {
return value;
}
function encodeObject(keyValuePairs) {
var obj = {};
while (keyValuePairs.ctor !== '[]') {
var pair = keyValuePairs._0;
obj[pair._0] = pair._1;
keyValuePairs = keyValuePairs._1;
}
return obj;
}
return localRuntime.Native.Json.values = {
encode: F2(encode),
runDecoderString: F2(runDecoderString),
runDecoderValue: F2(runDecoderValue),
get: F2(get),
oneOf: oneOf,
decodeNull: decodeNull,
decodeInt: decodeInt,
decodeFloat: decodeFloat,
decodeString: decodeString,
decodeBool: decodeBool,
decodeMaybe: decodeMaybe,
decodeList: decodeList,
decodeArray: decodeArray,
decodeField: F2(decodeField),
decodeObject1: F2(decodeObject1),
decodeObject2: F3(decodeObject2),
decodeObject3: F4(decodeObject3),
decodeObject4: F5(decodeObject4),
decodeObject5: F6(decodeObject5),
decodeObject6: F7(decodeObject6),
decodeObject7: F8(decodeObject7),
decodeObject8: F9(decodeObject8),
decodeKeyValuePairs: decodeKeyValuePairs,
decodeTuple1: F2(decodeTuple1),
decodeTuple2: F3(decodeTuple2),
decodeTuple3: F4(decodeTuple3),
decodeTuple4: F5(decodeTuple4),
decodeTuple5: F6(decodeTuple5),
decodeTuple6: F7(decodeTuple6),
decodeTuple7: F8(decodeTuple7),
decodeTuple8: F9(decodeTuple8),
andThen: F2(andThen),
decodeValue: decodeValue,
customDecoder: F2(customDecoder),
fail: fail,
succeed: succeed,
identity: identity,
encodeNull: null,
encodeArray: ElmArray.toJSArray,
encodeList: List.toArray,
encodeObject: encodeObject
};
};
Elm.Native.List = {};
Elm.Native.List.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.List = localRuntime.Native.List || {};
if (localRuntime.Native.List.values)
{
return localRuntime.Native.List.values;
}
if ('values' in Elm.Native.List)
{
return localRuntime.Native.List.values = Elm.Native.List.values;
}
var Utils = Elm.Native.Utils.make(localRuntime);
var Nil = Utils.Nil;
var Cons = Utils.Cons;
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
}
// 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 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 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 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,
foldl:F3(foldl),
foldr:F3(foldr),
any:F2(any),
map2:F3(map2),
map3:F4(map3),
map4:F5(map4),
map5:F6(map5),
sortBy:F2(sortBy),
sortWith:F2(sortWith),
take:F2(take),
drop:F2(drop),
repeat:F2(repeat)
};
return localRuntime.Native.List.values = Elm.Native.List.values;
};
// setup
Elm.Native = Elm.Native || {};
Elm.Native.Markdown = Elm.Native.Markdown || {};
// definition
Elm.Native.Markdown.make = function(localRuntime) {
'use strict';
// attempt to short-circuit
if ('values' in Elm.Native.Markdown)
{
return Elm.Native.Markdown.values;
}
var Element = Elm.Native.Graphics.Element.make(localRuntime);
/**
* marked - a markdown parser
* Copyright (c) 2011-2014, Christopher Jeffrey. (MIT Licensed)
* https://github.com/chjj/marked
*/
(function(){var block={newline:/^\n+/,code:/^( {4}[^\n]+\n*)+/,fences:noop,hr:/^( *[-*_]){3,} *(?:\n+|$)/,heading:/^ *(#{1,6}) *([^\n]+?) *#* *(?:\n+|$)/,nptable:noop,lheading:/^([^\n]+)\n *(=|-){2,} *(?:\n+|$)/,blockquote:/^( *>[^\n]+(\n(?!def)[^\n]+)*\n*)+/,list:/^( *)(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?!\1bull )\n*|\s*$)/,html:/^ *(?:comment|closed|closing) *(?:\n{2,}|\s*$)/,def:/^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +["(]([^\n]+)[")])? *(?:\n+|$)/,table:noop,paragraph:/^((?:[^\n]+\n?(?!hr|heading|lheading|blockquote|tag|def))+)\n*/,text:/^[^\n]+/};block.bullet=/(?:[*+-]|\d+\.)/;block.item=/^( *)(bull) [^\n]*(?:\n(?!\1bull )[^\n]*)*/;block.item=replace(block.item,"gm")(/bull/g,block.bullet)();block.list=replace(block.list)(/bull/g,block.bullet)("hr","\\n+(?=\\1?(?:[-*_] *){3,}(?:\\n+|$))")("def","\\n+(?="+block.def.source+")")();block.blockquote=replace(block.blockquote)("def",block.def)();block._tag="(?!(?:"+"a|em|strong|small|s|cite|q|dfn|abbr|data|time|code"+"|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo"+"|span|br|wbr|ins|del|img)\\b)\\w+(?!:/|[^\\w\\s@]*@)\\b";block.html=replace(block.html)("comment",/<!--[\s\S]*?-->/)("closed",/<(tag)[\s\S]+?<\/\1>/)("closing",/<tag(?:"[^"]*"|'[^']*'|[^'">])*?>/)(/tag/g,block._tag)();block.paragraph=replace(block.paragraph)("hr",block.hr)("heading",block.heading)("lheading",block.lheading)("blockquote",block.blockquote)("tag","<"+block._tag)("def",block.def)();block.normal=merge({},block);block.gfm=merge({},block.normal,{fences:/^ *(`{3,}|~{3,}) *(\S+)? *\n([\s\S]+?)\s*\1 *(?:\n+|$)/,paragraph:/^/});block.gfm.paragraph=replace(block.paragraph)("(?!","(?!"+block.gfm.fences.source.replace("\\1","\\2")+"|"+block.list.source.replace("\\1","\\3")+"|")();block.tables=merge({},block.gfm,{nptable:/^ *(\S.*\|.*)\n *([-:]+ *\|[-| :]*)\n((?:.*\|.*(?:\n|$))*)\n*/,table:/^ *\|(.+)\n *\|( *[-:]+[-| :]*)\n((?: *\|.*(?:\n|$))*)\n*/});function Lexer(options){this.tokens=[];this.tokens.links={};this.options=options||marked.defaults;this.rules=block.normal;if(this.options.gfm){if(this.options.tables){this.rules=block.tables}else{this.rules=block.gfm}}}Lexer.rules=block;Lexer.lex=function(src,options){var lexer=new Lexer(options);return lexer.lex(src)};Lexer.prototype.lex=function(src){src=src.replace(/\r\n|\r/g,"\n").replace(/\t/g," ").replace(/\u00a0/g," ").replace(/\u2424/g,"\n");return this.token(src,true)};Lexer.prototype.token=function(src,top,bq){var src=src.replace(/^ +$/gm,""),next,loose,cap,bull,b,item,space,i,l;while(src){if(cap=this.rules.newline.exec(src)){src=src.substring(cap[0].length);if(cap[0].length>1){this.tokens.push({type:"space"})}}if(cap=this.rules.code.exec(src)){src=src.substring(cap[0].length);cap=cap[0].replace(/^ {4}/gm,"");this.tokens.push({type:"code",text:!this.options.pedantic?cap.replace(/\n+$/,""):cap});continue}if(cap=this.rules.fences.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"code",lang:cap[2],text:cap[3]});continue}if(cap=this.rules.heading.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"heading",depth:cap[1].length,text:cap[2]});continue}if(top&&(cap=this.rules.nptable.exec(src))){src=src.substring(cap[0].length);item={type:"table",header:cap[1].replace(/^ *| *\| *$/g,"").split(/ *\| */),align:cap[2].replace(/^ *|\| *$/g,"").split(/ *\| */),cells:cap[3].replace(/\n$/,"").split("\n")};for(i=0;i<item.align.length;i++){if(/^ *-+: *$/.test(item.align[i])){item.align[i]="right"}else if(/^ *:-+: *$/.test(item.align[i])){item.align[i]="center"}else if(/^ *:-+ *$/.test(item.align[i])){item.align[i]="left"}else{item.align[i]=null}}for(i=0;i<item.cells.length;i++){item.cells[i]=item.cells[i].split(/ *\| */)}this.tokens.push(item);continue}if(cap=this.rules.lheading.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"heading",depth:cap[2]==="="?1:2,text:cap[1]});continue}if(cap=this.rules.hr.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"hr"});continue}if(cap=this.rules.blockquote.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"blockquote_start"});cap=cap[0
marked.setOptions({
highlight: function (code, lang) {
if (typeof hljs !== 'undefined'
&& lang
&& hljs.listLanguages().indexOf(lang) >= 0)
{
return hljs.highlight(lang, code, true).value;
}
return code;
}
});
function formatOptions(options) {
var gfm = options.githubFlavored;
if (gfm.ctor === 'Just')
{
return {
gfm: true,
tables: gfm.tables,
breaks: gfm.breaks,
sanitize: options.sanitize,
smartypants: options.smartypants
};
}
else
{
return {
gfm: false,
tables: false,
breaks: false,
sanitize: options.sanitize,
smartypants: options.smartypants
};
}
}
function toHtmlWith(options, rawMarkdown) {
var widget = {
type: "Widget",
init: function () {
var html = marked(rawMarkdown, formatOptions(options));
var div = document.createElement('div');
div.innerHTML = html;
return div;
},
update: function (previous, node) {
var html = marked(rawMarkdown, formatOptions(options));
node.innerHTML = html;
return node;
}
};
return widget;
}
function toElementWith(options, rawMarkdown) {
return Element.markdown(marked(rawMarkdown, formatOptions(options)));
}
return Elm.Native.Markdown.values = {
toHtmlWith: F2(toHtmlWith),
toElementWith: F2(toElementWith)
};
};
Elm.Native.Port = {};
Elm.Native.Port.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Port = localRuntime.Native.Port || {};
if (localRuntime.Native.Port.values)
{
return localRuntime.Native.Port.values;
}
var NS;
var Utils = Elm.Native.Utils.make(localRuntime);
// INBOUND
function inbound(name, type, converter)
{
if (!localRuntime.argsTracker[name])
{
throw new Error(
"Port Error:\n" +
"No argument was given for the port named '" + name + "' with type:\n\n" +
" " + type.split('\n').join('\n ') + "\n\n" +
"You need to provide an initial value!\n\n" +
"Find out more about ports here <http://elm-lang.org/learn/Ports.elm>"
);
}
var arg = localRuntime.argsTracker[name];
arg.used = true;
return jsToElm(name, type, converter, arg.value);
}
function inboundSignal(name, type, converter)
{
var initialValue = inbound(name, type, converter);
if (!NS)
{
NS = Elm.Native.Signal.make(localRuntime);
}
var signal = NS.input('inbound-port-' + name, initialValue);
function send(jsValue)
{
var elmValue = jsToElm(name, type, converter, jsValue);
setTimeout(function() {
localRuntime.notify(signal.id, elmValue);
}, 0);
}
localRuntime.ports[name] = { send: send };
return signal;
}
function jsToElm(name, type, converter, value)
{
try
{
return converter(value);
}
catch(e)
{
throw new Error(
"Port Error:\n" +
"Regarding the port named '" + name + "' with type:\n\n" +
" " + type.split('\n').join('\n ') + "\n\n" +
"You just sent the value:\n\n" +
" " + JSON.stringify(arg.value) + "\n\n" +
"but it cannot be converted to the necessary type.\n" +
e.message
);
}
}
// OUTBOUND
function outbound(name, converter, elmValue)
{
localRuntime.ports[name] = converter(elmValue);
}
function outboundSignal(name, converter, signal)
{
var subscribers = [];
function subscribe(handler)
{
subscribers.push(handler);
}
function unsubscribe(handler)
{
subscribers.pop(subscribers.indexOf(handler));
}
function notify(elmValue)
{
var jsValue = converter(elmValue);
var len = subscribers.length;
for (var i = 0; i < len; ++i)
{
subscribers[i](jsValue);
}
}
if (!NS)
{
NS = Elm.Native.Signal.make(localRuntime);
}
NS.output('outbound-port-' + name, notify, signal);
localRuntime.ports[name] = {
subscribe: subscribe,
unsubscribe: unsubscribe
};
return signal;
}
return localRuntime.Native.Port.values = {
inbound: inbound,
outbound: outbound,
inboundSignal: inboundSignal,
outboundSignal: outboundSignal
};
};
if (!Elm.fullscreen) {
(function() {
'use strict';
var Display = {
FULLSCREEN: 0,
COMPONENT: 1,
NONE: 2
};
Elm.fullscreen = function(module, args)
{
var container = document.createElement('div');
document.body.appendChild(container);
return init(Display.FULLSCREEN, container, module, args || {});
};
Elm.embed = function(module, container, args)
{
var tag = container.tagName;
if (tag !== 'DIV')
{
throw new Error('Elm.node must be given a DIV, not a ' + tag + '.');
}
return init(Display.COMPONENT, container, module, args || {});
};
Elm.worker = function(module, args)
{
return init(Display.NONE, {}, module, args || {});
};
function init(display, container, module, args, moduleToReplace)
{
// defining state needed for an instance of the Elm RTS
var inputs = [];
/* OFFSET
* Elm's time traveling debugger lets you pause time. This means
* "now" may be shifted a bit into the past. By wrapping Date.now()
* we can manage this.
*/
var timer = {
programStart: Date.now(),
now: function()
{
return Date.now();
}
};
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].notify(timestep, id, v);
}
updateInProgress = false;
}
function setTimeout(func, delay)
{
return 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 argsTracker = {};
for (var name in args)
{
argsTracker[name] = {
value: args[name],
used: false
};
}
// 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,
argsTracker: argsTracker,
ports: {},
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, args, elm);
inputs = [];
// elm.swap = newElm.swap;
return newElm;
}
function dispose()
{
removeListeners(listeners);
inputs = [];
}
var Module = {};
try
{
Module = module.make(elm);
checkInputs(elm);
}
catch (error)
{
if (typeof container.appendChild == 'undefined')
{
console.log(error.message);
}
else
{
container.appendChild(errorNode(error.message));
}
throw error;
}
if (display !== Display.NONE)
{
var graphicsNode = initGraphics(elm, Module);
}
var rootNode = { kids: inputs };
trimDeadNodes(rootNode);
inputs = rootNode.kids;
filterListeners(inputs, listeners);
addReceivers(elm.ports);
if (typeof moduleToReplace !== 'undefined')
{
hotSwap(moduleToReplace, elm);
// rerender scene if graphics are enabled.
if (typeof graphicsNode !== 'undefined')
{
graphicsNode.notify(0, true, 0);
}
}
return {
swap: swap,
ports: elm.ports,
dispose: dispose
};
};
function checkInputs(elm)
{
var argsTracker = elm.argsTracker;
for (var name in argsTracker)
{
if (!argsTracker[name].used)
{
throw new Error(
"Port Error:\nYou provided an argument named '" + name +
"' but there is no corresponding port!\n\n" +
"Maybe add a port '" + name + "' to your Elm module?\n" +
"Maybe remove the '" + name + "' argument from your initialization code in JS?"
);
}
}
}
function errorNode(message)
{
var code = document.createElement('code');
var lines = 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].replace(/ /g, '\u00A0 ')));
code.appendChild(document.createElement('br'));
}
code.appendChild(document.createElement('br'));
code.appendChild(document.createTextNode("Open the developer console for more details."));
return code;
}
//// 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 ('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;
}
});
}
}
// returns a boolean representing whether the node is alive or not.
function trimDeadNodes(node)
{
if (node.isOutput)
{
return true;
}
var liveKids = [];
for (var i = node.kids.length; i--; )
{
var kid = node.kids[i];
if (trimDeadNodes(kid))
{
liveKids.push(kid);
}
}
node.kids = liveKids;
return liveKids.length > 0;
}
//// 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
if (!('notify' in signalGraph))
{
signalGraph = Elm.Signal.make(elm).constant(signalGraph);
}
var initialScene = signalGraph.value;
// Figure out what the render functions should be
var render;
var update;
if (initialScene.props)
{
var Element = Elm.Native.Graphics.Element.make(elm);
render = Element.render;
update = Element.updateAndReplace;
}
else
{
var VirtualDom = Elm.Native.VirtualDom.make(elm);
render = VirtualDom.render;
update = VirtualDom.updateAndReplace;
}
// Add the initialScene to the DOM
var container = elm.node;
var node = render(initialScene);
while (container.firstChild)
{
container.removeChild(container.firstChild);
}
container.appendChild(node);
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()
{
update(elm.node.firstChild, savedScene, scheduledScene);
if (elm.Native.Window)
{
elm.Native.Window.values.resizeIfNeeded();
}
savedScene = scheduledScene;
}
var renderer = Elm.Native.Signal.make(elm).output('main', 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)
{
if (nodeOld.id !== nodeNew.id)
{
return false;
}
if (nodeOld.isOutput)
{
return nodeNew.isOutput;
}
return nodeOld.kids.length === nodeNew.kids.length;
}
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);
}
}
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
* @license MIT
*/
var base64 = require('base64-js')
var ieee754 = require('ieee754')
var isArray = require('is-array')
exports.Buffer = Buffer
exports.SlowBuffer = SlowBuffer
exports.INSPECT_MAX_BYTES = 50
Buffer.poolSize = 8192 // not used by this implementation
var kMaxLength = 0x3fffffff
var rootParent = {}
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Use Object implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
* Opera 11.6+, iOS 4.2+.
*
* Note:
*
* - Implementation must support adding new properties to `Uint8Array` instances.
* Firefox 4-29 lacked support, fixed in Firefox 30+.
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
*
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
*
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
* incorrect length in some situations.
*
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they will
* get the Object implementation, which is slower but will work correctly.
*/
Buffer.TYPED_ARRAY_SUPPORT = (function () {
try {
var buf = new ArrayBuffer(0)
var arr = new Uint8Array(buf)
arr.foo = function () { return 42 }
return arr.foo() === 42 && // typed array instances can be augmented
typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
} catch (e) {
return false
}
})()
/**
* Class: Buffer
* =============
*
* The Buffer constructor returns instances of `Uint8Array` that are augmented
* with function properties for all the node `Buffer` API functions. We use
* `Uint8Array` so that square bracket notation works as expected -- it returns
* a single octet.
*
* By augmenting the instances, we can avoid modifying the `Uint8Array`
* prototype.
*/
function Buffer (arg) {
if (!(this instanceof Buffer)) {
// Avoid going through an ArgumentsAdaptorTrampoline in the common case.
if (arguments.length > 1) return new Buffer(arg, arguments[1])
return new Buffer(arg)
}
this.length = 0
this.parent = undefined
// Common case.
if (typeof arg === 'number') {
return fromNumber(this, arg)
}
// Slightly less common case.
if (typeof arg === 'string') {
return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')
}
// Unusual.
return fromObject(this, arg)
}
function fromNumber (that, length) {
that = allocate(that, length < 0 ? 0 : checked(length) | 0)
if (!Buffer.TYPED_ARRAY_SUPPORT) {
for (var i = 0; i < length; i++) {
that[i] = 0
}
}
return that
}
function fromString (that, string, encoding) {
if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'
// Assumption: byteLength() return value is always < kMaxLength.
var length = byteLength(string, encoding) | 0
that = allocate(that, length)
that.write(string, encoding)
return that
}
function fromObject (that, object) {
if (Buffer.isBuffer(object)) return fromBuffer(that, object)
if (isArray(object)) return fromArray(that, object)
if (object == null) {
throw new TypeError('must start with number, buffer, array or string')
}
if (typeof ArrayBuffer !== 'undefined' && object.buffer instanceof ArrayBuffer) {
return fromTypedArray(that, object)
}
if (object.length) return fromArrayLike(that, object)
return fromJsonObject(that, object)
}
function fromBuffer (that, buffer) {
var length = checked(buffer.length) | 0
that = allocate(that, length)
buffer.copy(that, 0, 0, length)
return that
}
function fromArray (that, array) {
var length = checked(array.length) | 0
that = allocate(that, length)
for (var i = 0; i < length; i += 1) {
that[i] = array[i] & 255
}
return that
}
// Duplicate of fromArray() to keep fromArray() monomorphic.
function fromTypedArray (that, array) {
var length = checked(array.length) | 0
that = allocate(that, length)
// Truncating the elements is probably not what people expect from typed
// arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior
// of the old Buffer constructor.
for (var i = 0; i < length; i += 1) {
that[i] = array[i] & 255
}
return that
}
function fromArrayLike (that, array) {
var length = checked(array.length) | 0
that = allocate(that, length)
for (var i = 0; i < length; i += 1) {
that[i] = array[i] & 255
}
return that
}
// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.
// Returns a zero-length buffer for inputs that don't conform to the spec.
function fromJsonObject (that, object) {
var array
var length = 0
if (object.type === 'Buffer' && isArray(object.data)) {
array = object.data
length = checked(array.length) | 0
}
that = allocate(that, length)
for (var i = 0; i < length; i += 1) {
that[i] = array[i] & 255
}
return that
}
function allocate (that, length) {
if (Buffer.TYPED_ARRAY_SUPPORT) {
// Return an augmented `Uint8Array` instance, for best performance
that = Buffer._augment(new Uint8Array(length))
} else {
// Fallback: Return an object instance of the Buffer class
that.length = length
that._isBuffer = true
}
var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1
if (fromPool) that.parent = rootParent
return that
}
function checked (length) {
// Note: cannot use `length < kMaxLength` here because that fails when
// length is NaN (which is otherwise coerced to zero.)
if (length >= kMaxLength) {
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
'size: 0x' + kMaxLength.toString(16) + ' bytes')
}
return length | 0
}
function SlowBuffer (subject, encoding) {
if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)
var buf = new Buffer(subject, encoding)
delete buf.parent
return buf
}
Buffer.isBuffer = function isBuffer (b) {
return !!(b != null && b._isBuffer)
}
Buffer.compare = function compare (a, b) {
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
throw new TypeError('Arguments must be Buffers')
}
if (a === b) return 0
var x = a.length
var y = b.length
var i = 0
var len = Math.min(x, y)
while (i < len) {
if (a[i] !== b[i]) break
++i
}
if (i !== len) {
x = a[i]
y = b[i]
}
if (x < y) return -1
if (y < x) return 1
return 0
}
Buffer.isEncoding = function isEncoding (encoding) {
switch (String(encoding).toLowerCase()) {
case 'hex':
case 'utf8':
case 'utf-8':
case 'ascii':
case 'binary':
case 'base64':
case 'raw':
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return true
default:
return false
}
}
Buffer.concat = function concat (list, length) {
if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')
if (list.length === 0) {
return new Buffer(0)
} else if (list.length === 1) {
return list[0]
}
var i
if (length === undefined) {
length = 0
for (i = 0; i < list.length; i++) {
length += list[i].length
}
}
var buf = new Buffer(length)
var pos = 0
for (i = 0; i < list.length; i++) {
var item = list[i]
item.copy(buf, pos)
pos += item.length
}
return buf
}
function byteLength (string, encoding) {
if (typeof string !== 'string') string = String(string)
if (string.length === 0) return 0
switch (encoding || 'utf8') {
case 'ascii':
case 'binary':
case 'raw':
return string.length
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return string.length * 2
case 'hex':
return string.length >>> 1
case 'utf8':
case 'utf-8':
return utf8ToBytes(string).length
case 'base64':
return base64ToBytes(string).length
default:
return string.length
}
}
Buffer.byteLength = byteLength
// pre-set for values that may exist in the future
Buffer.prototype.length = undefined
Buffer.prototype.parent = undefined
// toString(encoding, start=0, end=buffer.length)
Buffer.prototype.toString = function toString (encoding, start, end) {
var loweredCase = false
start = start | 0
end = end === undefined || end === Infinity ? this.length : end | 0
if (!encoding) encoding = 'utf8'
if (start < 0) start = 0
if (end > this.length) end = this.length
if (end <= start) return ''
while (true) {
switch (encoding) {
case 'hex':
return hexSlice(this, start, end)
case 'utf8':
case 'utf-8':
return utf8Slice(this, start, end)
case 'ascii':
return asciiSlice(this, start, end)
case 'binary':
return binarySlice(this, start, end)
case 'base64':
return base64Slice(this, start, end)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return utf16leSlice(this, start, end)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = (encoding + '').toLowerCase()
loweredCase = true
}
}
}
Buffer.prototype.equals = function equals (b) {
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
if (this === b) return true
return Buffer.compare(this, b) === 0
}
Buffer.prototype.inspect = function inspect () {
var str = ''
var max = exports.INSPECT_MAX_BYTES
if (this.length > 0) {
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
if (this.length > max) str += ' ... '
}
return '<Buffer ' + str + '>'
}
Buffer.prototype.compare = function compare (b) {
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
if (this === b) return 0
return Buffer.compare(this, b)
}
Buffer.prototype.indexOf = function indexOf (val, byteOffset) {
if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff
else if (byteOffset < -0x80000000) byteOffset = -0x80000000
byteOffset >>= 0
if (this.length === 0) return -1
if (byteOffset >= this.length) return -1
// Negative offsets start from the end of the buffer
if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)
if (typeof val === 'string') {
if (val.length === 0) return -1 // special case: looking for empty string always fails
return String.prototype.indexOf.call(this, val, byteOffset)
}
if (Buffer.isBuffer(val)) {
return arrayIndexOf(this, val, byteOffset)
}
if (typeof val === 'number') {
if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {
return Uint8Array.prototype.indexOf.call(this, val, byteOffset)
}
return arrayIndexOf(this, [ val ], byteOffset)
}
function arrayIndexOf (arr, val, byteOffset) {
var foundIndex = -1
for (var i = 0; byteOffset + i < arr.length; i++) {
if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {
if (foundIndex === -1) foundIndex = i
if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex
} else {
foundIndex = -1
}
}
return -1
}
throw new TypeError('val must be string, number or Buffer')
}
// `get` will be removed in Node 0.13+
Buffer.prototype.get = function get (offset) {
console.log('.get() is deprecated. Access using array indexes instead.')
return this.readUInt8(offset)
}
// `set` will be removed in Node 0.13+
Buffer.prototype.set = function set (v, offset) {
console.log('.set() is deprecated. Access using array indexes instead.')
return this.writeUInt8(v, offset)
}
function hexWrite (buf, string, offset, length) {
offset = Number(offset) || 0
var remaining = buf.length - offset
if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}
// must be an even number of digits
var strLen = string.length
if (strLen % 2 !== 0) throw new Error('Invalid hex string')
if (length > strLen / 2) {
length = strLen / 2
}
for (var i = 0; i < length; i++) {
var parsed = parseInt(string.substr(i * 2, 2), 16)
if (isNaN(parsed)) throw new Error('Invalid hex string')
buf[offset + i] = parsed
}
return i
}
function utf8Write (buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}
function asciiWrite (buf, string, offset, length) {
return blitBuffer(asciiToBytes(string), buf, offset, length)
}
function binaryWrite (buf, string, offset, length) {
return asciiWrite(buf, string, offset, length)
}
function base64Write (buf, string, offset, length) {
return blitBuffer(base64ToBytes(string), buf, offset, length)
}
function ucs2Write (buf, string, offset, length) {
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
}
Buffer.prototype.write = function write (string, offset, length, encoding) {
// Buffer#write(string)
if (offset === undefined) {
encoding = 'utf8'
length = this.length
offset = 0
// Buffer#write(string, encoding)
} else if (length === undefined && typeof offset === 'string') {
encoding = offset
length = this.length
offset = 0
// Buffer#write(string, offset[, length][, encoding])
} else if (isFinite(offset)) {
offset = offset | 0
if (isFinite(length)) {
length = length | 0
if (encoding === undefined) encoding = 'utf8'
} else {
encoding = length
length = undefined
}
// legacy write(string, encoding, offset, length) - remove in v0.13
} else {
var swap = encoding
encoding = offset
offset = length | 0
length = swap
}
var remaining = this.length - offset
if (length === undefined || length > remaining) length = remaining
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
throw new RangeError('attempt to write outside buffer bounds')
}
if (!encoding) encoding = 'utf8'
var loweredCase = false
for (;;) {
switch (encoding) {
case 'hex':
return hexWrite(this, string, offset, length)
case 'utf8':
case 'utf-8':
return utf8Write(this, string, offset, length)
case 'ascii':
return asciiWrite(this, string, offset, length)
case 'binary':
return binaryWrite(this, string, offset, length)
case 'base64':
// Warning: maxLength not taken into account in base64Write
return base64Write(this, string, offset, length)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return ucs2Write(this, string, offset, length)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = ('' + encoding).toLowerCase()
loweredCase = true
}
}
}
Buffer.prototype.toJSON = function toJSON () {
return {
type: 'Buffer',
data: Array.prototype.slice.call(this._arr || this, 0)
}
}
function base64Slice (buf, start, end) {
if (start === 0 && end === buf.length) {
return base64.fromByteArray(buf)
} else {
return base64.fromByteArray(buf.slice(start, end))
}
}
function utf8Slice (buf, start, end) {
var res = ''
var tmp = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; i++) {
if (buf[i] <= 0x7F) {
res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
tmp = ''
} else {
tmp += '%' + buf[i].toString(16)
}
}
return res + decodeUtf8Char(tmp)
}
function asciiSlice (buf, start, end) {
var ret = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; i++) {
ret += String.fromCharCode(buf[i] & 0x7F)
}
return ret
}
function binarySlice (buf, start, end) {
var ret = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; i++) {
ret += String.fromCharCode(buf[i])
}
return ret
}
function hexSlice (buf, start, end) {
var len = buf.length
if (!start || start < 0) start = 0
if (!end || end < 0 || end > len) end = len
var out = ''
for (var i = start; i < end; i++) {
out += toHex(buf[i])
}
return out
}
function utf16leSlice (buf, start, end) {
var bytes = buf.slice(start, end)
var res = ''
for (var i = 0; i < bytes.length; i += 2) {
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
}
return res
}
Buffer.prototype.slice = function slice (start, end) {
var len = this.length
start = ~~start
end = end === undefined ? len : ~~end
if (start < 0) {
start += len
if (start < 0) start = 0
} else if (start > len) {
start = len
}
if (end < 0) {
end += len
if (end < 0) end = 0
} else if (end > len) {
end = len
}
if (end < start) end = start
var newBuf
if (Buffer.TYPED_ARRAY_SUPPORT) {
newBuf = Buffer._augment(this.subarray(start, end))
} else {
var sliceLen = end - start
newBuf = new Buffer(sliceLen, undefined)
for (var i = 0; i < sliceLen; i++) {
newBuf[i] = this[i + start]
}
}
if (newBuf.length) newBuf.parent = this.parent || this
return newBuf
}
/*
* Need to make sure that buffer isn't trying to write out of bounds.
*/
function checkOffset (offset, ext, length) {
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
}
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var val = this[offset]
var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul
}
return val
}
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) {
checkOffset(offset, byteLength, this.length)
}
var val = this[offset + --byteLength]
var mul = 1
while (byteLength > 0 && (mul *= 0x100)) {
val += this[offset + --byteLength] * mul
}
return val
}
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
if (!noAssert) checkOffset(offset, 1, this.length)
return this[offset]
}
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length)
return this[offset] | (this[offset + 1] << 8)
}
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length)
return (this[offset] << 8) | this[offset + 1]
}
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return ((this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16)) +
(this[offset + 3] * 0x1000000)
}
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset] * 0x1000000) +
((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3])
}
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var val = this[offset]
var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul
}
mul *= 0x80
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
return val
}
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var i = byteLength
var mul = 1
var val = this[offset + --i]
while (i > 0 && (mul *= 0x100)) {
val += this[offset + --i] * mul
}
mul *= 0x80
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
return val
}
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
if (!noAssert) checkOffset(offset, 1, this.length)
if (!(this[offset] & 0x80)) return (this[offset])
return ((0xff - this[offset] + 1) * -1)
}
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length)
var val = this[offset] | (this[offset + 1] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length)
var val = this[offset + 1] | (this[offset] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16) |
(this[offset + 3] << 24)
}
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset] << 24) |
(this[offset + 1] << 16) |
(this[offset + 2] << 8) |
(this[offset + 3])
}
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, true, 23, 4)
}
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, false, 23, 4)
}
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, true, 52, 8)
}
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, false, 52, 8)
}
function checkInt (buf, value, offset, ext, max, min) {
if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
if (value > max || value < min) throw new RangeError('value is out of bounds')
if (offset + ext > buf.length) throw new RangeError('index out of range')
}
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
value = +value
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
var mul = 1
var i = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
value = +value
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
var i = byteLength - 1
var mul = 1
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
this[offset] = value
return offset + 1
}
function objectWriteUInt16 (buf, value, offset, littleEndian) {
if (value < 0) value = 0xffff + value + 1
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
(littleEndian ? i : 1 - i) * 8
}
}
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
} else {
objectWriteUInt16(this, value, offset, true)
}
return offset + 2
}
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = value
} else {
objectWriteUInt16(this, value, offset, false)
}
return offset + 2
}
function objectWriteUInt32 (buf, value, offset, littleEndian) {
if (value < 0) value = 0xffffffff + value + 1
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
}
}
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset + 3] = (value >>> 24)
this[offset + 2] = (value >>> 16)
this[offset + 1] = (value >>> 8)
this[offset] = value
} else {
objectWriteUInt32(this, value, offset, true)
}
return offset + 4
}
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = value
} else {
objectWriteUInt32(this, value, offset, false)
}
return offset + 4
}
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) {
var limit = Math.pow(2, 8 * byteLength - 1)
checkInt(this, value, offset, byteLength, limit - 1, -limit)
}
var i = 0
var mul = 1
var sub = value < 0 ? 1 : 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100)) {
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) {
var limit = Math.pow(2, 8 * byteLength - 1)
checkInt(this, value, offset, byteLength, limit - 1, -limit)
}
var i = byteLength - 1
var mul = 1
var sub = value < 0 ? 1 : 0
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100)) {
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
if (value < 0) value = 0xff + value + 1
this[offset] = value
return offset + 1
}
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
} else {
objectWriteUInt16(this, value, offset, true)
}
return offset + 2
}
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = value
} else {
objectWriteUInt16(this, value, offset, false)
}
return offset + 2
}
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
this[offset + 2] = (value >>> 16)
this[offset + 3] = (value >>> 24)
} else {
objectWriteUInt32(this, value, offset, true)
}
return offset + 4
}
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (value < 0) value = 0xffffffff + value + 1
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = value
} else {
objectWriteUInt32(this, value, offset, false)
}
return offset + 4
}
function checkIEEE754 (buf, value, offset, ext, max, min) {
if (value > max || value < min) throw new RangeError('value is out of bounds')
if (offset + ext > buf.length) throw new RangeError('index out of range')
if (offset < 0) throw new RangeError('index out of range')
}
function writeFloat (buf, value, offset, littleEndian, noAssert) {
if (!noAssert) {
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
}
ieee754.write(buf, value, offset, littleEndian, 23, 4)
return offset + 4
}
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert)
}
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
return writeFloat(this, value, offset, false, noAssert)
}
function writeDouble (buf, value, offset, littleEndian, noAssert) {
if (!noAssert) {
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
}
ieee754.write(buf, value, offset, littleEndian, 52, 8)
return offset + 8
}
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert)
}
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert)
}
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
if (!start) start = 0
if (!end && end !== 0) end = this.length
if (targetStart >= target.length) targetStart = target.length
if (!targetStart) targetStart = 0
if (end > 0 && end < start) end = start
// Copy 0 bytes; we're done
if (end === start) return 0
if (target.length === 0 || this.length === 0) return 0
// Fatal error conditions
if (targetStart < 0) {
throw new RangeError('targetStart out of bounds')
}
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
if (end < 0) throw new RangeError('sourceEnd out of bounds')
// Are we oob?
if (end > this.length) end = this.length
if (target.length - targetStart < end - start) {
end = target.length - targetStart + start
}
var len = end - start
if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
for (var i = 0; i < len; i++) {
target[i + targetStart] = this[i + start]
}
} else {
target._set(this.subarray(start, start + len), targetStart)
}
return len
}
// fill(value, start=0, end=buffer.length)
Buffer.prototype.fill = function fill (value, start, end) {
if (!value) value = 0
if (!start) start = 0
if (!end) end = this.length
if (end < start) throw new RangeError('end < start')
// Fill 0 bytes; we're done
if (end === start) return
if (this.length === 0) return
if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')
if (end < 0 || end > this.length) throw new RangeError('end out of bounds')
var i
if (typeof value === 'number') {
for (i = start; i < end; i++) {
this[i] = value
}
} else {
var bytes = utf8ToBytes(value.toString())
var len = bytes.length
for (i = start; i < end; i++) {
this[i] = bytes[i % len]
}
}
return this
}
/**
* Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
* Added in Node 0.12. Only available in browsers that support ArrayBuffer.
*/
Buffer.prototype.toArrayBuffer = function toArrayBuffer () {
if (typeof Uint8Array !== 'undefined') {
if (Buffer.TYPED_ARRAY_SUPPORT) {
return (new Buffer(this)).buffer
} else {
var buf = new Uint8Array(this.length)
for (var i = 0, len = buf.length; i < len; i += 1) {
buf[i] = this[i]
}
return buf.buffer
}
} else {
throw new TypeError('Buffer.toArrayBuffer not supported in this browser')
}
}
// HELPER FUNCTIONS
// ================
var BP = Buffer.prototype
/**
* Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
*/
Buffer._augment = function _augment (arr) {
arr.constructor = Buffer
arr._isBuffer = true
// save reference to original Uint8Array set method before overwriting
arr._set = arr.set
// deprecated, will be removed in node 0.13+
arr.get = BP.get
arr.set = BP.set
arr.write = BP.write
arr.toString = BP.toString
arr.toLocaleString = BP.toString
arr.toJSON = BP.toJSON
arr.equals = BP.equals
arr.compare = BP.compare
arr.indexOf = BP.indexOf
arr.copy = BP.copy
arr.slice = BP.slice
arr.readUIntLE = BP.readUIntLE
arr.readUIntBE = BP.readUIntBE
arr.readUInt8 = BP.readUInt8
arr.readUInt16LE = BP.readUInt16LE
arr.readUInt16BE = BP.readUInt16BE
arr.readUInt32LE = BP.readUInt32LE
arr.readUInt32BE = BP.readUInt32BE
arr.readIntLE = BP.readIntLE
arr.readIntBE = BP.readIntBE
arr.readInt8 = BP.readInt8
arr.readInt16LE = BP.readInt16LE
arr.readInt16BE = BP.readInt16BE
arr.readInt32LE = BP.readInt32LE
arr.readInt32BE = BP.readInt32BE
arr.readFloatLE = BP.readFloatLE
arr.readFloatBE = BP.readFloatBE
arr.readDoubleLE = BP.readDoubleLE
arr.readDoubleBE = BP.readDoubleBE
arr.writeUInt8 = BP.writeUInt8
arr.writeUIntLE = BP.writeUIntLE
arr.writeUIntBE = BP.writeUIntBE
arr.writeUInt16LE = BP.writeUInt16LE
arr.writeUInt16BE = BP.writeUInt16BE
arr.writeUInt32LE = BP.writeUInt32LE
arr.writeUInt32BE = BP.writeUInt32BE
arr.writeIntLE = BP.writeIntLE
arr.writeIntBE = BP.writeIntBE
arr.writeInt8 = BP.writeInt8
arr.writeInt16LE = BP.writeInt16LE
arr.writeInt16BE = BP.writeInt16BE
arr.writeInt32LE = BP.writeInt32LE
arr.writeInt32BE = BP.writeInt32BE
arr.writeFloatLE = BP.writeFloatLE
arr.writeFloatBE = BP.writeFloatBE
arr.writeDoubleLE = BP.writeDoubleLE
arr.writeDoubleBE = BP.writeDoubleBE
arr.fill = BP.fill
arr.inspect = BP.inspect
arr.toArrayBuffer = BP.toArrayBuffer
return arr
}
var INVALID_BASE64_RE = /[^+\/0-9A-z\-]/g
function base64clean (str) {
// Node strips out invalid characters like \n and \t from the string, base64-js does not
str = stringtrim(str).replace(INVALID_BASE64_RE, '')
// Node converts strings with length < 2 to ''
if (str.length < 2) return ''
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
while (str.length % 4 !== 0) {
str = str + '='
}
return str
}
function stringtrim (str) {
if (str.trim) return str.trim()
return str.replace(/^\s+|\s+$/g, '')
}
function toHex (n) {
if (n < 16) return '0' + n.toString(16)
return n.toString(16)
}
function utf8ToBytes (string, units) {
units = units || Infinity
var codePoint
var length = string.length
var leadSurrogate = null
var bytes = []
var i = 0
for (; i < length; i++) {
codePoint = string.charCodeAt(i)
// is surrogate component
if (codePoint > 0xD7FF && codePoint < 0xE000) {
// last char was a lead
if (leadSurrogate) {
// 2 leads in a row
if (codePoint < 0xDC00) {
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
leadSurrogate = codePoint
continue
} else {
// valid surrogate pair
codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000
leadSurrogate = null
}
} else {
// no lead yet
if (codePoint > 0xDBFF) {
// unexpected trail
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
} else if (i + 1 === length) {
// unpaired lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
} else {
// valid lead
leadSurrogate = codePoint
continue
}
}
} else if (leadSurrogate) {
// valid bmp char, but last char was a lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
leadSurrogate = null
}
// encode utf8
if (codePoint < 0x80) {
if ((units -= 1) < 0) break
bytes.push(codePoint)
} else if (codePoint < 0x800) {
if ((units -= 2) < 0) break
bytes.push(
codePoint >> 0x6 | 0xC0,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x10000) {
if ((units -= 3) < 0) break
bytes.push(
codePoint >> 0xC | 0xE0,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x200000) {
if ((units -= 4) < 0) break
bytes.push(
codePoint >> 0x12 | 0xF0,
codePoint >> 0xC & 0x3F | 0x80,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else {
throw new Error('Invalid code point')
}
}
return bytes
}
function asciiToBytes (str) {
var byteArray = []
for (var i = 0; i < str.length; i++) {
// Node's code seems to be doing this and not & 0x7F..
byteArray.push(str.charCodeAt(i) & 0xFF)
}
return byteArray
}
function utf16leToBytes (str, units) {
var c, hi, lo
var byteArray = []
for (var i = 0; i < str.length; i++) {
if ((units -= 2) < 0) break
c = str.charCodeAt(i)
hi = c >> 8
lo = c % 256
byteArray.push(lo)
byteArray.push(hi)
}
return byteArray
}
function base64ToBytes (str) {
return base64.toByteArray(base64clean(str))
}
function blitBuffer (src, dst, offset, length) {
for (var i = 0; i < length; i++) {
if ((i + offset >= dst.length) || (i >= src.length)) break
dst[i + offset] = src[i]
}
return i
}
function decodeUtf8Char (str) {
try {
return decodeURIComponent(str)
} catch (err) {
return String.fromCharCode(0xFFFD) // UTF 8 invalid char
}
}
},{"base64-js":2,"ieee754":3,"is-array":4}],2:[function(require,module,exports){
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
;(function (exports) {
'use strict';
var Arr = (typeof Uint8Array !== 'undefined')
? Uint8Array
: Array
var PLUS = '+'.charCodeAt(0)
var SLASH = '/'.charCodeAt(0)
var NUMBER = '0'.charCodeAt(0)
var LOWER = 'a'.charCodeAt(0)
var UPPER = 'A'.charCodeAt(0)
var PLUS_URL_SAFE = '-'.charCodeAt(0)
var SLASH_URL_SAFE = '_'.charCodeAt(0)
function decode (elt) {
var code = elt.charCodeAt(0)
if (code === PLUS ||
code === PLUS_URL_SAFE)
return 62 // '+'
if (code === SLASH ||
code === SLASH_URL_SAFE)
return 63 // '/'
if (code < NUMBER)
return -1 //no match
if (code < NUMBER + 10)
return code - NUMBER + 26 + 26
if (code < UPPER + 26)
return code - UPPER
if (code < LOWER + 26)
return code - LOWER + 26
}
function b64ToByteArray (b64) {
var i, j, l, tmp, placeHolders, arr
if (b64.length % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}
// the number of equal signs (place holders)
// if there are two placeholders, than the two characters before it
// represent one byte
// if there is only one, then the three characters before it represent 2 bytes
// this is just a cheap hack to not do indexOf twice
var len = b64.length
placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
// base64 is 4/3 + up to two characters of the original data
arr = new Arr(b64.length * 3 / 4 - placeHolders)
// if there are placeholders, only get up to the last complete 4 chars
l = placeHolders > 0 ? b64.length - 4 : b64.length
var L = 0
function push (v) {
arr[L++] = v
}
for (i = 0, j = 0; i < l; i += 4, j += 3) {
tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
push((tmp & 0xFF0000) >> 16)
push((tmp & 0xFF00) >> 8)
push(tmp & 0xFF)
}
if (placeHolders === 2) {
tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
push(tmp & 0xFF)
} else if (placeHolders === 1) {
tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
push((tmp >> 8) & 0xFF)
push(tmp & 0xFF)
}
return arr
}
function uint8ToBase64 (uint8) {
var i,
extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
output = "",
temp, length
function encode (num) {
return lookup.charAt(num)
}
function tripletToBase64 (num) {
return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
}
// go through the array every three bytes, we'll deal with trailing stuff later
for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
output += tripletToBase64(temp)
}
// pad the end with zeros, but make sure to not forget the extra bytes
switch (extraBytes) {
case 1:
temp = uint8[uint8.length - 1]
output += encode(temp >> 2)
output += encode((temp << 4) & 0x3F)
output += '=='
break
case 2:
temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
output += encode(temp >> 10)
output += encode((temp >> 4) & 0x3F)
output += encode((temp << 2) & 0x3F)
output += '='
break
}
return output
}
exports.toByteArray = b64ToByteArray
exports.fromByteArray = uint8ToBase64
}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
},{}],3:[function(require,module,exports){
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
var e, m,
eLen = nBytes * 8 - mLen - 1,
eMax = (1 << eLen) - 1,
eBias = eMax >> 1,
nBits = -7,
i = isLE ? (nBytes - 1) : 0,
d = isLE ? -1 : 1,
s = buffer[offset + i]
i += d
e = s & ((1 << (-nBits)) - 1)
s >>= (-nBits)
nBits += eLen
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
m = e & ((1 << (-nBits)) - 1)
e >>= (-nBits)
nBits += mLen
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
if (e === 0) {
e = 1 - eBias
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity)
} else {
m = m + Math.pow(2, mLen)
e = e - eBias
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
}
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c,
eLen = nBytes * 8 - mLen - 1,
eMax = (1 << eLen) - 1,
eBias = eMax >> 1,
rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
i = isLE ? 0 : (nBytes - 1),
d = isLE ? 1 : -1,
s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
value = Math.abs(value)
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0
e = eMax
} else {
e = Math.floor(Math.log(value) / Math.LN2)
if (value * (c = Math.pow(2, -e)) < 1) {
e--
c *= 2
}
if (e + eBias >= 1) {
value += rt / c
} else {
value += rt * Math.pow(2, 1 - eBias)
}
if (value * c >= 2) {
e++
c /= 2
}
if (e + eBias >= eMax) {
m = 0
e = eMax
} else if (e + eBias >= 1) {
m = (value * c - 1) * Math.pow(2, mLen)
e = e + eBias
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
e = 0
}
}
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
e = (e << mLen) | m
eLen += mLen
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
buffer[offset + i - d] |= s * 128
}
},{}],4:[function(require,module,exports){
/**
* isArray
*/
var isArray = Array.isArray;
/**
* toString
*/
var str = Object.prototype.toString;
/**
* Whether or not the given `val`
* is an array.
*
* example:
*
* isArray([]);
* // > true
* isArray(arguments);
* // > false
* isArray('');
* // > false
*
* @param {mixed} val
* @return {bool}
*/
module.exports = isArray || function (val) {
return !! val && '[object Array]' == str.call(val);
};
},{}],5:[function(require,module,exports){
(function (Buffer){
//prototype class for hash functions
function Hash (blockSize, finalSize) {
this._block = new Buffer(blockSize) //new Uint32Array(blockSize/4)
this._finalSize = finalSize
this._blockSize = blockSize
this._len = 0
this._s = 0
}
Hash.prototype.update = function (data, enc) {
if ("string" === typeof data) {
enc = enc || "utf8"
data = new Buffer(data, enc)
}
var l = this._len += data.length
var s = this._s || 0
var f = 0
var buffer = this._block
while (s < l) {
var t = Math.min(data.length, f + this._blockSize - (s % this._blockSize))
var ch = (t - f)
for (var i = 0; i < ch; i++) {
buffer[(s % this._blockSize) + i] = data[i + f]
}
s += ch
f += ch
if ((s % this._blockSize) === 0) {
this._update(buffer)
}
}
this._s = s
return this
}
Hash.prototype.digest = function (enc) {
// Suppose the length of the message M, in bits, is l
var l = this._len * 8
// Append the bit 1 to the end of the message
this._block[this._len % this._blockSize] = 0x80
// and then k zero bits, where k is the smallest non-negative solution to the equation (l + 1 + k) === finalSize mod blockSize
this._block.fill(0, this._len % this._blockSize + 1)
if (l % (this._blockSize * 8) >= this._finalSize * 8) {
this._update(this._block)
this._block.fill(0)
}
// to this append the block which is equal to the number l written in binary
// TODO: handle case where l is > Math.pow(2, 29)
this._block.writeInt32BE(l, this._blockSize - 4)
var hash = this._update(this._block) || this._hash()
return enc ? hash.toString(enc) : hash
}
Hash.prototype._update = function () {
throw new Error('_update must be implemented by subclass')
}
module.exports = Hash
}).call(this,require("buffer").Buffer)
},{"buffer":1}],6:[function(require,module,exports){
var exports = module.exports = function (alg) {
var Alg = exports[alg.toLowerCase()]
if(!Alg) throw new Error(alg + ' is not supported (we accept pull requests)')
return new Alg()
}
exports.sha = require('./sha')
exports.sha1 = require('./sha1')
exports.sha224 = require('./sha224')
exports.sha256 = require('./sha256')
exports.sha384 = require('./sha384')
exports.sha512 = require('./sha512')
},{"./sha":8,"./sha1":9,"./sha224":10,"./sha256":11,"./sha384":12,"./sha512":13}],7:[function(require,module,exports){
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
},{}],8:[function(require,module,exports){
(function (Buffer){
/*
* A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
* in FIPS PUB 180-1
* This source code is derived from sha1.js of the same repository.
* The difference between SHA-0 and SHA-1 is just a bitwise rotate left
* operation was added.
*/
var inherits = require('inherits')
var Hash = require('./hash')
var W = new Array(80)
function Sha() {
this.init()
this._w = W
Hash.call(this, 64, 56)
}
inherits(Sha, Hash)
Sha.prototype.init = function () {
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
this._e = 0xc3d2e1f0
return this
}
/*
* Bitwise rotate a 32-bit number to the left.
*/
function rol(num, cnt) {
return (num << cnt) | (num >>> (32 - cnt));
}
Sha.prototype._update = function (M) {
var W = this._w
var a = this._a
var b = this._b
var c = this._c
var d = this._d
var e = this._e
var j = 0, k
/*
* SHA-1 has a bitwise rotate left operation. But, SHA is not
* function calcW() { return rol(W[j - 3] ^ W[j - 8] ^ W[j - 14] ^ W[j - 16], 1) }
*/
function calcW() { return W[j - 3] ^ W[j - 8] ^ W[j - 14] ^ W[j - 16] }
function loop(w, f) {
W[j] = w
var t = rol(a, 5) + f + e + w + k
e = d
d = c
c = rol(b, 30)
b = a
a = t
j++
}
k = 1518500249
while (j < 16) loop(M.readInt32BE(j * 4), (b & c) | ((~b) & d))
while (j < 20) loop(calcW(), (b & c) | ((~b) & d))
k = 1859775393
while (j < 40) loop(calcW(), b ^ c ^ d)
k = -1894007588
while (j < 60) loop(calcW(), (b & c) | (b & d) | (c & d))
k = -899497514
while (j < 80) loop(calcW(), b ^ c ^ d)
this._a = (a + this._a) | 0
this._b = (b + this._b) | 0
this._c = (c + this._c) | 0
this._d = (d + this._d) | 0
this._e = (e + this._e) | 0
}
Sha.prototype._hash = function () {
var H = new Buffer(20)
H.writeInt32BE(this._a|0, 0)
H.writeInt32BE(this._b|0, 4)
H.writeInt32BE(this._c|0, 8)
H.writeInt32BE(this._d|0, 12)
H.writeInt32BE(this._e|0, 16)
return H
}
module.exports = Sha
}).call(this,require("buffer").Buffer)
},{"./hash":5,"buffer":1,"inherits":7}],9:[function(require,module,exports){
(function (Buffer){
/*
* A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
* in FIPS PUB 180-1
* Version 2.1a Copyright Paul Johnston 2000 - 2002.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for details.
*/
var inherits = require('inherits')
var Hash = require('./hash')
var W = new Array(80)
function Sha1() {
this.init()
this._w = W
Hash.call(this, 64, 56)
}
inherits(Sha1, Hash)
Sha1.prototype.init = function () {
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
this._e = 0xc3d2e1f0
return this
}
/*
* Bitwise rotate a 32-bit number to the left.
*/
function rol(num, cnt) {
return (num << cnt) | (num >>> (32 - cnt));
}
Sha1.prototype._update = function (M) {
var W = this._w
var a = this._a
var b = this._b
var c = this._c
var d = this._d
var e = this._e
var j = 0, k
function calcW() { return rol(W[j - 3] ^ W[j - 8] ^ W[j - 14] ^ W[j - 16], 1) }
function loop(w, f) {
W[j] = w
var t = rol(a, 5) + f + e + w + k
e = d
d = c
c = rol(b, 30)
b = a
a = t
j++
}
k = 1518500249
while (j < 16) loop(M.readInt32BE(j * 4), (b & c) | ((~b) & d))
while (j < 20) loop(calcW(), (b & c) | ((~b) & d))
k = 1859775393
while (j < 40) loop(calcW(), b ^ c ^ d)
k = -1894007588
while (j < 60) loop(calcW(), (b & c) | (b & d) | (c & d))
k = -899497514
while (j < 80) loop(calcW(), b ^ c ^ d)
this._a = (a + this._a) | 0
this._b = (b + this._b) | 0
this._c = (c + this._c) | 0
this._d = (d + this._d) | 0
this._e = (e + this._e) | 0
}
Sha1.prototype._hash = function () {
var H = new Buffer(20)
H.writeInt32BE(this._a|0, 0)
H.writeInt32BE(this._b|0, 4)
H.writeInt32BE(this._c|0, 8)
H.writeInt32BE(this._d|0, 12)
H.writeInt32BE(this._e|0, 16)
return H
}
module.exports = Sha1
}).call(this,require("buffer").Buffer)
},{"./hash":5,"buffer":1,"inherits":7}],10:[function(require,module,exports){
(function (Buffer){
/**
* A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
* in FIPS 180-2
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
*
*/
var inherits = require('inherits')
var SHA256 = require('./sha256')
var Hash = require('./hash')
var W = new Array(64)
function Sha224() {
this.init()
this._w = W // new Array(64)
Hash.call(this, 64, 56)
}
inherits(Sha224, SHA256)
Sha224.prototype.init = function () {
this._a = 0xc1059ed8|0
this._b = 0x367cd507|0
this._c = 0x3070dd17|0
this._d = 0xf70e5939|0
this._e = 0xffc00b31|0
this._f = 0x68581511|0
this._g = 0x64f98fa7|0
this._h = 0xbefa4fa4|0
return this
}
Sha224.prototype._hash = function () {
var H = new Buffer(28)
H.writeInt32BE(this._a, 0)
H.writeInt32BE(this._b, 4)
H.writeInt32BE(this._c, 8)
H.writeInt32BE(this._d, 12)
H.writeInt32BE(this._e, 16)
H.writeInt32BE(this._f, 20)
H.writeInt32BE(this._g, 24)
return H
}
module.exports = Sha224
}).call(this,require("buffer").Buffer)
},{"./hash":5,"./sha256":11,"buffer":1,"inherits":7}],11:[function(require,module,exports){
(function (Buffer){
/**
* A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
* in FIPS 180-2
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
*
*/
var inherits = require('inherits')
var Hash = require('./hash')
var K = [
0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
]
var W = new Array(64)
function Sha256() {
this.init()
this._w = W // new Array(64)
Hash.call(this, 64, 56)
}
inherits(Sha256, Hash)
Sha256.prototype.init = function () {
this._a = 0x6a09e667|0
this._b = 0xbb67ae85|0
this._c = 0x3c6ef372|0
this._d = 0xa54ff53a|0
this._e = 0x510e527f|0
this._f = 0x9b05688c|0
this._g = 0x1f83d9ab|0
this._h = 0x5be0cd19|0
return this
}
function S (X, n) {
return (X >>> n) | (X << (32 - n));
}
function R (X, n) {
return (X >>> n);
}
function Ch (x, y, z) {
return ((x & y) ^ ((~x) & z));
}
function Maj (x, y, z) {
return ((x & y) ^ (x & z) ^ (y & z));
}
function Sigma0256 (x) {
return (S(x, 2) ^ S(x, 13) ^ S(x, 22));
}
function Sigma1256 (x) {
return (S(x, 6) ^ S(x, 11) ^ S(x, 25));
}
function Gamma0256 (x) {
return (S(x, 7) ^ S(x, 18) ^ R(x, 3));
}
function Gamma1256 (x) {
return (S(x, 17) ^ S(x, 19) ^ R(x, 10));
}
Sha256.prototype._update = function(M) {
var W = this._w
var a = this._a | 0
var b = this._b | 0
var c = this._c | 0
var d = this._d | 0
var e = this._e | 0
var f = this._f | 0
var g = this._g | 0
var h = this._h | 0
var j = 0
function calcW() { return Gamma1256(W[j - 2]) + W[j - 7] + Gamma0256(W[j - 15]) + W[j - 16] }
function loop(w) {
W[j] = w
var T1 = h + Sigma1256(e) + Ch(e, f, g) + K[j] + w
var T2 = Sigma0256(a) + Maj(a, b, c);
h = g;
g = f;
f = e;
e = d + T1;
d = c;
c = b;
b = a;
a = T1 + T2;
j++
}
while (j < 16) loop(M.readInt32BE(j * 4))
while (j < 64) loop(calcW())
this._a = (a + this._a) | 0
this._b = (b + this._b) | 0
this._c = (c + this._c) | 0
this._d = (d + this._d) | 0
this._e = (e + this._e) | 0
this._f = (f + this._f) | 0
this._g = (g + this._g) | 0
this._h = (h + this._h) | 0
};
Sha256.prototype._hash = function () {
var H = new Buffer(32)
H.writeInt32BE(this._a, 0)
H.writeInt32BE(this._b, 4)
H.writeInt32BE(this._c, 8)
H.writeInt32BE(this._d, 12)
H.writeInt32BE(this._e, 16)
H.writeInt32BE(this._f, 20)
H.writeInt32BE(this._g, 24)
H.writeInt32BE(this._h, 28)
return H
}
module.exports = Sha256
}).call(this,require("buffer").Buffer)
},{"./hash":5,"buffer":1,"inherits":7}],12:[function(require,module,exports){
(function (Buffer){
var inherits = require('inherits')
var SHA512 = require('./sha512');
var Hash = require('./hash')
var W = new Array(160)
function Sha384() {
this.init()
this._w = W
Hash.call(this, 128, 112)
}
inherits(Sha384, SHA512)
Sha384.prototype.init = function () {
this._a = 0xcbbb9d5d|0
this._b = 0x629a292a|0
this._c = 0x9159015a|0
this._d = 0x152fecd8|0
this._e = 0x67332667|0
this._f = 0x8eb44a87|0
this._g = 0xdb0c2e0d|0
this._h = 0x47b5481d|0
this._al = 0xc1059ed8|0
this._bl = 0x367cd507|0
this._cl = 0x3070dd17|0
this._dl = 0xf70e5939|0
this._el = 0xffc00b31|0
this._fl = 0x68581511|0
this._gl = 0x64f98fa7|0
this._hl = 0xbefa4fa4|0
return this
}
Sha384.prototype._hash = function () {
var H = new Buffer(48)
function writeInt64BE(h, l, offset) {
H.writeInt32BE(h, offset)
H.writeInt32BE(l, offset + 4)
}
writeInt64BE(this._a, this._al, 0)
writeInt64BE(this._b, this._bl, 8)
writeInt64BE(this._c, this._cl, 16)
writeInt64BE(this._d, this._dl, 24)
writeInt64BE(this._e, this._el, 32)
writeInt64BE(this._f, this._fl, 40)
return H
}
module.exports = Sha384
}).call(this,require("buffer").Buffer)
},{"./hash":5,"./sha512":13,"buffer":1,"inherits":7}],13:[function(require,module,exports){
(function (Buffer){
var inherits = require('inherits')
var Hash = require('./hash')
var K = [
0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
]
var W = new Array(160)
function Sha512() {
this.init()
this._w = W
Hash.call(this, 128, 112)
}
inherits(Sha512, Hash)
Sha512.prototype.init = function () {
this._a = 0x6a09e667|0
this._b = 0xbb67ae85|0
this._c = 0x3c6ef372|0
this._d = 0xa54ff53a|0
this._e = 0x510e527f|0
this._f = 0x9b05688c|0
this._g = 0x1f83d9ab|0
this._h = 0x5be0cd19|0
this._al = 0xf3bcc908|0
this._bl = 0x84caa73b|0
this._cl = 0xfe94f82b|0
this._dl = 0x5f1d36f1|0
this._el = 0xade682d1|0
this._fl = 0x2b3e6c1f|0
this._gl = 0xfb41bd6b|0
this._hl = 0x137e2179|0
return this
}
function S (X, Xl, n) {
return (X >>> n) | (Xl << (32 - n))
}
function Ch (x, y, z) {
return ((x & y) ^ ((~x) & z));
}
function Maj (x, y, z) {
return ((x & y) ^ (x & z) ^ (y & z));
}
Sha512.prototype._update = function(M) {
var W = this._w
var a = this._a | 0
var b = this._b | 0
var c = this._c | 0
var d = this._d | 0
var e = this._e | 0
var f = this._f | 0
var g = this._g | 0
var h = this._h | 0
var al = this._al | 0
var bl = this._bl | 0
var cl = this._cl | 0
var dl = this._dl | 0
var el = this._el | 0
var fl = this._fl | 0
var gl = this._gl | 0
var hl = this._hl | 0
var i = 0, j = 0
var Wi, Wil
function calcW() {
var x = W[j - 15*2]
var xl = W[j - 15*2 + 1]
var gamma0 = S(x, xl, 1) ^ S(x, xl, 8) ^ (x >>> 7)
var gamma0l = S(xl, x, 1) ^ S(xl, x, 8) ^ S(xl, x, 7)
x = W[j - 2*2]
xl = W[j - 2*2 + 1]
var gamma1 = S(x, xl, 19) ^ S(xl, x, 29) ^ (x >>> 6)
var gamma1l = S(xl, x, 19) ^ S(x, xl, 29) ^ S(xl, x, 6)
// W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
var Wi7 = W[j - 7*2]
var Wi7l = W[j - 7*2 + 1]
var Wi16 = W[j - 16*2]
var Wi16l = W[j - 16*2 + 1]
Wil = gamma0l + Wi7l
Wi = gamma0 + Wi7 + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0)
Wil = Wil + gamma1l
Wi = Wi + gamma1 + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0)
Wil = Wil + Wi16l
Wi = Wi + Wi16 + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0)
}
function loop() {
W[j] = Wi
W[j + 1] = Wil
var maj = Maj(a, b, c)
var majl = Maj(al, bl, cl)
var sigma0h = S(a, al, 28) ^ S(al, a, 2) ^ S(al, a, 7)
var sigma0l = S(al, a, 28) ^ S(a, al, 2) ^ S(a, al, 7)
var sigma1h = S(e, el, 14) ^ S(e, el, 18) ^ S(el, e, 9)
var sigma1l = S(el, e, 14) ^ S(el, e, 18) ^ S(e, el, 9)
// t1 = h + sigma1 + ch + K[i] + W[i]
var Ki = K[j]
var Kil = K[j + 1]
var ch = Ch(e, f, g)
var chl = Ch(el, fl, gl)
var t1l = hl + sigma1l
var t1 = h + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0)
t1l = t1l + chl
t1 = t1 + ch + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0)
t1l = t1l + Kil
t1 = t1 + Ki + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0)
t1l = t1l + Wil
t1 = t1 + Wi + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0)
// t2 = sigma0 + maj
var t2l = sigma0l + majl
var t2 = sigma0h + maj + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0)
h = g
hl = gl
g = f
gl = fl
f = e
fl = el
el = (dl + t1l) | 0
e = (d + t1 + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0
d = c
dl = cl
c = b
cl = bl
b = a
bl = al
al = (t1l + t2l) | 0
a = (t1 + t2 + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0
i++
j += 2
}
while (i < 16) {
Wi = M.readInt32BE(j * 4)
Wil = M.readInt32BE(j * 4 + 4)
loop()
}
while (i < 80) {
calcW()
loop()
}
this._al = (this._al + al) | 0
this._bl = (this._bl + bl) | 0
this._cl = (this._cl + cl) | 0
this._dl = (this._dl + dl) | 0
this._el = (this._el + el) | 0
this._fl = (this._fl + fl) | 0
this._gl = (this._gl + gl) | 0
this._hl = (this._hl + hl) | 0
this._a = (this._a + a + ((this._al >>> 0) < (al >>> 0) ? 1 : 0)) | 0
this._b = (this._b + b + ((this._bl >>> 0) < (bl >>> 0) ? 1 : 0)) | 0
this._c = (this._c + c + ((this._cl >>> 0) < (cl >>> 0) ? 1 : 0)) | 0
this._d = (this._d + d + ((this._dl >>> 0) < (dl >>> 0) ? 1 : 0)) | 0
this._e = (this._e + e + ((this._el >>> 0) < (el >>> 0) ? 1 : 0)) | 0
this._f = (this._f + f + ((this._fl >>> 0) < (fl >>> 0) ? 1 : 0)) | 0
this._g = (this._g + g + ((this._gl >>> 0) < (gl >>> 0) ? 1 : 0)) | 0
this._h = (this._h + h + ((this._hl >>> 0) < (hl >>> 0) ? 1 : 0)) | 0
}
Sha512.prototype._hash = function () {
var H = new Buffer(64)
function writeInt64BE(h, l, offset) {
H.writeInt32BE(h, offset)
H.writeInt32BE(l, offset + 4)
}
writeInt64BE(this._a, this._al, 0)
writeInt64BE(this._b, this._bl, 8)
writeInt64BE(this._c, this._cl, 16)
writeInt64BE(this._d, this._dl, 24)
writeInt64BE(this._e, this._el, 32)
writeInt64BE(this._f, this._fl, 40)
writeInt64BE(this._g, this._gl, 48)
writeInt64BE(this._h, this._hl, 56)
return H
}
module.exports = Sha512
}).call(this,require("buffer").Buffer)
},{"./hash":5,"buffer":1,"inherits":7}],14:[function(require,module,exports){
Elm.Native.Sha = {};
Elm.Native.Sha.make = function(elm) {
elm.Native = elm.Native || {};
elm.Native.Sha = elm.Native.Sha || {};
if (elm.Native.Sha.values) {
return elm.Native.Sha.values;
}
function update(data, inputEncoding, algorithm) {
return algorithm.update(data, inputEncoding);
}
function digest(encoding, hash) {
return hash.digest(encoding);
}
return Elm.Native.Sha.values = {
createHash: require('sha.js'),
update: F3(update),
digest: F2(digest)
};
};
},{"sha.js":6}]},{},[14]);
;
Elm.Native.Show = {};
Elm.Native.Show.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Show = localRuntime.Native.Show || {};
if (localRuntime.Native.Show.values)
{
return localRuntime.Native.Show.values;
}
var _Array;
var Dict;
var List;
var Utils = Elm.Native.Utils.make(localRuntime);
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, true) + "'";
}
else if (type === "string")
{
return '"' + addSlashes(v, false) + '"';
}
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(localRuntime);
}
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(localRuntime);
}
if (!List)
{
List = Elm.List.make(localRuntime);
}
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 if (v.ctor.slice(0,5) === "Text:")
{
return '<text>'
}
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' && 'notify' in v && 'id' in v)
{
return 'initialValue' in v
? '<Signal>'
: '<Stream>';
}
return "<internal structure>";
};
function addSlashes(str, isChar)
{
var s = str.replace(/\\/g, '\\\\')
.replace(/\n/g, '\\n')
.replace(/\t/g, '\\t')
.replace(/\r/g, '\\r')
.replace(/\v/g, '\\v')
.replace(/\0/g, '\\0');
if (isChar)
{
return s.replace(/\'/g, "\\'")
}
else
{
return s.replace(/\"/g, '\\"');
}
}
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 localRuntime.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 Task = Elm.Native.Task.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
function broadcastToKids(node, timestamp, update)
{
var kids = node.kids;
for (var i = kids.length; i--; )
{
kids[i].notify(timestamp, update, node.id);
}
}
// INPUT
function input(name, base)
{
var node = {
id: Utils.guid(),
name: 'input-' + name,
value: base,
parents: [],
kids: []
};
node.notify = function(timestamp, targetId, value) {
var update = targetId === node.id;
if (update)
{
node.value = value;
}
broadcastToKids(node, timestamp, update);
return update;
};
localRuntime.inputs.push(node);
return node;
}
function constant(value)
{
return input('constant', value);
}
// MAILBOX
function mailbox(base)
{
var signal = input('mailbox', base);
function send(value) {
return Task.asyncFunction(function(callback) {
localRuntime.setTimeout(function() {
localRuntime.notify(signal.id, value);
}, 0);
callback(Task.succeed(Utils.Tuple0));
});
}
return {
_: {},
signal: signal,
address: {
ctor: 'Address',
_0: send
}
};
}
function sendMessage(message)
{
Task.perform(message._0);
}
// OUTPUT
function output(name, handler, parent)
{
var node = {
id: Utils.guid(),
name: 'output-' + name,
parents: [parent],
isOutput: true
};
node.notify = function(timestamp, parentUpdate, parentID)
{
if (parentUpdate)
{
handler(parent.value);
}
};
parent.kids.push(node);
return node;
}
// MAP
function mapMany(refreshValue, args)
{
var node = {
id: Utils.guid(),
name: 'map' + args.length,
value: refreshValue(),
parents: args,
kids: []
};
var numberOfParents = args.length;
var count = 0;
var update = false;
node.notify = function(timestamp, parentUpdate, parentID)
{
++count;
update = update || parentUpdate;
if (count === numberOfParents)
{
if (update)
{
node.value = refreshValue();
}
broadcastToKids(node, timestamp, update);
update = false;
count = 0;
}
};
for (var i = numberOfParents; i--; )
{
args[i].kids.push(node);
}
return node;
}
function map(func, a)
{
function refreshValue()
{
return func(a.value);
}
return mapMany(refreshValue, [a]);
}
function map2(func, a, b)
{
function refreshValue()
{
return A2( func, a.value, b.value );
}
return mapMany(refreshValue, [a,b]);
}
function map3(func, a, b, c)
{
function refreshValue()
{
return A3( func, a.value, b.value, c.value );
}
return mapMany(refreshValue, [a,b,c]);
}
function map4(func, a, b, c, d)
{
function refreshValue()
{
return A4( func, a.value, b.value, c.value, d.value );
}
return mapMany(refreshValue, [a,b,c,d]);
}
function map5(func, a, b, c, d, e)
{
function refreshValue()
{
return A5( func, a.value, b.value, c.value, d.value, e.value );
}
return mapMany(refreshValue, [a,b,c,d,e]);
}
// FOLD
function foldp(update, state, signal)
{
var node = {
id: Utils.guid(),
name: 'foldp',
parents: [signal],
kids: [],
value: state
};
node.notify = function(timestamp, parentUpdate, parentID)
{
if (parentUpdate)
{
node.value = A2( update, signal.value, node.value );
}
broadcastToKids(node, timestamp, parentUpdate);
};
signal.kids.push(node);
return node;
}
// TIME
function timestamp(signal)
{
var node = {
id: Utils.guid(),
name: 'timestamp',
value: Utils.Tuple2(localRuntime.timer.programStart, signal.value),
parents: [signal],
kids: []
};
node.notify = function(timestamp, parentUpdate, parentID)
{
if (parentUpdate)
{
node.value = Utils.Tuple2(timestamp, signal.value);
}
broadcastToKids(node, timestamp, parentUpdate);
};
signal.kids.push(node);
return node;
}
function delay(time, signal)
{
var delayed = input('delay-input-' + time, signal.value);
function handler(value)
{
setTimeout(function() {
localRuntime.notify(delayed.id, value);
}, time);
}
output('delay-output-' + time, handler, signal);
return delayed;
}
// MERGING
function genericMerge(tieBreaker, leftStream, rightStream)
{
var node = {
id: Utils.guid(),
name: 'merge',
value: A2(tieBreaker, leftStream.value, rightStream.value),
parents: [leftStream, rightStream],
kids: []
};
var left = { touched: false, update: false, value: null };
var right = { touched: false, update: false, value: null };
node.notify = function(timestamp, parentUpdate, parentID)
{
if (parentID === leftStream.id)
{
left.touched = true;
left.update = parentUpdate;
left.value = leftStream.value;
}
if (parentID === rightStream.id)
{
right.touched = true;
right.update = parentUpdate;
right.value = rightStream.value;
}
if (left.touched && right.touched)
{
var update = false;
if (left.update && right.update)
{
node.value = A2(tieBreaker, left.value, right.value);
update = true;
}
else if (left.update)
{
node.value = left.value;
update = true;
}
else if (right.update)
{
node.value = right.value;
update = true;
}
left.touched = false;
right.touched = false;
broadcastToKids(node, timestamp, update);
}
};
leftStream.kids.push(node);
rightStream.kids.push(node);
return node;
}
// FILTERING
function filterMap(toMaybe, base, signal)
{
var maybe = toMaybe(signal.value);
var node = {
id: Utils.guid(),
name: 'filterMap',
value: maybe.ctor === 'Nothing' ? base : maybe._0,
parents: [signal],
kids: []
};
node.notify = function(timestamp, parentUpdate, parentID)
{
var update = false;
if (parentUpdate)
{
var maybe = toMaybe(signal.value);
if (maybe.ctor === 'Just')
{
update = true;
node.value = maybe._0;
}
}
broadcastToKids(node, timestamp, update);
};
signal.kids.push(node);
return node;
}
// SAMPLING
function sampleOn(ticker, signal)
{
var node = {
id: Utils.guid(),
name: 'sampleOn',
value: signal.value,
parents: [ticker, signal],
kids: []
};
var signalTouch = false;
var tickerTouch = false;
var tickerUpdate = false;
node.notify = function(timestamp, parentUpdate, parentID)
{
if (parentID === ticker.id)
{
tickerTouch = true;
tickerUpdate = parentUpdate;
}
if (parentID === signal.id)
{
signalTouch = true;
}
if (tickerTouch && signalTouch)
{
if (tickerUpdate)
{
node.value = signal.value;
}
tickerTouch = false;
signalTouch = false;
broadcastToKids(node, timestamp, tickerUpdate);
}
};
ticker.kids.push(node);
signal.kids.push(node);
return node;
}
// DROP REPEATS
function dropRepeats(signal)
{
var node = {
id: Utils.guid(),
name: 'dropRepeats',
value: signal.value,
parents: [signal],
kids: []
};
node.notify = function(timestamp, parentUpdate, parentID)
{
var update = false;
if (parentUpdate && !Utils.eq(node.value, signal.value))
{
node.value = signal.value;
update = true;
}
broadcastToKids(node, timestamp, update);
};
signal.kids.push(node);
return node;
}
return localRuntime.Native.Signal.values = {
input: input,
constant: constant,
mailbox: mailbox,
sendMessage: sendMessage,
output: output,
map: F2(map),
map2: F3(map2),
map3: F4(map3),
map4: F5(map4),
map5: F6(map5),
foldp: F3(foldp),
genericMerge: F3(genericMerge),
filterMap: F3(filterMap),
sampleOn: F2(sampleOn),
dropRepeats: dropRepeats,
timestamp: timestamp,
delay: F2(delay)
};
};
Elm.Native.String = {};
Elm.Native.String.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.String = localRuntime.Native.String || {};
if (localRuntime.Native.String.values)
{
return localRuntime.Native.String.values;
}
if ('values' in Elm.Native.String)
{
return localRuntime.Native.String.values = Elm.Native.String.values;
}
var Char = Elm.Char.make(localRuntime);
var List = Elm.Native.List.make(localRuntime);
var Maybe = Elm.Maybe.make(localRuntime);
var Result = Elm.Result.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
function isEmpty(str)
{
return str.length === 0;
}
function cons(chr,str)
{
return chr + str;
}
function uncons(str)
{
var hd;
return (hd = str[0])
? Maybe.Just(Utils.Tuple2(Utils.chr(hd), str.slice(1)))
: Maybe.Nothing;
}
function append(a,b)
{
return a + b;
}
function concat(strs)
{
return List.toArray(strs).join('');
}
function length(str)
{
return str.length;
}
function map(f,str)
{
var out = str.split('');
for (var i = out.length; i--; )
{
out[i] = f(Utils.chr(out[i]));
}
return out.join('');
}
function filter(pred,str)
{
return str.split('').map(Utils.chr).filter(pred).join('');
}
function reverse(str)
{
return str.split('').reverse().join('');
}
function foldl(f,b,str)
{
var len = str.length;
for (var i = 0; i < len; ++i)
{
b = A2(f, Utils.chr(str[i]), b);
}
return b;
}
function foldr(f,b,str)
{
for (var i = str.length; i--; )
{
b = A2(f, Utils.chr(str[i]), b);
}
return b;
}
function split(sep, str)
{
return List.fromArray(str.split(sep));
}
function join(sep, strs)
{
return List.toArray(strs).join(sep);
}
function repeat(n, str)
{
var result = '';
while (n > 0)
{
if (n & 1)
{
result += str;
}
n >>= 1, str += str;
}
return result;
}
function slice(start, end, str)
{
return str.slice(start,end);
}
function left(n, str)
{
return n < 1 ? "" : str.slice(0,n);
}
function right(n, str)
{
return n < 1 ? "" : str.slice(-n);
}
function dropLeft(n, str)
{
return n < 1 ? str : str.slice(n);
}
function dropRight(n, str)
{
return n < 1 ? str : str.slice(0,-n);
}
function pad(n,chr,str)
{
var half = (n - str.length) / 2;
return repeat(Math.ceil(half),chr) + str + repeat(half|0,chr);
}
function padRight(n,chr,str)
{
return str + repeat(n - str.length, chr);
}
function padLeft(n,chr,str)
{
return repeat(n - str.length, chr) + str;
}
function trim(str)
{
return str.trim();
}
function trimLeft(str)
{
return str.trimLeft();
}
function trimRight(str)
{
return str.trimRight();
}
function words(str)
{
return List.fromArray(str.trim().split(/\s+/g));
}
function lines(str)
{
return List.fromArray(str.split(/\r\n|\r|\n/g));
}
function toUpper(str)
{
return str.toUpperCase();
}
function toLower(str)
{
return str.toLowerCase();
}
function any(pred, str)
{
for (var i = str.length; i--; )
{
if (pred(Utils.chr(str[i])))
{
return true;
}
}
return false;
}
function all(pred, str)
{
for (var i = str.length; i--; )
{
if (!pred(Utils.chr(str[i])))
{
return false;
}
}
return true;
}
function contains(sub, str)
{
return str.indexOf(sub) > -1;
}
function startsWith(sub, str)
{
return str.indexOf(sub) === 0;
}
function endsWith(sub, str)
{
return str.length >= sub.length &&
str.lastIndexOf(sub) === str.length - sub.length;
}
function indexes(sub, str)
{
var subLen = sub.length;
var i = 0;
var is = [];
while ((i = str.indexOf(sub, i)) > -1)
{
is.push(i);
i = i + subLen;
}
return List.fromArray(is);
}
function toInt(s)
{
var len = s.length;
if (len === 0)
{
return Result.Err("could not convert string '" + s + "' to an Int" );
}
var start = 0;
if (s[0] == '-')
{
if (len === 1)
{
return Result.Err("could not convert string '" + s + "' to an Int" );
}
start = 1;
}
for (var i = start; i < len; ++i)
{
if (!Char.isDigit(s[i]))
{
return Result.Err("could not convert string '" + s + "' to an Int" );
}
}
return Result.Ok(parseInt(s, 10));
}
function toFloat(s)
{
var len = s.length;
if (len === 0)
{
return Result.Err("could not convert string '" + s + "' to a Float" );
}
var start = 0;
if (s[0] == '-')
{
if (len === 1)
{
return Result.Err("could not convert string '" + s + "' to a Float" );
}
start = 1;
}
var dotCount = 0;
for (var i = start; i < len; ++i)
{
if (Char.isDigit(s[i]))
{
continue;
}
if (s[i] === '.')
{
dotCount += 1;
if (dotCount <= 1)
{
continue;
}
}
return Result.Err("could not convert string '" + s + "' to a Float" );
}
return Result.Ok(parseFloat(s));
}
function toList(str)
{
return List.fromArray(str.split('').map(Utils.chr));
}
function fromList(chars)
{
return List.toArray(chars).join('');
}
return Elm.Native.String.values = {
isEmpty: isEmpty,
cons: F2(cons),
uncons: uncons,
append: F2(append),
concat: concat,
length: length,
map: F2(map),
filter: F2(filter),
reverse: reverse,
foldl: F3(foldl),
foldr: F3(foldr),
split: F2(split),
join: F2(join),
repeat: F2(repeat),
slice: F3(slice),
left: F2(left),
right: F2(right),
dropLeft: F2(dropLeft),
dropRight: F2(dropRight),
pad: F3(pad),
padLeft: F3(padLeft),
padRight: F3(padRight),
trim: trim,
trimLeft: trimLeft,
trimRight: trimRight,
words: words,
lines: lines,
toUpper: toUpper,
toLower: toLower,
any: F2(any),
all: F2(all),
contains: F2(contains),
startsWith: F2(startsWith),
endsWith: F2(endsWith),
indexes: F2(indexes),
toInt: toInt,
toFloat: toFloat,
toList: toList,
fromList: fromList
};
};
Elm.Native.Task = {};
Elm.Native.Task.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Task = localRuntime.Native.Task || {};
if (localRuntime.Native.Task.values)
{
return localRuntime.Native.Task.values;
}
var Result = Elm.Result.make(localRuntime);
var Signal;
var Utils = Elm.Native.Utils.make(localRuntime);
// CONSTRUCTORS
function succeed(value)
{
return {
tag: 'Succeed',
value: value
};
}
function fail(error)
{
return {
tag: 'Fail',
value: error
};
}
function asyncFunction(func)
{
return {
tag: 'Async',
asyncFunction: func
};
}
function andThen(task, callback)
{
return {
tag: 'AndThen',
task: task,
callback: callback
};
}
function catch_(task, callback)
{
return {
tag: 'Catch',
task: task,
callback: callback
};
}
// RUNNER
function perform(task) {
runTask({ task: task }, function() {});
}
function performSignal(name, signal)
{
var workQueue = [];
function onComplete()
{
workQueue.shift();
setTimeout(function() {
if (workQueue.length > 0)
{
runTask(workQueue[0], onComplete);
}
}, 0);
}
function register(task)
{
var root = { task: task };
workQueue.push(root);
if (workQueue.length === 1)
{
runTask(root, onComplete);
}
}
if (!Signal)
{
Signal = Elm.Native.Signal.make(localRuntime);
}
Signal.output('perform-tasks-' + name, register, signal);
register(signal.value);
return signal;
}
function mark(status, task)
{
return { status: status, task: task };
}
function runTask(root, onComplete)
{
var result = mark('runnable', root.task);
while (result.status === 'runnable')
{
result = stepTask(onComplete, root, result.task);
}
if (result.status === 'done')
{
root.task = result.task;
onComplete();
}
if (result.status === 'blocked')
{
root.task = result.task;
}
}
function stepTask(onComplete, root, task)
{
var tag = task.tag;
if (tag === 'Succeed' || tag === 'Fail')
{
return mark('done', task);
}
if (tag === 'Async')
{
var placeHolder = {};
var couldBeSync = true;
var wasSync = false;
task.asyncFunction(function(result) {
placeHolder.tag = result.tag;
placeHolder.value = result.value;
if (couldBeSync)
{
wasSync = true;
}
else
{
runTask(root, onComplete);
}
});
couldBeSync = false;
return mark(wasSync ? 'done' : 'blocked', placeHolder);
}
if (tag === 'AndThen' || tag === 'Catch')
{
var result = mark('runnable', task.task);
while (result.status === 'runnable')
{
result = stepTask(onComplete, root, result.task);
}
if (result.status === 'done')
{
var activeTask = result.task;
var activeTag = activeTask.tag;
var succeedChain = activeTag === 'Succeed' && tag === 'AndThen';
var failChain = activeTag === 'Fail' && tag === 'Catch';
return (succeedChain || failChain)
? mark('runnable', task.callback(activeTask.value))
: mark('runnable', activeTask);
}
if (result.status === 'blocked')
{
return mark('blocked', {
tag: tag,
task: result.task,
callback: task.callback
});
}
}
}
// THREADS
function sleep(time) {
return asyncFunction(function(callback) {
setTimeout(function() {
callback(succeed(Utils.Tuple0));
}, time);
});
}
function spawn(task) {
return asyncFunction(function(callback) {
var id = setTimeout(function() {
perform(task);
}, 0);
callback(succeed(id));
});
}
return localRuntime.Native.Task.values = {
succeed: succeed,
fail: fail,
asyncFunction: asyncFunction,
andThen: F2(andThen),
catch_: F2(catch_),
perform: perform,
performSignal: performSignal,
spawn: spawn,
sleep: sleep
};
};
Elm.Native.Text = {};
Elm.Native.Text.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Text = localRuntime.Native.Text || {};
if (localRuntime.Native.Text.values)
{
return localRuntime.Native.Text.values;
}
var toCss = Elm.Native.Color.make(localRuntime).toCss;
var List = Elm.Native.List.make(localRuntime);
// CONSTRUCTORS
function fromString(str)
{
return {
ctor: 'Text:Text',
_0: str
};
}
function append(a, b)
{
return {
ctor: 'Text:Append',
_0: a,
_1: b
};
}
function addMeta(field, value, text)
{
var newProps = {};
var newText = {
ctor: 'Text:Meta',
_0: newProps,
_1: text
};
if (text.ctor === 'Text:Meta')
{
newText._1 = text._1;
var props = text._0;
for (var i = metaKeys.length; i--; )
{
var key = metaKeys[i];
var val = props[key];
if (val)
{
newProps[key] = val;
}
}
}
newProps[field] = value;
return newText;
}
var metaKeys = [
'font-size',
'font-family',
'font-style',
'font-weight',
'href',
'text-decoration',
'color'
];
// conversions from Elm values to CSS
function toTypefaces(list)
{
var typefaces = List.toArray(list);
for (var i = typefaces.length; i--; )
{
var typeface = typefaces[i];
if (typeface.indexOf(' ') > -1)
{
typefaces[i] = "'" + typeface + "'";
}
}
return typefaces.join(',');
}
function toLine(line)
{
var ctor = line.ctor;
return ctor === 'Under'
? 'underline'
: ctor === 'Over'
? 'overline'
: 'line-through';
}
// setting styles of Text
function style(style, text)
{
var newText = addMeta('color', toCss(style.color), text);
var props = newText._0;
if (style.typeface.ctor !== '[]')
{
props['font-family'] = toTypefaces(style.typeface);
}
if (style.height.ctor !== "Nothing")
{
props['font-size'] = style.height._0 + 'px';
}
if (style.bold)
{
props['font-weight'] = 'bold';
}
if (style.italic)
{
props['font-style'] = 'italic';
}
if (style.line.ctor !== 'Nothing')
{
props['text-decoration'] = toLine(style.line._0);
}
return newText;
}
function height(px, text)
{
return addMeta('font-size', px + 'px', text);
}
function typeface(names, text)
{
return addMeta('font-family', toTypefaces(names), text);
}
function monospace(text)
{
return addMeta('font-family', 'monospace', text);
}
function italic(text)
{
return addMeta('font-style', 'italic', text);
}
function bold(text)
{
return addMeta('font-weight', 'bold', text);
}
function link(href, text)
{
return addMeta('href', href, text);
}
function line(line, text)
{
return addMeta('text-decoration', toLine(line), text);
}
function color(color, text)
{
return addMeta('color', toCss(color), text);;
}
// RENDER
function renderHtml(text)
{
var tag = text.ctor;
if (tag === 'Text:Append')
{
return renderHtml(text._0) + renderHtml(text._1);
}
if (tag === 'Text:Text')
{
return properEscape(text._0);
}
if (tag === 'Text:Meta')
{
return renderMeta(text._0, renderHtml(text._1));
}
}
function renderMeta(metas, string)
{
var href = metas['href'];
if (href)
{
string = '<a href="' + href + '">' + string + '</a>';
}
var styles = '';
for (var key in metas)
{
if (key === 'href')
{
continue;
}
styles += key + ':' + metas[key] + ';';
}
if (styles)
{
string = '<span style="' + styles + '">' + string + '</span>';
}
return string;
}
function properEscape(str)
{
if (str.length == 0)
{
return str;
}
str = str //.replace(/&/g, "&#38;")
.replace(/"/g, '&#34;')
.replace(/'/g, "&#39;")
.replace(/</g, "&#60;")
.replace(/>/g, "&#62;");
var arr = str.split('\n');
for (var i = arr.length; i--; )
{
arr[i] = makeSpaces(arr[i]);
}
return arr.join('<br/>');
}
function makeSpaces(s)
{
if (s.length == 0)
{
return s;
}
var arr = s.split('');
if (arr[0] == ' ')
{
arr[0] = "&nbsp;"
}
for (var i = arr.length; --i; )
{
if (arr[i][0] == ' ' && arr[i-1] == ' ')
{
arr[i-1] = arr[i-1] + arr[i];
arr[i] = '';
}
}
for (var i = arr.length; i--; )
{
if (arr[i].length > 1 && arr[i][0] == ' ')
{
var spaces = arr[i].split('');
for (var j = spaces.length - 2; j >= 0; j -= 2)
{
spaces[j] = '&nbsp;';
}
arr[i] = spaces.join('');
}
}
arr = arr.join('');
if (arr[arr.length-1] === " ")
{
return arr.slice(0,-1) + '&nbsp;';
}
return arr;
}
return localRuntime.Native.Text.values = {
fromString: fromString,
append: F2(append),
height: F2(height),
italic: italic,
bold: bold,
line: F2(line),
monospace: monospace,
typeface: F2(typeface),
color: F2(color),
link: F2(link),
style: F2(style),
toTypefaces: toTypefaces,
toLine: toLine,
renderHtml: renderHtml
};
};
Elm.Native.Transform2D = {};
Elm.Native.Transform2D.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Transform2D = localRuntime.Native.Transform2D || {};
if (localRuntime.Native.Transform2D.values)
{
return localRuntime.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 localRuntime.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;
}
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 Strings
if (typeof xs === "string")
{
return xs + ys;
}
// append Text
if (xs.ctor.slice(0,5) === 'Text:')
{
return {
ctor: 'Text:Append',
_0: xs,
_1: 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,
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
};
};
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
module.exports = createHash
function createHash(elem) {
var attributes = elem.attributes
var hash = {}
if (attributes === null || attributes === undefined) {
return hash
}
for (var i = 0; i < attributes.length; i++) {
var attr = attributes[i]
if (attr.name.substr(0,5) !== "data-") {
continue
}
hash[attr.name.substr(5)] = attr.value
}
return hash
}
},{}],2:[function(require,module,exports){
var createStore = require("weakmap-shim/create-store")
var Individual = require("individual")
var createHash = require("./create-hash.js")
var hashStore = Individual("__DATA_SET_WEAKMAP@3", createStore())
module.exports = DataSet
function DataSet(elem) {
var store = hashStore(elem)
if (!store.hash) {
store.hash = createHash(elem)
}
return store.hash
}
},{"./create-hash.js":1,"individual":3,"weakmap-shim/create-store":4}],3:[function(require,module,exports){
(function (global){
var root = typeof window !== 'undefined' ?
window : typeof global !== 'undefined' ?
global : {};
module.exports = Individual
function Individual(key, value) {
if (root[key]) {
return root[key]
}
Object.defineProperty(root, key, {
value: value
, configurable: true
})
return value
}
}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],4:[function(require,module,exports){
var hiddenStore = require('./hidden-store.js');
module.exports = createStore;
function createStore() {
var key = {};
return function (obj) {
if (typeof obj !== 'object' || obj === null) {
throw new Error('Weakmap-shim: Key must be object')
}
var store = obj.valueOf(key);
return store && store.identity === key ?
store : hiddenStore(obj, key);
};
}
},{"./hidden-store.js":5}],5:[function(require,module,exports){
module.exports = hiddenStore;
function hiddenStore(obj, key) {
var store = { identity: key };
var valueOf = obj.valueOf;
Object.defineProperty(obj, "valueOf", {
value: function (value) {
return value !== key ?
valueOf.apply(this, arguments) : store;
},
writable: true
});
return store;
}
},{}],6:[function(require,module,exports){
var DataSet = require("data-set")
module.exports = addEvent
function addEvent(target, type, handler) {
var ds = DataSet(target)
var events = ds[type]
if (!events) {
ds[type] = handler
} else if (Array.isArray(events)) {
if (events.indexOf(handler) === -1) {
events.push(handler)
}
} else if (events !== handler) {
ds[type] = [events, handler]
}
}
},{"data-set":2}],7:[function(require,module,exports){
var globalDocument = require("global/document")
var DataSet = require("data-set")
var createStore = require("weakmap-shim/create-store")
var addEvent = require("./add-event.js")
var removeEvent = require("./remove-event.js")
var ProxyEvent = require("./proxy-event.js")
var HANDLER_STORE = createStore()
module.exports = DOMDelegator
function DOMDelegator(document) {
document = document || globalDocument
this.target = document.documentElement
this.events = {}
this.rawEventListeners = {}
this.globalListeners = {}
}
DOMDelegator.prototype.addEventListener = addEvent
DOMDelegator.prototype.removeEventListener = removeEvent
DOMDelegator.prototype.allocateHandle =
function allocateHandle(func) {
var handle = new Handle()
HANDLER_STORE(handle).func = func;
return handle
}
DOMDelegator.prototype.transformHandle =
function transformHandle(handle, lambda) {
var func = HANDLER_STORE(handle).func
return this.allocateHandle(function (ev) {
var result = lambda(ev)
if (result) {
func(result)
}
})
}
DOMDelegator.prototype.addGlobalEventListener =
function addGlobalEventListener(eventName, fn) {
var listeners = this.globalListeners[eventName] || [];
if (listeners.indexOf(fn) === -1) {
listeners.push(fn)
}
this.globalListeners[eventName] = listeners;
}
DOMDelegator.prototype.removeGlobalEventListener =
function removeGlobalEventListener(eventName, fn) {
var listeners = this.globalListeners[eventName] || [];
var index = listeners.indexOf(fn)
if (index !== -1) {
listeners.splice(index, 1)
}
}
DOMDelegator.prototype.listenTo = function listenTo(eventName) {
if (this.events[eventName]) {
return
}
this.events[eventName] = true
var listener = this.rawEventListeners[eventName]
if (!listener) {
listener = this.rawEventListeners[eventName] =
createHandler(eventName, this)
}
this.target.addEventListener(eventName, listener, true)
}
DOMDelegator.prototype.unlistenTo = function unlistenTo(eventName) {
if (!this.events[eventName]) {
return
}
this.events[eventName] = false
var listener = this.rawEventListeners[eventName]
if (!listener) {
throw new Error("dom-delegator#unlistenTo: cannot " +
"unlisten to " + eventName)
}
this.target.removeEventListener(eventName, listener, true)
}
function createHandler(eventName, delegator) {
var globalListeners = delegator.globalListeners;
var delegatorTarget = delegator.target;
return handler
function handler(ev) {
var globalHandlers = globalListeners[eventName] || []
if (globalHandlers.length > 0) {
var globalEvent = new ProxyEvent(ev);
globalEvent.currentTarget = delegatorTarget;
callListeners(globalHandlers, globalEvent)
}
findAndInvokeListeners(ev.target, ev, eventName)
}
}
function findAndInvokeListeners(elem, ev, eventName) {
var listener = getListener(elem, eventName)
if (listener && listener.handlers.length > 0) {
var listenerEvent = new ProxyEvent(ev);
listenerEvent.currentTarget = listener.currentTarget
callListeners(listener.handlers, listenerEvent)
if (listenerEvent._bubbles) {
var nextTarget = listener.currentTarget.parentNode
findAndInvokeListeners(nextTarget, ev, eventName)
}
}
}
function getListener(target, type) {
// terminate recursion if parent is `null`
if (target === null) {
return null
}
var ds = DataSet(target)
// fetch list of handler fns for this event
var handler = ds[type]
var allHandler = ds.event
if (!handler && !allHandler) {
return getListener(target.parentNode, type)
}
var handlers = [].concat(handler || [], allHandler || [])
return new Listener(target, handlers)
}
function callListeners(handlers, ev) {
handlers.forEach(function (handler) {
if (typeof handler === "function") {
handler(ev)
} else if (typeof handler.handleEvent === "function") {
handler.handleEvent(ev)
} else if (handler.type === "dom-delegator-handle") {
HANDLER_STORE(handler).func(ev)
} else {
throw new Error("dom-delegator: unknown handler " +
"found: " + JSON.stringify(handlers));
}
})
}
function Listener(target, handlers) {
this.currentTarget = target
this.handlers = handlers
}
function Handle() {
this.type = "dom-delegator-handle"
}
},{"./add-event.js":6,"./proxy-event.js":15,"./remove-event.js":16,"data-set":2,"global/document":10,"weakmap-shim/create-store":13}],8:[function(require,module,exports){
var Individual = require("individual")
var cuid = require("cuid")
var globalDocument = require("global/document")
var DOMDelegator = require("./dom-delegator.js")
var delegatorCache = Individual("__DOM_DELEGATOR_CACHE@9", {
delegators: {}
})
var commonEvents = [
"blur", "change", "click", "contextmenu", "dblclick",
"error","focus", "focusin", "focusout", "input", "keydown",
"keypress", "keyup", "load", "mousedown", "mouseup",
"resize", "scroll", "select", "submit", "touchcancel",
"touchend", "touchstart", "unload"
]
/* Delegator is a thin wrapper around a singleton `DOMDelegator`
instance.
Only one DOMDelegator should exist because we do not want
duplicate event listeners bound to the DOM.
`Delegator` will also `listenTo()` all events unless
every caller opts out of it
*/
module.exports = Delegator
function Delegator(opts) {
opts = opts || {}
var document = opts.document || globalDocument
var cacheKey = document["__DOM_DELEGATOR_CACHE_TOKEN@9"]
if (!cacheKey) {
cacheKey =
document["__DOM_DELEGATOR_CACHE_TOKEN@9"] = cuid()
}
var delegator = delegatorCache.delegators[cacheKey]
if (!delegator) {
delegator = delegatorCache.delegators[cacheKey] =
new DOMDelegator(document)
}
if (opts.defaultEvents !== false) {
for (var i = 0; i < commonEvents.length; i++) {
delegator.listenTo(commonEvents[i])
}
}
return delegator
}
},{"./dom-delegator.js":7,"cuid":9,"global/document":10,"individual":11}],9:[function(require,module,exports){
/**
* cuid.js
* Collision-resistant UID generator for browsers and node.
* Sequential for fast db lookups and recency sorting.
* Safe for element IDs and server-side lookups.
*
* Extracted from CLCTR
*
* Copyright (c) Eric Elliott 2012
* MIT License
*/
/*global window, navigator, document, require, process, module */
(function (app) {
'use strict';
var namespace = 'cuid',
c = 0,
blockSize = 4,
base = 36,
discreteValues = Math.pow(base, blockSize),
pad = function pad(num, size) {
var s = "000000000" + num;
return s.substr(s.length-size);
},
randomBlock = function randomBlock() {
return pad((Math.random() *
discreteValues << 0)
.toString(base), blockSize);
},
safeCounter = function () {
c = (c < discreteValues) ? c : 0;
c++; // this is not subliminal
return c - 1;
},
api = function cuid() {
// Starting with a lowercase letter makes
// it HTML element ID friendly.
var letter = 'c', // hard-coded allows for sequential access
// timestamp
// warning: this exposes the exact date and time
// that the uid was created.
timestamp = (new Date().getTime()).toString(base),
// Prevent same-machine collisions.
counter,
// A few chars to generate distinct ids for different
// clients (so different computers are far less
// likely to generate the same id)
fingerprint = api.fingerprint(),
// Grab some more chars from Math.random()
random = randomBlock() + randomBlock();
counter = pad(safeCounter().toString(base), blockSize);
return (letter + timestamp + counter + fingerprint + random);
};
api.slug = function slug() {
var date = new Date().getTime().toString(36),
counter,
print = api.fingerprint().slice(0,1) +
api.fingerprint().slice(-1),
random = randomBlock().slice(-2);
counter = safeCounter().toString(36).slice(-4);
return date.slice(-2) +
counter + print + random;
};
api.globalCount = function globalCount() {
// We want to cache the results of this
var cache = (function calc() {
var i,
count = 0;
for (i in window) {
count++;
}
return count;
}());
api.globalCount = function () { return cache; };
return cache;
};
api.fingerprint = function browserPrint() {
return pad((navigator.mimeTypes.length +
navigator.userAgent.length).toString(36) +
api.globalCount().toString(36), 4);
};
// don't change anything from here down.
if (app.register) {
app.register(namespace, api);
} else if (typeof module !== 'undefined') {
module.exports = api;
} else {
app[namespace] = api;
}
}(this.applitude || this));
},{}],10:[function(require,module,exports){
(function (global){
var topLevel = typeof global !== 'undefined' ? global :
typeof window !== 'undefined' ? window : {}
var minDoc = require('min-document');
if (typeof document !== 'undefined') {
module.exports = document;
} else {
var doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'];
if (!doccy) {
doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDoc;
}
module.exports = doccy;
}
}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"min-document":40}],11:[function(require,module,exports){
module.exports=require(3)
},{}],12:[function(require,module,exports){
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
},{}],13:[function(require,module,exports){
module.exports=require(4)
},{"./hidden-store.js":14}],14:[function(require,module,exports){
module.exports=require(5)
},{}],15:[function(require,module,exports){
var inherits = require("inherits")
var ALL_PROPS = [
"altKey", "bubbles", "cancelable", "ctrlKey",
"eventPhase", "metaKey", "relatedTarget", "shiftKey",
"target", "timeStamp", "type", "view", "which"
]
var KEY_PROPS = ["char", "charCode", "key", "keyCode"]
var MOUSE_PROPS = [
"button", "buttons", "clientX", "clientY", "layerX",
"layerY", "offsetX", "offsetY", "pageX", "pageY",
"screenX", "screenY", "toElement"
]
var rkeyEvent = /^key|input/
var rmouseEvent = /^(?:mouse|pointer|contextmenu)|click/
module.exports = ProxyEvent
function ProxyEvent(ev) {
if (!(this instanceof ProxyEvent)) {
return new ProxyEvent(ev)
}
if (rkeyEvent.test(ev.type)) {
return new KeyEvent(ev)
} else if (rmouseEvent.test(ev.type)) {
return new MouseEvent(ev)
}
for (var i = 0; i < ALL_PROPS.length; i++) {
var propKey = ALL_PROPS[i]
this[propKey] = ev[propKey]
}
this._rawEvent = ev
this._bubbles = false;
}
ProxyEvent.prototype.preventDefault = function () {
this._rawEvent.preventDefault()
}
ProxyEvent.prototype.startPropagation = function () {
this._bubbles = true;
}
function MouseEvent(ev) {
for (var i = 0; i < ALL_PROPS.length; i++) {
var propKey = ALL_PROPS[i]
this[propKey] = ev[propKey]
}
for (var j = 0; j < MOUSE_PROPS.length; j++) {
var mousePropKey = MOUSE_PROPS[j]
this[mousePropKey] = ev[mousePropKey]
}
this._rawEvent = ev
}
inherits(MouseEvent, ProxyEvent)
function KeyEvent(ev) {
for (var i = 0; i < ALL_PROPS.length; i++) {
var propKey = ALL_PROPS[i]
this[propKey] = ev[propKey]
}
for (var j = 0; j < KEY_PROPS.length; j++) {
var keyPropKey = KEY_PROPS[j]
this[keyPropKey] = ev[keyPropKey]
}
this._rawEvent = ev
}
inherits(KeyEvent, ProxyEvent)
},{"inherits":12}],16:[function(require,module,exports){
var DataSet = require("data-set")
module.exports = removeEvent
function removeEvent(target, type, handler) {
var ds = DataSet(target)
var events = ds[type]
if (!events) {
return
} else if (Array.isArray(events)) {
var index = events.indexOf(handler)
if (index !== -1) {
events.splice(index, 1)
}
} else if (events === handler) {
ds[type] = null
}
}
},{"data-set":2}],17:[function(require,module,exports){
var isObject = require("is-object")
var isHook = require("vtree/is-vhook")
module.exports = applyProperties
function applyProperties(node, props, previous) {
for (var propName in props) {
var propValue = props[propName]
if (propValue === undefined) {
removeProperty(node, props, previous, propName);
} else if (isHook(propValue)) {
propValue.hook(node,
propName,
previous ? previous[propName] : undefined)
} else {
if (isObject(propValue)) {
patchObject(node, props, previous, propName, propValue);
} else if (propValue !== undefined) {
node[propName] = propValue
}
}
}
}
function removeProperty(node, props, previous, propName) {
if (previous) {
var previousValue = previous[propName]
if (!isHook(previousValue)) {
if (propName === "attributes") {
for (var attrName in previousValue) {
node.removeAttribute(attrName)
}
} else if (propName === "style") {
for (var i in previousValue) {
node.style[i] = ""
}
} else if (typeof previousValue === "string") {
node[propName] = ""
} else {
node[propName] = null
}
}
}
}
function patchObject(node, props, previous, propName, propValue) {
var previousValue = previous ? previous[propName] : undefined
// Set attributes
if (propName === "attributes") {
for (var attrName in propValue) {
var attrValue = propValue[attrName]
if (attrValue === undefined) {
node.removeAttribute(attrName)
} else {
node.setAttribute(attrName, attrValue)
}
}
return
}
if(previousValue && isObject(previousValue) &&
getPrototype(previousValue) !== getPrototype(propValue)) {
node[propName] = propValue
return
}
if (!isObject(node[propName])) {
node[propName] = {}
}
var replacer = propName === "style" ? "" : undefined
for (var k in propValue) {
var value = propValue[k]
node[propName][k] = (value === undefined) ? replacer : value
}
}
function getPrototype(value) {
if (Object.getPrototypeOf) {
return Object.getPrototypeOf(value)
} else if (value.__proto__) {
return value.__proto__
} else if (value.constructor) {
return value.constructor.prototype
}
}
},{"is-object":21,"vtree/is-vhook":29}],18:[function(require,module,exports){
var document = require("global/document")
var applyProperties = require("./apply-properties")
var isVNode = require("vtree/is-vnode")
var isVText = require("vtree/is-vtext")
var isWidget = require("vtree/is-widget")
var handleThunk = require("vtree/handle-thunk")
module.exports = createElement
function createElement(vnode, opts) {
var doc = opts ? opts.document || document : document
var warn = opts ? opts.warn : null
vnode = handleThunk(vnode).a
if (isWidget(vnode)) {
return vnode.init()
} else if (isVText(vnode)) {
return doc.createTextNode(vnode.text)
} else if (!isVNode(vnode)) {
if (warn) {
warn("Item is not a valid virtual dom node", vnode)
}
return null
}
var node = (vnode.namespace === null) ?
doc.createElement(vnode.tagName) :
doc.createElementNS(vnode.namespace, vnode.tagName)
var props = vnode.properties
applyProperties(node, props)
var children = vnode.children
for (var i = 0; i < children.length; i++) {
var childNode = createElement(children[i], opts)
if (childNode) {
node.appendChild(childNode)
}
}
return node
}
},{"./apply-properties":17,"global/document":20,"vtree/handle-thunk":27,"vtree/is-vnode":30,"vtree/is-vtext":31,"vtree/is-widget":32}],19:[function(require,module,exports){
// Maps a virtual DOM tree onto a real DOM tree in an efficient manner.
// We don't want to read all of the DOM nodes in the tree so we use
// the in-order tree indexing to eliminate recursion down certain branches.
// We only recurse into a DOM node if we know that it contains a child of
// interest.
var noChild = {}
module.exports = domIndex
function domIndex(rootNode, tree, indices, nodes) {
if (!indices || indices.length === 0) {
return {}
} else {
indices.sort(ascending)
return recurse(rootNode, tree, indices, nodes, 0)
}
}
function recurse(rootNode, tree, indices, nodes, rootIndex) {
nodes = nodes || {}
if (rootNode) {
if (indexInRange(indices, rootIndex, rootIndex)) {
nodes[rootIndex] = rootNode
}
var vChildren = tree.children
if (vChildren) {
var childNodes = rootNode.childNodes
for (var i = 0; i < tree.children.length; i++) {
rootIndex += 1
var vChild = vChildren[i] || noChild
var nextIndex = rootIndex + (vChild.count || 0)
// skip recursion down the tree if there are no nodes down here
if (indexInRange(indices, rootIndex, nextIndex)) {
recurse(childNodes[i], vChild, indices, nodes, rootIndex)
}
rootIndex = nextIndex
}
}
}
return nodes
}
// Binary search for an index in the interval [left, right]
function indexInRange(indices, left, right) {
if (indices.length === 0) {
return false
}
var minIndex = 0
var maxIndex = indices.length - 1
var currentIndex
var currentItem
while (minIndex <= maxIndex) {
currentIndex = ((maxIndex + minIndex) / 2) >> 0
currentItem = indices[currentIndex]
if (minIndex === maxIndex) {
return currentItem >= left && currentItem <= right
} else if (currentItem < left) {
minIndex = currentIndex + 1
} else if (currentItem > right) {
maxIndex = currentIndex - 1
} else {
return true
}
}
return false;
}
function ascending(a, b) {
return a > b ? 1 : -1
}
},{}],20:[function(require,module,exports){
module.exports=require(10)
},{"min-document":40}],21:[function(require,module,exports){
module.exports = isObject
function isObject(x) {
return typeof x === "object" && x !== null
}
},{}],22:[function(require,module,exports){
var nativeIsArray = Array.isArray
var toString = Object.prototype.toString
module.exports = nativeIsArray || isArray
function isArray(obj) {
return toString.call(obj) === "[object Array]"
}
},{}],23:[function(require,module,exports){
var applyProperties = require("./apply-properties")
var isWidget = require("vtree/is-widget")
var VPatch = require("vtree/vpatch")
var render = require("./create-element")
var updateWidget = require("./update-widget")
module.exports = applyPatch
function applyPatch(vpatch, domNode, renderOptions) {
var type = vpatch.type
var vNode = vpatch.vNode
var patch = vpatch.patch
switch (type) {
case VPatch.REMOVE:
return removeNode(domNode, vNode)
case VPatch.INSERT:
return insertNode(domNode, patch, renderOptions)
case VPatch.VTEXT:
return stringPatch(domNode, vNode, patch, renderOptions)
case VPatch.WIDGET:
return widgetPatch(domNode, vNode, patch, renderOptions)
case VPatch.VNODE:
return vNodePatch(domNode, vNode, patch, renderOptions)
case VPatch.ORDER:
reorderChildren(domNode, patch)
return domNode
case VPatch.PROPS:
applyProperties(domNode, patch, vNode.properties)
return domNode
case VPatch.THUNK:
return replaceRoot(domNode,
renderOptions.patch(domNode, patch, renderOptions))
default:
return domNode
}
}
function removeNode(domNode, vNode) {
var parentNode = domNode.parentNode
if (parentNode) {
parentNode.removeChild(domNode)
}
destroyWidget(domNode, vNode);
return null
}
function insertNode(parentNode, vNode, renderOptions) {
var newNode = render(vNode, renderOptions)
if (parentNode) {
parentNode.appendChild(newNode)
}
return parentNode
}
function stringPatch(domNode, leftVNode, vText, renderOptions) {
var newNode
if (domNode.nodeType === 3) {
domNode.replaceData(0, domNode.length, vText.text)
newNode = domNode
} else {
var parentNode = domNode.parentNode
newNode = render(vText, renderOptions)
if (parentNode) {
parentNode.replaceChild(newNode, domNode)
}
}
destroyWidget(domNode, leftVNode)
return newNode
}
function widgetPatch(domNode, leftVNode, widget, renderOptions) {
if (updateWidget(leftVNode, widget)) {
return widget.update(leftVNode, domNode) || domNode
}
var parentNode = domNode.parentNode
var newWidget = render(widget, renderOptions)
if (parentNode) {
parentNode.replaceChild(newWidget, domNode)
}
destroyWidget(domNode, leftVNode)
return newWidget
}
function vNodePatch(domNode, leftVNode, vNode, renderOptions) {
var parentNode = domNode.parentNode
var newNode = render(vNode, renderOptions)
if (parentNode) {
parentNode.replaceChild(newNode, domNode)
}
destroyWidget(domNode, leftVNode)
return newNode
}
function destroyWidget(domNode, w) {
if (typeof w.destroy === "function" && isWidget(w)) {
w.destroy(domNode)
}
}
function reorderChildren(domNode, bIndex) {
var children = []
var childNodes = domNode.childNodes
var len = childNodes.length
var i
var reverseIndex = bIndex.reverse
for (i = 0; i < len; i++) {
children.push(domNode.childNodes[i])
}
var insertOffset = 0
var move
var node
var insertNode
for (i = 0; i < len; i++) {
move = bIndex[i]
if (move !== undefined && move !== i) {
// the element currently at this index will be moved later so increase the insert offset
if (reverseIndex[i] > i) {
insertOffset++
}
node = children[move]
insertNode = childNodes[i + insertOffset] || null
if (node !== insertNode) {
domNode.insertBefore(node, insertNode)
}
// the moved element came from the front of the array so reduce the insert offset
if (move < i) {
insertOffset--
}
}
// element at this index is scheduled to be removed so increase insert offset
if (i in bIndex.removes) {
insertOffset++
}
}
}
function replaceRoot(oldRoot, newRoot) {
if (oldRoot && newRoot && oldRoot !== newRoot && oldRoot.parentNode) {
console.log(oldRoot)
oldRoot.parentNode.replaceChild(newRoot, oldRoot)
}
return newRoot;
}
},{"./apply-properties":17,"./create-element":18,"./update-widget":25,"vtree/is-widget":32,"vtree/vpatch":37}],24:[function(require,module,exports){
var document = require("global/document")
var isArray = require("x-is-array")
var domIndex = require("./dom-index")
var patchOp = require("./patch-op")
module.exports = patch
function patch(rootNode, patches) {
return patchRecursive(rootNode, patches)
}
function patchRecursive(rootNode, patches, renderOptions) {
var indices = patchIndices(patches)
if (indices.length === 0) {
return rootNode
}
var index = domIndex(rootNode, patches.a, indices)
var ownerDocument = rootNode.ownerDocument
if (!renderOptions) {
renderOptions = { patch: patchRecursive }
if (ownerDocument !== document) {
renderOptions.document = ownerDocument
}
}
for (var i = 0; i < indices.length; i++) {
var nodeIndex = indices[i]
rootNode = applyPatch(rootNode,
index[nodeIndex],
patches[nodeIndex],
renderOptions)
}
return rootNode
}
function applyPatch(rootNode, domNode, patchList, renderOptions) {
if (!domNode) {
return rootNode
}
var newNode
if (isArray(patchList)) {
for (var i = 0; i < patchList.length; i++) {
newNode = patchOp(patchList[i], domNode, renderOptions)
if (domNode === rootNode) {
rootNode = newNode
}
}
} else {
newNode = patchOp(patchList, domNode, renderOptions)
if (domNode === rootNode) {
rootNode = newNode
}
}
return rootNode
}
function patchIndices(patches) {
var indices = []
for (var key in patches) {
if (key !== "a") {
indices.push(Number(key))
}
}
return indices
}
},{"./dom-index":19,"./patch-op":23,"global/document":20,"x-is-array":22}],25:[function(require,module,exports){
var isWidget = require("vtree/is-widget")
module.exports = updateWidget
function updateWidget(a, b) {
if (isWidget(a) && isWidget(b)) {
if ("name" in a && "name" in b) {
return a.id === b.id
} else {
return a.init === b.init
}
}
return false
}
},{"vtree/is-widget":32}],26:[function(require,module,exports){
var isArray = require("x-is-array")
var isObject = require("is-object")
var VPatch = require("./vpatch")
var isVNode = require("./is-vnode")
var isVText = require("./is-vtext")
var isWidget = require("./is-widget")
var isThunk = require("./is-thunk")
var handleThunk = require("./handle-thunk")
module.exports = diff
function diff(a, b) {
var patch = { a: a }
walk(a, b, patch, 0)
return patch
}
function walk(a, b, patch, index) {
if (a === b) {
if (isThunk(a) || isThunk(b)) {
thunks(a, b, patch, index)
} else {
hooks(b, patch, index)
}
return
}
var apply = patch[index]
if (b == null) {
apply = appendPatch(apply, new VPatch(VPatch.REMOVE, a, b))
destroyWidgets(a, patch, index)
} else if (isThunk(a) || isThunk(b)) {
thunks(a, b, patch, index)
} else if (isVNode(b)) {
if (isVNode(a)) {
if (a.tagName === b.tagName &&
a.namespace === b.namespace &&
a.key === b.key) {
var propsPatch = diffProps(a.properties, b.properties, b.hooks)
if (propsPatch) {
apply = appendPatch(apply,
new VPatch(VPatch.PROPS, a, propsPatch))
}
apply = diffChildren(a, b, patch, apply, index)
} else {
apply = appendPatch(apply, new VPatch(VPatch.VNODE, a, b))
destroyWidgets(a, patch, index)
}
} else {
apply = appendPatch(apply, new VPatch(VPatch.VNODE, a, b))
destroyWidgets(a, patch, index)
}
} else if (isVText(b)) {
if (!isVText(a)) {
apply = appendPatch(apply, new VPatch(VPatch.VTEXT, a, b))
destroyWidgets(a, patch, index)
} else if (a.text !== b.text) {
apply = appendPatch(apply, new VPatch(VPatch.VTEXT, a, b))
}
} else if (isWidget(b)) {
apply = appendPatch(apply, new VPatch(VPatch.WIDGET, a, b))
if (!isWidget(a)) {
destroyWidgets(a, patch, index)
}
}
if (apply) {
patch[index] = apply
}
}
function diffProps(a, b, hooks) {
var diff
for (var aKey in a) {
if (!(aKey in b)) {
diff = diff || {}
diff[aKey] = undefined
}
var aValue = a[aKey]
var bValue = b[aKey]
if (hooks && aKey in hooks) {
diff = diff || {}
diff[aKey] = bValue
} else {
if (isObject(aValue) && isObject(bValue)) {
if (getPrototype(bValue) !== getPrototype(aValue)) {
diff = diff || {}
diff[aKey] = bValue
} else {
var objectDiff = diffProps(aValue, bValue)
if (objectDiff) {
diff = diff || {}
diff[aKey] = objectDiff
}
}
} else if (aValue !== bValue) {
diff = diff || {}
diff[aKey] = bValue
}
}
}
for (var bKey in b) {
if (!(bKey in a)) {
diff = diff || {}
diff[bKey] = b[bKey]
}
}
return diff
}
function getPrototype(value) {
if (Object.getPrototypeOf) {
return Object.getPrototypeOf(value)
} else if (value.__proto__) {
return value.__proto__
} else if (value.constructor) {
return value.constructor.prototype
}
}
function diffChildren(a, b, patch, apply, index) {
var aChildren = a.children
var bChildren = reorder(aChildren, b.children)
var aLen = aChildren.length
var bLen = bChildren.length
var len = aLen > bLen ? aLen : bLen
for (var i = 0; i < len; i++) {
var leftNode = aChildren[i]
var rightNode = bChildren[i]
index += 1
if (!leftNode) {
if (rightNode) {
// Excess nodes in b need to be added
apply = appendPatch(apply,
new VPatch(VPatch.INSERT, null, rightNode))
}
} else if (!rightNode) {
if (leftNode) {
// Excess nodes in a need to be removed
patch[index] = new VPatch(VPatch.REMOVE, leftNode, null)
destroyWidgets(leftNode, patch, index)
}
} else {
walk(leftNode, rightNode, patch, index)
}
if (isVNode(leftNode) && leftNode.count) {
index += leftNode.count
}
}
if (bChildren.moves) {
// Reorder nodes last
apply = appendPatch(apply, new VPatch(VPatch.ORDER, a, bChildren.moves))
}
return apply
}
// Patch records for all destroyed widgets must be added because we need
// a DOM node reference for the destroy function
function destroyWidgets(vNode, patch, index) {
if (isWidget(vNode)) {
if (typeof vNode.destroy === "function") {
patch[index] = new VPatch(VPatch.REMOVE, vNode, null)
}
} else if (isVNode(vNode) && vNode.hasWidgets) {
var children = vNode.children
var len = children.length
for (var i = 0; i < len; i++) {
var child = children[i]
index += 1
destroyWidgets(child, patch, index)
if (isVNode(child) && child.count) {
index += child.count
}
}
}
}
// Create a sub-patch for thunks
function thunks(a, b, patch, index) {
var nodes = handleThunk(a, b);
var thunkPatch = diff(nodes.a, nodes.b)
if (hasPatches(thunkPatch)) {
patch[index] = new VPatch(VPatch.THUNK, null, thunkPatch)
}
}
function hasPatches(patch) {
for (var index in patch) {
if (index !== "a") {
return true;
}
}
return false;
}
// Execute hooks when two nodes are identical
function hooks(vNode, patch, index) {
if (isVNode(vNode)) {
if (vNode.hooks) {
patch[index] = new VPatch(VPatch.PROPS, vNode.hooks, vNode.hooks)
}
if (vNode.descendantHooks) {
var children = vNode.children
var len = children.length
for (var i = 0; i < len; i++) {
var child = children[i]
index += 1
hooks(child, patch, index)
if (isVNode(child) && child.count) {
index += child.count
}
}
}
}
}
// List diff, naive left to right reordering
function reorder(aChildren, bChildren) {
var bKeys = keyIndex(bChildren)
if (!bKeys) {
return bChildren
}
var aKeys = keyIndex(aChildren)
if (!aKeys) {
return bChildren
}
var bMatch = {}, aMatch = {}
for (var key in bKeys) {
bMatch[bKeys[key]] = aKeys[key]
}
for (var key in aKeys) {
aMatch[aKeys[key]] = bKeys[key]
}
var aLen = aChildren.length
var bLen = bChildren.length
var len = aLen > bLen ? aLen : bLen
var shuffle = []
var freeIndex = 0
var i = 0
var moveIndex = 0
var moves = {}
var removes = moves.removes = {}
var reverse = moves.reverse = {}
var hasMoves = false
while (freeIndex < len) {
var move = aMatch[i]
if (move !== undefined) {
shuffle[i] = bChildren[move]
if (move !== moveIndex) {
moves[move] = moveIndex
reverse[moveIndex] = move
hasMoves = true
}
moveIndex++
} else if (i in aMatch) {
shuffle[i] = undefined
removes[i] = moveIndex++
hasMoves = true
} else {
while (bMatch[freeIndex] !== undefined) {
freeIndex++
}
if (freeIndex < len) {
var freeChild = bChildren[freeIndex]
if (freeChild) {
shuffle[i] = freeChild
if (freeIndex !== moveIndex) {
hasMoves = true
moves[freeIndex] = moveIndex
reverse[moveIndex] = freeIndex
}
moveIndex++
}
freeIndex++
}
}
i++
}
if (hasMoves) {
shuffle.moves = moves
}
return shuffle
}
function keyIndex(children) {
var i, keys
for (i = 0; i < children.length; i++) {
var child = children[i]
if (child.key !== undefined) {
keys = keys || {}
keys[child.key] = i
}
}
return keys
}
function appendPatch(apply, patch) {
if (apply) {
if (isArray(apply)) {
apply.push(patch)
} else {
apply = [apply, patch]
}
return apply
} else {
return patch
}
}
},{"./handle-thunk":27,"./is-thunk":28,"./is-vnode":30,"./is-vtext":31,"./is-widget":32,"./vpatch":37,"is-object":33,"x-is-array":34}],27:[function(require,module,exports){
var isVNode = require("./is-vnode")
var isVText = require("./is-vtext")
var isWidget = require("./is-widget")
var isThunk = require("./is-thunk")
module.exports = handleThunk
function handleThunk(a, b) {
var renderedA = a
var renderedB = b
if (isThunk(b)) {
renderedB = renderThunk(b, a)
}
if (isThunk(a)) {
renderedA = renderThunk(a, null)
}
return {
a: renderedA,
b: renderedB
}
}
function renderThunk(thunk, previous) {
var renderedThunk = thunk.vnode
if (!renderedThunk) {
renderedThunk = thunk.vnode = thunk.render(previous)
}
if (!(isVNode(renderedThunk) ||
isVText(renderedThunk) ||
isWidget(renderedThunk))) {
throw new Error("thunk did not return a valid node");
}
return renderedThunk
}
},{"./is-thunk":28,"./is-vnode":30,"./is-vtext":31,"./is-widget":32}],28:[function(require,module,exports){
module.exports = isThunk
function isThunk(t) {
return t && t.type === "Thunk"
}
},{}],29:[function(require,module,exports){
module.exports = isHook
function isHook(hook) {
return hook && typeof hook.hook === "function" &&
!hook.hasOwnProperty("hook")
}
},{}],30:[function(require,module,exports){
var version = require("./version")
module.exports = isVirtualNode
function isVirtualNode(x) {
return x && x.type === "VirtualNode" && x.version === version
}
},{"./version":35}],31:[function(require,module,exports){
var version = require("./version")
module.exports = isVirtualText
function isVirtualText(x) {
return x && x.type === "VirtualText" && x.version === version
}
},{"./version":35}],32:[function(require,module,exports){
module.exports = isWidget
function isWidget(w) {
return w && w.type === "Widget"
}
},{}],33:[function(require,module,exports){
module.exports=require(21)
},{}],34:[function(require,module,exports){
module.exports=require(22)
},{}],35:[function(require,module,exports){
module.exports = "1"
},{}],36:[function(require,module,exports){
var version = require("./version")
var isVNode = require("./is-vnode")
var isWidget = require("./is-widget")
var isVHook = require("./is-vhook")
module.exports = VirtualNode
var noProperties = {}
var noChildren = []
function VirtualNode(tagName, properties, children, key, namespace) {
this.tagName = tagName
this.properties = properties || noProperties
this.children = children || noChildren
this.key = key != null ? String(key) : undefined
this.namespace = (typeof namespace === "string") ? namespace : null
var count = (children && children.length) || 0
var descendants = 0
var hasWidgets = false
var descendantHooks = false
var hooks
for (var propName in properties) {
if (properties.hasOwnProperty(propName)) {
var property = properties[propName]
if (isVHook(property)) {
if (!hooks) {
hooks = {}
}
hooks[propName] = property
}
}
}
for (var i = 0; i < count; i++) {
var child = children[i]
if (isVNode(child)) {
descendants += child.count || 0
if (!hasWidgets && child.hasWidgets) {
hasWidgets = true
}
if (!descendantHooks && (child.hooks || child.descendantHooks)) {
descendantHooks = true
}
} else if (!hasWidgets && isWidget(child)) {
if (typeof child.destroy === "function") {
hasWidgets = true
}
}
}
this.count = count + descendants
this.hasWidgets = hasWidgets
this.hooks = hooks
this.descendantHooks = descendantHooks
}
VirtualNode.prototype.version = version
VirtualNode.prototype.type = "VirtualNode"
},{"./is-vhook":29,"./is-vnode":30,"./is-widget":32,"./version":35}],37:[function(require,module,exports){
var version = require("./version")
VirtualPatch.NONE = 0
VirtualPatch.VTEXT = 1
VirtualPatch.VNODE = 2
VirtualPatch.WIDGET = 3
VirtualPatch.PROPS = 4
VirtualPatch.ORDER = 5
VirtualPatch.INSERT = 6
VirtualPatch.REMOVE = 7
VirtualPatch.THUNK = 8
module.exports = VirtualPatch
function VirtualPatch(type, vNode, patch) {
this.type = Number(type)
this.vNode = vNode
this.patch = patch
}
VirtualPatch.prototype.version = version
VirtualPatch.prototype.type = "VirtualPatch"
},{"./version":35}],38:[function(require,module,exports){
var version = require("./version")
module.exports = VirtualText
function VirtualText(text) {
this.text = String(text)
}
VirtualText.prototype.version = version
VirtualText.prototype.type = "VirtualText"
},{"./version":35}],39:[function(require,module,exports){
var VNode = require('vtree/vnode');
var VText = require('vtree/vtext');
var diff = require('vtree/diff');
var patch = require('vdom/patch');
var createElement = require('vdom/create-element');
var DataSet = require("data-set");
var Delegator = require("dom-delegator");
var isHook = require("vtree/is-vhook");
Elm.Native.VirtualDom = {};
Elm.Native.VirtualDom.make = function(elm)
{
elm.Native = elm.Native || {};
elm.Native.VirtualDom = elm.Native.VirtualDom || {};
if (elm.Native.VirtualDom.values)
{
return elm.Native.VirtualDom.values;
}
// This manages event listeners. Somehow...
// Save a reference for use in on(...)
var delegator = Delegator();
var Element = Elm.Native.Graphics.Element.make(elm);
var Json = Elm.Native.Json.make(elm);
var List = Elm.Native.List.make(elm);
var Signal = Elm.Native.Signal.make(elm);
var Utils = Elm.Native.Utils.make(elm);
var ATTRIBUTE_KEY = 'UniqueNameThatOthersAreVeryUnlikelyToUse';
function listToProperties(list)
{
var object = {};
while (list.ctor !== '[]')
{
var entry = list._0;
if (entry.key === ATTRIBUTE_KEY)
{
object.attributes = object.attributes || {};
object.attributes[entry.value.attrKey] = entry.value.attrValue;
}
else
{
object[entry.key] = entry.value;
}
list = list._1;
}
return object;
}
function node(name, propertyList, contents)
{
var props = listToProperties(propertyList);
var key, namespace;
// support keys
if (props.key !== undefined)
{
key = props.key;
props.key = undefined;
}
// support namespace
if (props.namespace !== undefined)
{
namespace = props.namespace;
props.namespace = undefined;
}
// ensure that setting text of an input does not move the cursor
var useSoftSet =
name === 'input'
&& props.value !== undefined
&& !isHook(props.value);
if (useSoftSet)
{
props.value = SoftSetHook(props.value);
}
return new VNode(name, props, List.toArray(contents), key, namespace);
}
function property(key, value)
{
return {
key: key,
value: value
};
}
function attribute(key, value)
{
return {
key: ATTRIBUTE_KEY,
value: {
attrKey: key,
attrValue: value
}
};
}
function on(name, decoder, createMessage)
{
// Ensure we're listening for this type of event
delegator.listenTo(name);
function eventHandler(event)
{
var value = A2(Json.runDecoderValue, decoder, event);
if (value.ctor === 'Ok')
{
Signal.sendMessage(createMessage(value._0));
}
}
return property(name, DataSetHook(eventHandler));
}
function DataSetHook(value)
{
if (!(this instanceof DataSetHook))
{
return new DataSetHook(value);
}
this.value = value;
}
DataSetHook.prototype.hook = function (node, propertyName) {
var ds = DataSet(node);
ds[propertyName] = this.value;
};
function SoftSetHook(value)
{
if (!(this instanceof SoftSetHook))
{
return new SoftSetHook(value);
}
this.value = value;
}
SoftSetHook.prototype.hook = function (node, propertyName)
{
if (node[propertyName] !== this.value)
{
node[propertyName] = this.value;
}
};
function text(string)
{
return new VText(string);
}
function fromElement(element)
{
return {
type: "Widget",
element: element,
init: function () {
return Element.render(element);
},
update: function (previous, node) {
return Element.update(node, previous.element, element);
}
};
}
function toElement(width, height, html)
{
return A3(Element.newElement, width, height, {
ctor: 'Custom',
type: 'evancz/elm-html',
render: render,
update: update,
model: html
});
}
function render(model)
{
var element = Element.createNode('div');
element.appendChild(createElement(model));
return element;
}
function update(node, oldModel, newModel)
{
updateAndReplace(node.firstChild, oldModel, newModel);
return node;
}
function updateAndReplace(node, oldModel, newModel)
{
var patches = diff(oldModel, newModel);
var newNode = patch(node, patches);
return newNode;
}
function lazyRef(fn, a)
{
function thunk()
{
return fn(a);
}
return new Thunk(fn, [a], thunk);
}
function lazyRef2(fn, a, b)
{
function thunk()
{
return A2(fn, a, b);
}
return new Thunk(fn, [a,b], thunk);
}
function lazyRef3(fn, a, b, c)
{
function thunk()
{
return A3(fn, a, b, c);
}
return new Thunk(fn, [a,b,c], thunk);
}
function Thunk(fn, args, thunk)
{
this.fn = fn;
this.args = args;
this.vnode = null;
this.key = undefined;
this.thunk = thunk;
}
Thunk.prototype.type = "Thunk";
Thunk.prototype.update = updateThunk;
Thunk.prototype.render = renderThunk;
function shouldUpdate(current, previous)
{
if (current.fn !== previous.fn)
{
return true;
}
// if it's the same function, we know the number of args must match
var cargs = current.args;
var pargs = previous.args;
for (var i = cargs.length; i--; )
{
if (cargs[i] !== pargs[i])
{
return true;
}
}
return false;
}
function updateThunk(previous, domNode)
{
if (!shouldUpdate(this, previous))
{
this.vnode = previous.vnode;
return;
}
if (!this.vnode)
{
this.vnode = this.thunk();
}
var patches = diff(previous.vnode, this.vnode);
patch(domNode, patches);
}
function renderThunk()
{
return this.thunk();
}
return Elm.Native.VirtualDom.values = {
node: F3(node),
text: text,
on: F3(on),
property: F2(property),
attribute: F2(attribute),
lazy: F2(lazyRef),
lazy2: F3(lazyRef2),
lazy3: F4(lazyRef3),
toElement: F3(toElement),
fromElement: fromElement,
render: createElement,
updateAndReplace: updateAndReplace
};
};
},{"data-set":2,"dom-delegator":8,"vdom/create-element":18,"vdom/patch":24,"vtree/diff":26,"vtree/is-vhook":29,"vtree/vnode":36,"vtree/vtext":38}],40:[function(require,module,exports){
},{}]},{},[39]);
Elm.Native = Elm.Native || {};
Elm.Native.Window = {};
Elm.Native.Window.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Window = localRuntime.Native.Window || {};
if (localRuntime.Native.Window.values)
{
return localRuntime.Native.Window.values;
}
var NS = Elm.Native.Signal.make(localRuntime);
var Tuple2 = Elm.Native.Utils.make(localRuntime).Tuple2;
function getWidth()
{
return localRuntime.node.clientWidth;
}
function getHeight()
{
if (localRuntime.isFullscreen())
{
return window.innerHeight;
}
return localRuntime.node.clientHeight;
}
var dimensions = NS.input('Window.dimensions', Tuple2(getWidth(), getHeight()));
function resizeIfNeeded()
{
// Do not trigger event if the dimensions have not changed.
// This should be most of the time.
var w = getWidth();
var h = getHeight();
if (dimensions.value._0 === w && dimensions.value._1 === h)
{
return;
}
setTimeout(function () {
// Check again to see if the dimensions have changed.
// It is conceivable that the dimensions have changed
// again while some other event was being processed.
var w = getWidth();
var h = getHeight();
if (dimensions.value._0 === w && dimensions.value._1 === h)
{
return;
}
localRuntime.notify(dimensions.id, Tuple2(w,h));
}, 0);
}
localRuntime.addListener([dimensions.id], window, 'resize', resizeIfNeeded);
return localRuntime.Native.Window.values = {
dimensions: dimensions,
resizeIfNeeded: resizeIfNeeded
};
};
Elm.Result = Elm.Result || {};
Elm.Result.make = function (_elm) {
"use strict";
_elm.Result = _elm.Result || {};
if (_elm.Result.values)
return _elm.Result.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Result",
$Maybe = Elm.Maybe.make(_elm);
var toMaybe = function (result) {
return function () {
switch (result.ctor)
{case "Err":
return $Maybe.Nothing;
case "Ok":
return $Maybe.Just(result._0);}
_U.badCase($moduleName,
"between lines 164 and 177");
}();
};
var Err = function (a) {
return {ctor: "Err",_0: a};
};
var andThen = F2(function (result,
callback) {
return function () {
switch (result.ctor)
{case "Err":
return Err(result._0);
case "Ok":
return callback(result._0);}
_U.badCase($moduleName,
"between lines 126 and 145");
}();
});
var Ok = function (a) {
return {ctor: "Ok",_0: a};
};
var map = F2(function (func,
ra) {
return function () {
switch (ra.ctor)
{case "Err": return Err(ra._0);
case "Ok":
return Ok(func(ra._0));}
_U.badCase($moduleName,
"between lines 41 and 52");
}();
});
var map2 = F3(function (func,
ra,
rb) {
return function () {
var _v9 = {ctor: "_Tuple2"
,_0: ra
,_1: rb};
switch (_v9.ctor)
{case "_Tuple2":
switch (_v9._0.ctor)
{case "Err":
return Err(_v9._0._0);
case "Ok": switch (_v9._1.ctor)
{case "Ok": return Ok(A2(func,
_v9._0._0,
_v9._1._0));}
break;}
switch (_v9._1.ctor)
{case "Err":
return Err(_v9._1._0);}
break;}
_U.badCase($moduleName,
"between lines 55 and 58");
}();
});
var map3 = F4(function (func,
ra,
rb,
rc) {
return function () {
var _v16 = {ctor: "_Tuple3"
,_0: ra
,_1: rb
,_2: rc};
switch (_v16.ctor)
{case "_Tuple3":
switch (_v16._0.ctor)
{case "Err":
return Err(_v16._0._0);
case "Ok": switch (_v16._1.ctor)
{case "Ok":
switch (_v16._2.ctor)
{case "Ok": return Ok(A3(func,
_v16._0._0,
_v16._1._0,
_v16._2._0));}
break;}
break;}
switch (_v16._1.ctor)
{case "Err":
return Err(_v16._1._0);}
switch (_v16._2.ctor)
{case "Err":
return Err(_v16._2._0);}
break;}
_U.badCase($moduleName,
"between lines 63 and 67");
}();
});
var map4 = F5(function (func,
ra,
rb,
rc,
rd) {
return function () {
var _v26 = {ctor: "_Tuple4"
,_0: ra
,_1: rb
,_2: rc
,_3: rd};
switch (_v26.ctor)
{case "_Tuple4":
switch (_v26._0.ctor)
{case "Err":
return Err(_v26._0._0);
case "Ok": switch (_v26._1.ctor)
{case "Ok":
switch (_v26._2.ctor)
{case "Ok":
switch (_v26._3.ctor)
{case "Ok": return Ok(A4(func,
_v26._0._0,
_v26._1._0,
_v26._2._0,
_v26._3._0));}
break;}
break;}
break;}
switch (_v26._1.ctor)
{case "Err":
return Err(_v26._1._0);}
switch (_v26._2.ctor)
{case "Err":
return Err(_v26._2._0);}
switch (_v26._3.ctor)
{case "Err":
return Err(_v26._3._0);}
break;}
_U.badCase($moduleName,
"between lines 72 and 77");
}();
});
var map5 = F6(function (func,
ra,
rb,
rc,
rd,
re) {
return function () {
var _v39 = {ctor: "_Tuple5"
,_0: ra
,_1: rb
,_2: rc
,_3: rd
,_4: re};
switch (_v39.ctor)
{case "_Tuple5":
switch (_v39._0.ctor)
{case "Err":
return Err(_v39._0._0);
case "Ok": switch (_v39._1.ctor)
{case "Ok":
switch (_v39._2.ctor)
{case "Ok":
switch (_v39._3.ctor)
{case "Ok":
switch (_v39._4.ctor)
{case "Ok": return Ok(A5(func,
_v39._0._0,
_v39._1._0,
_v39._2._0,
_v39._3._0,
_v39._4._0));}
break;}
break;}
break;}
break;}
switch (_v39._1.ctor)
{case "Err":
return Err(_v39._1._0);}
switch (_v39._2.ctor)
{case "Err":
return Err(_v39._2._0);}
switch (_v39._3.ctor)
{case "Err":
return Err(_v39._3._0);}
switch (_v39._4.ctor)
{case "Err":
return Err(_v39._4._0);}
break;}
_U.badCase($moduleName,
"between lines 82 and 123");
}();
});
var formatError = F2(function (f,
result) {
return function () {
switch (result.ctor)
{case "Err":
return Err(f(result._0));
case "Ok":
return Ok(result._0);}
_U.badCase($moduleName,
"between lines 148 and 161");
}();
});
var fromMaybe = F2(function (err,
maybe) {
return function () {
switch (maybe.ctor)
{case "Just":
return Ok(maybe._0);
case "Nothing":
return Err(err);}
_U.badCase($moduleName,
"between lines 180 and 182");
}();
});
_elm.Result.values = {_op: _op
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,andThen: andThen
,toMaybe: toMaybe
,fromMaybe: fromMaybe
,formatError: formatError
,Ok: Ok
,Err: Err};
return _elm.Result.values;
};
Elm.Sha = Elm.Sha || {};
Elm.Sha.make = function (_elm) {
"use strict";
_elm.Sha = _elm.Sha || {};
if (_elm.Sha.values)
return _elm.Sha.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Sha",
$Native$Sha = Elm.Native.Sha.make(_elm);
var digest = $Native$Sha.digest;
var update = $Native$Sha.update;
var createHash = $Native$Sha.createHash;
var Hash = {ctor: "Hash"};
_elm.Sha.values = {_op: _op
,Hash: Hash
,createHash: createHash
,update: update
,digest: digest};
return _elm.Sha.values;
};
Elm.Signal = Elm.Signal || {};
Elm.Signal.make = function (_elm) {
"use strict";
_elm.Signal = _elm.Signal || {};
if (_elm.Signal.values)
return _elm.Signal.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Signal",
$Basics = Elm.Basics.make(_elm),
$Debug = Elm.Debug.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Signal = Elm.Native.Signal.make(_elm),
$Task = Elm.Task.make(_elm);
var send = F2(function (_v0,
value) {
return function () {
switch (_v0.ctor)
{case "Address":
return A2($Task.onError,
_v0._0(value),
function (_v3) {
return function () {
return $Task.succeed({ctor: "_Tuple0"});
}();
});}
_U.badCase($moduleName,
"between lines 370 and 371");
}();
});
var Message = function (a) {
return {ctor: "Message"
,_0: a};
};
var message = F2(function (_v5,
value) {
return function () {
switch (_v5.ctor)
{case "Address":
return Message(_v5._0(value));}
_U.badCase($moduleName,
"on line 352, column 5 to 24");
}();
});
var mailbox = $Native$Signal.mailbox;
var Address = function (a) {
return {ctor: "Address"
,_0: a};
};
var forwardTo = F2(function (_v8,
f) {
return function () {
switch (_v8.ctor)
{case "Address":
return Address(function (x) {
return _v8._0(f(x));
});}
_U.badCase($moduleName,
"on line 339, column 5 to 29");
}();
});
var Mailbox = F2(function (a,
b) {
return {_: {}
,address: a
,signal: b};
});
var sampleOn = $Native$Signal.sampleOn;
var dropRepeats = $Native$Signal.dropRepeats;
var filterMap = $Native$Signal.filterMap;
var filter = F3(function (isOk,
base,
signal) {
return A3(filterMap,
function (value) {
return isOk(value) ? $Maybe.Just(value) : $Maybe.Nothing;
},
base,
signal);
});
var merge = F2(function (left,
right) {
return A3($Native$Signal.genericMerge,
$Basics.always,
left,
right);
});
var mergeMany = function (signalList) {
return function () {
var _v11 = $List.reverse(signalList);
switch (_v11.ctor)
{case "::":
return A3($List.foldl,
merge,
_v11._0,
_v11._1);
case "[]":
return $Debug.crash("mergeMany was given an empty list!");}
_U.badCase($moduleName,
"between lines 177 and 197");
}();
};
var foldp = $Native$Signal.foldp;
var map5 = $Native$Signal.map5;
var map4 = $Native$Signal.map4;
var map3 = $Native$Signal.map3;
var map2 = $Native$Signal.map2;
_op["~"] = F2(function (funcs,
args) {
return A3(map2,
F2(function (f,v) {
return f(v);
}),
funcs,
args);
});
var map = $Native$Signal.map;
_op["<~"] = map;
var constant = $Native$Signal.constant;
var Signal = {ctor: "Signal"};
_elm.Signal.values = {_op: _op
,merge: merge
,mergeMany: mergeMany
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,constant: constant
,dropRepeats: dropRepeats
,filter: filter
,filterMap: filterMap
,sampleOn: sampleOn
,foldp: foldp
,mailbox: mailbox
,send: send
,message: message
,forwardTo: forwardTo
,Mailbox: Mailbox};
return _elm.Signal.values;
};
Elm.String = Elm.String || {};
Elm.String.make = function (_elm) {
"use strict";
_elm.String = _elm.String || {};
if (_elm.String.values)
return _elm.String.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "String",
$Maybe = Elm.Maybe.make(_elm),
$Native$String = Elm.Native.String.make(_elm),
$Result = Elm.Result.make(_elm);
var fromList = $Native$String.fromList;
var toList = $Native$String.toList;
var toFloat = $Native$String.toFloat;
var toInt = $Native$String.toInt;
var indices = $Native$String.indexes;
var indexes = $Native$String.indexes;
var endsWith = $Native$String.endsWith;
var startsWith = $Native$String.startsWith;
var contains = $Native$String.contains;
var all = $Native$String.all;
var any = $Native$String.any;
var toLower = $Native$String.toLower;
var toUpper = $Native$String.toUpper;
var lines = $Native$String.lines;
var words = $Native$String.words;
var trimRight = $Native$String.trimRight;
var trimLeft = $Native$String.trimLeft;
var trim = $Native$String.trim;
var padRight = $Native$String.padRight;
var padLeft = $Native$String.padLeft;
var pad = $Native$String.pad;
var dropRight = $Native$String.dropRight;
var dropLeft = $Native$String.dropLeft;
var right = $Native$String.right;
var left = $Native$String.left;
var slice = $Native$String.slice;
var repeat = $Native$String.repeat;
var join = $Native$String.join;
var split = $Native$String.split;
var foldr = $Native$String.foldr;
var foldl = $Native$String.foldl;
var reverse = $Native$String.reverse;
var filter = $Native$String.filter;
var map = $Native$String.map;
var length = $Native$String.length;
var concat = $Native$String.concat;
var append = $Native$String.append;
var uncons = $Native$String.uncons;
var cons = $Native$String.cons;
var fromChar = function ($char) {
return A2(cons,$char,"");
};
var isEmpty = $Native$String.isEmpty;
_elm.String.values = {_op: _op
,isEmpty: isEmpty
,length: length
,reverse: reverse
,repeat: repeat
,cons: cons
,uncons: uncons
,fromChar: fromChar
,append: append
,concat: concat
,split: split
,join: join
,words: words
,lines: lines
,slice: slice
,left: left
,right: right
,dropLeft: dropLeft
,dropRight: dropRight
,contains: contains
,startsWith: startsWith
,endsWith: endsWith
,indexes: indexes
,indices: indices
,toInt: toInt
,toFloat: toFloat
,toList: toList
,fromList: fromList
,toUpper: toUpper
,toLower: toLower
,pad: pad
,padLeft: padLeft
,padRight: padRight
,trim: trim
,trimLeft: trimLeft
,trimRight: trimRight
,map: map
,filter: filter
,foldl: foldl
,foldr: foldr
,any: any
,all: all};
return _elm.String.values;
};
Elm.Task = Elm.Task || {};
Elm.Task.make = function (_elm) {
"use strict";
_elm.Task = _elm.Task || {};
if (_elm.Task.values)
return _elm.Task.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Task",
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Task = Elm.Native.Task.make(_elm),
$Result = Elm.Result.make(_elm);
var sleep = $Native$Task.sleep;
var spawn = $Native$Task.spawn;
var ThreadID = function (a) {
return {ctor: "ThreadID"
,_0: a};
};
var onError = $Native$Task.catch_;
var andThen = $Native$Task.andThen;
var fail = $Native$Task.fail;
var mapError = F2(function (f,
promise) {
return A2(onError,
promise,
function (err) {
return fail(f(err));
});
});
var succeed = $Native$Task.succeed;
var map = F2(function (func,
promiseA) {
return A2(andThen,
promiseA,
function (a) {
return succeed(func(a));
});
});
var map2 = F3(function (func,
promiseA,
promiseB) {
return A2(andThen,
promiseA,
function (a) {
return A2(andThen,
promiseB,
function (b) {
return succeed(A2(func,a,b));
});
});
});
var map3 = F4(function (func,
promiseA,
promiseB,
promiseC) {
return A2(andThen,
promiseA,
function (a) {
return A2(andThen,
promiseB,
function (b) {
return A2(andThen,
promiseC,
function (c) {
return succeed(A3(func,
a,
b,
c));
});
});
});
});
var map4 = F5(function (func,
promiseA,
promiseB,
promiseC,
promiseD) {
return A2(andThen,
promiseA,
function (a) {
return A2(andThen,
promiseB,
function (b) {
return A2(andThen,
promiseC,
function (c) {
return A2(andThen,
promiseD,
function (d) {
return succeed(A4(func,
a,
b,
c,
d));
});
});
});
});
});
var map5 = F6(function (func,
promiseA,
promiseB,
promiseC,
promiseD,
promiseE) {
return A2(andThen,
promiseA,
function (a) {
return A2(andThen,
promiseB,
function (b) {
return A2(andThen,
promiseC,
function (c) {
return A2(andThen,
promiseD,
function (d) {
return A2(andThen,
promiseE,
function (e) {
return succeed(A5(func,
a,
b,
c,
d,
e));
});
});
});
});
});
});
var andMap = F2(function (promiseFunc,
promiseValue) {
return A2(andThen,
promiseFunc,
function (func) {
return A2(andThen,
promiseValue,
function (value) {
return succeed(func(value));
});
});
});
var sequence = function (promises) {
return function () {
switch (promises.ctor)
{case "::": return A3(map2,
F2(function (x,y) {
return A2($List._op["::"],
x,
y);
}),
promises._0,
sequence(promises._1));
case "[]":
return succeed(_L.fromArray([]));}
_U.badCase($moduleName,
"between lines 101 and 106");
}();
};
var toMaybe = function (task) {
return A2(onError,
A2(map,$Maybe.Just,task),
function (_v3) {
return function () {
return succeed($Maybe.Nothing);
}();
});
};
var fromMaybe = F2(function ($default,
maybe) {
return function () {
switch (maybe.ctor)
{case "Just":
return succeed(maybe._0);
case "Nothing":
return fail($default);}
_U.badCase($moduleName,
"between lines 139 and 141");
}();
});
var toResult = function (task) {
return A2(onError,
A2(map,$Result.Ok,task),
function (msg) {
return succeed($Result.Err(msg));
});
};
var fromResult = function (result) {
return function () {
switch (result.ctor)
{case "Err":
return fail(result._0);
case "Ok":
return succeed(result._0);}
_U.badCase($moduleName,
"between lines 151 and 153");
}();
};
var Task = {ctor: "Task"};
_elm.Task.values = {_op: _op
,succeed: succeed
,fail: fail
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,andMap: andMap
,sequence: sequence
,andThen: andThen
,onError: onError
,mapError: mapError
,toMaybe: toMaybe
,fromMaybe: fromMaybe
,toResult: toResult
,fromResult: fromResult
,spawn: spawn
,sleep: sleep};
return _elm.Task.values;
};
Elm.Text = Elm.Text || {};
Elm.Text.make = function (_elm) {
"use strict";
_elm.Text = _elm.Text || {};
if (_elm.Text.values)
return _elm.Text.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Text",
$Color = Elm.Color.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Text = Elm.Native.Text.make(_elm);
var line = $Native$Text.line;
var italic = $Native$Text.italic;
var bold = $Native$Text.bold;
var color = $Native$Text.color;
var height = $Native$Text.height;
var link = $Native$Text.link;
var monospace = $Native$Text.monospace;
var typeface = $Native$Text.typeface;
var style = $Native$Text.style;
var append = $Native$Text.append;
var fromString = $Native$Text.fromString;
var empty = fromString("");
var concat = function (texts) {
return A3($List.foldr,
append,
empty,
texts);
};
var join = F2(function (seperator,
texts) {
return concat(A2($List.intersperse,
seperator,
texts));
});
var defaultStyle = {_: {}
,bold: false
,color: $Color.black
,height: $Maybe.Nothing
,italic: false
,line: $Maybe.Nothing
,typeface: _L.fromArray([])};
var Style = F6(function (a,
b,
c,
d,
e,
f) {
return {_: {}
,bold: d
,color: c
,height: b
,italic: e
,line: f
,typeface: a};
});
var Through = {ctor: "Through"};
var Over = {ctor: "Over"};
var Under = {ctor: "Under"};
var Text = {ctor: "Text"};
_elm.Text.values = {_op: _op
,fromString: fromString
,empty: empty
,append: append
,concat: concat
,join: join
,link: link
,style: style
,defaultStyle: defaultStyle
,typeface: typeface
,monospace: monospace
,height: height
,color: color
,bold: bold
,italic: italic
,line: line
,Style: Style
,Under: Under
,Over: Over
,Through: Through};
return _elm.Text.values;
};
Elm.Transform2D = Elm.Transform2D || {};
Elm.Transform2D.make = function (_elm) {
"use strict";
_elm.Transform2D = _elm.Transform2D || {};
if (_elm.Transform2D.values)
return _elm.Transform2D.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Transform2D",
$Native$Transform2D = Elm.Native.Transform2D.make(_elm);
var multiply = $Native$Transform2D.multiply;
var rotation = $Native$Transform2D.rotation;
var matrix = $Native$Transform2D.matrix;
var translation = F2(function (x,
y) {
return A6(matrix,
1,
0,
0,
1,
x,
y);
});
var scale = function (s) {
return A6(matrix,
s,
0,
0,
s,
0,
0);
};
var scaleX = function (x) {
return A6(matrix,
x,
0,
0,
1,
0,
0);
};
var scaleY = function (y) {
return A6(matrix,
1,
0,
0,
y,
0,
0);
};
var identity = $Native$Transform2D.identity;
var Transform2D = {ctor: "Transform2D"};
_elm.Transform2D.values = {_op: _op
,identity: identity
,matrix: matrix
,multiply: multiply
,rotation: rotation
,translation: translation
,scale: scale
,scaleX: scaleX
,scaleY: scaleY};
return _elm.Transform2D.values;
};
Elm.VirtualDom = Elm.VirtualDom || {};
Elm.VirtualDom.make = function (_elm) {
"use strict";
_elm.VirtualDom = _elm.VirtualDom || {};
if (_elm.VirtualDom.values)
return _elm.VirtualDom.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "VirtualDom",
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$Json$Decode = Elm.Json.Decode.make(_elm),
$Native$VirtualDom = Elm.Native.VirtualDom.make(_elm),
$Signal = Elm.Signal.make(_elm);
var lazy3 = $Native$VirtualDom.lazy3;
var lazy2 = $Native$VirtualDom.lazy2;
var lazy = $Native$VirtualDom.lazy;
var on = $Native$VirtualDom.on;
var attribute = $Native$VirtualDom.attribute;
var property = $Native$VirtualDom.property;
var Property = {ctor: "Property"};
var fromElement = $Native$VirtualDom.fromElement;
var toElement = $Native$VirtualDom.toElement;
var text = $Native$VirtualDom.text;
var node = $Native$VirtualDom.node;
var Node = {ctor: "Node"};
_elm.VirtualDom.values = {_op: _op
,Node: Node
,node: node
,text: text
,toElement: toElement
,fromElement: fromElement
,Property: Property
,property: property
,attribute: attribute
,on: on
,lazy: lazy
,lazy2: lazy2
,lazy3: lazy3};
return _elm.VirtualDom.values;
};
Elm.Window = Elm.Window || {};
Elm.Window.make = function (_elm) {
"use strict";
_elm.Window = _elm.Window || {};
if (_elm.Window.values)
return _elm.Window.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "Window",
$Basics = Elm.Basics.make(_elm),
$Native$Window = Elm.Native.Window.make(_elm),
$Signal = Elm.Signal.make(_elm);
var dimensions = $Native$Window.dimensions;
var width = A2($Signal.map,
$Basics.fst,
dimensions);
var height = A2($Signal.map,
$Basics.snd,
dimensions);
_elm.Window.values = {_op: _op
,dimensions: dimensions
,width: width
,height: height};
return _elm.Window.values;
};
Elm.YPassword = Elm.YPassword || {};
Elm.YPassword.make = function (_elm) {
"use strict";
_elm.YPassword = _elm.YPassword || {};
if (_elm.YPassword.values)
return _elm.YPassword.values;
var _op = {},
_N = Elm.Native,
_U = _N.Utils.make(_elm),
_L = _N.List.make(_elm),
$moduleName = "YPassword",
$Basics = Elm.Basics.make(_elm),
$Color = Elm.Color.make(_elm),
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$Graphics$Input = Elm.Graphics.Input.make(_elm),
$Graphics$Input$Field = Elm.Graphics.Input.Field.make(_elm),
$Markdown = Elm.Markdown.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Sha = Elm.Sha.make(_elm),
$Signal = Elm.Signal.make(_elm),
$String = Elm.String.make(_elm),
$Text = Elm.Text.make(_elm),
$Window = Elm.Window.make(_elm);
var yStyle = function (n) {
return function () {
var ystyle = {_: {}
,bold: false
,color: $Color.charcoal
,height: $Maybe.Just(n)
,italic: false
,line: $Maybe.Nothing
,typeface: _L.fromArray(["Futura"
,"sans-serif"])};
var f = $Graphics$Input$Field.defaultStyle;
return _U.replace([["style"
,ystyle]],
f);
}();
};
var masterContent = $Signal.mailbox($Graphics$Input$Field.noContent);
var domainContent = $Signal.mailbox($Graphics$Input$Field.noContent);
var nbMailbox = $Signal.mailbox(0);
var nbDropdown = A2($Graphics$Input.dropDown,
$Signal.message(nbMailbox.address),
_L.fromArray([{ctor: "_Tuple2"
,_0: "0"
,_1: 0}
,{ctor: "_Tuple2",_0: "1",_1: 1}
,{ctor: "_Tuple2",_0: "2",_1: 2}
,{ctor: "_Tuple2",_0: "3",_1: 3}
,{ctor: "_Tuple2",_0: "4",_1: 4}
,{ctor: "_Tuple2"
,_0: "5"
,_1: 5}]));
var fmtMailbox = $Signal.mailbox("base64");
var fmtDropdown = A2($Graphics$Input.dropDown,
$Signal.message(fmtMailbox.address),
_L.fromArray([{ctor: "_Tuple2"
,_0: "base64"
,_1: "base64"}
,{ctor: "_Tuple2"
,_0: "hex"
,_1: "hex"}]));
var lenMailbox = $Signal.mailbox(10);
var lenDropdown = A2($Graphics$Input.dropDown,
$Signal.message(lenMailbox.address),
_L.fromArray([{ctor: "_Tuple2"
,_0: "10"
,_1: 10}
,{ctor: "_Tuple2"
,_0: "27"
,_1: 27}
,{ctor: "_Tuple2"
,_0: "40"
,_1: 40}]));
var makePass = function (m) {
return function () {
var sha1 = $Sha.createHash("sha1");
var s_concatenated = _U.cmp(m.nb,
0) > 0 ? A2($Basics._op["++"],
m.master.string,
$Basics.toString(m.nb)) : m.master.string;
var concatenated = A2($Basics._op["++"],
s_concatenated,
m.domain.string);
var hash = A3($Sha.update,
concatenated,
"utf8",
sha1);
return A3($String.slice,
0,
m.len,
A2($Sha.digest,m.fmt,hash));
}();
};
var update = F2(function (action,
m) {
return function () {
var tmp = function () {
switch (action.ctor)
{case "DomainChanged":
return _U.replace([["domain"
,action._0]],
m);
case "FormatChanged":
return _U.replace([["fmt"
,action._0]],
m);
case "LengthChanged":
return _U.replace([["len"
,action._0]],
m);
case "MasterChanged":
return _U.replace([["master"
,action._0]],
m);
case "NbChanged":
return _U.replace([["nb"
,action._0]],
m);}
_U.badCase($moduleName,
"between lines 60 and 66");
}();
return _U.replace([["pass"
,makePass(tmp)]],
tmp);
}();
});
var basicWidth = 320;
var introduction = $Graphics$Element.width(basicWidth)(A3($Graphics$Element.container,
basicWidth,
210,
$Graphics$Element.middle)($Graphics$Element.width(220)($Markdown.toElement("\n# YPassword\n\nSimply enter\n- the domain name\n- your master password\n- Max len / format\n- Nb (if you want to change your password)\n"))));
var passwordView = function (pass) {
return $Graphics$Element.color($Color.grey)(A3($Graphics$Element.container,
basicWidth,
30,
$Graphics$Element.middle)($Graphics$Element.width(basicWidth)($Graphics$Element.centered($Text.monospace($Text.fromString(pass))))));
};
var textInput = function (fieldContent) {
return $Graphics$Element.width(basicWidth)(A4($Graphics$Input$Field.field,
yStyle(18),
$Signal.message(domainContent.address),
"Domain Name",
fieldContent));
};
var passInput = function (fieldContent) {
return $Graphics$Element.width(basicWidth)(A4($Graphics$Input$Field.password,
yStyle(18),
$Signal.message(masterContent.address),
"Master Password",
fieldContent));
};
var view = F2(function (m,_v6) {
return function () {
switch (_v6.ctor)
{case "WindowSizeChanged":
switch (_v6._0.ctor)
{case "_Tuple2":
return A2($Graphics$Element.color,
$Color.lightGrey,
A4($Graphics$Element.container,
A2($Basics.max,
_v6._0._0,
basicWidth),
A2($Basics.max,_v6._0._1,430),
$Graphics$Element.middle,
A2($Graphics$Element.flow,
$Graphics$Element.down,
_L.fromArray([introduction
,A2($Graphics$Element.spacer,
10,
10)
,textInput(m.domain)
,A2($Graphics$Element.spacer,
10,
10)
,passInput(m.master)
,A2($Graphics$Element.spacer,
10,
10)
,A2($Graphics$Element.flow,
$Graphics$Element.right,
_L.fromArray([$Graphics$Element.width(80)(lenDropdown)
,A2($Graphics$Element.spacer,
(basicWidth - 3 * 80) / 2 | 0,
10)
,$Graphics$Element.width(80)(fmtDropdown)
,A2($Graphics$Element.spacer,
(basicWidth - 3 * 80) / 2 | 0,
10)
,$Graphics$Element.width(80)(nbDropdown)]))
,A2($Graphics$Element.spacer,
30,
30)
,passwordView(m.pass)]))));}
break;}
_U.badCase($moduleName,
"between lines 102 and 121");
}();
});
var initialState = {_: {}
,domain: $Graphics$Input$Field.noContent
,fmt: "base64"
,len: 10
,master: $Graphics$Input$Field.noContent
,nb: 0
,pass: ""};
var WindowSizeChanged = function (a) {
return {ctor: "WindowSizeChanged"
,_0: a};
};
var NbChanged = function (a) {
return {ctor: "NbChanged"
,_0: a};
};
var FormatChanged = function (a) {
return {ctor: "FormatChanged"
,_0: a};
};
var LengthChanged = function (a) {
return {ctor: "LengthChanged"
,_0: a};
};
var DomainChanged = function (a) {
return {ctor: "DomainChanged"
,_0: a};
};
var MasterChanged = function (a) {
return {ctor: "MasterChanged"
,_0: a};
};
var actions = $Signal.mergeMany(_L.fromArray([A2($Signal.map,
MasterChanged,
masterContent.signal)
,A2($Signal.map,
DomainChanged,
domainContent.signal)
,A2($Signal.map,
LengthChanged,
lenMailbox.signal)
,A2($Signal.map,
FormatChanged,
fmtMailbox.signal)
,A2($Signal.map,
NbChanged,
nbMailbox.signal)]));
var main = A3($Signal.map2,
view,
A3($Signal.foldp,
update,
initialState,
actions),
A2($Signal.map,
WindowSizeChanged,
$Window.dimensions));
var Model = F6(function (a,
b,
c,
d,
e,
f) {
return {_: {}
,domain: b
,fmt: d
,len: c
,master: a
,nb: e
,pass: f};
});
_elm.YPassword.values = {_op: _op
,Model: Model
,MasterChanged: MasterChanged
,DomainChanged: DomainChanged
,LengthChanged: LengthChanged
,FormatChanged: FormatChanged
,NbChanged: NbChanged
,WindowSizeChanged: WindowSizeChanged
,actions: actions
,initialState: initialState
,basicWidth: basicWidth
,main: main
,update: update
,makePass: makePass
,lenMailbox: lenMailbox
,fmtMailbox: fmtMailbox
,nbMailbox: nbMailbox
,introduction: introduction
,view: view
,lenDropdown: lenDropdown
,fmtDropdown: fmtDropdown
,nbDropdown: nbDropdown
,passwordView: passwordView
,domainContent: domainContent
,masterContent: masterContent
,yStyle: yStyle
,textInput: textInput
,passInput: passInput};
return _elm.YPassword.values;
};
Reference in a new issue Copy permalink