yogsototh/her.esy.fun
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
her.esy.fun/src/YPassword/elm.js
Yann Esposito (Yogsototh) 7f5758cd6e
support raw HTML and merged old blog
2021-04-18 12:23:24 +02:00

16184 lines
413 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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].replace(/^ *> ?/gm,"");this.token(cap,top,true);this.tokens.push({type:"blockquote_end"});continue}if(cap=this.rules.list.exec(src)){src=src.substring(cap[0].length);bull=cap[2];this.tokens.push({type:"list_start",ordered:bull.length>1});cap=cap[0].match(this.rules.item);next=false;l=cap.length;i=0;for(;i<l;i++){item=cap[i];space=item.length;item=item.replace(/^ *([*+-]|\d+\.) +/,"");if(~item.indexOf("\n ")){space-=item.length;item=!this.options.pedantic?item.replace(new RegExp("^ {1,"+space+"}","gm"),""):item.replace(/^ {1,4}/gm,"")}if(this.options.smartLists&&i!==l-1){b=block.bullet.exec(cap[i+1])[0];if(bull!==b&&!(bull.length>1&&b.length>1)){src=cap.slice(i+1).join("\n")+src;i=l-1}}loose=next||/\n\n(?!\s*$)/.test(item);if(i!==l-1){next=item.charAt(item.length-1)==="\n";if(!loose)loose=next}this.tokens.push({type:loose?"loose_item_start":"list_item_start"});this.token(item,false,bq);this.tokens.push({type:"list_item_end"})}this.tokens.push({type:"list_end"});continue}if(cap=this.rules.html.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:this.options.sanitize?"paragraph":"html",pre:cap[1]==="pre"||cap[1]==="script"||cap[1]==="style",text:cap[0]});continue}if(!bq&&top&&(cap=this.rules.def.exec(src))){src=src.substring(cap[0].length);this.tokens.links[cap[1].toLowerCase()]={href:cap[2],title:cap[3]};continue}if(top&&(cap=this.rules.table.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].replace(/^ *\| *| *\| *$/g,"").split(/ *\| */)}this.tokens.push(item);continue}if(top&&(cap=this.rules.paragraph.exec(src))){src=src.substring(cap[0].length);this.tokens.push({type:"paragraph",text:cap[1].charAt(cap[1].length-1)==="\n"?cap[1].slice(0,-1):cap[1]});continue}if(cap=this.rules.text.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"text",text:cap[0]});continue}if(src){throw new Error("Infinite loop on byte: "+src.charCodeAt(0))}}return this.tokens};var inline={escape:/^\\([\\`*{}\[\]()#+\-.!_>])/,autolink:/^<([^ >]+(@|:\/)[^ >]+)>/,url:noop,tag:/^<!--[\s\S]*?-->|^<\/?\w+(?:"[^"]*"|'[^']*'|[^'">])*?>/,link:/^!?\[(inside)\]\(href\)/,reflink:/^!?\[(inside)\]\s*\[([^\]]*)\]/,nolink:/^!?\[((?:\[[^\]]*\]|[^\[\]])*)\]/,strong:/^__([\s\S]+?)__(?!_)|^\*\*([\s\S]+?)\*\*(?!\*)/,em:/^\b_((?:__|[\s\S])+?)_\b|^\*((?:\*\*|[\s\S])+?)\*(?!\*)/,code:/^(`+)\s*([\s\S]*?[^`])\s*\1(?!`)/,br:/^ {2,}\n(?!\s*$)/,del:noop,text:/^[\s\S]+?(?=[\\<!\[_*`]| {2,}\n|$)/};inline._inside=/(?:\[[^\]]*\]|[^\[\]]|\](?=[^\[]*\]))*/;inline._href=/\s*<?([\s\S]*?)>?(?:\s+['"]([\s\S]*?)['"])?\s*/;inline.link=replace(inline.link)("inside",inline._inside)("href",inline._href)();inline.reflink=replace(inline.reflink)("inside",inline._inside)();inline.normal=merge({},inline);inline.pedantic=merge({},inline.normal,{strong:/^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,em:/^_(?=\S)([\s\S]*?\S)_(?!_)|^\*(?=\S)([\s\S]*?\S)\*(?!\*)/});inline.gfm=merge({},inline.normal,{escape:replace(inline.escape)("])","~|])")(),url:/^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/,del:/^~~(?=\S)([\s\S]*?\S)~~/,text:replace(inline.text)("]|","~]|")("|","|https?://|")()});inline.breaks=merge({},inline.gfm,{br:replace(inline.br)("{2,}","*")(),text:replace(inline.gfm.text)("{2,}","*")()});function InlineLexer(links,options){this.options=options||marked.defaults;this.links=links;this.rules=inline.normal;this.renderer=this.options.renderer||new Renderer;this.renderer.options=this.options;if(!this.links){throw new Error("Tokens array requires a `links` property.")}if(this.options.gfm){if(this.options.breaks){this.rules=inline.breaks}else{this.rules=inline.gfm}}else if(this.options.pedantic){this.rules=inline.pedantic}}InlineLexer.rules=inline;InlineLexer.output=function(src,links,options){var inline=new InlineLexer(links,options);return inline.output(src)};InlineLexer.prototype.output=function(src){var out="",link,text,href,cap;while(src){if(cap=this.rules.escape.exec(src)){src=src.substring(cap[0].length);out+=cap[1];continue}if(cap=this.rules.autolink.exec(src)){src=src.substring(cap[0].length);if(cap[2]==="@"){text=cap[1].charAt(6)===":"?this.mangle(cap[1].substring(7)):this.mangle(cap[1]);href=this.mangle("mailto:")+text}else{text=escape(cap[1]);href=text}out+=this.renderer.link(href,null,text);continue}if(!this.inLink&&(cap=this.rules.url.exec(src))){src=src.substring(cap[0].length);text=escape(cap[1]);href=text;out+=this.renderer.link(href,null,text);continue}if(cap=this.rules.tag.exec(src)){if(!this.inLink&&/^<a /i.test(cap[0])){this.inLink=true}else if(this.inLink&&/^<\/a>/i.test(cap[0])){this.inLink=false}src=src.substring(cap[0].length);out+=this.options.sanitize?escape(cap[0]):cap[0];continue}if(cap=this.rules.link.exec(src)){src=src.substring(cap[0].length);this.inLink=true;out+=this.outputLink(cap,{href:cap[2],title:cap[3]});this.inLink=false;continue}if((cap=this.rules.reflink.exec(src))||(cap=this.rules.nolink.exec(src))){src=src.substring(cap[0].length);link=(cap[2]||cap[1]).replace(/\s+/g," ");link=this.links[link.toLowerCase()];if(!link||!link.href){out+=cap[0].charAt(0);src=cap[0].substring(1)+src;continue}this.inLink=true;out+=this.outputLink(cap,link);this.inLink=false;continue}if(cap=this.rules.strong.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.strong(this.output(cap[2]||cap[1]));continue}if(cap=this.rules.em.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.em(this.output(cap[2]||cap[1]));continue}if(cap=this.rules.code.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.codespan(escape(cap[2],true));continue}if(cap=this.rules.br.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.br();continue}if(cap=this.rules.del.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.del(this.output(cap[1]));continue}if(cap=this.rules.text.exec(src)){src=src.substring(cap[0].length);out+=escape(this.smartypants(cap[0]));continue}if(src){throw new Error("Infinite loop on byte: "+src.charCodeAt(0))}}return out};InlineLexer.prototype.outputLink=function(cap,link){var href=escape(link.href),title=link.title?escape(link.title):null;return cap[0].charAt(0)!=="!"?this.renderer.link(href,title,this.output(cap[1])):this.renderer.image(href,title,escape(cap[1]))};InlineLexer.prototype.smartypants=function(text){if(!this.options.smartypants)return text;return text.replace(/--/g,"—").replace(/(^|[-\u2014/(\[{"\s])'/g,"$1‘").replace(/'/g,"’").replace(/(^|[-\u2014/(\[{\u2018\s])"/g,"$1“").replace(/"/g,"”").replace(/\.{3}/g,"…")};InlineLexer.prototype.mangle=function(text){var out="",l=text.length,i=0,ch;for(;i<l;i++){ch=text.charCodeAt(i);if(Math.random()>.5){ch="x"+ch.toString(16)}out+="&#"+ch+";"}return out};function Renderer(options){this.options=options||{}}Renderer.prototype.code=function(code,lang,escaped){if(this.options.highlight){var out=this.options.highlight(code,lang);if(out!=null&&out!==code){escaped=true;code=out}}if(!lang){return"<pre><code>"+(escaped?code:escape(code,true))+"\n</code></pre>"}return'<pre><code class="'+this.options.langPrefix+escape(lang,true)+'">'+(escaped?code:escape(code,true))+"\n</code></pre>\n"};Renderer.prototype.blockquote=function(quote){return"<blockquote>\n"+quote+"</blockquote>\n"};Renderer.prototype.html=function(html){return html};Renderer.prototype.heading=function(text,level,raw){return"<h"+level+' id="'+this.options.headerPrefix+raw.toLowerCase().replace(/[^\w]+/g,"-")+'">'+text+"</h"+level+">\n"};Renderer.prototype.hr=function(){return this.options.xhtml?"<hr/>\n":"<hr>\n"};Renderer.prototype.list=function(body,ordered){var type=ordered?"ol":"ul";return"<"+type+">\n"+body+"</"+type+">\n"};Renderer.prototype.listitem=function(text){return"<li>"+text+"</li>\n"};Renderer.prototype.paragraph=function(text){return"<p>"+text+"</p>\n"};Renderer.prototype.table=function(header,body){return"<table>\n"+"<thead>\n"+header+"</thead>\n"+"<tbody>\n"+body+"</tbody>\n"+"</table>\n"};Renderer.prototype.tablerow=function(content){return"<tr>\n"+content+"</tr>\n"};Renderer.prototype.tablecell=function(content,flags){var type=flags.header?"th":"td";var tag=flags.align?"<"+type+' style="text-align:'+flags.align+'">':"<"+type+">";return tag+content+"</"+type+">\n"};Renderer.prototype.strong=function(text){return"<strong>"+text+"</strong>"};Renderer.prototype.em=function(text){return"<em>"+text+"</em>"};Renderer.prototype.codespan=function(text){return"<code>"+text+"</code>"};Renderer.prototype.br=function(){return this.options.xhtml?"<br/>":"<br>"};Renderer.prototype.del=function(text){return"<del>"+text+"</del>"};Renderer.prototype.link=function(href,title,text){if(this.options.sanitize){try{var prot=decodeURIComponent(unescape(href)).replace(/[^\w:]/g,"").toLowerCase()}catch(e){return""}if(prot.indexOf("javascript:")===0){return""}}var out='<a href="'+href+'"';if(title){out+=' title="'+title+'"'}out+=">"+text+"</a>";return out};Renderer.prototype.image=function(href,title,text){var out='<img src="'+href+'" alt="'+text+'"';if(title){out+=' title="'+title+'"'}out+=this.options.xhtml?"/>":">";return out};function Parser(options){this.tokens=[];this.token=null;this.options=options||marked.defaults;this.options.renderer=this.options.renderer||new Renderer;this.renderer=this.options.renderer;this.renderer.options=this.options}Parser.parse=function(src,options,renderer){var parser=new Parser(options,renderer);return parser.parse(src)};Parser.prototype.parse=function(src){this.inline=new InlineLexer(src.links,this.options,this.renderer);this.tokens=src.reverse();var out="";while(this.next()){out+=this.tok()}return out};Parser.prototype.next=function(){return this.token=this.tokens.pop()};Parser.prototype.peek=function(){return this.tokens[this.tokens.length-1]||0};Parser.prototype.parseText=function(){var body=this.token.text;while(this.peek().type==="text"){body+="\n"+this.next().text}return this.inline.output(body)};Parser.prototype.tok=function(){switch(this.token.type){case"space":{return""}case"hr":{return this.renderer.hr()}case"heading":{return this.renderer.heading(this.inline.output(this.token.text),this.token.depth,this.token.text)}case"code":{return this.renderer.code(this.token.text,this.token.lang,this.token.escaped)}case"table":{var header="",body="",i,row,cell,flags,j;cell="";for(i=0;i<this.token.header.length;i++){flags={header:true,align:this.token.align[i]};cell+=this.renderer.tablecell(this.inline.output(this.token.header[i]),{header:true,align:this.token.align[i]})}header+=this.renderer.tablerow(cell);for(i=0;i<this.token.cells.length;i++){row=this.token.cells[i];cell="";for(j=0;j<row.length;j++){cell+=this.renderer.tablecell(this.inline.output(row[j]),{header:false,align:this.token.align[j]})}body+=this.renderer.tablerow(cell)}return this.renderer.table(header,body)}case"blockquote_start":{var body="";while(this.next().type!=="blockquote_end"){body+=this.tok()}return this.renderer.blockquote(body)}case"list_start":{var body="",ordered=this.token.ordered;while(this.next().type!=="list_end"){body+=this.tok()}return this.renderer.list(body,ordered)}case"list_item_start":{var body="";while(this.next().type!=="list_item_end"){body+=this.token.type==="text"?this.parseText():this.tok()}return this.renderer.listitem(body)}case"loose_item_start":{var body="";while(this.next().type!=="list_item_end"){body+=this.tok()}return this.renderer.listitem(body)}case"html":{var html=!this.token.pre&&!this.options.pedantic?this.inline.output(this.token.text):this.token.text;return this.renderer.html(html)}case"paragraph":{return this.renderer.paragraph(this.inline.output(this.token.text))}case"text":{return this.renderer.paragraph(this.parseText())}}};function escape(html,encode){return html.replace(!encode?/&(?!#?\w+;)/g:/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#39;")}function unescape(html){return html.replace(/&([#\w]+);/g,function(_,n){n=n.toLowerCase();if(n==="colon")return":";if(n.charAt(0)==="#"){return n.charAt(1)==="x"?String.fromCharCode(parseInt(n.substring(2),16)):String.fromCharCode(+n.substring(1))}return""})}function replace(regex,opt){regex=regex.source;opt=opt||"";return function self(name,val){if(!name)return new RegExp(regex,opt);val=val.source||val;val=val.replace(/(^|[^\[])\^/g,"$1");regex=regex.replace(name,val);return self}}function noop(){}noop.exec=noop;function merge(obj){var i=1,target,key;for(;i<arguments.length;i++){target=arguments[i];for(key in target){if(Object.prototype.hasOwnProperty.call(target,key)){obj[key]=target[key]}}}return obj}function marked(src,opt,callback){if(callback||typeof opt==="function"){if(!callback){callback=opt;opt=null}opt=merge({},marked.defaults,opt||{});var highlight=opt.highlight,tokens,pending,i=0;try{tokens=Lexer.lex(src,opt)}catch(e){return callback(e)}pending=tokens.length;var done=function(err){if(err){opt.highlight=highlight;return callback(err)}var out;try{out=Parser.parse(tokens,opt)}catch(e){err=e}opt.highlight=highlight;return err?callback(err):callback(null,out)};if(!highlight||highlight.length<3){return done()}delete opt.highlight;if(!pending)return done();for(;i<tokens.length;i++){(function(token){if(token.type!=="code"){return--pending||done()}return highlight(token.text,token.lang,function(err,code){if(err)return done(err);if(code==null||code===token.text){return--pending||done()}token.text=code;token.escaped=true;--pending||done()})})(tokens[i])}return}try{if(opt)opt=merge({},marked.defaults,opt);return Parser.parse(Lexer.lex(src,opt),opt)}catch(e){e.message+="\nPlease report this to https://github.com/chjj/marked.";if((opt||marked.defaults).silent){return"<p>An error occured:</p><pre>"+escape(e.message+"",true)+"</pre>"}throw e}}marked.options=marked.setOptions=function(opt){merge(marked.defaults,opt);return marked};marked.defaults={gfm:true,tables:true,breaks:false,pedantic:false,sanitize:false,smartLists:false,silent:false,highlight:null,langPrefix:"lang-",smartypants:false,headerPrefix:"",renderer:new Renderer,xhtml:false};marked.Parser=Parser;marked.parser=Parser.parse;marked.Renderer=Renderer;marked.Lexer=Lexer;marked.lexer=Lexer.lex;marked.InlineLexer=InlineLexer;marked.inlineLexer=InlineLexer.output;marked.parse=marked;if(typeof module!=="undefined"&&typeof exports==="object"){module.exports=marked}else if(typeof define==="function"&&define.amd){define(function(){return marked})}else{this.marked=marked}}).call(function(){return this||(typeof window!=="undefined"?window:global)}());
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 View git blame Copy permalink