16184 lines
413 KiB
JavaScript
16184 lines
413 KiB
JavaScript
|
var Elm = Elm || { Native: {} };
|
||
|
Elm.Array = Elm.Array || {};
|
||
|
Elm.Array.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Array = _elm.Array || {};
|
||
|
if (_elm.Array.values)
|
||
|
return _elm.Array.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Array",
|
||
|
$Basics = Elm.Basics.make(_elm),
|
||
|
$List = Elm.List.make(_elm),
|
||
|
$Maybe = Elm.Maybe.make(_elm),
|
||
|
$Native$Array = Elm.Native.Array.make(_elm);
|
||
|
var append = $Native$Array.append;
|
||
|
var length = $Native$Array.length;
|
||
|
var slice = $Native$Array.slice;
|
||
|
var set = $Native$Array.set;
|
||
|
var get = F2(function (i,
|
||
|
array) {
|
||
|
return _U.cmp(0,
|
||
|
i) < 1 && _U.cmp(i,
|
||
|
$Native$Array.length(array)) < 0 ? $Maybe.Just(A2($Native$Array.get,
|
||
|
i,
|
||
|
array)) : $Maybe.Nothing;
|
||
|
});
|
||
|
var push = $Native$Array.push;
|
||
|
var empty = $Native$Array.empty;
|
||
|
var filter = F2(function (isOkay,
|
||
|
arr) {
|
||
|
return function () {
|
||
|
var update = F2(function (x,
|
||
|
xs) {
|
||
|
return isOkay(x) ? A2($Native$Array.push,
|
||
|
x,
|
||
|
xs) : xs;
|
||
|
});
|
||
|
return A3($Native$Array.foldl,
|
||
|
update,
|
||
|
$Native$Array.empty,
|
||
|
arr);
|
||
|
}();
|
||
|
});
|
||
|
var foldr = $Native$Array.foldr;
|
||
|
var foldl = $Native$Array.foldl;
|
||
|
var indexedMap = $Native$Array.indexedMap;
|
||
|
var map = $Native$Array.map;
|
||
|
var toIndexedList = function (array) {
|
||
|
return A3($List.map2,
|
||
|
F2(function (v0,v1) {
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: v0
|
||
|
,_1: v1};
|
||
|
}),
|
||
|
_L.range(0,
|
||
|
$Native$Array.length(array) - 1),
|
||
|
$Native$Array.toList(array));
|
||
|
};
|
||
|
var toList = $Native$Array.toList;
|
||
|
var fromList = $Native$Array.fromList;
|
||
|
var initialize = $Native$Array.initialize;
|
||
|
var repeat = F2(function (n,e) {
|
||
|
return A2(initialize,
|
||
|
n,
|
||
|
$Basics.always(e));
|
||
|
});
|
||
|
var Array = {ctor: "Array"};
|
||
|
_elm.Array.values = {_op: _op
|
||
|
,empty: empty
|
||
|
,repeat: repeat
|
||
|
,initialize: initialize
|
||
|
,fromList: fromList
|
||
|
,length: length
|
||
|
,push: push
|
||
|
,append: append
|
||
|
,get: get
|
||
|
,set: set
|
||
|
,slice: slice
|
||
|
,toList: toList
|
||
|
,toIndexedList: toIndexedList
|
||
|
,map: map
|
||
|
,indexedMap: indexedMap
|
||
|
,filter: filter
|
||
|
,foldl: foldl
|
||
|
,foldr: foldr};
|
||
|
return _elm.Array.values;
|
||
|
};
|
||
|
Elm.Basics = Elm.Basics || {};
|
||
|
Elm.Basics.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Basics = _elm.Basics || {};
|
||
|
if (_elm.Basics.values)
|
||
|
return _elm.Basics.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Basics",
|
||
|
$Native$Basics = Elm.Native.Basics.make(_elm),
|
||
|
$Native$Show = Elm.Native.Show.make(_elm),
|
||
|
$Native$Utils = Elm.Native.Utils.make(_elm);
|
||
|
var uncurry = F2(function (f,
|
||
|
_v0) {
|
||
|
return function () {
|
||
|
switch (_v0.ctor)
|
||
|
{case "_Tuple2": return A2(f,
|
||
|
_v0._0,
|
||
|
_v0._1);}
|
||
|
_U.badCase($moduleName,
|
||
|
"on line 595, column 3 to 8");
|
||
|
}();
|
||
|
});
|
||
|
var curry = F3(function (f,
|
||
|
a,
|
||
|
b) {
|
||
|
return f({ctor: "_Tuple2"
|
||
|
,_0: a
|
||
|
,_1: b});
|
||
|
});
|
||
|
var flip = F3(function (f,b,a) {
|
||
|
return A2(f,a,b);
|
||
|
});
|
||
|
var snd = function (_v4) {
|
||
|
return function () {
|
||
|
switch (_v4.ctor)
|
||
|
{case "_Tuple2": return _v4._1;}
|
||
|
_U.badCase($moduleName,
|
||
|
"on line 573, column 3 to 4");
|
||
|
}();
|
||
|
};
|
||
|
var fst = function (_v8) {
|
||
|
return function () {
|
||
|
switch (_v8.ctor)
|
||
|
{case "_Tuple2": return _v8._0;}
|
||
|
_U.badCase($moduleName,
|
||
|
"on line 567, column 3 to 4");
|
||
|
}();
|
||
|
};
|
||
|
var always = F2(function (a,
|
||
|
_v12) {
|
||
|
return function () {
|
||
|
return a;
|
||
|
}();
|
||
|
});
|
||
|
var identity = function (x) {
|
||
|
return x;
|
||
|
};
|
||
|
_op["<|"] = F2(function (f,x) {
|
||
|
return f(x);
|
||
|
});
|
||
|
_op["|>"] = F2(function (x,f) {
|
||
|
return f(x);
|
||
|
});
|
||
|
_op[">>"] = F3(function (f,
|
||
|
g,
|
||
|
x) {
|
||
|
return g(f(x));
|
||
|
});
|
||
|
_op["<<"] = F3(function (g,
|
||
|
f,
|
||
|
x) {
|
||
|
return g(f(x));
|
||
|
});
|
||
|
_op["++"] = $Native$Utils.append;
|
||
|
var toString = $Native$Show.toString;
|
||
|
var isInfinite = $Native$Basics.isInfinite;
|
||
|
var isNaN = $Native$Basics.isNaN;
|
||
|
var toFloat = $Native$Basics.toFloat;
|
||
|
var ceiling = $Native$Basics.ceiling;
|
||
|
var floor = $Native$Basics.floor;
|
||
|
var truncate = $Native$Basics.truncate;
|
||
|
var round = $Native$Basics.round;
|
||
|
var otherwise = true;
|
||
|
var not = $Native$Basics.not;
|
||
|
var xor = $Native$Basics.xor;
|
||
|
_op["||"] = $Native$Basics.or;
|
||
|
_op["&&"] = $Native$Basics.and;
|
||
|
var max = $Native$Basics.max;
|
||
|
var min = $Native$Basics.min;
|
||
|
var GT = {ctor: "GT"};
|
||
|
var EQ = {ctor: "EQ"};
|
||
|
var LT = {ctor: "LT"};
|
||
|
var compare = $Native$Basics.compare;
|
||
|
_op[">="] = $Native$Basics.ge;
|
||
|
_op["<="] = $Native$Basics.le;
|
||
|
_op[">"] = $Native$Basics.gt;
|
||
|
_op["<"] = $Native$Basics.lt;
|
||
|
_op["/="] = $Native$Basics.neq;
|
||
|
_op["=="] = $Native$Basics.eq;
|
||
|
var e = $Native$Basics.e;
|
||
|
var pi = $Native$Basics.pi;
|
||
|
var clamp = $Native$Basics.clamp;
|
||
|
var logBase = $Native$Basics.logBase;
|
||
|
var abs = $Native$Basics.abs;
|
||
|
var negate = $Native$Basics.negate;
|
||
|
var sqrt = $Native$Basics.sqrt;
|
||
|
var atan2 = $Native$Basics.atan2;
|
||
|
var atan = $Native$Basics.atan;
|
||
|
var asin = $Native$Basics.asin;
|
||
|
var acos = $Native$Basics.acos;
|
||
|
var tan = $Native$Basics.tan;
|
||
|
var sin = $Native$Basics.sin;
|
||
|
var cos = $Native$Basics.cos;
|
||
|
_op["^"] = $Native$Basics.exp;
|
||
|
_op["%"] = $Native$Basics.mod;
|
||
|
var rem = $Native$Basics.rem;
|
||
|
_op["//"] = $Native$Basics.div;
|
||
|
_op["/"] = $Native$Basics.floatDiv;
|
||
|
_op["*"] = $Native$Basics.mul;
|
||
|
_op["-"] = $Native$Basics.sub;
|
||
|
_op["+"] = $Native$Basics.add;
|
||
|
var toPolar = $Native$Basics.toPolar;
|
||
|
var fromPolar = $Native$Basics.fromPolar;
|
||
|
var turns = $Native$Basics.turns;
|
||
|
var degrees = $Native$Basics.degrees;
|
||
|
var radians = function (t) {
|
||
|
return t;
|
||
|
};
|
||
|
_elm.Basics.values = {_op: _op
|
||
|
,max: max
|
||
|
,min: min
|
||
|
,compare: compare
|
||
|
,not: not
|
||
|
,xor: xor
|
||
|
,otherwise: otherwise
|
||
|
,rem: rem
|
||
|
,negate: negate
|
||
|
,abs: abs
|
||
|
,sqrt: sqrt
|
||
|
,clamp: clamp
|
||
|
,logBase: logBase
|
||
|
,e: e
|
||
|
,pi: pi
|
||
|
,cos: cos
|
||
|
,sin: sin
|
||
|
,tan: tan
|
||
|
,acos: acos
|
||
|
,asin: asin
|
||
|
,atan: atan
|
||
|
,atan2: atan2
|
||
|
,round: round
|
||
|
,floor: floor
|
||
|
,ceiling: ceiling
|
||
|
,truncate: truncate
|
||
|
,toFloat: toFloat
|
||
|
,degrees: degrees
|
||
|
,radians: radians
|
||
|
,turns: turns
|
||
|
,toPolar: toPolar
|
||
|
,fromPolar: fromPolar
|
||
|
,isNaN: isNaN
|
||
|
,isInfinite: isInfinite
|
||
|
,toString: toString
|
||
|
,fst: fst
|
||
|
,snd: snd
|
||
|
,identity: identity
|
||
|
,always: always
|
||
|
,flip: flip
|
||
|
,curry: curry
|
||
|
,uncurry: uncurry
|
||
|
,LT: LT
|
||
|
,EQ: EQ
|
||
|
,GT: GT};
|
||
|
return _elm.Basics.values;
|
||
|
};
|
||
|
Elm.Char = Elm.Char || {};
|
||
|
Elm.Char.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Char = _elm.Char || {};
|
||
|
if (_elm.Char.values)
|
||
|
return _elm.Char.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Char",
|
||
|
$Basics = Elm.Basics.make(_elm),
|
||
|
$Native$Char = Elm.Native.Char.make(_elm);
|
||
|
var fromCode = $Native$Char.fromCode;
|
||
|
var toCode = $Native$Char.toCode;
|
||
|
var toLocaleLower = $Native$Char.toLocaleLower;
|
||
|
var toLocaleUpper = $Native$Char.toLocaleUpper;
|
||
|
var toLower = $Native$Char.toLower;
|
||
|
var toUpper = $Native$Char.toUpper;
|
||
|
var isBetween = F3(function (low,
|
||
|
high,
|
||
|
$char) {
|
||
|
return function () {
|
||
|
var code = toCode($char);
|
||
|
return _U.cmp(code,
|
||
|
toCode(low)) > -1 && _U.cmp(code,
|
||
|
toCode(high)) < 1;
|
||
|
}();
|
||
|
});
|
||
|
var isUpper = A2(isBetween,
|
||
|
_U.chr("A"),
|
||
|
_U.chr("Z"));
|
||
|
var isLower = A2(isBetween,
|
||
|
_U.chr("a"),
|
||
|
_U.chr("z"));
|
||
|
var isDigit = A2(isBetween,
|
||
|
_U.chr("0"),
|
||
|
_U.chr("9"));
|
||
|
var isOctDigit = A2(isBetween,
|
||
|
_U.chr("0"),
|
||
|
_U.chr("7"));
|
||
|
var isHexDigit = function ($char) {
|
||
|
return isDigit($char) || (A3(isBetween,
|
||
|
_U.chr("a"),
|
||
|
_U.chr("f"),
|
||
|
$char) || A3(isBetween,
|
||
|
_U.chr("A"),
|
||
|
_U.chr("F"),
|
||
|
$char));
|
||
|
};
|
||
|
_elm.Char.values = {_op: _op
|
||
|
,isUpper: isUpper
|
||
|
,isLower: isLower
|
||
|
,isDigit: isDigit
|
||
|
,isOctDigit: isOctDigit
|
||
|
,isHexDigit: isHexDigit
|
||
|
,toUpper: toUpper
|
||
|
,toLower: toLower
|
||
|
,toLocaleUpper: toLocaleUpper
|
||
|
,toLocaleLower: toLocaleLower
|
||
|
,toCode: toCode
|
||
|
,fromCode: fromCode};
|
||
|
return _elm.Char.values;
|
||
|
};
|
||
|
Elm.Color = Elm.Color || {};
|
||
|
Elm.Color.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Color = _elm.Color || {};
|
||
|
if (_elm.Color.values)
|
||
|
return _elm.Color.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Color",
|
||
|
$Basics = Elm.Basics.make(_elm);
|
||
|
var Radial = F5(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d,
|
||
|
e) {
|
||
|
return {ctor: "Radial"
|
||
|
,_0: a
|
||
|
,_1: b
|
||
|
,_2: c
|
||
|
,_3: d
|
||
|
,_4: e};
|
||
|
});
|
||
|
var radial = Radial;
|
||
|
var Linear = F3(function (a,
|
||
|
b,
|
||
|
c) {
|
||
|
return {ctor: "Linear"
|
||
|
,_0: a
|
||
|
,_1: b
|
||
|
,_2: c};
|
||
|
});
|
||
|
var linear = Linear;
|
||
|
var fmod = F2(function (f,n) {
|
||
|
return function () {
|
||
|
var integer = $Basics.floor(f);
|
||
|
return $Basics.toFloat(A2($Basics._op["%"],
|
||
|
integer,
|
||
|
n)) + f - $Basics.toFloat(integer);
|
||
|
}();
|
||
|
});
|
||
|
var rgbToHsl = F3(function (red,
|
||
|
green,
|
||
|
blue) {
|
||
|
return function () {
|
||
|
var b = $Basics.toFloat(blue) / 255;
|
||
|
var g = $Basics.toFloat(green) / 255;
|
||
|
var r = $Basics.toFloat(red) / 255;
|
||
|
var cMax = A2($Basics.max,
|
||
|
A2($Basics.max,r,g),
|
||
|
b);
|
||
|
var cMin = A2($Basics.min,
|
||
|
A2($Basics.min,r,g),
|
||
|
b);
|
||
|
var c = cMax - cMin;
|
||
|
var lightness = (cMax + cMin) / 2;
|
||
|
var saturation = _U.eq(lightness,
|
||
|
0) ? 0 : c / (1 - $Basics.abs(2 * lightness - 1));
|
||
|
var hue = $Basics.degrees(60) * (_U.eq(cMax,
|
||
|
r) ? A2(fmod,
|
||
|
(g - b) / c,
|
||
|
6) : _U.eq(cMax,
|
||
|
g) ? (b - r) / c + 2 : _U.eq(cMax,
|
||
|
b) ? (r - g) / c + 4 : _U.badIf($moduleName,
|
||
|
"between lines 150 and 152"));
|
||
|
return {ctor: "_Tuple3"
|
||
|
,_0: hue
|
||
|
,_1: saturation
|
||
|
,_2: lightness};
|
||
|
}();
|
||
|
});
|
||
|
var hslToRgb = F3(function (hue,
|
||
|
saturation,
|
||
|
lightness) {
|
||
|
return function () {
|
||
|
var hue$ = hue / $Basics.degrees(60);
|
||
|
var chroma = (1 - $Basics.abs(2 * lightness - 1)) * saturation;
|
||
|
var x = chroma * (1 - $Basics.abs(A2(fmod,
|
||
|
hue$,
|
||
|
2) - 1));
|
||
|
var $ = _U.cmp(hue$,
|
||
|
0) < 0 ? {ctor: "_Tuple3"
|
||
|
,_0: 0
|
||
|
,_1: 0
|
||
|
,_2: 0} : _U.cmp(hue$,
|
||
|
1) < 0 ? {ctor: "_Tuple3"
|
||
|
,_0: chroma
|
||
|
,_1: x
|
||
|
,_2: 0} : _U.cmp(hue$,
|
||
|
2) < 0 ? {ctor: "_Tuple3"
|
||
|
,_0: x
|
||
|
,_1: chroma
|
||
|
,_2: 0} : _U.cmp(hue$,
|
||
|
3) < 0 ? {ctor: "_Tuple3"
|
||
|
,_0: 0
|
||
|
,_1: chroma
|
||
|
,_2: x} : _U.cmp(hue$,
|
||
|
4) < 0 ? {ctor: "_Tuple3"
|
||
|
,_0: 0
|
||
|
,_1: x
|
||
|
,_2: chroma} : _U.cmp(hue$,
|
||
|
5) < 0 ? {ctor: "_Tuple3"
|
||
|
,_0: x
|
||
|
,_1: 0
|
||
|
,_2: chroma} : _U.cmp(hue$,
|
||
|
6) < 0 ? {ctor: "_Tuple3"
|
||
|
,_0: chroma
|
||
|
,_1: 0
|
||
|
,_2: x} : {ctor: "_Tuple3"
|
||
|
,_0: 0
|
||
|
,_1: 0
|
||
|
,_2: 0},
|
||
|
r = $._0,
|
||
|
g = $._1,
|
||
|
b = $._2;
|
||
|
var m = lightness - chroma / 2;
|
||
|
return {ctor: "_Tuple3"
|
||
|
,_0: r + m
|
||
|
,_1: g + m
|
||
|
,_2: b + m};
|
||
|
}();
|
||
|
});
|
||
|
var toRgb = function (color) {
|
||
|
return function () {
|
||
|
switch (color.ctor)
|
||
|
{case "HSLA":
|
||
|
return function () {
|
||
|
var $ = A3(hslToRgb,
|
||
|
color._0,
|
||
|
color._1,
|
||
|
color._2),
|
||
|
r = $._0,
|
||
|
g = $._1,
|
||
|
b = $._2;
|
||
|
return {_: {}
|
||
|
,alpha: color._3
|
||
|
,blue: $Basics.round(255 * b)
|
||
|
,green: $Basics.round(255 * g)
|
||
|
,red: $Basics.round(255 * r)};
|
||
|
}();
|
||
|
case "RGBA": return {_: {}
|
||
|
,alpha: color._3
|
||
|
,blue: color._2
|
||
|
,green: color._1
|
||
|
,red: color._0};}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 124 and 132");
|
||
|
}();
|
||
|
};
|
||
|
var toHsl = function (color) {
|
||
|
return function () {
|
||
|
switch (color.ctor)
|
||
|
{case "HSLA": return {_: {}
|
||
|
,alpha: color._3
|
||
|
,hue: color._0
|
||
|
,lightness: color._2
|
||
|
,saturation: color._1};
|
||
|
case "RGBA":
|
||
|
return function () {
|
||
|
var $ = A3(rgbToHsl,
|
||
|
color._0,
|
||
|
color._1,
|
||
|
color._2),
|
||
|
h = $._0,
|
||
|
s = $._1,
|
||
|
l = $._2;
|
||
|
return {_: {}
|
||
|
,alpha: color._3
|
||
|
,hue: h
|
||
|
,lightness: l
|
||
|
,saturation: s};
|
||
|
}();}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 114 and 121");
|
||
|
}();
|
||
|
};
|
||
|
var HSLA = F4(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d) {
|
||
|
return {ctor: "HSLA"
|
||
|
,_0: a
|
||
|
,_1: b
|
||
|
,_2: c
|
||
|
,_3: d};
|
||
|
});
|
||
|
var hsla = F4(function (hue,
|
||
|
saturation,
|
||
|
lightness,
|
||
|
alpha) {
|
||
|
return A4(HSLA,
|
||
|
hue - $Basics.turns($Basics.toFloat($Basics.floor(hue / (2 * $Basics.pi)))),
|
||
|
saturation,
|
||
|
lightness,
|
||
|
alpha);
|
||
|
});
|
||
|
var hsl = F3(function (hue,
|
||
|
saturation,
|
||
|
lightness) {
|
||
|
return A4(hsla,
|
||
|
hue,
|
||
|
saturation,
|
||
|
lightness,
|
||
|
1);
|
||
|
});
|
||
|
var complement = function (color) {
|
||
|
return function () {
|
||
|
switch (color.ctor)
|
||
|
{case "HSLA": return A4(hsla,
|
||
|
color._0 + $Basics.degrees(180),
|
||
|
color._1,
|
||
|
color._2,
|
||
|
color._3);
|
||
|
case "RGBA":
|
||
|
return function () {
|
||
|
var $ = A3(rgbToHsl,
|
||
|
color._0,
|
||
|
color._1,
|
||
|
color._2),
|
||
|
h = $._0,
|
||
|
s = $._1,
|
||
|
l = $._2;
|
||
|
return A4(hsla,
|
||
|
h + $Basics.degrees(180),
|
||
|
s,
|
||
|
l,
|
||
|
color._3);
|
||
|
}();}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 105 and 111");
|
||
|
}();
|
||
|
};
|
||
|
var grayscale = function (p) {
|
||
|
return A4(HSLA,0,0,1 - p,1);
|
||
|
};
|
||
|
var greyscale = function (p) {
|
||
|
return A4(HSLA,0,0,1 - p,1);
|
||
|
};
|
||
|
var RGBA = F4(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d) {
|
||
|
return {ctor: "RGBA"
|
||
|
,_0: a
|
||
|
,_1: b
|
||
|
,_2: c
|
||
|
,_3: d};
|
||
|
});
|
||
|
var rgba = RGBA;
|
||
|
var rgb = F3(function (r,g,b) {
|
||
|
return A4(RGBA,r,g,b,1);
|
||
|
});
|
||
|
var lightRed = A4(RGBA,
|
||
|
239,
|
||
|
41,
|
||
|
41,
|
||
|
1);
|
||
|
var red = A4(RGBA,204,0,0,1);
|
||
|
var darkRed = A4(RGBA,
|
||
|
164,
|
||
|
0,
|
||
|
0,
|
||
|
1);
|
||
|
var lightOrange = A4(RGBA,
|
||
|
252,
|
||
|
175,
|
||
|
62,
|
||
|
1);
|
||
|
var orange = A4(RGBA,
|
||
|
245,
|
||
|
121,
|
||
|
0,
|
||
|
1);
|
||
|
var darkOrange = A4(RGBA,
|
||
|
206,
|
||
|
92,
|
||
|
0,
|
||
|
1);
|
||
|
var lightYellow = A4(RGBA,
|
||
|
255,
|
||
|
233,
|
||
|
79,
|
||
|
1);
|
||
|
var yellow = A4(RGBA,
|
||
|
237,
|
||
|
212,
|
||
|
0,
|
||
|
1);
|
||
|
var darkYellow = A4(RGBA,
|
||
|
196,
|
||
|
160,
|
||
|
0,
|
||
|
1);
|
||
|
var lightGreen = A4(RGBA,
|
||
|
138,
|
||
|
226,
|
||
|
52,
|
||
|
1);
|
||
|
var green = A4(RGBA,
|
||
|
115,
|
||
|
210,
|
||
|
22,
|
||
|
1);
|
||
|
var darkGreen = A4(RGBA,
|
||
|
78,
|
||
|
154,
|
||
|
6,
|
||
|
1);
|
||
|
var lightBlue = A4(RGBA,
|
||
|
114,
|
||
|
159,
|
||
|
207,
|
||
|
1);
|
||
|
var blue = A4(RGBA,
|
||
|
52,
|
||
|
101,
|
||
|
164,
|
||
|
1);
|
||
|
var darkBlue = A4(RGBA,
|
||
|
32,
|
||
|
74,
|
||
|
135,
|
||
|
1);
|
||
|
var lightPurple = A4(RGBA,
|
||
|
173,
|
||
|
127,
|
||
|
168,
|
||
|
1);
|
||
|
var purple = A4(RGBA,
|
||
|
117,
|
||
|
80,
|
||
|
123,
|
||
|
1);
|
||
|
var darkPurple = A4(RGBA,
|
||
|
92,
|
||
|
53,
|
||
|
102,
|
||
|
1);
|
||
|
var lightBrown = A4(RGBA,
|
||
|
233,
|
||
|
185,
|
||
|
110,
|
||
|
1);
|
||
|
var brown = A4(RGBA,
|
||
|
193,
|
||
|
125,
|
||
|
17,
|
||
|
1);
|
||
|
var darkBrown = A4(RGBA,
|
||
|
143,
|
||
|
89,
|
||
|
2,
|
||
|
1);
|
||
|
var black = A4(RGBA,0,0,0,1);
|
||
|
var white = A4(RGBA,
|
||
|
255,
|
||
|
255,
|
||
|
255,
|
||
|
1);
|
||
|
var lightGrey = A4(RGBA,
|
||
|
238,
|
||
|
238,
|
||
|
236,
|
||
|
1);
|
||
|
var grey = A4(RGBA,
|
||
|
211,
|
||
|
215,
|
||
|
207,
|
||
|
1);
|
||
|
var darkGrey = A4(RGBA,
|
||
|
186,
|
||
|
189,
|
||
|
182,
|
||
|
1);
|
||
|
var lightGray = A4(RGBA,
|
||
|
238,
|
||
|
238,
|
||
|
236,
|
||
|
1);
|
||
|
var gray = A4(RGBA,
|
||
|
211,
|
||
|
215,
|
||
|
207,
|
||
|
1);
|
||
|
var darkGray = A4(RGBA,
|
||
|
186,
|
||
|
189,
|
||
|
182,
|
||
|
1);
|
||
|
var lightCharcoal = A4(RGBA,
|
||
|
136,
|
||
|
138,
|
||
|
133,
|
||
|
1);
|
||
|
var charcoal = A4(RGBA,
|
||
|
85,
|
||
|
87,
|
||
|
83,
|
||
|
1);
|
||
|
var darkCharcoal = A4(RGBA,
|
||
|
46,
|
||
|
52,
|
||
|
54,
|
||
|
1);
|
||
|
_elm.Color.values = {_op: _op
|
||
|
,rgb: rgb
|
||
|
,rgba: rgba
|
||
|
,hsl: hsl
|
||
|
,hsla: hsla
|
||
|
,greyscale: greyscale
|
||
|
,grayscale: grayscale
|
||
|
,complement: complement
|
||
|
,linear: linear
|
||
|
,radial: radial
|
||
|
,toRgb: toRgb
|
||
|
,toHsl: toHsl
|
||
|
,red: red
|
||
|
,orange: orange
|
||
|
,yellow: yellow
|
||
|
,green: green
|
||
|
,blue: blue
|
||
|
,purple: purple
|
||
|
,brown: brown
|
||
|
,lightRed: lightRed
|
||
|
,lightOrange: lightOrange
|
||
|
,lightYellow: lightYellow
|
||
|
,lightGreen: lightGreen
|
||
|
,lightBlue: lightBlue
|
||
|
,lightPurple: lightPurple
|
||
|
,lightBrown: lightBrown
|
||
|
,darkRed: darkRed
|
||
|
,darkOrange: darkOrange
|
||
|
,darkYellow: darkYellow
|
||
|
,darkGreen: darkGreen
|
||
|
,darkBlue: darkBlue
|
||
|
,darkPurple: darkPurple
|
||
|
,darkBrown: darkBrown
|
||
|
,white: white
|
||
|
,lightGrey: lightGrey
|
||
|
,grey: grey
|
||
|
,darkGrey: darkGrey
|
||
|
,lightCharcoal: lightCharcoal
|
||
|
,charcoal: charcoal
|
||
|
,darkCharcoal: darkCharcoal
|
||
|
,black: black
|
||
|
,lightGray: lightGray
|
||
|
,gray: gray
|
||
|
,darkGray: darkGray};
|
||
|
return _elm.Color.values;
|
||
|
};
|
||
|
Elm.Debug = Elm.Debug || {};
|
||
|
Elm.Debug.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Debug = _elm.Debug || {};
|
||
|
if (_elm.Debug.values)
|
||
|
return _elm.Debug.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Debug",
|
||
|
$Graphics$Collage = Elm.Graphics.Collage.make(_elm),
|
||
|
$Native$Debug = Elm.Native.Debug.make(_elm);
|
||
|
var trace = $Native$Debug.tracePath;
|
||
|
var watchSummary = $Native$Debug.watchSummary;
|
||
|
var watch = $Native$Debug.watch;
|
||
|
var crash = $Native$Debug.crash;
|
||
|
var log = $Native$Debug.log;
|
||
|
_elm.Debug.values = {_op: _op
|
||
|
,log: log
|
||
|
,crash: crash
|
||
|
,watch: watch
|
||
|
,watchSummary: watchSummary
|
||
|
,trace: trace};
|
||
|
return _elm.Debug.values;
|
||
|
};
|
||
|
Elm.Dict = Elm.Dict || {};
|
||
|
Elm.Dict.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Dict = _elm.Dict || {};
|
||
|
if (_elm.Dict.values)
|
||
|
return _elm.Dict.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Dict",
|
||
|
$Basics = Elm.Basics.make(_elm),
|
||
|
$List = Elm.List.make(_elm),
|
||
|
$Maybe = Elm.Maybe.make(_elm),
|
||
|
$Native$Debug = Elm.Native.Debug.make(_elm),
|
||
|
$String = Elm.String.make(_elm);
|
||
|
var foldr = F3(function (f,
|
||
|
acc,
|
||
|
t) {
|
||
|
return function () {
|
||
|
switch (t.ctor)
|
||
|
{case "RBEmpty":
|
||
|
switch (t._0.ctor)
|
||
|
{case "LBlack": return acc;}
|
||
|
break;
|
||
|
case "RBNode": return A3(foldr,
|
||
|
f,
|
||
|
A3(f,
|
||
|
t._1,
|
||
|
t._2,
|
||
|
A3(foldr,f,acc,t._4)),
|
||
|
t._3);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 408 and 416");
|
||
|
}();
|
||
|
});
|
||
|
var keys = function (dict) {
|
||
|
return A3(foldr,
|
||
|
F3(function (key,
|
||
|
value,
|
||
|
keyList) {
|
||
|
return A2($List._op["::"],
|
||
|
key,
|
||
|
keyList);
|
||
|
}),
|
||
|
_L.fromArray([]),
|
||
|
dict);
|
||
|
};
|
||
|
var values = function (dict) {
|
||
|
return A3(foldr,
|
||
|
F3(function (key,
|
||
|
value,
|
||
|
valueList) {
|
||
|
return A2($List._op["::"],
|
||
|
value,
|
||
|
valueList);
|
||
|
}),
|
||
|
_L.fromArray([]),
|
||
|
dict);
|
||
|
};
|
||
|
var toList = function (dict) {
|
||
|
return A3(foldr,
|
||
|
F3(function (key,value,list) {
|
||
|
return A2($List._op["::"],
|
||
|
{ctor: "_Tuple2"
|
||
|
,_0: key
|
||
|
,_1: value},
|
||
|
list);
|
||
|
}),
|
||
|
_L.fromArray([]),
|
||
|
dict);
|
||
|
};
|
||
|
var foldl = F3(function (f,
|
||
|
acc,
|
||
|
dict) {
|
||
|
return function () {
|
||
|
switch (dict.ctor)
|
||
|
{case "RBEmpty":
|
||
|
switch (dict._0.ctor)
|
||
|
{case "LBlack": return acc;}
|
||
|
break;
|
||
|
case "RBNode": return A3(foldl,
|
||
|
f,
|
||
|
A3(f,
|
||
|
dict._1,
|
||
|
dict._2,
|
||
|
A3(foldl,f,acc,dict._3)),
|
||
|
dict._4);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 397 and 405");
|
||
|
}();
|
||
|
});
|
||
|
var isBBlack = function (dict) {
|
||
|
return function () {
|
||
|
switch (dict.ctor)
|
||
|
{case "RBEmpty":
|
||
|
switch (dict._0.ctor)
|
||
|
{case "LBBlack": return true;}
|
||
|
break;
|
||
|
case "RBNode":
|
||
|
switch (dict._0.ctor)
|
||
|
{case "BBlack": return true;}
|
||
|
break;}
|
||
|
return false;
|
||
|
}();
|
||
|
};
|
||
|
var showFlag = function (f) {
|
||
|
return function () {
|
||
|
switch (f.ctor)
|
||
|
{case "Insert": return "Insert";
|
||
|
case "Remove": return "Remove";
|
||
|
case "Same": return "Same";}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 173 and 179");
|
||
|
}();
|
||
|
};
|
||
|
var Same = {ctor: "Same"};
|
||
|
var Remove = {ctor: "Remove"};
|
||
|
var Insert = {ctor: "Insert"};
|
||
|
var get = F2(function (targetKey,
|
||
|
dict) {
|
||
|
return function () {
|
||
|
switch (dict.ctor)
|
||
|
{case "RBEmpty":
|
||
|
switch (dict._0.ctor)
|
||
|
{case "LBlack":
|
||
|
return $Maybe.Nothing;}
|
||
|
break;
|
||
|
case "RBNode":
|
||
|
return function () {
|
||
|
var _v29 = A2($Basics.compare,
|
||
|
targetKey,
|
||
|
dict._1);
|
||
|
switch (_v29.ctor)
|
||
|
{case "EQ":
|
||
|
return $Maybe.Just(dict._2);
|
||
|
case "GT": return A2(get,
|
||
|
targetKey,
|
||
|
dict._4);
|
||
|
case "LT": return A2(get,
|
||
|
targetKey,
|
||
|
dict._3);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 129 and 135");
|
||
|
}();}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 124 and 135");
|
||
|
}();
|
||
|
});
|
||
|
var member = F2(function (key,
|
||
|
dict) {
|
||
|
return function () {
|
||
|
var _v30 = A2(get,key,dict);
|
||
|
switch (_v30.ctor)
|
||
|
{case "Just": return true;
|
||
|
case "Nothing": return false;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 138 and 140");
|
||
|
}();
|
||
|
});
|
||
|
var max = function (dict) {
|
||
|
return function () {
|
||
|
switch (dict.ctor)
|
||
|
{case "RBEmpty":
|
||
|
return $Native$Debug.crash("(max Empty) is not defined");
|
||
|
case "RBNode":
|
||
|
switch (dict._4.ctor)
|
||
|
{case "RBEmpty":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: dict._1
|
||
|
,_1: dict._2};}
|
||
|
return max(dict._4);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 100 and 121");
|
||
|
}();
|
||
|
};
|
||
|
var min = function (dict) {
|
||
|
return function () {
|
||
|
switch (dict.ctor)
|
||
|
{case "RBEmpty":
|
||
|
switch (dict._0.ctor)
|
||
|
{case "LBlack":
|
||
|
return $Native$Debug.crash("(min Empty) is not defined");}
|
||
|
break;
|
||
|
case "RBNode":
|
||
|
switch (dict._3.ctor)
|
||
|
{case "RBEmpty":
|
||
|
switch (dict._3._0.ctor)
|
||
|
{case "LBlack":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: dict._1
|
||
|
,_1: dict._2};}
|
||
|
break;}
|
||
|
return min(dict._3);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 87 and 95");
|
||
|
}();
|
||
|
};
|
||
|
var RBEmpty = function (a) {
|
||
|
return {ctor: "RBEmpty"
|
||
|
,_0: a};
|
||
|
};
|
||
|
var RBNode = F5(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d,
|
||
|
e) {
|
||
|
return {ctor: "RBNode"
|
||
|
,_0: a
|
||
|
,_1: b
|
||
|
,_2: c
|
||
|
,_3: d
|
||
|
,_4: e};
|
||
|
});
|
||
|
var showLColor = function (color) {
|
||
|
return function () {
|
||
|
switch (color.ctor)
|
||
|
{case "LBBlack":
|
||
|
return "LBBlack";
|
||
|
case "LBlack": return "LBlack";}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 70 and 72");
|
||
|
}();
|
||
|
};
|
||
|
var LBBlack = {ctor: "LBBlack"};
|
||
|
var LBlack = {ctor: "LBlack"};
|
||
|
var empty = RBEmpty(LBlack);
|
||
|
var map = F2(function (f,dict) {
|
||
|
return function () {
|
||
|
switch (dict.ctor)
|
||
|
{case "RBEmpty":
|
||
|
switch (dict._0.ctor)
|
||
|
{case "LBlack":
|
||
|
return RBEmpty(LBlack);}
|
||
|
break;
|
||
|
case "RBNode": return A5(RBNode,
|
||
|
dict._0,
|
||
|
dict._1,
|
||
|
A2(f,dict._1,dict._2),
|
||
|
A2(map,f,dict._3),
|
||
|
A2(map,f,dict._4));}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 385 and 394");
|
||
|
}();
|
||
|
});
|
||
|
var showNColor = function (c) {
|
||
|
return function () {
|
||
|
switch (c.ctor)
|
||
|
{case "BBlack": return "BBlack";
|
||
|
case "Black": return "Black";
|
||
|
case "NBlack": return "NBlack";
|
||
|
case "Red": return "Red";}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 56 and 60");
|
||
|
}();
|
||
|
};
|
||
|
var reportRemBug = F4(function (msg,
|
||
|
c,
|
||
|
lgot,
|
||
|
rgot) {
|
||
|
return $Native$Debug.crash($String.concat(_L.fromArray(["Internal red-black tree invariant violated, expected "
|
||
|
,msg
|
||
|
," and got "
|
||
|
,showNColor(c)
|
||
|
,"/"
|
||
|
,lgot
|
||
|
,"/"
|
||
|
,rgot
|
||
|
,"\nPlease report this bug to <https://github.com/elm-lang/Elm/issues>"])));
|
||
|
});
|
||
|
var NBlack = {ctor: "NBlack"};
|
||
|
var BBlack = {ctor: "BBlack"};
|
||
|
var Black = {ctor: "Black"};
|
||
|
var ensureBlackRoot = function (dict) {
|
||
|
return function () {
|
||
|
switch (dict.ctor)
|
||
|
{case "RBEmpty":
|
||
|
switch (dict._0.ctor)
|
||
|
{case "LBlack": return dict;}
|
||
|
break;
|
||
|
case "RBNode":
|
||
|
switch (dict._0.ctor)
|
||
|
{case "Black": return dict;
|
||
|
case "Red": return A5(RBNode,
|
||
|
Black,
|
||
|
dict._1,
|
||
|
dict._2,
|
||
|
dict._3,
|
||
|
dict._4);}
|
||
|
break;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 145 and 157");
|
||
|
}();
|
||
|
};
|
||
|
var blackish = function (t) {
|
||
|
return function () {
|
||
|
switch (t.ctor)
|
||
|
{case "RBEmpty": return true;
|
||
|
case "RBNode":
|
||
|
return _U.eq(t._0,
|
||
|
Black) || _U.eq(t._0,BBlack);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 330 and 332");
|
||
|
}();
|
||
|
};
|
||
|
var blacken = function (t) {
|
||
|
return function () {
|
||
|
switch (t.ctor)
|
||
|
{case "RBEmpty":
|
||
|
return RBEmpty(LBlack);
|
||
|
case "RBNode": return A5(RBNode,
|
||
|
Black,
|
||
|
t._1,
|
||
|
t._2,
|
||
|
t._3,
|
||
|
t._4);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 369 and 371");
|
||
|
}();
|
||
|
};
|
||
|
var Red = {ctor: "Red"};
|
||
|
var moreBlack = function (color) {
|
||
|
return function () {
|
||
|
switch (color.ctor)
|
||
|
{case "BBlack":
|
||
|
return $Native$Debug.crash("Can\'t make a double black node more black!");
|
||
|
case "Black": return BBlack;
|
||
|
case "NBlack": return Red;
|
||
|
case "Red": return Black;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 235 and 239");
|
||
|
}();
|
||
|
};
|
||
|
var lessBlack = function (color) {
|
||
|
return function () {
|
||
|
switch (color.ctor)
|
||
|
{case "BBlack": return Black;
|
||
|
case "Black": return Red;
|
||
|
case "NBlack":
|
||
|
return $Native$Debug.crash("Can\'t make a negative black node less black!");
|
||
|
case "Red": return NBlack;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 244 and 248");
|
||
|
}();
|
||
|
};
|
||
|
var lessBlackTree = function (dict) {
|
||
|
return function () {
|
||
|
switch (dict.ctor)
|
||
|
{case "RBEmpty":
|
||
|
switch (dict._0.ctor)
|
||
|
{case "LBBlack":
|
||
|
return RBEmpty(LBlack);}
|
||
|
break;
|
||
|
case "RBNode": return A5(RBNode,
|
||
|
lessBlack(dict._0),
|
||
|
dict._1,
|
||
|
dict._2,
|
||
|
dict._3,
|
||
|
dict._4);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 253 and 255");
|
||
|
}();
|
||
|
};
|
||
|
var redden = function (t) {
|
||
|
return function () {
|
||
|
switch (t.ctor)
|
||
|
{case "RBEmpty":
|
||
|
return $Native$Debug.crash("can\'t make a Leaf red");
|
||
|
case "RBNode": return A5(RBNode,
|
||
|
Red,
|
||
|
t._1,
|
||
|
t._2,
|
||
|
t._3,
|
||
|
t._4);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 377 and 382");
|
||
|
}();
|
||
|
};
|
||
|
var balance_node = function (t) {
|
||
|
return function () {
|
||
|
var assemble = function (col) {
|
||
|
return function (xk) {
|
||
|
return function (xv) {
|
||
|
return function (yk) {
|
||
|
return function (yv) {
|
||
|
return function (zk) {
|
||
|
return function (zv) {
|
||
|
return function (a) {
|
||
|
return function (b) {
|
||
|
return function (c) {
|
||
|
return function (d) {
|
||
|
return A5(RBNode,
|
||
|
lessBlack(col),
|
||
|
yk,
|
||
|
yv,
|
||
|
A5(RBNode,Black,xk,xv,a,b),
|
||
|
A5(RBNode,Black,zk,zv,c,d));
|
||
|
};
|
||
|
};
|
||
|
};
|
||
|
};
|
||
|
};
|
||
|
};
|
||
|
};
|
||
|
};
|
||
|
};
|
||
|
};
|
||
|
};
|
||
|
return blackish(t) ? function () {
|
||
|
switch (t.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._3.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._3._0.ctor)
|
||
|
{case "Red":
|
||
|
switch (t._3._3.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._3._3._0.ctor)
|
||
|
{case "Red":
|
||
|
return assemble(t._0)(t._3._3._1)(t._3._3._2)(t._3._1)(t._3._2)(t._1)(t._2)(t._3._3._3)(t._3._3._4)(t._3._4)(t._4);}
|
||
|
break;}
|
||
|
switch (t._3._4.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._3._4._0.ctor)
|
||
|
{case "Red":
|
||
|
return assemble(t._0)(t._3._1)(t._3._2)(t._3._4._1)(t._3._4._2)(t._1)(t._2)(t._3._3)(t._3._4._3)(t._3._4._4)(t._4);}
|
||
|
break;}
|
||
|
break;}
|
||
|
break;}
|
||
|
switch (t._4.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._4._0.ctor)
|
||
|
{case "Red":
|
||
|
switch (t._4._3.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._4._3._0.ctor)
|
||
|
{case "Red":
|
||
|
return assemble(t._0)(t._1)(t._2)(t._4._3._1)(t._4._3._2)(t._4._1)(t._4._2)(t._3)(t._4._3._3)(t._4._3._4)(t._4._4);}
|
||
|
break;}
|
||
|
switch (t._4._4.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._4._4._0.ctor)
|
||
|
{case "Red":
|
||
|
return assemble(t._0)(t._1)(t._2)(t._4._1)(t._4._2)(t._4._4._1)(t._4._4._2)(t._3)(t._4._3)(t._4._4._3)(t._4._4._4);}
|
||
|
break;}
|
||
|
break;}
|
||
|
break;}
|
||
|
switch (t._0.ctor)
|
||
|
{case "BBlack":
|
||
|
switch (t._4.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._4._0.ctor)
|
||
|
{case "NBlack":
|
||
|
switch (t._4._3.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._4._3._0.ctor)
|
||
|
{case "Black":
|
||
|
return function () {
|
||
|
switch (t._4._4.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._4._4._0.ctor)
|
||
|
{case "Black":
|
||
|
return A5(RBNode,
|
||
|
Black,
|
||
|
t._4._3._1,
|
||
|
t._4._3._2,
|
||
|
A5(RBNode,
|
||
|
Black,
|
||
|
t._1,
|
||
|
t._2,
|
||
|
t._3,
|
||
|
t._4._3._3),
|
||
|
A5(balance,
|
||
|
Black,
|
||
|
t._4._1,
|
||
|
t._4._2,
|
||
|
t._4._3._4,
|
||
|
redden(t._4._4)));}
|
||
|
break;}
|
||
|
return t;
|
||
|
}();}
|
||
|
break;}
|
||
|
break;}
|
||
|
break;}
|
||
|
switch (t._3.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._3._0.ctor)
|
||
|
{case "NBlack":
|
||
|
switch (t._3._4.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._3._4._0.ctor)
|
||
|
{case "Black":
|
||
|
return function () {
|
||
|
switch (t._3._3.ctor)
|
||
|
{case "RBNode":
|
||
|
switch (t._3._3._0.ctor)
|
||
|
{case "Black":
|
||
|
return A5(RBNode,
|
||
|
Black,
|
||
|
t._3._4._1,
|
||
|
t._3._4._2,
|
||
|
A5(balance,
|
||
|
Black,
|
||
|
t._3._1,
|
||
|
t._3._2,
|
||
|
redden(t._3._3),
|
||
|
t._3._4._3),
|
||
|
A5(RBNode,
|
||
|
Black,
|
||
|
t._1,
|
||
|
t._2,
|
||
|
t._3._4._4,
|
||
|
t._4));}
|
||
|
break;}
|
||
|
return t;
|
||
|
}();}
|
||
|
break;}
|
||
|
break;}
|
||
|
break;}
|
||
|
break;}
|
||
|
break;}
|
||
|
return t;
|
||
|
}() : t;
|
||
|
}();
|
||
|
};
|
||
|
var balance = F5(function (c,
|
||
|
k,
|
||
|
v,
|
||
|
l,
|
||
|
r) {
|
||
|
return balance_node(A5(RBNode,
|
||
|
c,
|
||
|
k,
|
||
|
v,
|
||
|
l,
|
||
|
r));
|
||
|
});
|
||
|
var bubble = F5(function (c,
|
||
|
k,
|
||
|
v,
|
||
|
l,
|
||
|
r) {
|
||
|
return isBBlack(l) || isBBlack(r) ? A5(balance,
|
||
|
moreBlack(c),
|
||
|
k,
|
||
|
v,
|
||
|
lessBlackTree(l),
|
||
|
lessBlackTree(r)) : A5(RBNode,
|
||
|
c,
|
||
|
k,
|
||
|
v,
|
||
|
l,
|
||
|
r);
|
||
|
});
|
||
|
var remove_max = F5(function (c,
|
||
|
k,
|
||
|
v,
|
||
|
l,
|
||
|
r) {
|
||
|
return function () {
|
||
|
switch (r.ctor)
|
||
|
{case "RBEmpty": return A3(rem,
|
||
|
c,
|
||
|
l,
|
||
|
r);
|
||
|
case "RBNode": return A5(bubble,
|
||
|
c,
|
||
|
k,
|
||
|
v,
|
||
|
l,
|
||
|
A5(remove_max,
|
||
|
r._0,
|
||
|
r._1,
|
||
|
r._2,
|
||
|
r._3,
|
||
|
r._4));}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 314 and 319");
|
||
|
}();
|
||
|
});
|
||
|
var rem = F3(function (c,l,r) {
|
||
|
return function () {
|
||
|
var _v169 = {ctor: "_Tuple2"
|
||
|
,_0: l
|
||
|
,_1: r};
|
||
|
switch (_v169.ctor)
|
||
|
{case "_Tuple2":
|
||
|
switch (_v169._0.ctor)
|
||
|
{case "RBEmpty":
|
||
|
switch (_v169._1.ctor)
|
||
|
{case "RBEmpty":
|
||
|
return function () {
|
||
|
switch (c.ctor)
|
||
|
{case "Black":
|
||
|
return RBEmpty(LBBlack);
|
||
|
case "Red":
|
||
|
return RBEmpty(LBlack);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 273 and 277");
|
||
|
}();
|
||
|
case "RBNode":
|
||
|
return function () {
|
||
|
var _v191 = {ctor: "_Tuple3"
|
||
|
,_0: c
|
||
|
,_1: _v169._0._0
|
||
|
,_2: _v169._1._0};
|
||
|
switch (_v191.ctor)
|
||
|
{case "_Tuple3":
|
||
|
switch (_v191._0.ctor)
|
||
|
{case "Black":
|
||
|
switch (_v191._1.ctor)
|
||
|
{case "LBlack":
|
||
|
switch (_v191._2.ctor)
|
||
|
{case "Red": return A5(RBNode,
|
||
|
Black,
|
||
|
_v169._1._1,
|
||
|
_v169._1._2,
|
||
|
_v169._1._3,
|
||
|
_v169._1._4);}
|
||
|
break;}
|
||
|
break;}
|
||
|
break;}
|
||
|
return A4(reportRemBug,
|
||
|
"Black/LBlack/Red",
|
||
|
c,
|
||
|
showLColor(_v169._0._0),
|
||
|
showNColor(_v169._1._0));
|
||
|
}();}
|
||
|
break;
|
||
|
case "RBNode":
|
||
|
switch (_v169._1.ctor)
|
||
|
{case "RBEmpty":
|
||
|
return function () {
|
||
|
var _v195 = {ctor: "_Tuple3"
|
||
|
,_0: c
|
||
|
,_1: _v169._0._0
|
||
|
,_2: _v169._1._0};
|
||
|
switch (_v195.ctor)
|
||
|
{case "_Tuple3":
|
||
|
switch (_v195._0.ctor)
|
||
|
{case "Black":
|
||
|
switch (_v195._1.ctor)
|
||
|
{case "Red":
|
||
|
switch (_v195._2.ctor)
|
||
|
{case "LBlack":
|
||
|
return A5(RBNode,
|
||
|
Black,
|
||
|
_v169._0._1,
|
||
|
_v169._0._2,
|
||
|
_v169._0._3,
|
||
|
_v169._0._4);}
|
||
|
break;}
|
||
|
break;}
|
||
|
break;}
|
||
|
return A4(reportRemBug,
|
||
|
"Black/Red/LBlack",
|
||
|
c,
|
||
|
showNColor(_v169._0._0),
|
||
|
showLColor(_v169._1._0));
|
||
|
}();
|
||
|
case "RBNode":
|
||
|
return function () {
|
||
|
var l$ = A5(remove_max,
|
||
|
_v169._0._0,
|
||
|
_v169._0._1,
|
||
|
_v169._0._2,
|
||
|
_v169._0._3,
|
||
|
_v169._0._4);
|
||
|
var r = A5(RBNode,
|
||
|
_v169._1._0,
|
||
|
_v169._1._1,
|
||
|
_v169._1._2,
|
||
|
_v169._1._3,
|
||
|
_v169._1._4);
|
||
|
var l = A5(RBNode,
|
||
|
_v169._0._0,
|
||
|
_v169._0._1,
|
||
|
_v169._0._2,
|
||
|
_v169._0._3,
|
||
|
_v169._0._4);
|
||
|
var $ = max(l),
|
||
|
k = $._0,
|
||
|
v = $._1;
|
||
|
return A5(bubble,c,k,v,l$,r);
|
||
|
}();}
|
||
|
break;}
|
||
|
break;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 271 and 300");
|
||
|
}();
|
||
|
});
|
||
|
var update = F3(function (k,
|
||
|
alter,
|
||
|
dict) {
|
||
|
return function () {
|
||
|
var up = function (dict) {
|
||
|
return function () {
|
||
|
switch (dict.ctor)
|
||
|
{case "RBEmpty":
|
||
|
switch (dict._0.ctor)
|
||
|
{case "LBlack":
|
||
|
return function () {
|
||
|
var _v206 = alter($Maybe.Nothing);
|
||
|
switch (_v206.ctor)
|
||
|
{case "Just":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: Insert
|
||
|
,_1: A5(RBNode,
|
||
|
Red,
|
||
|
k,
|
||
|
_v206._0,
|
||
|
empty,
|
||
|
empty)};
|
||
|
case "Nothing":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: Same
|
||
|
,_1: empty};}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 185 and 189");
|
||
|
}();}
|
||
|
break;
|
||
|
case "RBNode":
|
||
|
return function () {
|
||
|
var _v208 = A2($Basics.compare,
|
||
|
k,
|
||
|
dict._1);
|
||
|
switch (_v208.ctor)
|
||
|
{case "EQ": return function () {
|
||
|
var _v209 = alter($Maybe.Just(dict._2));
|
||
|
switch (_v209.ctor)
|
||
|
{case "Just":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: Same
|
||
|
,_1: A5(RBNode,
|
||
|
dict._0,
|
||
|
dict._1,
|
||
|
_v209._0,
|
||
|
dict._3,
|
||
|
dict._4)};
|
||
|
case "Nothing":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: Remove
|
||
|
,_1: A3(rem,
|
||
|
dict._0,
|
||
|
dict._3,
|
||
|
dict._4)};}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 192 and 197");
|
||
|
}();
|
||
|
case "GT": return function () {
|
||
|
var $ = up(dict._4),
|
||
|
flag = $._0,
|
||
|
newRight = $._1;
|
||
|
return function () {
|
||
|
switch (flag.ctor)
|
||
|
{case "Insert":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: Insert
|
||
|
,_1: A5(balance,
|
||
|
dict._0,
|
||
|
dict._1,
|
||
|
dict._2,
|
||
|
dict._3,
|
||
|
newRight)};
|
||
|
case "Remove":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: Remove
|
||
|
,_1: A5(bubble,
|
||
|
dict._0,
|
||
|
dict._1,
|
||
|
dict._2,
|
||
|
dict._3,
|
||
|
newRight)};
|
||
|
case "Same":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: Same
|
||
|
,_1: A5(RBNode,
|
||
|
dict._0,
|
||
|
dict._1,
|
||
|
dict._2,
|
||
|
dict._3,
|
||
|
newRight)};}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 206 and 211");
|
||
|
}();
|
||
|
}();
|
||
|
case "LT": return function () {
|
||
|
var $ = up(dict._3),
|
||
|
flag = $._0,
|
||
|
newLeft = $._1;
|
||
|
return function () {
|
||
|
switch (flag.ctor)
|
||
|
{case "Insert":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: Insert
|
||
|
,_1: A5(balance,
|
||
|
dict._0,
|
||
|
dict._1,
|
||
|
dict._2,
|
||
|
newLeft,
|
||
|
dict._4)};
|
||
|
case "Remove":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: Remove
|
||
|
,_1: A5(bubble,
|
||
|
dict._0,
|
||
|
dict._1,
|
||
|
dict._2,
|
||
|
newLeft,
|
||
|
dict._4)};
|
||
|
case "Same":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: Same
|
||
|
,_1: A5(RBNode,
|
||
|
dict._0,
|
||
|
dict._1,
|
||
|
dict._2,
|
||
|
newLeft,
|
||
|
dict._4)};}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 199 and 204");
|
||
|
}();
|
||
|
}();}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 190 and 211");
|
||
|
}();}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 183 and 211");
|
||
|
}();
|
||
|
};
|
||
|
var $ = up(dict),
|
||
|
flag = $._0,
|
||
|
updatedDict = $._1;
|
||
|
return function () {
|
||
|
switch (flag.ctor)
|
||
|
{case "Insert":
|
||
|
return ensureBlackRoot(updatedDict);
|
||
|
case "Remove":
|
||
|
return blacken(updatedDict);
|
||
|
case "Same":
|
||
|
return updatedDict;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 213 and 219");
|
||
|
}();
|
||
|
}();
|
||
|
});
|
||
|
var insert = F3(function (key,
|
||
|
value,
|
||
|
dict) {
|
||
|
return A3(update,
|
||
|
key,
|
||
|
$Basics.always($Maybe.Just(value)),
|
||
|
dict);
|
||
|
});
|
||
|
var singleton = F2(function (key,
|
||
|
value) {
|
||
|
return A3(insert,
|
||
|
key,
|
||
|
value,
|
||
|
RBEmpty(LBlack));
|
||
|
});
|
||
|
var union = F2(function (t1,
|
||
|
t2) {
|
||
|
return A3(foldl,
|
||
|
insert,
|
||
|
t2,
|
||
|
t1);
|
||
|
});
|
||
|
var fromList = function (assocs) {
|
||
|
return A3($List.foldl,
|
||
|
F2(function (_v214,dict) {
|
||
|
return function () {
|
||
|
switch (_v214.ctor)
|
||
|
{case "_Tuple2":
|
||
|
return A3(insert,
|
||
|
_v214._0,
|
||
|
_v214._1,
|
||
|
dict);}
|
||
|
_U.badCase($moduleName,
|
||
|
"on line 457, column 38 to 59");
|
||
|
}();
|
||
|
}),
|
||
|
empty,
|
||
|
assocs);
|
||
|
};
|
||
|
var filter = F2(function (predicate,
|
||
|
dictionary) {
|
||
|
return function () {
|
||
|
var add = F3(function (key,
|
||
|
value,
|
||
|
dict) {
|
||
|
return A2(predicate,
|
||
|
key,
|
||
|
value) ? A3(insert,
|
||
|
key,
|
||
|
value,
|
||
|
dict) : dict;
|
||
|
});
|
||
|
return A3(foldl,
|
||
|
add,
|
||
|
empty,
|
||
|
dictionary);
|
||
|
}();
|
||
|
});
|
||
|
var intersect = F2(function (t1,
|
||
|
t2) {
|
||
|
return A2(filter,
|
||
|
F2(function (k,_v218) {
|
||
|
return function () {
|
||
|
return A2(member,k,t2);
|
||
|
}();
|
||
|
}),
|
||
|
t1);
|
||
|
});
|
||
|
var partition = F2(function (predicate,
|
||
|
dict) {
|
||
|
return function () {
|
||
|
var add = F3(function (key,
|
||
|
value,
|
||
|
_v220) {
|
||
|
return function () {
|
||
|
switch (_v220.ctor)
|
||
|
{case "_Tuple2":
|
||
|
return A2(predicate,
|
||
|
key,
|
||
|
value) ? {ctor: "_Tuple2"
|
||
|
,_0: A3(insert,
|
||
|
key,
|
||
|
value,
|
||
|
_v220._0)
|
||
|
,_1: _v220._1} : {ctor: "_Tuple2"
|
||
|
,_0: _v220._0
|
||
|
,_1: A3(insert,
|
||
|
key,
|
||
|
value,
|
||
|
_v220._1)};}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 478 and 480");
|
||
|
}();
|
||
|
});
|
||
|
return A3(foldl,
|
||
|
add,
|
||
|
{ctor: "_Tuple2"
|
||
|
,_0: empty
|
||
|
,_1: empty},
|
||
|
dict);
|
||
|
}();
|
||
|
});
|
||
|
var remove = F2(function (key,
|
||
|
dict) {
|
||
|
return A3(update,
|
||
|
key,
|
||
|
$Basics.always($Maybe.Nothing),
|
||
|
dict);
|
||
|
});
|
||
|
var diff = F2(function (t1,t2) {
|
||
|
return A3(foldl,
|
||
|
F3(function (k,v,t) {
|
||
|
return A2(remove,k,t);
|
||
|
}),
|
||
|
t1,
|
||
|
t2);
|
||
|
});
|
||
|
_elm.Dict.values = {_op: _op
|
||
|
,empty: empty
|
||
|
,singleton: singleton
|
||
|
,insert: insert
|
||
|
,update: update
|
||
|
,get: get
|
||
|
,remove: remove
|
||
|
,member: member
|
||
|
,filter: filter
|
||
|
,partition: partition
|
||
|
,foldl: foldl
|
||
|
,foldr: foldr
|
||
|
,map: map
|
||
|
,union: union
|
||
|
,intersect: intersect
|
||
|
,diff: diff
|
||
|
,keys: keys
|
||
|
,values: values
|
||
|
,toList: toList
|
||
|
,fromList: fromList};
|
||
|
return _elm.Dict.values;
|
||
|
};
|
||
|
Elm.Graphics = Elm.Graphics || {};
|
||
|
Elm.Graphics.Collage = Elm.Graphics.Collage || {};
|
||
|
Elm.Graphics.Collage.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Graphics = _elm.Graphics || {};
|
||
|
_elm.Graphics.Collage = _elm.Graphics.Collage || {};
|
||
|
if (_elm.Graphics.Collage.values)
|
||
|
return _elm.Graphics.Collage.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Graphics.Collage",
|
||
|
$Basics = Elm.Basics.make(_elm),
|
||
|
$Color = Elm.Color.make(_elm),
|
||
|
$Graphics$Element = Elm.Graphics.Element.make(_elm),
|
||
|
$List = Elm.List.make(_elm),
|
||
|
$Native$Graphics$Collage = Elm.Native.Graphics.Collage.make(_elm),
|
||
|
$Text = Elm.Text.make(_elm),
|
||
|
$Transform2D = Elm.Transform2D.make(_elm);
|
||
|
var ngon = F2(function (n,r) {
|
||
|
return function () {
|
||
|
var m = $Basics.toFloat(n);
|
||
|
var t = 2 * $Basics.pi / m;
|
||
|
var f = function (i) {
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: r * $Basics.cos(t * i)
|
||
|
,_1: r * $Basics.sin(t * i)};
|
||
|
};
|
||
|
return A2($List.map,
|
||
|
f,
|
||
|
_L.range(0,m - 1));
|
||
|
}();
|
||
|
});
|
||
|
var oval = F2(function (w,h) {
|
||
|
return function () {
|
||
|
var hh = h / 2;
|
||
|
var hw = w / 2;
|
||
|
var n = 50;
|
||
|
var t = 2 * $Basics.pi / n;
|
||
|
var f = function (i) {
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: hw * $Basics.cos(t * i)
|
||
|
,_1: hh * $Basics.sin(t * i)};
|
||
|
};
|
||
|
return A2($List.map,
|
||
|
f,
|
||
|
_L.range(0,n - 1));
|
||
|
}();
|
||
|
});
|
||
|
var circle = function (r) {
|
||
|
return A2(oval,2 * r,2 * r);
|
||
|
};
|
||
|
var rect = F2(function (w,h) {
|
||
|
return function () {
|
||
|
var hh = h / 2;
|
||
|
var hw = w / 2;
|
||
|
return _L.fromArray([{ctor: "_Tuple2"
|
||
|
,_0: 0 - hw
|
||
|
,_1: 0 - hh}
|
||
|
,{ctor: "_Tuple2"
|
||
|
,_0: 0 - hw
|
||
|
,_1: hh}
|
||
|
,{ctor: "_Tuple2",_0: hw,_1: hh}
|
||
|
,{ctor: "_Tuple2"
|
||
|
,_0: hw
|
||
|
,_1: 0 - hh}]);
|
||
|
}();
|
||
|
});
|
||
|
var square = function (n) {
|
||
|
return A2(rect,n,n);
|
||
|
};
|
||
|
var polygon = function (points) {
|
||
|
return points;
|
||
|
};
|
||
|
var segment = F2(function (p1,
|
||
|
p2) {
|
||
|
return _L.fromArray([p1,p2]);
|
||
|
});
|
||
|
var path = function (ps) {
|
||
|
return ps;
|
||
|
};
|
||
|
var collage = $Native$Graphics$Collage.collage;
|
||
|
var alpha = F2(function (a,f) {
|
||
|
return _U.replace([["alpha"
|
||
|
,a]],
|
||
|
f);
|
||
|
});
|
||
|
var rotate = F2(function (t,f) {
|
||
|
return _U.replace([["theta"
|
||
|
,f.theta + t]],
|
||
|
f);
|
||
|
});
|
||
|
var scale = F2(function (s,f) {
|
||
|
return _U.replace([["scale"
|
||
|
,f.scale * s]],
|
||
|
f);
|
||
|
});
|
||
|
var moveY = F2(function (y,f) {
|
||
|
return _U.replace([["y"
|
||
|
,f.y + y]],
|
||
|
f);
|
||
|
});
|
||
|
var moveX = F2(function (x,f) {
|
||
|
return _U.replace([["x"
|
||
|
,f.x + x]],
|
||
|
f);
|
||
|
});
|
||
|
var move = F2(function (_v0,f) {
|
||
|
return function () {
|
||
|
switch (_v0.ctor)
|
||
|
{case "_Tuple2":
|
||
|
return _U.replace([["x"
|
||
|
,f.x + _v0._0]
|
||
|
,["y",f.y + _v0._1]],
|
||
|
f);}
|
||
|
_U.badCase($moduleName,
|
||
|
"on line 226, column 7 to 35");
|
||
|
}();
|
||
|
});
|
||
|
var form = function (f) {
|
||
|
return {_: {}
|
||
|
,alpha: 1
|
||
|
,form: f
|
||
|
,scale: 1
|
||
|
,theta: 0
|
||
|
,x: 0
|
||
|
,y: 0};
|
||
|
};
|
||
|
var Fill = function (a) {
|
||
|
return {ctor: "Fill",_0: a};
|
||
|
};
|
||
|
var Line = function (a) {
|
||
|
return {ctor: "Line",_0: a};
|
||
|
};
|
||
|
var FGroup = F2(function (a,b) {
|
||
|
return {ctor: "FGroup"
|
||
|
,_0: a
|
||
|
,_1: b};
|
||
|
});
|
||
|
var group = function (fs) {
|
||
|
return form(A2(FGroup,
|
||
|
$Transform2D.identity,
|
||
|
fs));
|
||
|
};
|
||
|
var groupTransform = F2(function (matrix,
|
||
|
fs) {
|
||
|
return form(A2(FGroup,
|
||
|
matrix,
|
||
|
fs));
|
||
|
});
|
||
|
var FElement = function (a) {
|
||
|
return {ctor: "FElement"
|
||
|
,_0: a};
|
||
|
};
|
||
|
var toForm = function (e) {
|
||
|
return form(FElement(e));
|
||
|
};
|
||
|
var FImage = F4(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d) {
|
||
|
return {ctor: "FImage"
|
||
|
,_0: a
|
||
|
,_1: b
|
||
|
,_2: c
|
||
|
,_3: d};
|
||
|
});
|
||
|
var sprite = F4(function (w,
|
||
|
h,
|
||
|
pos,
|
||
|
src) {
|
||
|
return form(A4(FImage,
|
||
|
w,
|
||
|
h,
|
||
|
pos,
|
||
|
src));
|
||
|
});
|
||
|
var FText = function (a) {
|
||
|
return {ctor: "FText",_0: a};
|
||
|
};
|
||
|
var text = function (t) {
|
||
|
return form(FText(t));
|
||
|
};
|
||
|
var FOutlinedText = F2(function (a,
|
||
|
b) {
|
||
|
return {ctor: "FOutlinedText"
|
||
|
,_0: a
|
||
|
,_1: b};
|
||
|
});
|
||
|
var outlinedText = F2(function (ls,
|
||
|
t) {
|
||
|
return form(A2(FOutlinedText,
|
||
|
ls,
|
||
|
t));
|
||
|
});
|
||
|
var FShape = F2(function (a,b) {
|
||
|
return {ctor: "FShape"
|
||
|
,_0: a
|
||
|
,_1: b};
|
||
|
});
|
||
|
var fill = F2(function (style,
|
||
|
shape) {
|
||
|
return form(A2(FShape,
|
||
|
Fill(style),
|
||
|
shape));
|
||
|
});
|
||
|
var outlined = F2(function (style,
|
||
|
shape) {
|
||
|
return form(A2(FShape,
|
||
|
Line(style),
|
||
|
shape));
|
||
|
});
|
||
|
var FPath = F2(function (a,b) {
|
||
|
return {ctor: "FPath"
|
||
|
,_0: a
|
||
|
,_1: b};
|
||
|
});
|
||
|
var traced = F2(function (style,
|
||
|
path) {
|
||
|
return form(A2(FPath,
|
||
|
style,
|
||
|
path));
|
||
|
});
|
||
|
var LineStyle = F6(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d,
|
||
|
e,
|
||
|
f) {
|
||
|
return {_: {}
|
||
|
,cap: c
|
||
|
,color: a
|
||
|
,dashOffset: f
|
||
|
,dashing: e
|
||
|
,join: d
|
||
|
,width: b};
|
||
|
});
|
||
|
var Clipped = {ctor: "Clipped"};
|
||
|
var Sharp = function (a) {
|
||
|
return {ctor: "Sharp",_0: a};
|
||
|
};
|
||
|
var Smooth = {ctor: "Smooth"};
|
||
|
var Padded = {ctor: "Padded"};
|
||
|
var Round = {ctor: "Round"};
|
||
|
var Flat = {ctor: "Flat"};
|
||
|
var defaultLine = {_: {}
|
||
|
,cap: Flat
|
||
|
,color: $Color.black
|
||
|
,dashOffset: 0
|
||
|
,dashing: _L.fromArray([])
|
||
|
,join: Sharp(10)
|
||
|
,width: 1};
|
||
|
var solid = function (clr) {
|
||
|
return _U.replace([["color"
|
||
|
,clr]],
|
||
|
defaultLine);
|
||
|
};
|
||
|
var dashed = function (clr) {
|
||
|
return _U.replace([["color"
|
||
|
,clr]
|
||
|
,["dashing"
|
||
|
,_L.fromArray([8,4])]],
|
||
|
defaultLine);
|
||
|
};
|
||
|
var dotted = function (clr) {
|
||
|
return _U.replace([["color"
|
||
|
,clr]
|
||
|
,["dashing"
|
||
|
,_L.fromArray([3,3])]],
|
||
|
defaultLine);
|
||
|
};
|
||
|
var Grad = function (a) {
|
||
|
return {ctor: "Grad",_0: a};
|
||
|
};
|
||
|
var gradient = F2(function (grad,
|
||
|
shape) {
|
||
|
return A2(fill,
|
||
|
Grad(grad),
|
||
|
shape);
|
||
|
});
|
||
|
var Texture = function (a) {
|
||
|
return {ctor: "Texture"
|
||
|
,_0: a};
|
||
|
};
|
||
|
var textured = F2(function (src,
|
||
|
shape) {
|
||
|
return A2(fill,
|
||
|
Texture(src),
|
||
|
shape);
|
||
|
});
|
||
|
var Solid = function (a) {
|
||
|
return {ctor: "Solid",_0: a};
|
||
|
};
|
||
|
var filled = F2(function (color,
|
||
|
shape) {
|
||
|
return A2(fill,
|
||
|
Solid(color),
|
||
|
shape);
|
||
|
});
|
||
|
var Form = F6(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d,
|
||
|
e,
|
||
|
f) {
|
||
|
return {_: {}
|
||
|
,alpha: e
|
||
|
,form: f
|
||
|
,scale: b
|
||
|
,theta: a
|
||
|
,x: c
|
||
|
,y: d};
|
||
|
});
|
||
|
_elm.Graphics.Collage.values = {_op: _op
|
||
|
,collage: collage
|
||
|
,toForm: toForm
|
||
|
,filled: filled
|
||
|
,textured: textured
|
||
|
,gradient: gradient
|
||
|
,outlined: outlined
|
||
|
,traced: traced
|
||
|
,text: text
|
||
|
,outlinedText: outlinedText
|
||
|
,move: move
|
||
|
,moveX: moveX
|
||
|
,moveY: moveY
|
||
|
,scale: scale
|
||
|
,rotate: rotate
|
||
|
,alpha: alpha
|
||
|
,group: group
|
||
|
,groupTransform: groupTransform
|
||
|
,rect: rect
|
||
|
,oval: oval
|
||
|
,square: square
|
||
|
,circle: circle
|
||
|
,ngon: ngon
|
||
|
,polygon: polygon
|
||
|
,segment: segment
|
||
|
,path: path
|
||
|
,solid: solid
|
||
|
,dashed: dashed
|
||
|
,dotted: dotted
|
||
|
,defaultLine: defaultLine
|
||
|
,Form: Form
|
||
|
,LineStyle: LineStyle
|
||
|
,Flat: Flat
|
||
|
,Round: Round
|
||
|
,Padded: Padded
|
||
|
,Smooth: Smooth
|
||
|
,Sharp: Sharp
|
||
|
,Clipped: Clipped};
|
||
|
return _elm.Graphics.Collage.values;
|
||
|
};
|
||
|
Elm.Graphics = Elm.Graphics || {};
|
||
|
Elm.Graphics.Element = Elm.Graphics.Element || {};
|
||
|
Elm.Graphics.Element.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Graphics = _elm.Graphics || {};
|
||
|
_elm.Graphics.Element = _elm.Graphics.Element || {};
|
||
|
if (_elm.Graphics.Element.values)
|
||
|
return _elm.Graphics.Element.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Graphics.Element",
|
||
|
$Basics = Elm.Basics.make(_elm),
|
||
|
$Color = Elm.Color.make(_elm),
|
||
|
$List = Elm.List.make(_elm),
|
||
|
$Maybe = Elm.Maybe.make(_elm),
|
||
|
$Native$Graphics$Element = Elm.Native.Graphics.Element.make(_elm),
|
||
|
$Text = Elm.Text.make(_elm);
|
||
|
var DOut = {ctor: "DOut"};
|
||
|
var outward = DOut;
|
||
|
var DIn = {ctor: "DIn"};
|
||
|
var inward = DIn;
|
||
|
var DRight = {ctor: "DRight"};
|
||
|
var right = DRight;
|
||
|
var DLeft = {ctor: "DLeft"};
|
||
|
var left = DLeft;
|
||
|
var DDown = {ctor: "DDown"};
|
||
|
var down = DDown;
|
||
|
var DUp = {ctor: "DUp"};
|
||
|
var up = DUp;
|
||
|
var Position = F4(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d) {
|
||
|
return {_: {}
|
||
|
,horizontal: a
|
||
|
,vertical: b
|
||
|
,x: c
|
||
|
,y: d};
|
||
|
});
|
||
|
var Relative = function (a) {
|
||
|
return {ctor: "Relative"
|
||
|
,_0: a};
|
||
|
};
|
||
|
var relative = Relative;
|
||
|
var Absolute = function (a) {
|
||
|
return {ctor: "Absolute"
|
||
|
,_0: a};
|
||
|
};
|
||
|
var absolute = Absolute;
|
||
|
var N = {ctor: "N"};
|
||
|
var bottomLeftAt = F2(function (x,
|
||
|
y) {
|
||
|
return {_: {}
|
||
|
,horizontal: N
|
||
|
,vertical: N
|
||
|
,x: x
|
||
|
,y: y};
|
||
|
});
|
||
|
var Z = {ctor: "Z"};
|
||
|
var middle = {_: {}
|
||
|
,horizontal: Z
|
||
|
,vertical: Z
|
||
|
,x: Relative(0.5)
|
||
|
,y: Relative(0.5)};
|
||
|
var midLeft = _U.replace([["horizontal"
|
||
|
,N]
|
||
|
,["x",Absolute(0)]],
|
||
|
middle);
|
||
|
var middleAt = F2(function (x,
|
||
|
y) {
|
||
|
return {_: {}
|
||
|
,horizontal: Z
|
||
|
,vertical: Z
|
||
|
,x: x
|
||
|
,y: y};
|
||
|
});
|
||
|
var midLeftAt = F2(function (x,
|
||
|
y) {
|
||
|
return {_: {}
|
||
|
,horizontal: N
|
||
|
,vertical: Z
|
||
|
,x: x
|
||
|
,y: y};
|
||
|
});
|
||
|
var midBottomAt = F2(function (x,
|
||
|
y) {
|
||
|
return {_: {}
|
||
|
,horizontal: Z
|
||
|
,vertical: N
|
||
|
,x: x
|
||
|
,y: y};
|
||
|
});
|
||
|
var P = {ctor: "P"};
|
||
|
var topLeft = {_: {}
|
||
|
,horizontal: N
|
||
|
,vertical: P
|
||
|
,x: Absolute(0)
|
||
|
,y: Absolute(0)};
|
||
|
var bottomLeft = _U.replace([["vertical"
|
||
|
,N]],
|
||
|
topLeft);
|
||
|
var topRight = _U.replace([["horizontal"
|
||
|
,P]],
|
||
|
topLeft);
|
||
|
var bottomRight = _U.replace([["horizontal"
|
||
|
,P]],
|
||
|
bottomLeft);
|
||
|
var midRight = _U.replace([["horizontal"
|
||
|
,P]],
|
||
|
midLeft);
|
||
|
var midTop = _U.replace([["vertical"
|
||
|
,P]
|
||
|
,["y",Absolute(0)]],
|
||
|
middle);
|
||
|
var midBottom = _U.replace([["vertical"
|
||
|
,N]],
|
||
|
midTop);
|
||
|
var topLeftAt = F2(function (x,
|
||
|
y) {
|
||
|
return {_: {}
|
||
|
,horizontal: N
|
||
|
,vertical: P
|
||
|
,x: x
|
||
|
,y: y};
|
||
|
});
|
||
|
var topRightAt = F2(function (x,
|
||
|
y) {
|
||
|
return {_: {}
|
||
|
,horizontal: P
|
||
|
,vertical: P
|
||
|
,x: x
|
||
|
,y: y};
|
||
|
});
|
||
|
var bottomRightAt = F2(function (x,
|
||
|
y) {
|
||
|
return {_: {}
|
||
|
,horizontal: P
|
||
|
,vertical: N
|
||
|
,x: x
|
||
|
,y: y};
|
||
|
});
|
||
|
var midRightAt = F2(function (x,
|
||
|
y) {
|
||
|
return {_: {}
|
||
|
,horizontal: P
|
||
|
,vertical: Z
|
||
|
,x: x
|
||
|
,y: y};
|
||
|
});
|
||
|
var midTopAt = F2(function (x,
|
||
|
y) {
|
||
|
return {_: {}
|
||
|
,horizontal: Z
|
||
|
,vertical: P
|
||
|
,x: x
|
||
|
,y: y};
|
||
|
});
|
||
|
var justified = $Native$Graphics$Element.block("justify");
|
||
|
var centered = $Native$Graphics$Element.block("center");
|
||
|
var rightAligned = $Native$Graphics$Element.block("right");
|
||
|
var leftAligned = $Native$Graphics$Element.block("left");
|
||
|
var show = function (value) {
|
||
|
return leftAligned($Text.monospace($Text.fromString($Basics.toString(value))));
|
||
|
};
|
||
|
var Tiled = {ctor: "Tiled"};
|
||
|
var Cropped = function (a) {
|
||
|
return {ctor: "Cropped"
|
||
|
,_0: a};
|
||
|
};
|
||
|
var Fitted = {ctor: "Fitted"};
|
||
|
var Plain = {ctor: "Plain"};
|
||
|
var Custom = {ctor: "Custom"};
|
||
|
var RawHtml = {ctor: "RawHtml"};
|
||
|
var Spacer = {ctor: "Spacer"};
|
||
|
var Flow = F2(function (a,b) {
|
||
|
return {ctor: "Flow"
|
||
|
,_0: a
|
||
|
,_1: b};
|
||
|
});
|
||
|
var Container = F2(function (a,
|
||
|
b) {
|
||
|
return {ctor: "Container"
|
||
|
,_0: a
|
||
|
,_1: b};
|
||
|
});
|
||
|
var Image = F4(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d) {
|
||
|
return {ctor: "Image"
|
||
|
,_0: a
|
||
|
,_1: b
|
||
|
,_2: c
|
||
|
,_3: d};
|
||
|
});
|
||
|
var newElement = $Native$Graphics$Element.newElement;
|
||
|
var image = F3(function (w,
|
||
|
h,
|
||
|
src) {
|
||
|
return A3(newElement,
|
||
|
w,
|
||
|
h,
|
||
|
A4(Image,Plain,w,h,src));
|
||
|
});
|
||
|
var fittedImage = F3(function (w,
|
||
|
h,
|
||
|
src) {
|
||
|
return A3(newElement,
|
||
|
w,
|
||
|
h,
|
||
|
A4(Image,Fitted,w,h,src));
|
||
|
});
|
||
|
var croppedImage = F4(function (pos,
|
||
|
w,
|
||
|
h,
|
||
|
src) {
|
||
|
return A3(newElement,
|
||
|
w,
|
||
|
h,
|
||
|
A4(Image,Cropped(pos),w,h,src));
|
||
|
});
|
||
|
var tiledImage = F3(function (w,
|
||
|
h,
|
||
|
src) {
|
||
|
return A3(newElement,
|
||
|
w,
|
||
|
h,
|
||
|
A4(Image,Tiled,w,h,src));
|
||
|
});
|
||
|
var container = F4(function (w,
|
||
|
h,
|
||
|
pos,
|
||
|
e) {
|
||
|
return A3(newElement,
|
||
|
w,
|
||
|
h,
|
||
|
A2(Container,pos,e));
|
||
|
});
|
||
|
var spacer = F2(function (w,h) {
|
||
|
return A3(newElement,
|
||
|
w,
|
||
|
h,
|
||
|
Spacer);
|
||
|
});
|
||
|
var link = F2(function (href,
|
||
|
e) {
|
||
|
return function () {
|
||
|
var p = e.props;
|
||
|
return {_: {}
|
||
|
,element: e.element
|
||
|
,props: _U.replace([["href"
|
||
|
,href]],
|
||
|
p)};
|
||
|
}();
|
||
|
});
|
||
|
var tag = F2(function (name,e) {
|
||
|
return function () {
|
||
|
var p = e.props;
|
||
|
return {_: {}
|
||
|
,element: e.element
|
||
|
,props: _U.replace([["tag"
|
||
|
,name]],
|
||
|
p)};
|
||
|
}();
|
||
|
});
|
||
|
var color = F2(function (c,e) {
|
||
|
return function () {
|
||
|
var p = e.props;
|
||
|
return {_: {}
|
||
|
,element: e.element
|
||
|
,props: _U.replace([["color"
|
||
|
,$Maybe.Just(c)]],
|
||
|
p)};
|
||
|
}();
|
||
|
});
|
||
|
var opacity = F2(function (o,
|
||
|
e) {
|
||
|
return function () {
|
||
|
var p = e.props;
|
||
|
return {_: {}
|
||
|
,element: e.element
|
||
|
,props: _U.replace([["opacity"
|
||
|
,o]],
|
||
|
p)};
|
||
|
}();
|
||
|
});
|
||
|
var height = F2(function (nh,
|
||
|
e) {
|
||
|
return function () {
|
||
|
var p = e.props;
|
||
|
var props = function () {
|
||
|
var _v0 = e.element;
|
||
|
switch (_v0.ctor)
|
||
|
{case "Image":
|
||
|
return _U.replace([["width"
|
||
|
,$Basics.round($Basics.toFloat(_v0._1) / $Basics.toFloat(_v0._2) * $Basics.toFloat(nh))]],
|
||
|
p);}
|
||
|
return p;
|
||
|
}();
|
||
|
return {_: {}
|
||
|
,element: e.element
|
||
|
,props: _U.replace([["height"
|
||
|
,nh]],
|
||
|
p)};
|
||
|
}();
|
||
|
});
|
||
|
var width = F2(function (nw,e) {
|
||
|
return function () {
|
||
|
var p = e.props;
|
||
|
var props = function () {
|
||
|
var _v5 = e.element;
|
||
|
switch (_v5.ctor)
|
||
|
{case "Image":
|
||
|
return _U.replace([["height"
|
||
|
,$Basics.round($Basics.toFloat(_v5._2) / $Basics.toFloat(_v5._1) * $Basics.toFloat(nw))]],
|
||
|
p);
|
||
|
case "RawHtml":
|
||
|
return _U.replace([["height"
|
||
|
,$Basics.snd(A2($Native$Graphics$Element.htmlHeight,
|
||
|
nw,
|
||
|
e.element))]],
|
||
|
p);}
|
||
|
return p;
|
||
|
}();
|
||
|
return {_: {}
|
||
|
,element: e.element
|
||
|
,props: _U.replace([["width"
|
||
|
,nw]],
|
||
|
props)};
|
||
|
}();
|
||
|
});
|
||
|
var size = F3(function (w,h,e) {
|
||
|
return A2(height,
|
||
|
h,
|
||
|
A2(width,w,e));
|
||
|
});
|
||
|
var sizeOf = function (e) {
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: e.props.width
|
||
|
,_1: e.props.height};
|
||
|
};
|
||
|
var heightOf = function (e) {
|
||
|
return e.props.height;
|
||
|
};
|
||
|
var widthOf = function (e) {
|
||
|
return e.props.width;
|
||
|
};
|
||
|
var above = F2(function (hi,
|
||
|
lo) {
|
||
|
return A3(newElement,
|
||
|
A2($Basics.max,
|
||
|
widthOf(hi),
|
||
|
widthOf(lo)),
|
||
|
heightOf(hi) + heightOf(lo),
|
||
|
A2(Flow,
|
||
|
DDown,
|
||
|
_L.fromArray([hi,lo])));
|
||
|
});
|
||
|
var below = F2(function (lo,
|
||
|
hi) {
|
||
|
return A3(newElement,
|
||
|
A2($Basics.max,
|
||
|
widthOf(hi),
|
||
|
widthOf(lo)),
|
||
|
heightOf(hi) + heightOf(lo),
|
||
|
A2(Flow,
|
||
|
DDown,
|
||
|
_L.fromArray([hi,lo])));
|
||
|
});
|
||
|
var beside = F2(function (lft,
|
||
|
rht) {
|
||
|
return A3(newElement,
|
||
|
widthOf(lft) + widthOf(rht),
|
||
|
A2($Basics.max,
|
||
|
heightOf(lft),
|
||
|
heightOf(rht)),
|
||
|
A2(Flow,
|
||
|
right,
|
||
|
_L.fromArray([lft,rht])));
|
||
|
});
|
||
|
var layers = function (es) {
|
||
|
return function () {
|
||
|
var hs = A2($List.map,
|
||
|
heightOf,
|
||
|
es);
|
||
|
var ws = A2($List.map,
|
||
|
widthOf,
|
||
|
es);
|
||
|
return A3(newElement,
|
||
|
A2($Maybe.withDefault,
|
||
|
0,
|
||
|
$List.maximum(ws)),
|
||
|
A2($Maybe.withDefault,
|
||
|
0,
|
||
|
$List.maximum(hs)),
|
||
|
A2(Flow,DOut,es));
|
||
|
}();
|
||
|
};
|
||
|
var empty = A2(spacer,0,0);
|
||
|
var flow = F2(function (dir,
|
||
|
es) {
|
||
|
return function () {
|
||
|
var newFlow = F2(function (w,
|
||
|
h) {
|
||
|
return A3(newElement,
|
||
|
w,
|
||
|
h,
|
||
|
A2(Flow,dir,es));
|
||
|
});
|
||
|
var maxOrZero = function (list) {
|
||
|
return A2($Maybe.withDefault,
|
||
|
0,
|
||
|
$List.maximum(list));
|
||
|
};
|
||
|
var hs = A2($List.map,
|
||
|
heightOf,
|
||
|
es);
|
||
|
var ws = A2($List.map,
|
||
|
widthOf,
|
||
|
es);
|
||
|
return _U.eq(es,
|
||
|
_L.fromArray([])) ? empty : function () {
|
||
|
switch (dir.ctor)
|
||
|
{case "DDown":
|
||
|
return A2(newFlow,
|
||
|
maxOrZero(ws),
|
||
|
$List.sum(hs));
|
||
|
case "DIn": return A2(newFlow,
|
||
|
maxOrZero(ws),
|
||
|
maxOrZero(hs));
|
||
|
case "DLeft": return A2(newFlow,
|
||
|
$List.sum(ws),
|
||
|
maxOrZero(hs));
|
||
|
case "DOut": return A2(newFlow,
|
||
|
maxOrZero(ws),
|
||
|
maxOrZero(hs));
|
||
|
case "DRight":
|
||
|
return A2(newFlow,
|
||
|
$List.sum(ws),
|
||
|
maxOrZero(hs));
|
||
|
case "DUp": return A2(newFlow,
|
||
|
maxOrZero(ws),
|
||
|
$List.sum(hs));}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 362 and 373");
|
||
|
}();
|
||
|
}();
|
||
|
});
|
||
|
var Properties = F9(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d,
|
||
|
e,
|
||
|
f,
|
||
|
g,
|
||
|
h,
|
||
|
i) {
|
||
|
return {_: {}
|
||
|
,click: i
|
||
|
,color: e
|
||
|
,height: c
|
||
|
,hover: h
|
||
|
,href: f
|
||
|
,id: a
|
||
|
,opacity: d
|
||
|
,tag: g
|
||
|
,width: b};
|
||
|
});
|
||
|
var Element = F2(function (a,
|
||
|
b) {
|
||
|
return {_: {}
|
||
|
,element: b
|
||
|
,props: a};
|
||
|
});
|
||
|
_elm.Graphics.Element.values = {_op: _op
|
||
|
,image: image
|
||
|
,fittedImage: fittedImage
|
||
|
,croppedImage: croppedImage
|
||
|
,tiledImage: tiledImage
|
||
|
,leftAligned: leftAligned
|
||
|
,rightAligned: rightAligned
|
||
|
,centered: centered
|
||
|
,justified: justified
|
||
|
,show: show
|
||
|
,width: width
|
||
|
,height: height
|
||
|
,size: size
|
||
|
,color: color
|
||
|
,opacity: opacity
|
||
|
,link: link
|
||
|
,tag: tag
|
||
|
,widthOf: widthOf
|
||
|
,heightOf: heightOf
|
||
|
,sizeOf: sizeOf
|
||
|
,flow: flow
|
||
|
,up: up
|
||
|
,down: down
|
||
|
,left: left
|
||
|
,right: right
|
||
|
,inward: inward
|
||
|
,outward: outward
|
||
|
,layers: layers
|
||
|
,above: above
|
||
|
,below: below
|
||
|
,beside: beside
|
||
|
,empty: empty
|
||
|
,spacer: spacer
|
||
|
,container: container
|
||
|
,middle: middle
|
||
|
,midTop: midTop
|
||
|
,midBottom: midBottom
|
||
|
,midLeft: midLeft
|
||
|
,midRight: midRight
|
||
|
,topLeft: topLeft
|
||
|
,topRight: topRight
|
||
|
,bottomLeft: bottomLeft
|
||
|
,bottomRight: bottomRight
|
||
|
,absolute: absolute
|
||
|
,relative: relative
|
||
|
,middleAt: middleAt
|
||
|
,midTopAt: midTopAt
|
||
|
,midBottomAt: midBottomAt
|
||
|
,midLeftAt: midLeftAt
|
||
|
,midRightAt: midRightAt
|
||
|
,topLeftAt: topLeftAt
|
||
|
,topRightAt: topRightAt
|
||
|
,bottomLeftAt: bottomLeftAt
|
||
|
,bottomRightAt: bottomRightAt
|
||
|
,Element: Element
|
||
|
,Position: Position};
|
||
|
return _elm.Graphics.Element.values;
|
||
|
};
|
||
|
Elm.Graphics = Elm.Graphics || {};
|
||
|
Elm.Graphics.Input = Elm.Graphics.Input || {};
|
||
|
Elm.Graphics.Input.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Graphics = _elm.Graphics || {};
|
||
|
_elm.Graphics.Input = _elm.Graphics.Input || {};
|
||
|
if (_elm.Graphics.Input.values)
|
||
|
return _elm.Graphics.Input.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Graphics.Input",
|
||
|
$Graphics$Element = Elm.Graphics.Element.make(_elm),
|
||
|
$Native$Graphics$Input = Elm.Native.Graphics.Input.make(_elm),
|
||
|
$Signal = Elm.Signal.make(_elm);
|
||
|
var clickable = $Native$Graphics$Input.clickable;
|
||
|
var hoverable = $Native$Graphics$Input.hoverable;
|
||
|
var dropDown = $Native$Graphics$Input.dropDown;
|
||
|
var checkbox = $Native$Graphics$Input.checkbox;
|
||
|
var customButton = $Native$Graphics$Input.customButton;
|
||
|
var button = $Native$Graphics$Input.button;
|
||
|
_elm.Graphics.Input.values = {_op: _op
|
||
|
,button: button
|
||
|
,customButton: customButton
|
||
|
,checkbox: checkbox
|
||
|
,dropDown: dropDown
|
||
|
,hoverable: hoverable
|
||
|
,clickable: clickable};
|
||
|
return _elm.Graphics.Input.values;
|
||
|
};
|
||
|
Elm.Graphics = Elm.Graphics || {};
|
||
|
Elm.Graphics.Input = Elm.Graphics.Input || {};
|
||
|
Elm.Graphics.Input.Field = Elm.Graphics.Input.Field || {};
|
||
|
Elm.Graphics.Input.Field.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Graphics = _elm.Graphics || {};
|
||
|
_elm.Graphics.Input = _elm.Graphics.Input || {};
|
||
|
_elm.Graphics.Input.Field = _elm.Graphics.Input.Field || {};
|
||
|
if (_elm.Graphics.Input.Field.values)
|
||
|
return _elm.Graphics.Input.Field.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Graphics.Input.Field",
|
||
|
$Color = Elm.Color.make(_elm),
|
||
|
$Graphics$Element = Elm.Graphics.Element.make(_elm),
|
||
|
$Native$Graphics$Input = Elm.Native.Graphics.Input.make(_elm),
|
||
|
$Signal = Elm.Signal.make(_elm),
|
||
|
$Text = Elm.Text.make(_elm);
|
||
|
var email = $Native$Graphics$Input.email;
|
||
|
var password = $Native$Graphics$Input.password;
|
||
|
var field = $Native$Graphics$Input.field;
|
||
|
var Backward = {ctor: "Backward"};
|
||
|
var Forward = {ctor: "Forward"};
|
||
|
var Selection = F3(function (a,
|
||
|
b,
|
||
|
c) {
|
||
|
return {_: {}
|
||
|
,direction: c
|
||
|
,end: b
|
||
|
,start: a};
|
||
|
});
|
||
|
var Content = F2(function (a,
|
||
|
b) {
|
||
|
return {_: {}
|
||
|
,selection: b
|
||
|
,string: a};
|
||
|
});
|
||
|
var noContent = A2(Content,
|
||
|
"",
|
||
|
A3(Selection,0,0,Forward));
|
||
|
var Style = F4(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d) {
|
||
|
return {_: {}
|
||
|
,highlight: c
|
||
|
,outline: b
|
||
|
,padding: a
|
||
|
,style: d};
|
||
|
});
|
||
|
var Highlight = F2(function (a,
|
||
|
b) {
|
||
|
return {_: {}
|
||
|
,color: a
|
||
|
,width: b};
|
||
|
});
|
||
|
var noHighlight = A2(Highlight,
|
||
|
$Color.blue,
|
||
|
0);
|
||
|
var Outline = F3(function (a,
|
||
|
b,
|
||
|
c) {
|
||
|
return {_: {}
|
||
|
,color: a
|
||
|
,radius: c
|
||
|
,width: b};
|
||
|
});
|
||
|
var Dimensions = F4(function (a,
|
||
|
b,
|
||
|
c,
|
||
|
d) {
|
||
|
return {_: {}
|
||
|
,bottom: d
|
||
|
,left: a
|
||
|
,right: b
|
||
|
,top: c};
|
||
|
});
|
||
|
var uniformly = function (n) {
|
||
|
return A4(Dimensions,
|
||
|
n,
|
||
|
n,
|
||
|
n,
|
||
|
n);
|
||
|
};
|
||
|
var noOutline = A3(Outline,
|
||
|
$Color.grey,
|
||
|
uniformly(0),
|
||
|
0);
|
||
|
var defaultStyle = {_: {}
|
||
|
,highlight: A2(Highlight,
|
||
|
$Color.blue,
|
||
|
1)
|
||
|
,outline: A3(Outline,
|
||
|
$Color.grey,
|
||
|
uniformly(1),
|
||
|
2)
|
||
|
,padding: uniformly(4)
|
||
|
,style: $Text.defaultStyle};
|
||
|
_elm.Graphics.Input.Field.values = {_op: _op
|
||
|
,uniformly: uniformly
|
||
|
,Dimensions: Dimensions
|
||
|
,Outline: Outline
|
||
|
,noOutline: noOutline
|
||
|
,Highlight: Highlight
|
||
|
,noHighlight: noHighlight
|
||
|
,Style: Style
|
||
|
,defaultStyle: defaultStyle
|
||
|
,Content: Content
|
||
|
,Selection: Selection
|
||
|
,Forward: Forward
|
||
|
,Backward: Backward
|
||
|
,noContent: noContent
|
||
|
,field: field
|
||
|
,password: password
|
||
|
,email: email};
|
||
|
return _elm.Graphics.Input.Field.values;
|
||
|
};
|
||
|
Elm.Html = Elm.Html || {};
|
||
|
Elm.Html.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Html = _elm.Html || {};
|
||
|
if (_elm.Html.values)
|
||
|
return _elm.Html.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Html",
|
||
|
$Graphics$Element = Elm.Graphics.Element.make(_elm),
|
||
|
$VirtualDom = Elm.VirtualDom.make(_elm);
|
||
|
var fromElement = $VirtualDom.fromElement;
|
||
|
var toElement = $VirtualDom.toElement;
|
||
|
var text = $VirtualDom.text;
|
||
|
var node = $VirtualDom.node;
|
||
|
var body = node("body");
|
||
|
var section = node("section");
|
||
|
var nav = node("nav");
|
||
|
var article = node("article");
|
||
|
var aside = node("aside");
|
||
|
var h1 = node("h1");
|
||
|
var h2 = node("h2");
|
||
|
var h3 = node("h3");
|
||
|
var h4 = node("h4");
|
||
|
var h5 = node("h5");
|
||
|
var h6 = node("h6");
|
||
|
var header = node("header");
|
||
|
var footer = node("footer");
|
||
|
var address = node("address");
|
||
|
var main$ = node("main");
|
||
|
var p = node("p");
|
||
|
var hr = node("hr");
|
||
|
var pre = node("pre");
|
||
|
var blockquote = node("blockquote");
|
||
|
var ol = node("ol");
|
||
|
var ul = node("ul");
|
||
|
var li = node("li");
|
||
|
var dl = node("dl");
|
||
|
var dt = node("dt");
|
||
|
var dd = node("dd");
|
||
|
var figure = node("figure");
|
||
|
var figcaption = node("figcaption");
|
||
|
var div = node("div");
|
||
|
var a = node("a");
|
||
|
var em = node("em");
|
||
|
var strong = node("strong");
|
||
|
var small = node("small");
|
||
|
var s = node("s");
|
||
|
var cite = node("cite");
|
||
|
var q = node("q");
|
||
|
var dfn = node("dfn");
|
||
|
var abbr = node("abbr");
|
||
|
var time = node("time");
|
||
|
var code = node("code");
|
||
|
var $var = node("var");
|
||
|
var samp = node("samp");
|
||
|
var kbd = node("kbd");
|
||
|
var sub = node("sub");
|
||
|
var sup = node("sup");
|
||
|
var i = node("i");
|
||
|
var b = node("b");
|
||
|
var u = node("u");
|
||
|
var mark = node("mark");
|
||
|
var ruby = node("ruby");
|
||
|
var rt = node("rt");
|
||
|
var rp = node("rp");
|
||
|
var bdi = node("bdi");
|
||
|
var bdo = node("bdo");
|
||
|
var span = node("span");
|
||
|
var br = node("br");
|
||
|
var wbr = node("wbr");
|
||
|
var ins = node("ins");
|
||
|
var del = node("del");
|
||
|
var img = node("img");
|
||
|
var iframe = node("iframe");
|
||
|
var embed = node("embed");
|
||
|
var object = node("object");
|
||
|
var param = node("param");
|
||
|
var video = node("video");
|
||
|
var audio = node("audio");
|
||
|
var source = node("source");
|
||
|
var track = node("track");
|
||
|
var canvas = node("canvas");
|
||
|
var svg = node("svg");
|
||
|
var math = node("math");
|
||
|
var table = node("table");
|
||
|
var caption = node("caption");
|
||
|
var colgroup = node("colgroup");
|
||
|
var col = node("col");
|
||
|
var tbody = node("tbody");
|
||
|
var thead = node("thead");
|
||
|
var tfoot = node("tfoot");
|
||
|
var tr = node("tr");
|
||
|
var td = node("td");
|
||
|
var th = node("th");
|
||
|
var form = node("form");
|
||
|
var fieldset = node("fieldset");
|
||
|
var legend = node("legend");
|
||
|
var label = node("label");
|
||
|
var input = node("input");
|
||
|
var button = node("button");
|
||
|
var select = node("select");
|
||
|
var datalist = node("datalist");
|
||
|
var optgroup = node("optgroup");
|
||
|
var option = node("option");
|
||
|
var textarea = node("textarea");
|
||
|
var keygen = node("keygen");
|
||
|
var output = node("output");
|
||
|
var progress = node("progress");
|
||
|
var meter = node("meter");
|
||
|
var details = node("details");
|
||
|
var summary = node("summary");
|
||
|
var menuitem = node("menuitem");
|
||
|
var menu = node("menu");
|
||
|
_elm.Html.values = {_op: _op
|
||
|
,node: node
|
||
|
,text: text
|
||
|
,toElement: toElement
|
||
|
,fromElement: fromElement
|
||
|
,body: body
|
||
|
,section: section
|
||
|
,nav: nav
|
||
|
,article: article
|
||
|
,aside: aside
|
||
|
,h1: h1
|
||
|
,h2: h2
|
||
|
,h3: h3
|
||
|
,h4: h4
|
||
|
,h5: h5
|
||
|
,h6: h6
|
||
|
,header: header
|
||
|
,footer: footer
|
||
|
,address: address
|
||
|
,main$: main$
|
||
|
,p: p
|
||
|
,hr: hr
|
||
|
,pre: pre
|
||
|
,blockquote: blockquote
|
||
|
,ol: ol
|
||
|
,ul: ul
|
||
|
,li: li
|
||
|
,dl: dl
|
||
|
,dt: dt
|
||
|
,dd: dd
|
||
|
,figure: figure
|
||
|
,figcaption: figcaption
|
||
|
,div: div
|
||
|
,a: a
|
||
|
,em: em
|
||
|
,strong: strong
|
||
|
,small: small
|
||
|
,s: s
|
||
|
,cite: cite
|
||
|
,q: q
|
||
|
,dfn: dfn
|
||
|
,abbr: abbr
|
||
|
,time: time
|
||
|
,code: code
|
||
|
,$var: $var
|
||
|
,samp: samp
|
||
|
,kbd: kbd
|
||
|
,sub: sub
|
||
|
,sup: sup
|
||
|
,i: i
|
||
|
,b: b
|
||
|
,u: u
|
||
|
,mark: mark
|
||
|
,ruby: ruby
|
||
|
,rt: rt
|
||
|
,rp: rp
|
||
|
,bdi: bdi
|
||
|
,bdo: bdo
|
||
|
,span: span
|
||
|
,br: br
|
||
|
,wbr: wbr
|
||
|
,ins: ins
|
||
|
,del: del
|
||
|
,img: img
|
||
|
,iframe: iframe
|
||
|
,embed: embed
|
||
|
,object: object
|
||
|
,param: param
|
||
|
,video: video
|
||
|
,audio: audio
|
||
|
,source: source
|
||
|
,track: track
|
||
|
,canvas: canvas
|
||
|
,svg: svg
|
||
|
,math: math
|
||
|
,table: table
|
||
|
,caption: caption
|
||
|
,colgroup: colgroup
|
||
|
,col: col
|
||
|
,tbody: tbody
|
||
|
,thead: thead
|
||
|
,tfoot: tfoot
|
||
|
,tr: tr
|
||
|
,td: td
|
||
|
,th: th
|
||
|
,form: form
|
||
|
,fieldset: fieldset
|
||
|
,legend: legend
|
||
|
,label: label
|
||
|
,input: input
|
||
|
,button: button
|
||
|
,select: select
|
||
|
,datalist: datalist
|
||
|
,optgroup: optgroup
|
||
|
,option: option
|
||
|
,textarea: textarea
|
||
|
,keygen: keygen
|
||
|
,output: output
|
||
|
,progress: progress
|
||
|
,meter: meter
|
||
|
,details: details
|
||
|
,summary: summary
|
||
|
,menuitem: menuitem
|
||
|
,menu: menu};
|
||
|
return _elm.Html.values;
|
||
|
};
|
||
|
Elm.Json = Elm.Json || {};
|
||
|
Elm.Json.Decode = Elm.Json.Decode || {};
|
||
|
Elm.Json.Decode.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Json = _elm.Json || {};
|
||
|
_elm.Json.Decode = _elm.Json.Decode || {};
|
||
|
if (_elm.Json.Decode.values)
|
||
|
return _elm.Json.Decode.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Json.Decode",
|
||
|
$Array = Elm.Array.make(_elm),
|
||
|
$Dict = Elm.Dict.make(_elm),
|
||
|
$Json$Encode = Elm.Json.Encode.make(_elm),
|
||
|
$List = Elm.List.make(_elm),
|
||
|
$Maybe = Elm.Maybe.make(_elm),
|
||
|
$Native$Json = Elm.Native.Json.make(_elm),
|
||
|
$Result = Elm.Result.make(_elm);
|
||
|
var tuple8 = $Native$Json.decodeTuple8;
|
||
|
var tuple7 = $Native$Json.decodeTuple7;
|
||
|
var tuple6 = $Native$Json.decodeTuple6;
|
||
|
var tuple5 = $Native$Json.decodeTuple5;
|
||
|
var tuple4 = $Native$Json.decodeTuple4;
|
||
|
var tuple3 = $Native$Json.decodeTuple3;
|
||
|
var tuple2 = $Native$Json.decodeTuple2;
|
||
|
var tuple1 = $Native$Json.decodeTuple1;
|
||
|
var succeed = $Native$Json.succeed;
|
||
|
var fail = $Native$Json.fail;
|
||
|
var andThen = $Native$Json.andThen;
|
||
|
var customDecoder = $Native$Json.customDecoder;
|
||
|
var decodeValue = $Native$Json.runDecoderValue;
|
||
|
var value = $Native$Json.decodeValue;
|
||
|
var maybe = $Native$Json.decodeMaybe;
|
||
|
var $null = $Native$Json.decodeNull;
|
||
|
var array = $Native$Json.decodeArray;
|
||
|
var list = $Native$Json.decodeList;
|
||
|
var bool = $Native$Json.decodeBool;
|
||
|
var $int = $Native$Json.decodeInt;
|
||
|
var $float = $Native$Json.decodeFloat;
|
||
|
var string = $Native$Json.decodeString;
|
||
|
var oneOf = $Native$Json.oneOf;
|
||
|
var keyValuePairs = $Native$Json.decodeKeyValuePairs;
|
||
|
var object8 = $Native$Json.decodeObject8;
|
||
|
var object7 = $Native$Json.decodeObject7;
|
||
|
var object6 = $Native$Json.decodeObject6;
|
||
|
var object5 = $Native$Json.decodeObject5;
|
||
|
var object4 = $Native$Json.decodeObject4;
|
||
|
var object3 = $Native$Json.decodeObject3;
|
||
|
var object2 = $Native$Json.decodeObject2;
|
||
|
var object1 = $Native$Json.decodeObject1;
|
||
|
_op[":="] = $Native$Json.decodeField;
|
||
|
var at = F2(function (fields,
|
||
|
decoder) {
|
||
|
return A3($List.foldr,
|
||
|
F2(function (x,y) {
|
||
|
return A2(_op[":="],x,y);
|
||
|
}),
|
||
|
decoder,
|
||
|
fields);
|
||
|
});
|
||
|
var decodeString = $Native$Json.runDecoderString;
|
||
|
var map = $Native$Json.decodeObject1;
|
||
|
var dict = function (decoder) {
|
||
|
return A2(map,
|
||
|
$Dict.fromList,
|
||
|
keyValuePairs(decoder));
|
||
|
};
|
||
|
var Decoder = {ctor: "Decoder"};
|
||
|
_elm.Json.Decode.values = {_op: _op
|
||
|
,Decoder: Decoder
|
||
|
,map: map
|
||
|
,decodeString: decodeString
|
||
|
,at: at
|
||
|
,object1: object1
|
||
|
,object2: object2
|
||
|
,object3: object3
|
||
|
,object4: object4
|
||
|
,object5: object5
|
||
|
,object6: object6
|
||
|
,object7: object7
|
||
|
,object8: object8
|
||
|
,keyValuePairs: keyValuePairs
|
||
|
,dict: dict
|
||
|
,oneOf: oneOf
|
||
|
,string: string
|
||
|
,$float: $float
|
||
|
,$int: $int
|
||
|
,bool: bool
|
||
|
,list: list
|
||
|
,array: array
|
||
|
,$null: $null
|
||
|
,maybe: maybe
|
||
|
,value: value
|
||
|
,decodeValue: decodeValue
|
||
|
,customDecoder: customDecoder
|
||
|
,andThen: andThen
|
||
|
,fail: fail
|
||
|
,succeed: succeed
|
||
|
,tuple1: tuple1
|
||
|
,tuple2: tuple2
|
||
|
,tuple3: tuple3
|
||
|
,tuple4: tuple4
|
||
|
,tuple5: tuple5
|
||
|
,tuple6: tuple6
|
||
|
,tuple7: tuple7
|
||
|
,tuple8: tuple8};
|
||
|
return _elm.Json.Decode.values;
|
||
|
};
|
||
|
Elm.Json = Elm.Json || {};
|
||
|
Elm.Json.Encode = Elm.Json.Encode || {};
|
||
|
Elm.Json.Encode.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Json = _elm.Json || {};
|
||
|
_elm.Json.Encode = _elm.Json.Encode || {};
|
||
|
if (_elm.Json.Encode.values)
|
||
|
return _elm.Json.Encode.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Json.Encode",
|
||
|
$Array = Elm.Array.make(_elm),
|
||
|
$Native$Json = Elm.Native.Json.make(_elm);
|
||
|
var list = $Native$Json.encodeList;
|
||
|
var array = $Native$Json.encodeArray;
|
||
|
var object = $Native$Json.encodeObject;
|
||
|
var $null = $Native$Json.encodeNull;
|
||
|
var bool = $Native$Json.identity;
|
||
|
var $float = $Native$Json.identity;
|
||
|
var $int = $Native$Json.identity;
|
||
|
var string = $Native$Json.identity;
|
||
|
var encode = $Native$Json.encode;
|
||
|
var Value = {ctor: "Value"};
|
||
|
_elm.Json.Encode.values = {_op: _op
|
||
|
,Value: Value
|
||
|
,encode: encode
|
||
|
,string: string
|
||
|
,$int: $int
|
||
|
,$float: $float
|
||
|
,bool: bool
|
||
|
,$null: $null
|
||
|
,object: object
|
||
|
,array: array
|
||
|
,list: list};
|
||
|
return _elm.Json.Encode.values;
|
||
|
};
|
||
|
Elm.List = Elm.List || {};
|
||
|
Elm.List.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.List = _elm.List || {};
|
||
|
if (_elm.List.values)
|
||
|
return _elm.List.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "List",
|
||
|
$Basics = Elm.Basics.make(_elm),
|
||
|
$Maybe = Elm.Maybe.make(_elm),
|
||
|
$Native$List = Elm.Native.List.make(_elm);
|
||
|
var sortWith = $Native$List.sortWith;
|
||
|
var sortBy = $Native$List.sortBy;
|
||
|
var sort = function (xs) {
|
||
|
return A2(sortBy,
|
||
|
$Basics.identity,
|
||
|
xs);
|
||
|
};
|
||
|
var repeat = $Native$List.repeat;
|
||
|
var drop = $Native$List.drop;
|
||
|
var take = $Native$List.take;
|
||
|
var map5 = $Native$List.map5;
|
||
|
var map4 = $Native$List.map4;
|
||
|
var map3 = $Native$List.map3;
|
||
|
var map2 = $Native$List.map2;
|
||
|
var any = $Native$List.any;
|
||
|
var all = F2(function (pred,
|
||
|
xs) {
|
||
|
return $Basics.not(A2(any,
|
||
|
function ($) {
|
||
|
return $Basics.not(pred($));
|
||
|
},
|
||
|
xs));
|
||
|
});
|
||
|
var foldr = $Native$List.foldr;
|
||
|
var foldl = $Native$List.foldl;
|
||
|
var length = function (xs) {
|
||
|
return A3(foldl,
|
||
|
F2(function (_v0,i) {
|
||
|
return function () {
|
||
|
return i + 1;
|
||
|
}();
|
||
|
}),
|
||
|
0,
|
||
|
xs);
|
||
|
};
|
||
|
var sum = function (numbers) {
|
||
|
return A3(foldl,
|
||
|
F2(function (x,y) {
|
||
|
return x + y;
|
||
|
}),
|
||
|
0,
|
||
|
numbers);
|
||
|
};
|
||
|
var product = function (numbers) {
|
||
|
return A3(foldl,
|
||
|
F2(function (x,y) {
|
||
|
return x * y;
|
||
|
}),
|
||
|
1,
|
||
|
numbers);
|
||
|
};
|
||
|
var maximum = function (list) {
|
||
|
return function () {
|
||
|
switch (list.ctor)
|
||
|
{case "::":
|
||
|
return $Maybe.Just(A3(foldl,
|
||
|
$Basics.max,
|
||
|
list._0,
|
||
|
list._1));}
|
||
|
return $Maybe.Nothing;
|
||
|
}();
|
||
|
};
|
||
|
var minimum = function (list) {
|
||
|
return function () {
|
||
|
switch (list.ctor)
|
||
|
{case "::":
|
||
|
return $Maybe.Just(A3(foldl,
|
||
|
$Basics.min,
|
||
|
list._0,
|
||
|
list._1));}
|
||
|
return $Maybe.Nothing;
|
||
|
}();
|
||
|
};
|
||
|
var indexedMap = F2(function (f,
|
||
|
xs) {
|
||
|
return A3(map2,
|
||
|
f,
|
||
|
_L.range(0,length(xs) - 1),
|
||
|
xs);
|
||
|
});
|
||
|
var member = F2(function (x,
|
||
|
xs) {
|
||
|
return A2(any,
|
||
|
function (a) {
|
||
|
return _U.eq(a,x);
|
||
|
},
|
||
|
xs);
|
||
|
});
|
||
|
var isEmpty = function (xs) {
|
||
|
return function () {
|
||
|
switch (xs.ctor)
|
||
|
{case "[]": return true;}
|
||
|
return false;
|
||
|
}();
|
||
|
};
|
||
|
var tail = function (list) {
|
||
|
return function () {
|
||
|
switch (list.ctor)
|
||
|
{case "::":
|
||
|
return $Maybe.Just(list._1);
|
||
|
case "[]":
|
||
|
return $Maybe.Nothing;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 87 and 95");
|
||
|
}();
|
||
|
};
|
||
|
var head = function (list) {
|
||
|
return function () {
|
||
|
switch (list.ctor)
|
||
|
{case "::":
|
||
|
return $Maybe.Just(list._0);
|
||
|
case "[]":
|
||
|
return $Maybe.Nothing;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 75 and 84");
|
||
|
}();
|
||
|
};
|
||
|
_op["::"] = $Native$List.cons;
|
||
|
var map = F2(function (f,xs) {
|
||
|
return A3(foldr,
|
||
|
F2(function (x,acc) {
|
||
|
return A2(_op["::"],
|
||
|
f(x),
|
||
|
acc);
|
||
|
}),
|
||
|
_L.fromArray([]),
|
||
|
xs);
|
||
|
});
|
||
|
var filter = F2(function (pred,
|
||
|
xs) {
|
||
|
return function () {
|
||
|
var conditionalCons = F2(function (x,
|
||
|
xs$) {
|
||
|
return pred(x) ? A2(_op["::"],
|
||
|
x,
|
||
|
xs$) : xs$;
|
||
|
});
|
||
|
return A3(foldr,
|
||
|
conditionalCons,
|
||
|
_L.fromArray([]),
|
||
|
xs);
|
||
|
}();
|
||
|
});
|
||
|
var maybeCons = F3(function (f,
|
||
|
mx,
|
||
|
xs) {
|
||
|
return function () {
|
||
|
var _v15 = f(mx);
|
||
|
switch (_v15.ctor)
|
||
|
{case "Just":
|
||
|
return A2(_op["::"],_v15._0,xs);
|
||
|
case "Nothing": return xs;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 179 and 186");
|
||
|
}();
|
||
|
});
|
||
|
var filterMap = F2(function (f,
|
||
|
xs) {
|
||
|
return A3(foldr,
|
||
|
maybeCons(f),
|
||
|
_L.fromArray([]),
|
||
|
xs);
|
||
|
});
|
||
|
var reverse = function (list) {
|
||
|
return A3(foldl,
|
||
|
F2(function (x,y) {
|
||
|
return A2(_op["::"],x,y);
|
||
|
}),
|
||
|
_L.fromArray([]),
|
||
|
list);
|
||
|
};
|
||
|
var scanl = F3(function (f,
|
||
|
b,
|
||
|
xs) {
|
||
|
return function () {
|
||
|
var scan1 = F2(function (x,
|
||
|
accAcc) {
|
||
|
return function () {
|
||
|
switch (accAcc.ctor)
|
||
|
{case "::": return A2(_op["::"],
|
||
|
A2(f,x,accAcc._0),
|
||
|
accAcc);
|
||
|
case "[]":
|
||
|
return _L.fromArray([]);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 148 and 151");
|
||
|
}();
|
||
|
});
|
||
|
return reverse(A3(foldl,
|
||
|
scan1,
|
||
|
_L.fromArray([b]),
|
||
|
xs));
|
||
|
}();
|
||
|
});
|
||
|
var append = F2(function (xs,
|
||
|
ys) {
|
||
|
return function () {
|
||
|
switch (ys.ctor)
|
||
|
{case "[]": return xs;}
|
||
|
return A3(foldr,
|
||
|
F2(function (x,y) {
|
||
|
return A2(_op["::"],x,y);
|
||
|
}),
|
||
|
ys,
|
||
|
xs);
|
||
|
}();
|
||
|
});
|
||
|
var concat = function (lists) {
|
||
|
return A3(foldr,
|
||
|
append,
|
||
|
_L.fromArray([]),
|
||
|
lists);
|
||
|
};
|
||
|
var concatMap = F2(function (f,
|
||
|
list) {
|
||
|
return concat(A2(map,
|
||
|
f,
|
||
|
list));
|
||
|
});
|
||
|
var partition = F2(function (pred,
|
||
|
list) {
|
||
|
return function () {
|
||
|
var step = F2(function (x,
|
||
|
_v21) {
|
||
|
return function () {
|
||
|
switch (_v21.ctor)
|
||
|
{case "_Tuple2":
|
||
|
return pred(x) ? {ctor: "_Tuple2"
|
||
|
,_0: A2(_op["::"],x,_v21._0)
|
||
|
,_1: _v21._1} : {ctor: "_Tuple2"
|
||
|
,_0: _v21._0
|
||
|
,_1: A2(_op["::"],
|
||
|
x,
|
||
|
_v21._1)};}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 301 and 303");
|
||
|
}();
|
||
|
});
|
||
|
return A3(foldr,
|
||
|
step,
|
||
|
{ctor: "_Tuple2"
|
||
|
,_0: _L.fromArray([])
|
||
|
,_1: _L.fromArray([])},
|
||
|
list);
|
||
|
}();
|
||
|
});
|
||
|
var unzip = function (pairs) {
|
||
|
return function () {
|
||
|
var step = F2(function (_v25,
|
||
|
_v26) {
|
||
|
return function () {
|
||
|
switch (_v26.ctor)
|
||
|
{case "_Tuple2":
|
||
|
return function () {
|
||
|
switch (_v25.ctor)
|
||
|
{case "_Tuple2":
|
||
|
return {ctor: "_Tuple2"
|
||
|
,_0: A2(_op["::"],
|
||
|
_v25._0,
|
||
|
_v26._0)
|
||
|
,_1: A2(_op["::"],
|
||
|
_v25._1,
|
||
|
_v26._1)};}
|
||
|
_U.badCase($moduleName,
|
||
|
"on line 339, column 12 to 28");
|
||
|
}();}
|
||
|
_U.badCase($moduleName,
|
||
|
"on line 339, column 12 to 28");
|
||
|
}();
|
||
|
});
|
||
|
return A3(foldr,
|
||
|
step,
|
||
|
{ctor: "_Tuple2"
|
||
|
,_0: _L.fromArray([])
|
||
|
,_1: _L.fromArray([])},
|
||
|
pairs);
|
||
|
}();
|
||
|
};
|
||
|
var intersperse = F2(function (sep,
|
||
|
xs) {
|
||
|
return function () {
|
||
|
switch (xs.ctor)
|
||
|
{case "::": return function () {
|
||
|
var step = F2(function (x,
|
||
|
rest) {
|
||
|
return A2(_op["::"],
|
||
|
sep,
|
||
|
A2(_op["::"],x,rest));
|
||
|
});
|
||
|
var spersed = A3(foldr,
|
||
|
step,
|
||
|
_L.fromArray([]),
|
||
|
xs._1);
|
||
|
return A2(_op["::"],
|
||
|
xs._0,
|
||
|
spersed);
|
||
|
}();
|
||
|
case "[]":
|
||
|
return _L.fromArray([]);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 350 and 361");
|
||
|
}();
|
||
|
});
|
||
|
_elm.List.values = {_op: _op
|
||
|
,isEmpty: isEmpty
|
||
|
,length: length
|
||
|
,reverse: reverse
|
||
|
,member: member
|
||
|
,head: head
|
||
|
,tail: tail
|
||
|
,filter: filter
|
||
|
,take: take
|
||
|
,drop: drop
|
||
|
,repeat: repeat
|
||
|
,append: append
|
||
|
,concat: concat
|
||
|
,intersperse: intersperse
|
||
|
,partition: partition
|
||
|
,unzip: unzip
|
||
|
,map: map
|
||
|
,map2: map2
|
||
|
,map3: map3
|
||
|
,map4: map4
|
||
|
,map5: map5
|
||
|
,filterMap: filterMap
|
||
|
,concatMap: concatMap
|
||
|
,indexedMap: indexedMap
|
||
|
,foldr: foldr
|
||
|
,foldl: foldl
|
||
|
,sum: sum
|
||
|
,product: product
|
||
|
,maximum: maximum
|
||
|
,minimum: minimum
|
||
|
,all: all
|
||
|
,any: any
|
||
|
,scanl: scanl
|
||
|
,sort: sort
|
||
|
,sortBy: sortBy
|
||
|
,sortWith: sortWith};
|
||
|
return _elm.List.values;
|
||
|
};
|
||
|
Elm.Markdown = Elm.Markdown || {};
|
||
|
Elm.Markdown.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Markdown = _elm.Markdown || {};
|
||
|
if (_elm.Markdown.values)
|
||
|
return _elm.Markdown.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Markdown",
|
||
|
$Graphics$Element = Elm.Graphics.Element.make(_elm),
|
||
|
$Html = Elm.Html.make(_elm),
|
||
|
$Maybe = Elm.Maybe.make(_elm),
|
||
|
$Native$Markdown = Elm.Native.Markdown.make(_elm);
|
||
|
var toElementWith = $Native$Markdown.toElementWith;
|
||
|
var toHtmlWith = $Native$Markdown.toHtmlWith;
|
||
|
var defaultOptions = {_: {}
|
||
|
,githubFlavored: $Maybe.Just({_: {}
|
||
|
,breaks: false
|
||
|
,tables: false})
|
||
|
,sanitize: false
|
||
|
,smartypants: false};
|
||
|
var Options = F3(function (a,
|
||
|
b,
|
||
|
c) {
|
||
|
return {_: {}
|
||
|
,githubFlavored: a
|
||
|
,sanitize: b
|
||
|
,smartypants: c};
|
||
|
});
|
||
|
var toElement = function (string) {
|
||
|
return A2($Native$Markdown.toElementWith,
|
||
|
defaultOptions,
|
||
|
string);
|
||
|
};
|
||
|
var toHtml = function (string) {
|
||
|
return A2($Native$Markdown.toHtmlWith,
|
||
|
defaultOptions,
|
||
|
string);
|
||
|
};
|
||
|
_elm.Markdown.values = {_op: _op
|
||
|
,toHtml: toHtml
|
||
|
,toElement: toElement
|
||
|
,Options: Options
|
||
|
,defaultOptions: defaultOptions
|
||
|
,toHtmlWith: toHtmlWith
|
||
|
,toElementWith: toElementWith};
|
||
|
return _elm.Markdown.values;
|
||
|
};
|
||
|
Elm.Maybe = Elm.Maybe || {};
|
||
|
Elm.Maybe.make = function (_elm) {
|
||
|
"use strict";
|
||
|
_elm.Maybe = _elm.Maybe || {};
|
||
|
if (_elm.Maybe.values)
|
||
|
return _elm.Maybe.values;
|
||
|
var _op = {},
|
||
|
_N = Elm.Native,
|
||
|
_U = _N.Utils.make(_elm),
|
||
|
_L = _N.List.make(_elm),
|
||
|
$moduleName = "Maybe";
|
||
|
var withDefault = F2(function ($default,
|
||
|
maybe) {
|
||
|
return function () {
|
||
|
switch (maybe.ctor)
|
||
|
{case "Just": return maybe._0;
|
||
|
case "Nothing":
|
||
|
return $default;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 45 and 56");
|
||
|
}();
|
||
|
});
|
||
|
var Nothing = {ctor: "Nothing"};
|
||
|
var oneOf = function (maybes) {
|
||
|
return function () {
|
||
|
switch (maybes.ctor)
|
||
|
{case "::": return function () {
|
||
|
switch (maybes._0.ctor)
|
||
|
{case "Just": return maybes._0;
|
||
|
case "Nothing":
|
||
|
return oneOf(maybes._1);}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 64 and 73");
|
||
|
}();
|
||
|
case "[]": return Nothing;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 59 and 73");
|
||
|
}();
|
||
|
};
|
||
|
var andThen = F2(function (maybeValue,
|
||
|
callback) {
|
||
|
return function () {
|
||
|
switch (maybeValue.ctor)
|
||
|
{case "Just":
|
||
|
return callback(maybeValue._0);
|
||
|
case "Nothing": return Nothing;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 110 and 112");
|
||
|
}();
|
||
|
});
|
||
|
var Just = function (a) {
|
||
|
return {ctor: "Just",_0: a};
|
||
|
};
|
||
|
var map = F2(function (f,
|
||
|
maybe) {
|
||
|
return function () {
|
||
|
switch (maybe.ctor)
|
||
|
{case "Just":
|
||
|
return Just(f(maybe._0));
|
||
|
case "Nothing": return Nothing;}
|
||
|
_U.badCase($moduleName,
|
||
|
"between lines 76 and 107");
|
||
|
}();
|
||
|
});
|
||
|
_elm.Maybe.values = {_op: _op
|
||
|
,andThen: andThen
|
||
|
,map: map
|
||
|
,withDefault: withDefault
|
||
|
,oneOf: oneOf
|
||
|
,Just: Just
|
||
|
,Nothing: Nothing};
|
||
|
return _elm.Maybe.values;
|
||
|
};
|
||
|
Elm.Native.Array = {};
|
||
|
Elm.Native.Array.make = function(localRuntime) {
|
||
|
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Array = localRuntime.Native.Array || {};
|
||
|
if (localRuntime.Native.Array.values)
|
||
|
{
|
||
|
return localRuntime.Native.Array.values;
|
||
|
}
|
||
|
if ('values' in Elm.Native.Array)
|
||
|
{
|
||
|
return localRuntime.Native.Array.values = Elm.Native.Array.values;
|
||
|
}
|
||
|
|
||
|
var List = Elm.Native.List.make(localRuntime);
|
||
|
|
||
|
// A RRB-Tree has two distinct data types.
|
||
|
// Leaf -> "height" is always 0
|
||
|
// "table" is an array of elements
|
||
|
// Node -> "height" is always greater than 0
|
||
|
// "table" is an array of child nodes
|
||
|
// "lengths" is an array of accumulated lengths of the child nodes
|
||
|
|
||
|
// M is the maximal table size. 32 seems fast. E is the allowed increase
|
||
|
// of search steps when concatting to find an index. Lower values will
|
||
|
// decrease balancing, but will increase search steps.
|
||
|
var M = 32;
|
||
|
var E = 2;
|
||
|
|
||
|
// An empty array.
|
||
|
var empty = {
|
||
|
ctor: "_Array",
|
||
|
height: 0,
|
||
|
table: new Array()
|
||
|
};
|
||
|
|
||
|
|
||
|
function get(i, array)
|
||
|
{
|
||
|
if (i < 0 || i >= length(array))
|
||
|
{
|
||
|
throw new Error(
|
||
|
"Index " + i + " is out of range. Check the length of " +
|
||
|
"your array first or use getMaybe or getWithDefault.");
|
||
|
}
|
||
|
return unsafeGet(i, array);
|
||
|
}
|
||
|
|
||
|
|
||
|
function unsafeGet(i, array)
|
||
|
{
|
||
|
for (var x = array.height; x > 0; x--)
|
||
|
{
|
||
|
var slot = i >> (x * 5);
|
||
|
while (array.lengths[slot] <= i)
|
||
|
{
|
||
|
slot++;
|
||
|
}
|
||
|
if (slot > 0)
|
||
|
{
|
||
|
i -= array.lengths[slot - 1];
|
||
|
}
|
||
|
array = array.table[slot];
|
||
|
}
|
||
|
return array.table[i];
|
||
|
}
|
||
|
|
||
|
|
||
|
// Sets the value at the index i. Only the nodes leading to i will get
|
||
|
// copied and updated.
|
||
|
function set(i, item, array)
|
||
|
{
|
||
|
if (i < 0 || length(array) <= i)
|
||
|
{
|
||
|
return array;
|
||
|
}
|
||
|
return unsafeSet(i, item, array);
|
||
|
}
|
||
|
|
||
|
|
||
|
function unsafeSet(i, item, array)
|
||
|
{
|
||
|
array = nodeCopy(array);
|
||
|
|
||
|
if (array.height == 0)
|
||
|
{
|
||
|
array.table[i] = item;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
var slot = getSlot(i, array);
|
||
|
if (slot > 0)
|
||
|
{
|
||
|
i -= array.lengths[slot - 1];
|
||
|
}
|
||
|
array.table[slot] = unsafeSet(i, item, array.table[slot]);
|
||
|
}
|
||
|
return array;
|
||
|
}
|
||
|
|
||
|
|
||
|
function initialize(len, f)
|
||
|
{
|
||
|
if (len == 0)
|
||
|
{
|
||
|
return empty;
|
||
|
}
|
||
|
var h = Math.floor( Math.log(len) / Math.log(M) );
|
||
|
return initialize_(f, h, 0, len);
|
||
|
}
|
||
|
|
||
|
function initialize_(f, h, from, to)
|
||
|
{
|
||
|
if (h == 0)
|
||
|
{
|
||
|
var table = new Array((to - from) % (M + 1));
|
||
|
for (var i = 0; i < table.length; i++)
|
||
|
{
|
||
|
table[i] = f(from + i);
|
||
|
}
|
||
|
return {
|
||
|
ctor: "_Array",
|
||
|
height: 0,
|
||
|
table: table
|
||
|
};
|
||
|
}
|
||
|
|
||
|
var step = Math.pow(M, h);
|
||
|
var table = new Array(Math.ceil((to - from) / step));
|
||
|
var lengths = new Array(table.length);
|
||
|
for (var i = 0; i < table.length; i++)
|
||
|
{
|
||
|
table[i] = initialize_(f, h - 1, from + (i * step), Math.min(from + ((i + 1) * step), to));
|
||
|
lengths[i] = length(table[i]) + (i > 0 ? lengths[i-1] : 0);
|
||
|
}
|
||
|
return {
|
||
|
ctor: "_Array",
|
||
|
height: h,
|
||
|
table: table,
|
||
|
lengths: lengths
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function fromList(list)
|
||
|
{
|
||
|
if (list == List.Nil)
|
||
|
{
|
||
|
return empty;
|
||
|
}
|
||
|
|
||
|
// Allocate M sized blocks (table) and write list elements to it.
|
||
|
var table = new Array(M);
|
||
|
var nodes = new Array();
|
||
|
var i = 0;
|
||
|
|
||
|
while (list.ctor !== '[]')
|
||
|
{
|
||
|
table[i] = list._0;
|
||
|
list = list._1;
|
||
|
i++;
|
||
|
|
||
|
// table is full, so we can push a leaf containing it into the
|
||
|
// next node.
|
||
|
if (i == M)
|
||
|
{
|
||
|
var leaf = {
|
||
|
ctor: "_Array",
|
||
|
height: 0,
|
||
|
table: table
|
||
|
};
|
||
|
fromListPush(leaf, nodes);
|
||
|
table = new Array(M);
|
||
|
i = 0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Maybe there is something left on the table.
|
||
|
if (i > 0)
|
||
|
{
|
||
|
var leaf = {
|
||
|
ctor: "_Array",
|
||
|
height: 0,
|
||
|
table: table.splice(0,i)
|
||
|
};
|
||
|
fromListPush(leaf, nodes);
|
||
|
}
|
||
|
|
||
|
// Go through all of the nodes and eventually push them into higher nodes.
|
||
|
for (var h = 0; h < nodes.length - 1; h++)
|
||
|
{
|
||
|
if (nodes[h].table.length > 0)
|
||
|
{
|
||
|
fromListPush(nodes[h], nodes);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
var head = nodes[nodes.length - 1];
|
||
|
if (head.height > 0 && head.table.length == 1)
|
||
|
{
|
||
|
return head.table[0];
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return head;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Push a node into a higher node as a child.
|
||
|
function fromListPush(toPush, nodes)
|
||
|
{
|
||
|
var h = toPush.height;
|
||
|
|
||
|
// Maybe the node on this height does not exist.
|
||
|
if (nodes.length == h)
|
||
|
{
|
||
|
var node = {
|
||
|
ctor: "_Array",
|
||
|
height: h + 1,
|
||
|
table: new Array(),
|
||
|
lengths: new Array()
|
||
|
};
|
||
|
nodes.push(node);
|
||
|
}
|
||
|
|
||
|
nodes[h].table.push(toPush);
|
||
|
var len = length(toPush);
|
||
|
if (nodes[h].lengths.length > 0)
|
||
|
{
|
||
|
len += nodes[h].lengths[nodes[h].lengths.length - 1];
|
||
|
}
|
||
|
nodes[h].lengths.push(len);
|
||
|
|
||
|
if (nodes[h].table.length == M)
|
||
|
{
|
||
|
fromListPush(nodes[h], nodes);
|
||
|
nodes[h] = {
|
||
|
ctor: "_Array",
|
||
|
height: h + 1,
|
||
|
table: new Array(),
|
||
|
lengths: new Array()
|
||
|
};
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Pushes an item via push_ to the bottom right of a tree.
|
||
|
function push(item, a)
|
||
|
{
|
||
|
var pushed = push_(item, a);
|
||
|
if (pushed !== null)
|
||
|
{
|
||
|
return pushed;
|
||
|
}
|
||
|
|
||
|
var newTree = create(item, a.height);
|
||
|
return siblise(a, newTree);
|
||
|
}
|
||
|
|
||
|
// Recursively tries to push an item to the bottom-right most
|
||
|
// tree possible. If there is no space left for the item,
|
||
|
// null will be returned.
|
||
|
function push_(item, a)
|
||
|
{
|
||
|
// Handle resursion stop at leaf level.
|
||
|
if (a.height == 0)
|
||
|
{
|
||
|
if (a.table.length < M)
|
||
|
{
|
||
|
var newA = {
|
||
|
ctor: "_Array",
|
||
|
height: 0,
|
||
|
table: a.table.slice()
|
||
|
};
|
||
|
newA.table.push(item);
|
||
|
return newA;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return null;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Recursively push
|
||
|
var pushed = push_(item, botRight(a));
|
||
|
|
||
|
// There was space in the bottom right tree, so the slot will
|
||
|
// be updated.
|
||
|
if (pushed != null)
|
||
|
{
|
||
|
var newA = nodeCopy(a);
|
||
|
newA.table[newA.table.length - 1] = pushed;
|
||
|
newA.lengths[newA.lengths.length - 1]++;
|
||
|
return newA;
|
||
|
}
|
||
|
|
||
|
// When there was no space left, check if there is space left
|
||
|
// for a new slot with a tree which contains only the item
|
||
|
// at the bottom.
|
||
|
if (a.table.length < M)
|
||
|
{
|
||
|
var newSlot = create(item, a.height - 1);
|
||
|
var newA = nodeCopy(a);
|
||
|
newA.table.push(newSlot);
|
||
|
newA.lengths.push(newA.lengths[newA.lengths.length - 1] + length(newSlot));
|
||
|
return newA;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return null;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Converts an array into a list of elements.
|
||
|
function toList(a)
|
||
|
{
|
||
|
return toList_(List.Nil, a);
|
||
|
}
|
||
|
|
||
|
function toList_(list, a)
|
||
|
{
|
||
|
for (var i = a.table.length - 1; i >= 0; i--)
|
||
|
{
|
||
|
list =
|
||
|
a.height == 0
|
||
|
? List.Cons(a.table[i], list)
|
||
|
: toList_(list, a.table[i]);
|
||
|
}
|
||
|
return list;
|
||
|
}
|
||
|
|
||
|
// Maps a function over the elements of an array.
|
||
|
function map(f, a)
|
||
|
{
|
||
|
var newA = {
|
||
|
ctor: "_Array",
|
||
|
height: a.height,
|
||
|
table: new Array(a.table.length)
|
||
|
};
|
||
|
if (a.height > 0)
|
||
|
{
|
||
|
newA.lengths = a.lengths;
|
||
|
}
|
||
|
for (var i = 0; i < a.table.length; i++)
|
||
|
{
|
||
|
newA.table[i] =
|
||
|
a.height == 0
|
||
|
? f(a.table[i])
|
||
|
: map(f, a.table[i]);
|
||
|
}
|
||
|
return newA;
|
||
|
}
|
||
|
|
||
|
// Maps a function over the elements with their index as first argument.
|
||
|
function indexedMap(f, a)
|
||
|
{
|
||
|
return indexedMap_(f, a, 0);
|
||
|
}
|
||
|
|
||
|
function indexedMap_(f, a, from)
|
||
|
{
|
||
|
var newA = {
|
||
|
ctor: "_Array",
|
||
|
height: a.height,
|
||
|
table: new Array(a.table.length)
|
||
|
};
|
||
|
if (a.height > 0)
|
||
|
{
|
||
|
newA.lengths = a.lengths;
|
||
|
}
|
||
|
for (var i = 0; i < a.table.length; i++)
|
||
|
{
|
||
|
newA.table[i] =
|
||
|
a.height == 0
|
||
|
? A2(f, from + i, a.table[i])
|
||
|
: indexedMap_(f, a.table[i], i == 0 ? 0 : a.lengths[i - 1]);
|
||
|
}
|
||
|
return newA;
|
||
|
}
|
||
|
|
||
|
function foldl(f, b, a)
|
||
|
{
|
||
|
if (a.height == 0)
|
||
|
{
|
||
|
for (var i = 0; i < a.table.length; i++)
|
||
|
{
|
||
|
b = A2(f, a.table[i], b);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
for (var i = 0; i < a.table.length; i++)
|
||
|
{
|
||
|
b = foldl(f, b, a.table[i]);
|
||
|
}
|
||
|
}
|
||
|
return b;
|
||
|
}
|
||
|
|
||
|
function foldr(f, b, a)
|
||
|
{
|
||
|
if (a.height == 0)
|
||
|
{
|
||
|
for (var i = a.table.length; i--; )
|
||
|
{
|
||
|
b = A2(f, a.table[i], b);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
for (var i = a.table.length; i--; )
|
||
|
{
|
||
|
b = foldr(f, b, a.table[i]);
|
||
|
}
|
||
|
}
|
||
|
return b;
|
||
|
}
|
||
|
|
||
|
// TODO: currently, it slices the right, then the left. This can be
|
||
|
// optimized.
|
||
|
function slice(from, to, a)
|
||
|
{
|
||
|
if (from < 0)
|
||
|
{
|
||
|
from += length(a);
|
||
|
}
|
||
|
if (to < 0)
|
||
|
{
|
||
|
to += length(a);
|
||
|
}
|
||
|
return sliceLeft(from, sliceRight(to, a));
|
||
|
}
|
||
|
|
||
|
function sliceRight(to, a)
|
||
|
{
|
||
|
if (to == length(a))
|
||
|
{
|
||
|
return a;
|
||
|
}
|
||
|
|
||
|
// Handle leaf level.
|
||
|
if (a.height == 0)
|
||
|
{
|
||
|
var newA = { ctor:"_Array", height:0 };
|
||
|
newA.table = a.table.slice(0, to);
|
||
|
return newA;
|
||
|
}
|
||
|
|
||
|
// Slice the right recursively.
|
||
|
var right = getSlot(to, a);
|
||
|
var sliced = sliceRight(to - (right > 0 ? a.lengths[right - 1] : 0), a.table[right]);
|
||
|
|
||
|
// Maybe the a node is not even needed, as sliced contains the whole slice.
|
||
|
if (right == 0)
|
||
|
{
|
||
|
return sliced;
|
||
|
}
|
||
|
|
||
|
// Create new node.
|
||
|
var newA = {
|
||
|
ctor: "_Array",
|
||
|
height: a.height,
|
||
|
table: a.table.slice(0, right),
|
||
|
lengths: a.lengths.slice(0, right)
|
||
|
};
|
||
|
if (sliced.table.length > 0)
|
||
|
{
|
||
|
newA.table[right] = sliced;
|
||
|
newA.lengths[right] = length(sliced) + (right > 0 ? newA.lengths[right - 1] : 0);
|
||
|
}
|
||
|
return newA;
|
||
|
}
|
||
|
|
||
|
function sliceLeft(from, a)
|
||
|
{
|
||
|
if (from == 0)
|
||
|
{
|
||
|
return a;
|
||
|
}
|
||
|
|
||
|
// Handle leaf level.
|
||
|
if (a.height == 0)
|
||
|
{
|
||
|
var newA = { ctor:"_Array", height:0 };
|
||
|
newA.table = a.table.slice(from, a.table.length + 1);
|
||
|
return newA;
|
||
|
}
|
||
|
|
||
|
// Slice the left recursively.
|
||
|
var left = getSlot(from, a);
|
||
|
var sliced = sliceLeft(from - (left > 0 ? a.lengths[left - 1] : 0), a.table[left]);
|
||
|
|
||
|
// Maybe the a node is not even needed, as sliced contains the whole slice.
|
||
|
if (left == a.table.length - 1)
|
||
|
{
|
||
|
return sliced;
|
||
|
}
|
||
|
|
||
|
// Create new node.
|
||
|
var newA = {
|
||
|
ctor: "_Array",
|
||
|
height: a.height,
|
||
|
table: a.table.slice(left, a.table.length + 1),
|
||
|
lengths: new Array(a.table.length - left)
|
||
|
};
|
||
|
newA.table[0] = sliced;
|
||
|
var len = 0;
|
||
|
for (var i = 0; i < newA.table.length; i++)
|
||
|
{
|
||
|
len += length(newA.table[i]);
|
||
|
newA.lengths[i] = len;
|
||
|
}
|
||
|
|
||
|
return newA;
|
||
|
}
|
||
|
|
||
|
// Appends two trees.
|
||
|
function append(a,b)
|
||
|
{
|
||
|
if (a.table.length === 0)
|
||
|
{
|
||
|
return b;
|
||
|
}
|
||
|
if (b.table.length === 0)
|
||
|
{
|
||
|
return a;
|
||
|
}
|
||
|
|
||
|
var c = append_(a, b);
|
||
|
|
||
|
// Check if both nodes can be crunshed together.
|
||
|
if (c[0].table.length + c[1].table.length <= M)
|
||
|
{
|
||
|
if (c[0].table.length === 0)
|
||
|
{
|
||
|
return c[1];
|
||
|
}
|
||
|
if (c[1].table.length === 0)
|
||
|
{
|
||
|
return c[0];
|
||
|
}
|
||
|
|
||
|
// Adjust .table and .lengths
|
||
|
c[0].table = c[0].table.concat(c[1].table);
|
||
|
if (c[0].height > 0)
|
||
|
{
|
||
|
var len = length(c[0]);
|
||
|
for (var i = 0; i < c[1].lengths.length; i++)
|
||
|
{
|
||
|
c[1].lengths[i] += len;
|
||
|
}
|
||
|
c[0].lengths = c[0].lengths.concat(c[1].lengths);
|
||
|
}
|
||
|
|
||
|
return c[0];
|
||
|
}
|
||
|
|
||
|
if (c[0].height > 0)
|
||
|
{
|
||
|
var toRemove = calcToRemove(a, b);
|
||
|
if (toRemove > E)
|
||
|
{
|
||
|
c = shuffle(c[0], c[1], toRemove);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return siblise(c[0], c[1]);
|
||
|
}
|
||
|
|
||
|
// Returns an array of two nodes; right and left. One node _may_ be empty.
|
||
|
function append_(a, b)
|
||
|
{
|
||
|
if (a.height === 0 && b.height === 0)
|
||
|
{
|
||
|
return [a, b];
|
||
|
}
|
||
|
|
||
|
if (a.height !== 1 || b.height !== 1)
|
||
|
{
|
||
|
if (a.height === b.height)
|
||
|
{
|
||
|
a = nodeCopy(a);
|
||
|
b = nodeCopy(b);
|
||
|
var appended = append_(botRight(a), botLeft(b));
|
||
|
|
||
|
insertRight(a, appended[1]);
|
||
|
insertLeft(b, appended[0]);
|
||
|
}
|
||
|
else if (a.height > b.height)
|
||
|
{
|
||
|
a = nodeCopy(a);
|
||
|
var appended = append_(botRight(a), b);
|
||
|
|
||
|
insertRight(a, appended[0]);
|
||
|
b = parentise(appended[1], appended[1].height + 1);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
b = nodeCopy(b);
|
||
|
var appended = append_(a, botLeft(b));
|
||
|
|
||
|
var left = appended[0].table.length === 0 ? 0 : 1;
|
||
|
var right = left === 0 ? 1 : 0;
|
||
|
insertLeft(b, appended[left]);
|
||
|
a = parentise(appended[right], appended[right].height + 1);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Check if balancing is needed and return based on that.
|
||
|
if (a.table.length === 0 || b.table.length === 0)
|
||
|
{
|
||
|
return [a,b];
|
||
|
}
|
||
|
|
||
|
var toRemove = calcToRemove(a, b);
|
||
|
if (toRemove <= E)
|
||
|
{
|
||
|
return [a,b];
|
||
|
}
|
||
|
return shuffle(a, b, toRemove);
|
||
|
}
|
||
|
|
||
|
// Helperfunctions for append_. Replaces a child node at the side of the parent.
|
||
|
function insertRight(parent, node)
|
||
|
{
|
||
|
var index = parent.table.length - 1;
|
||
|
parent.table[index] = node;
|
||
|
parent.lengths[index] = length(node)
|
||
|
parent.lengths[index] += index > 0 ? parent.lengths[index - 1] : 0;
|
||
|
}
|
||
|
|
||
|
function insertLeft(parent, node)
|
||
|
{
|
||
|
if (node.table.length > 0)
|
||
|
{
|
||
|
parent.table[0] = node;
|
||
|
parent.lengths[0] = length(node);
|
||
|
|
||
|
var len = length(parent.table[0]);
|
||
|
for (var i = 1; i < parent.lengths.length; i++)
|
||
|
{
|
||
|
len += length(parent.table[i]);
|
||
|
parent.lengths[i] = len;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
parent.table.shift();
|
||
|
for (var i = 1; i < parent.lengths.length; i++)
|
||
|
{
|
||
|
parent.lengths[i] = parent.lengths[i] - parent.lengths[0];
|
||
|
}
|
||
|
parent.lengths.shift();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Returns the extra search steps for E. Refer to the paper.
|
||
|
function calcToRemove(a, b)
|
||
|
{
|
||
|
var subLengths = 0;
|
||
|
for (var i = 0; i < a.table.length; i++)
|
||
|
{
|
||
|
subLengths += a.table[i].table.length;
|
||
|
}
|
||
|
for (var i = 0; i < b.table.length; i++)
|
||
|
{
|
||
|
subLengths += b.table[i].table.length;
|
||
|
}
|
||
|
|
||
|
var toRemove = a.table.length + b.table.length
|
||
|
return toRemove - (Math.floor((subLengths - 1) / M) + 1);
|
||
|
}
|
||
|
|
||
|
// get2, set2 and saveSlot are helpers for accessing elements over two arrays.
|
||
|
function get2(a, b, index)
|
||
|
{
|
||
|
return index < a.length
|
||
|
? a[index]
|
||
|
: b[index - a.length];
|
||
|
}
|
||
|
|
||
|
function set2(a, b, index, value)
|
||
|
{
|
||
|
if (index < a.length)
|
||
|
{
|
||
|
a[index] = value;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
b[index - a.length] = value;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function saveSlot(a, b, index, slot)
|
||
|
{
|
||
|
set2(a.table, b.table, index, slot);
|
||
|
|
||
|
var l = (index == 0 || index == a.lengths.length)
|
||
|
? 0
|
||
|
: get2(a.lengths, a.lengths, index - 1);
|
||
|
|
||
|
set2(a.lengths, b.lengths, index, l + length(slot));
|
||
|
}
|
||
|
|
||
|
// Creates a node or leaf with a given length at their arrays for perfomance.
|
||
|
// Is only used by shuffle.
|
||
|
function createNode(h, length)
|
||
|
{
|
||
|
if (length < 0)
|
||
|
{
|
||
|
length = 0;
|
||
|
}
|
||
|
var a = {
|
||
|
ctor: "_Array",
|
||
|
height: h,
|
||
|
table: new Array(length)
|
||
|
};
|
||
|
if (h > 0)
|
||
|
{
|
||
|
a.lengths = new Array(length);
|
||
|
}
|
||
|
return a;
|
||
|
}
|
||
|
|
||
|
// Returns an array of two balanced nodes.
|
||
|
function shuffle(a, b, toRemove)
|
||
|
{
|
||
|
var newA = createNode(a.height, Math.min(M, a.table.length + b.table.length - toRemove));
|
||
|
var newB = createNode(a.height, newA.table.length - (a.table.length + b.table.length - toRemove));
|
||
|
|
||
|
// Skip the slots with size M. More precise: copy the slot references
|
||
|
// to the new node
|
||
|
var read = 0;
|
||
|
while (get2(a.table, b.table, read).table.length % M == 0)
|
||
|
{
|
||
|
set2(newA.table, newB.table, read, get2(a.table, b.table, read));
|
||
|
set2(newA.lengths, newB.lengths, read, get2(a.lengths, b.lengths, read));
|
||
|
read++;
|
||
|
}
|
||
|
|
||
|
// Pulling items from left to right, caching in a slot before writing
|
||
|
// it into the new nodes.
|
||
|
var write = read;
|
||
|
var slot = new createNode(a.height - 1, 0);
|
||
|
var from = 0;
|
||
|
|
||
|
// If the current slot is still containing data, then there will be at
|
||
|
// least one more write, so we do not break this loop yet.
|
||
|
while (read - write - (slot.table.length > 0 ? 1 : 0) < toRemove)
|
||
|
{
|
||
|
// Find out the max possible items for copying.
|
||
|
var source = get2(a.table, b.table, read);
|
||
|
var to = Math.min(M - slot.table.length, source.table.length)
|
||
|
|
||
|
// Copy and adjust size table.
|
||
|
slot.table = slot.table.concat(source.table.slice(from, to));
|
||
|
if (slot.height > 0)
|
||
|
{
|
||
|
var len = slot.lengths.length;
|
||
|
for (var i = len; i < len + to - from; i++)
|
||
|
{
|
||
|
slot.lengths[i] = length(slot.table[i]);
|
||
|
slot.lengths[i] += (i > 0 ? slot.lengths[i - 1] : 0);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
from += to;
|
||
|
|
||
|
// Only proceed to next slots[i] if the current one was
|
||
|
// fully copied.
|
||
|
if (source.table.length <= to)
|
||
|
{
|
||
|
read++; from = 0;
|
||
|
}
|
||
|
|
||
|
// Only create a new slot if the current one is filled up.
|
||
|
if (slot.table.length == M)
|
||
|
{
|
||
|
saveSlot(newA, newB, write, slot);
|
||
|
slot = createNode(a.height - 1,0);
|
||
|
write++;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Cleanup after the loop. Copy the last slot into the new nodes.
|
||
|
if (slot.table.length > 0)
|
||
|
{
|
||
|
saveSlot(newA, newB, write, slot);
|
||
|
write++;
|
||
|
}
|
||
|
|
||
|
// Shift the untouched slots to the left
|
||
|
while (read < a.table.length + b.table.length )
|
||
|
{
|
||
|
saveSlot(newA, newB, write, get2(a.table, b.table, read));
|
||
|
read++;
|
||
|
write++;
|
||
|
}
|
||
|
|
||
|
return [newA, newB];
|
||
|
}
|
||
|
|
||
|
// Navigation functions
|
||
|
function botRight(a)
|
||
|
{
|
||
|
return a.table[a.table.length - 1];
|
||
|
}
|
||
|
function botLeft(a)
|
||
|
{
|
||
|
return a.table[0];
|
||
|
}
|
||
|
|
||
|
// Copies a node for updating. Note that you should not use this if
|
||
|
// only updating only one of "table" or "lengths" for performance reasons.
|
||
|
function nodeCopy(a)
|
||
|
{
|
||
|
var newA = {
|
||
|
ctor: "_Array",
|
||
|
height: a.height,
|
||
|
table: a.table.slice()
|
||
|
};
|
||
|
if (a.height > 0)
|
||
|
{
|
||
|
newA.lengths = a.lengths.slice();
|
||
|
}
|
||
|
return newA;
|
||
|
}
|
||
|
|
||
|
// Returns how many items are in the tree.
|
||
|
function length(array)
|
||
|
{
|
||
|
if (array.height == 0)
|
||
|
{
|
||
|
return array.table.length;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return array.lengths[array.lengths.length - 1];
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Calculates in which slot of "table" the item probably is, then
|
||
|
// find the exact slot via forward searching in "lengths". Returns the index.
|
||
|
function getSlot(i, a)
|
||
|
{
|
||
|
var slot = i >> (5 * a.height);
|
||
|
while (a.lengths[slot] <= i)
|
||
|
{
|
||
|
slot++;
|
||
|
}
|
||
|
return slot;
|
||
|
}
|
||
|
|
||
|
// Recursively creates a tree with a given height containing
|
||
|
// only the given item.
|
||
|
function create(item, h)
|
||
|
{
|
||
|
if (h == 0)
|
||
|
{
|
||
|
return {
|
||
|
ctor: "_Array",
|
||
|
height: 0,
|
||
|
table: [item]
|
||
|
};
|
||
|
}
|
||
|
return {
|
||
|
ctor: "_Array",
|
||
|
height: h,
|
||
|
table: [create(item, h - 1)],
|
||
|
lengths: [1]
|
||
|
};
|
||
|
}
|
||
|
|
||
|
// Recursively creates a tree that contains the given tree.
|
||
|
function parentise(tree, h)
|
||
|
{
|
||
|
if (h == tree.height)
|
||
|
{
|
||
|
return tree;
|
||
|
}
|
||
|
|
||
|
return {
|
||
|
ctor: "_Array",
|
||
|
height: h,
|
||
|
table: [parentise(tree, h - 1)],
|
||
|
lengths: [length(tree)]
|
||
|
};
|
||
|
}
|
||
|
|
||
|
// Emphasizes blood brotherhood beneath two trees.
|
||
|
function siblise(a, b)
|
||
|
{
|
||
|
return {
|
||
|
ctor: "_Array",
|
||
|
height: a.height + 1,
|
||
|
table: [a, b],
|
||
|
lengths: [length(a), length(a) + length(b)]
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function toJSArray(a)
|
||
|
{
|
||
|
var jsArray = new Array(length(a));
|
||
|
toJSArray_(jsArray, 0, a);
|
||
|
return jsArray;
|
||
|
}
|
||
|
|
||
|
function toJSArray_(jsArray, i, a)
|
||
|
{
|
||
|
for (var t = 0; t < a.table.length; t++)
|
||
|
{
|
||
|
if (a.height == 0)
|
||
|
{
|
||
|
jsArray[i + t] = a.table[t];
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
var inc = t == 0 ? 0 : a.lengths[t - 1];
|
||
|
toJSArray_(jsArray, i + inc, a.table[t]);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function fromJSArray(jsArray)
|
||
|
{
|
||
|
if (jsArray.length == 0)
|
||
|
{
|
||
|
return empty;
|
||
|
}
|
||
|
var h = Math.floor(Math.log(jsArray.length) / Math.log(M));
|
||
|
return fromJSArray_(jsArray, h, 0, jsArray.length);
|
||
|
}
|
||
|
|
||
|
function fromJSArray_(jsArray, h, from, to)
|
||
|
{
|
||
|
if (h == 0)
|
||
|
{
|
||
|
return {
|
||
|
ctor: "_Array",
|
||
|
height: 0,
|
||
|
table: jsArray.slice(from, to)
|
||
|
};
|
||
|
}
|
||
|
|
||
|
var step = Math.pow(M, h);
|
||
|
var table = new Array(Math.ceil((to - from) / step));
|
||
|
var lengths = new Array(table.length);
|
||
|
for (var i = 0; i < table.length; i++)
|
||
|
{
|
||
|
table[i] = fromJSArray_(jsArray, h - 1, from + (i * step), Math.min(from + ((i + 1) * step), to));
|
||
|
lengths[i] = length(table[i]) + (i > 0 ? lengths[i-1] : 0);
|
||
|
}
|
||
|
return {
|
||
|
ctor: "_Array",
|
||
|
height: h,
|
||
|
table: table,
|
||
|
lengths: lengths
|
||
|
};
|
||
|
}
|
||
|
|
||
|
Elm.Native.Array.values = {
|
||
|
empty: empty,
|
||
|
fromList: fromList,
|
||
|
toList: toList,
|
||
|
initialize: F2(initialize),
|
||
|
append: F2(append),
|
||
|
push: F2(push),
|
||
|
slice: F3(slice),
|
||
|
get: F2(get),
|
||
|
set: F3(set),
|
||
|
map: F2(map),
|
||
|
indexedMap: F2(indexedMap),
|
||
|
foldl: F3(foldl),
|
||
|
foldr: F3(foldr),
|
||
|
length: length,
|
||
|
|
||
|
toJSArray:toJSArray,
|
||
|
fromJSArray:fromJSArray
|
||
|
};
|
||
|
|
||
|
return localRuntime.Native.Array.values = Elm.Native.Array.values;
|
||
|
|
||
|
}
|
||
|
|
||
|
Elm.Native.Basics = {};
|
||
|
Elm.Native.Basics.make = function(localRuntime) {
|
||
|
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Basics = localRuntime.Native.Basics || {};
|
||
|
if (localRuntime.Native.Basics.values)
|
||
|
{
|
||
|
return localRuntime.Native.Basics.values;
|
||
|
}
|
||
|
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
function div(a, b)
|
||
|
{
|
||
|
return (a/b)|0;
|
||
|
}
|
||
|
function rem(a, b)
|
||
|
{
|
||
|
return a % b;
|
||
|
}
|
||
|
function mod(a, b)
|
||
|
{
|
||
|
if (b === 0)
|
||
|
{
|
||
|
throw new Error("Cannot perform mod 0. Division by zero error.");
|
||
|
}
|
||
|
var r = a % b;
|
||
|
var m = a === 0 ? 0 : (b > 0 ? (a >= 0 ? r : r+b) : -mod(-a,-b));
|
||
|
|
||
|
return m === b ? 0 : m;
|
||
|
}
|
||
|
function logBase(base, n)
|
||
|
{
|
||
|
return Math.log(n) / Math.log(base);
|
||
|
}
|
||
|
function negate(n)
|
||
|
{
|
||
|
return -n;
|
||
|
}
|
||
|
function abs(n)
|
||
|
{
|
||
|
return n < 0 ? -n : n;
|
||
|
}
|
||
|
|
||
|
function min(a, b)
|
||
|
{
|
||
|
return Utils.cmp(a,b) < 0 ? a : b;
|
||
|
}
|
||
|
function max(a, b)
|
||
|
{
|
||
|
return Utils.cmp(a,b) > 0 ? a : b;
|
||
|
}
|
||
|
function clamp(lo, hi, n)
|
||
|
{
|
||
|
return Utils.cmp(n,lo) < 0 ? lo : Utils.cmp(n,hi) > 0 ? hi : n;
|
||
|
}
|
||
|
|
||
|
function xor(a, b)
|
||
|
{
|
||
|
return a !== b;
|
||
|
}
|
||
|
function not(b)
|
||
|
{
|
||
|
return !b;
|
||
|
}
|
||
|
function isInfinite(n)
|
||
|
{
|
||
|
return n === Infinity || n === -Infinity
|
||
|
}
|
||
|
|
||
|
function truncate(n)
|
||
|
{
|
||
|
return n|0;
|
||
|
}
|
||
|
|
||
|
function degrees(d)
|
||
|
{
|
||
|
return d * Math.PI / 180;
|
||
|
}
|
||
|
function turns(t)
|
||
|
{
|
||
|
return 2 * Math.PI * t;
|
||
|
}
|
||
|
function fromPolar(point)
|
||
|
{
|
||
|
var r = point._0;
|
||
|
var t = point._1;
|
||
|
return Utils.Tuple2(r * Math.cos(t), r * Math.sin(t));
|
||
|
}
|
||
|
function toPolar(point)
|
||
|
{
|
||
|
var x = point._0;
|
||
|
var y = point._1;
|
||
|
return Utils.Tuple2(Math.sqrt(x * x + y * y), Math.atan2(y,x));
|
||
|
}
|
||
|
|
||
|
return localRuntime.Native.Basics.values = {
|
||
|
div: F2(div),
|
||
|
rem: F2(rem),
|
||
|
mod: F2(mod),
|
||
|
|
||
|
pi: Math.PI,
|
||
|
e: Math.E,
|
||
|
cos: Math.cos,
|
||
|
sin: Math.sin,
|
||
|
tan: Math.tan,
|
||
|
acos: Math.acos,
|
||
|
asin: Math.asin,
|
||
|
atan: Math.atan,
|
||
|
atan2: F2(Math.atan2),
|
||
|
|
||
|
degrees: degrees,
|
||
|
turns: turns,
|
||
|
fromPolar: fromPolar,
|
||
|
toPolar: toPolar,
|
||
|
|
||
|
sqrt: Math.sqrt,
|
||
|
logBase: F2(logBase),
|
||
|
negate: negate,
|
||
|
abs: abs,
|
||
|
min: F2(min),
|
||
|
max: F2(max),
|
||
|
clamp: F3(clamp),
|
||
|
compare: Utils.compare,
|
||
|
|
||
|
xor: F2(xor),
|
||
|
not: not,
|
||
|
|
||
|
truncate: truncate,
|
||
|
ceiling: Math.ceil,
|
||
|
floor: Math.floor,
|
||
|
round: Math.round,
|
||
|
toFloat: function(x) { return x; },
|
||
|
isNaN: isNaN,
|
||
|
isInfinite: isInfinite
|
||
|
};
|
||
|
};
|
||
|
|
||
|
Elm.Native.Char = {};
|
||
|
Elm.Native.Char.make = function(localRuntime) {
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Char = localRuntime.Native.Char || {};
|
||
|
if (localRuntime.Native.Char.values)
|
||
|
{
|
||
|
return localRuntime.Native.Char.values;
|
||
|
}
|
||
|
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
return localRuntime.Native.Char.values = {
|
||
|
fromCode : function(c) { return Utils.chr(String.fromCharCode(c)); },
|
||
|
toCode : function(c) { return c.charCodeAt(0); },
|
||
|
toUpper : function(c) { return Utils.chr(c.toUpperCase()); },
|
||
|
toLower : function(c) { return Utils.chr(c.toLowerCase()); },
|
||
|
toLocaleUpper : function(c) { return Utils.chr(c.toLocaleUpperCase()); },
|
||
|
toLocaleLower : function(c) { return Utils.chr(c.toLocaleLowerCase()); },
|
||
|
};
|
||
|
};
|
||
|
|
||
|
Elm.Native.Color = {};
|
||
|
Elm.Native.Color.make = function(localRuntime) {
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Color = localRuntime.Native.Color || {};
|
||
|
if (localRuntime.Native.Color.values)
|
||
|
{
|
||
|
return localRuntime.Native.Color.values;
|
||
|
}
|
||
|
|
||
|
function toCss(c)
|
||
|
{
|
||
|
var format = '';
|
||
|
var colors = '';
|
||
|
if (c.ctor === 'RGBA')
|
||
|
{
|
||
|
format = 'rgb';
|
||
|
colors = c._0 + ', ' + c._1 + ', ' + c._2;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
format = 'hsl';
|
||
|
colors = (c._0 * 180 / Math.PI) + ', ' +
|
||
|
(c._1 * 100) + '%, ' +
|
||
|
(c._2 * 100) + '%';
|
||
|
}
|
||
|
if (c._3 === 1)
|
||
|
{
|
||
|
return format + '(' + colors + ')';
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return format + 'a(' + colors + ', ' + c._3 + ')';
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return localRuntime.Native.Color.values = {
|
||
|
toCss: toCss
|
||
|
};
|
||
|
|
||
|
};
|
||
|
|
||
|
Elm.Native.Debug = {};
|
||
|
Elm.Native.Debug.make = function(localRuntime) {
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Debug = localRuntime.Native.Debug || {};
|
||
|
if (localRuntime.Native.Debug.values)
|
||
|
{
|
||
|
return localRuntime.Native.Debug.values;
|
||
|
}
|
||
|
|
||
|
var toString = Elm.Native.Show.make(localRuntime).toString;
|
||
|
|
||
|
function log(tag, value)
|
||
|
{
|
||
|
var msg = tag + ': ' + toString(value);
|
||
|
var process = process || {};
|
||
|
if (process.stdout)
|
||
|
{
|
||
|
process.stdout.write(msg);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
console.log(msg);
|
||
|
}
|
||
|
return value;
|
||
|
}
|
||
|
|
||
|
function crash(message)
|
||
|
{
|
||
|
throw new Error(message);
|
||
|
}
|
||
|
|
||
|
function tracePath(tag, form)
|
||
|
{
|
||
|
if (localRuntime.debug)
|
||
|
{
|
||
|
return localRuntime.debug.trace(tag, form);
|
||
|
}
|
||
|
return form;
|
||
|
}
|
||
|
|
||
|
function watch(tag, value)
|
||
|
{
|
||
|
if (localRuntime.debug)
|
||
|
{
|
||
|
localRuntime.debug.watch(tag, value);
|
||
|
}
|
||
|
return value;
|
||
|
}
|
||
|
|
||
|
function watchSummary(tag, summarize, value)
|
||
|
{
|
||
|
if (localRuntime.debug)
|
||
|
{
|
||
|
localRuntime.debug.watch(tag, summarize(value));
|
||
|
}
|
||
|
return value;
|
||
|
}
|
||
|
|
||
|
return localRuntime.Native.Debug.values = {
|
||
|
crash: crash,
|
||
|
tracePath: F2(tracePath),
|
||
|
log: F2(log),
|
||
|
watch: F2(watch),
|
||
|
watchSummary:F3(watchSummary),
|
||
|
};
|
||
|
};
|
||
|
|
||
|
|
||
|
// setup
|
||
|
Elm.Native = Elm.Native || {};
|
||
|
Elm.Native.Graphics = Elm.Native.Graphics || {};
|
||
|
Elm.Native.Graphics.Collage = Elm.Native.Graphics.Collage || {};
|
||
|
|
||
|
// definition
|
||
|
Elm.Native.Graphics.Collage.make = function(localRuntime) {
|
||
|
'use strict';
|
||
|
|
||
|
// attempt to short-circuit
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Graphics = localRuntime.Native.Graphics || {};
|
||
|
localRuntime.Native.Graphics.Collage = localRuntime.Native.Graphics.Collage || {};
|
||
|
if ('values' in localRuntime.Native.Graphics.Collage)
|
||
|
{
|
||
|
return localRuntime.Native.Graphics.Collage.values;
|
||
|
}
|
||
|
|
||
|
// okay, we cannot short-ciruit, so now we define everything
|
||
|
var Color = Elm.Native.Color.make(localRuntime);
|
||
|
var List = Elm.Native.List.make(localRuntime);
|
||
|
var NativeElement = Elm.Native.Graphics.Element.make(localRuntime);
|
||
|
var Transform = Elm.Transform2D.make(localRuntime);
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
function setStrokeStyle(ctx, style)
|
||
|
{
|
||
|
ctx.lineWidth = style.width;
|
||
|
|
||
|
var cap = style.cap.ctor;
|
||
|
ctx.lineCap = cap === 'Flat'
|
||
|
? 'butt'
|
||
|
: cap === 'Round'
|
||
|
? 'round'
|
||
|
: 'square';
|
||
|
|
||
|
var join = style.join.ctor;
|
||
|
ctx.lineJoin = join === 'Smooth'
|
||
|
? 'round'
|
||
|
: join === 'Sharp'
|
||
|
? 'miter'
|
||
|
: 'bevel';
|
||
|
|
||
|
ctx.miterLimit = style.join._0 || 10;
|
||
|
ctx.strokeStyle = Color.toCss(style.color);
|
||
|
}
|
||
|
|
||
|
function setFillStyle(ctx, style)
|
||
|
{
|
||
|
var sty = style.ctor;
|
||
|
ctx.fillStyle = sty === 'Solid'
|
||
|
? Color.toCss(style._0)
|
||
|
: sty === 'Texture'
|
||
|
? texture(redo, ctx, style._0)
|
||
|
: gradient(ctx, style._0);
|
||
|
}
|
||
|
|
||
|
function trace(ctx, path)
|
||
|
{
|
||
|
var points = List.toArray(path);
|
||
|
var i = points.length - 1;
|
||
|
if (i <= 0)
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
ctx.moveTo(points[i]._0, points[i]._1);
|
||
|
while (i--)
|
||
|
{
|
||
|
ctx.lineTo(points[i]._0, points[i]._1);
|
||
|
}
|
||
|
if (path.closed)
|
||
|
{
|
||
|
i = points.length - 1;
|
||
|
ctx.lineTo(points[i]._0, points[i]._1);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function line(ctx,style,path)
|
||
|
{
|
||
|
(style.dashing.ctor === '[]')
|
||
|
? trace(ctx, path)
|
||
|
: customLineHelp(ctx, style, path);
|
||
|
ctx.scale(1,-1);
|
||
|
ctx.stroke();
|
||
|
}
|
||
|
|
||
|
function customLineHelp(ctx, style, path)
|
||
|
{
|
||
|
var points = List.toArray(path);
|
||
|
if (path.closed)
|
||
|
{
|
||
|
points.push(points[0]);
|
||
|
}
|
||
|
var pattern = List.toArray(style.dashing);
|
||
|
var i = points.length - 1;
|
||
|
if (i <= 0)
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
var x0 = points[i]._0, y0 = points[i]._1;
|
||
|
var x1=0, y1=0, dx=0, dy=0, remaining=0, nx=0, ny=0;
|
||
|
var pindex = 0, plen = pattern.length;
|
||
|
var draw = true, segmentLength = pattern[0];
|
||
|
ctx.moveTo(x0,y0);
|
||
|
while (i--)
|
||
|
{
|
||
|
x1 = points[i]._0;
|
||
|
y1 = points[i]._1;
|
||
|
dx = x1 - x0;
|
||
|
dy = y1 - y0;
|
||
|
remaining = Math.sqrt(dx * dx + dy * dy);
|
||
|
while (segmentLength <= remaining)
|
||
|
{
|
||
|
x0 += dx * segmentLength / remaining;
|
||
|
y0 += dy * segmentLength / remaining;
|
||
|
ctx[draw ? 'lineTo' : 'moveTo'](x0, y0);
|
||
|
// update starting position
|
||
|
dx = x1 - x0;
|
||
|
dy = y1 - y0;
|
||
|
remaining = Math.sqrt(dx * dx + dy * dy);
|
||
|
// update pattern
|
||
|
draw = !draw;
|
||
|
pindex = (pindex + 1) % plen;
|
||
|
segmentLength = pattern[pindex];
|
||
|
}
|
||
|
if (remaining > 0)
|
||
|
{
|
||
|
ctx[draw ? 'lineTo' : 'moveTo'](x1, y1);
|
||
|
segmentLength -= remaining;
|
||
|
}
|
||
|
x0 = x1;
|
||
|
y0 = y1;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function drawLine(ctx, style, path)
|
||
|
{
|
||
|
setStrokeStyle(ctx, style);
|
||
|
return line(ctx, style, path);
|
||
|
}
|
||
|
|
||
|
function texture(redo, ctx, src)
|
||
|
{
|
||
|
var img = new Image();
|
||
|
img.src = src;
|
||
|
img.onload = redo;
|
||
|
return ctx.createPattern(img, 'repeat');
|
||
|
}
|
||
|
|
||
|
function gradient(ctx, grad)
|
||
|
{
|
||
|
var g;
|
||
|
var stops = [];
|
||
|
if (grad.ctor === 'Linear')
|
||
|
{
|
||
|
var p0 = grad._0, p1 = grad._1;
|
||
|
g = ctx.createLinearGradient(p0._0, -p0._1, p1._0, -p1._1);
|
||
|
stops = List.toArray(grad._2);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
var p0 = grad._0, p2 = grad._2;
|
||
|
g = ctx.createRadialGradient(p0._0, -p0._1, grad._1, p2._0, -p2._1, grad._3);
|
||
|
stops = List.toArray(grad._4);
|
||
|
}
|
||
|
var len = stops.length;
|
||
|
for (var i = 0; i < len; ++i)
|
||
|
{
|
||
|
var stop = stops[i];
|
||
|
g.addColorStop(stop._0, Color.toCss(stop._1));
|
||
|
}
|
||
|
return g;
|
||
|
}
|
||
|
|
||
|
function drawShape(redo, ctx, style, path)
|
||
|
{
|
||
|
trace(ctx, path);
|
||
|
setFillStyle(ctx, style);
|
||
|
ctx.scale(1,-1);
|
||
|
ctx.fill();
|
||
|
}
|
||
|
|
||
|
|
||
|
// TEXT RENDERING
|
||
|
|
||
|
function fillText(redo, ctx, text)
|
||
|
{
|
||
|
drawText(ctx, text, ctx.fillText);
|
||
|
}
|
||
|
|
||
|
function strokeText(redo, ctx, style, text)
|
||
|
{
|
||
|
setStrokeStyle(ctx, style);
|
||
|
// Use native canvas API for dashes only for text for now
|
||
|
// Degrades to non-dashed on IE 9 + 10
|
||
|
if (style.dashing.ctor !== '[]' && ctx.setLineDash)
|
||
|
{
|
||
|
var pattern = List.toArray(style.dashing);
|
||
|
ctx.setLineDash(pattern);
|
||
|
}
|
||
|
drawText(ctx, text, ctx.strokeText);
|
||
|
}
|
||
|
|
||
|
function drawText(ctx, text, canvasDrawFn)
|
||
|
{
|
||
|
var textChunks = chunkText(defaultContext, text);
|
||
|
|
||
|
var totalWidth = 0;
|
||
|
var maxHeight = 0;
|
||
|
var numChunks = textChunks.length;
|
||
|
|
||
|
ctx.scale(1,-1);
|
||
|
|
||
|
for (var i = numChunks; i--; )
|
||
|
{
|
||
|
var chunk = textChunks[i];
|
||
|
ctx.font = chunk.font;
|
||
|
var metrics = ctx.measureText(chunk.text);
|
||
|
chunk.width = metrics.width;
|
||
|
totalWidth += chunk.width;
|
||
|
if (chunk.height > maxHeight)
|
||
|
{
|
||
|
maxHeight = chunk.height;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
var x = -totalWidth / 2.0;
|
||
|
for (var i = 0; i < numChunks; ++i)
|
||
|
{
|
||
|
var chunk = textChunks[i];
|
||
|
ctx.font = chunk.font;
|
||
|
ctx.fillStyle = chunk.color;
|
||
|
canvasDrawFn.call(ctx, chunk.text, x, maxHeight / 2);
|
||
|
x += chunk.width;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function toFont(props)
|
||
|
{
|
||
|
return [
|
||
|
props['font-style'],
|
||
|
props['font-variant'],
|
||
|
props['font-weight'],
|
||
|
props['font-size'],
|
||
|
props['font-family']
|
||
|
].join(' ');
|
||
|
}
|
||
|
|
||
|
|
||
|
// Convert the object returned by the text module
|
||
|
// into something we can use for styling canvas text
|
||
|
function chunkText(context, text)
|
||
|
{
|
||
|
var tag = text.ctor;
|
||
|
if (tag === 'Text:Append')
|
||
|
{
|
||
|
var leftChunks = chunkText(context, text._0);
|
||
|
var rightChunks = chunkText(context, text._1);
|
||
|
return leftChunks.concat(rightChunks);
|
||
|
}
|
||
|
if (tag === 'Text:Text')
|
||
|
{
|
||
|
return [{
|
||
|
text: text._0,
|
||
|
color: context.color,
|
||
|
height: context['font-size'].slice(0,-2) | 0,
|
||
|
font: toFont(context)
|
||
|
}];
|
||
|
}
|
||
|
if (tag === 'Text:Meta')
|
||
|
{
|
||
|
var newContext = freshContext(text._0, context);
|
||
|
return chunkText(newContext, text._1);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function freshContext(props, ctx)
|
||
|
{
|
||
|
return {
|
||
|
'font-style': props['font-style'] || ctx['font-style'],
|
||
|
'font-variant': props['font-variant'] || ctx['font-variant'],
|
||
|
'font-weight': props['font-weight'] || ctx['font-weight'],
|
||
|
'font-size': props['font-size'] || ctx['font-size'],
|
||
|
'font-family': props['font-family'] || ctx['font-family'],
|
||
|
'color': props['color'] || ctx['color']
|
||
|
};
|
||
|
}
|
||
|
|
||
|
var defaultContext = {
|
||
|
'font-style': 'normal',
|
||
|
'font-variant': 'normal',
|
||
|
'font-weight': 'normal',
|
||
|
'font-size': '12px',
|
||
|
'font-family': 'sans-serif',
|
||
|
'color': 'black'
|
||
|
};
|
||
|
|
||
|
|
||
|
// IMAGES
|
||
|
|
||
|
function drawImage(redo, ctx, form)
|
||
|
{
|
||
|
var img = new Image();
|
||
|
img.onload = redo;
|
||
|
img.src = form._3;
|
||
|
var w = form._0,
|
||
|
h = form._1,
|
||
|
pos = form._2,
|
||
|
srcX = pos._0,
|
||
|
srcY = pos._1,
|
||
|
srcW = w,
|
||
|
srcH = h,
|
||
|
destX = -w/2,
|
||
|
destY = -h/2,
|
||
|
destW = w,
|
||
|
destH = h;
|
||
|
|
||
|
ctx.scale(1,-1);
|
||
|
ctx.drawImage(img, srcX, srcY, srcW, srcH, destX, destY, destW, destH);
|
||
|
}
|
||
|
|
||
|
function renderForm(redo, ctx, form)
|
||
|
{
|
||
|
ctx.save();
|
||
|
|
||
|
var x = form.x,
|
||
|
y = form.y,
|
||
|
theta = form.theta,
|
||
|
scale = form.scale;
|
||
|
|
||
|
if (x !== 0 || y !== 0)
|
||
|
{
|
||
|
ctx.translate(x, y);
|
||
|
}
|
||
|
if (theta !== 0)
|
||
|
{
|
||
|
ctx.rotate(theta);
|
||
|
}
|
||
|
if (scale !== 1)
|
||
|
{
|
||
|
ctx.scale(scale,scale);
|
||
|
}
|
||
|
if (form.alpha !== 1)
|
||
|
{
|
||
|
ctx.globalAlpha = ctx.globalAlpha * form.alpha;
|
||
|
}
|
||
|
|
||
|
ctx.beginPath();
|
||
|
var f = form.form;
|
||
|
switch (f.ctor)
|
||
|
{
|
||
|
case 'FPath':
|
||
|
drawLine(ctx, f._0, f._1);
|
||
|
break;
|
||
|
|
||
|
case 'FImage':
|
||
|
drawImage(redo, ctx, f);
|
||
|
break;
|
||
|
|
||
|
case 'FShape':
|
||
|
if (f._0.ctor === 'Line')
|
||
|
{
|
||
|
f._1.closed = true;
|
||
|
drawLine(ctx, f._0._0, f._1);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
drawShape(redo, ctx, f._0._0, f._1);
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case 'FText':
|
||
|
fillText(redo, ctx, f._0);
|
||
|
break;
|
||
|
|
||
|
case 'FOutlinedText':
|
||
|
strokeText(redo, ctx, f._0, f._1);
|
||
|
break;
|
||
|
}
|
||
|
ctx.restore();
|
||
|
}
|
||
|
|
||
|
function formToMatrix(form)
|
||
|
{
|
||
|
var scale = form.scale;
|
||
|
var matrix = A6( Transform.matrix, scale, 0, 0, scale, form.x, form.y );
|
||
|
|
||
|
var theta = form.theta
|
||
|
if (theta !== 0)
|
||
|
{
|
||
|
matrix = A2( Transform.multiply, matrix, Transform.rotation(theta) );
|
||
|
}
|
||
|
|
||
|
return matrix;
|
||
|
}
|
||
|
|
||
|
function str(n)
|
||
|
{
|
||
|
if (n < 0.00001 && n > -0.00001)
|
||
|
{
|
||
|
return 0;
|
||
|
}
|
||
|
return n;
|
||
|
}
|
||
|
|
||
|
function makeTransform(w, h, form, matrices)
|
||
|
{
|
||
|
var props = form.form._0.props;
|
||
|
var m = A6( Transform.matrix, 1, 0, 0, -1,
|
||
|
(w - props.width ) / 2,
|
||
|
(h - props.height) / 2 );
|
||
|
var len = matrices.length;
|
||
|
for (var i = 0; i < len; ++i)
|
||
|
{
|
||
|
m = A2( Transform.multiply, m, matrices[i] );
|
||
|
}
|
||
|
m = A2( Transform.multiply, m, formToMatrix(form) );
|
||
|
|
||
|
return 'matrix(' +
|
||
|
str( m[0]) + ', ' + str( m[3]) + ', ' +
|
||
|
str(-m[1]) + ', ' + str(-m[4]) + ', ' +
|
||
|
str( m[2]) + ', ' + str( m[5]) + ')';
|
||
|
}
|
||
|
|
||
|
function stepperHelp(list)
|
||
|
{
|
||
|
var arr = List.toArray(list);
|
||
|
var i = 0;
|
||
|
function peekNext()
|
||
|
{
|
||
|
return i < arr.length ? arr[i].form.ctor : '';
|
||
|
}
|
||
|
// assumes that there is a next element
|
||
|
function next()
|
||
|
{
|
||
|
var out = arr[i];
|
||
|
++i;
|
||
|
return out;
|
||
|
}
|
||
|
return {
|
||
|
peekNext: peekNext,
|
||
|
next: next
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function formStepper(forms)
|
||
|
{
|
||
|
var ps = [stepperHelp(forms)];
|
||
|
var matrices = [];
|
||
|
var alphas = [];
|
||
|
function peekNext()
|
||
|
{
|
||
|
var len = ps.length;
|
||
|
var formType = '';
|
||
|
for (var i = 0; i < len; ++i )
|
||
|
{
|
||
|
if (formType = ps[i].peekNext()) return formType;
|
||
|
}
|
||
|
return '';
|
||
|
}
|
||
|
// assumes that there is a next element
|
||
|
function next(ctx)
|
||
|
{
|
||
|
while (!ps[0].peekNext())
|
||
|
{
|
||
|
ps.shift();
|
||
|
matrices.pop();
|
||
|
alphas.shift();
|
||
|
if (ctx)
|
||
|
{
|
||
|
ctx.restore();
|
||
|
}
|
||
|
}
|
||
|
var out = ps[0].next();
|
||
|
var f = out.form;
|
||
|
if (f.ctor === 'FGroup')
|
||
|
{
|
||
|
ps.unshift(stepperHelp(f._1));
|
||
|
var m = A2(Transform.multiply, f._0, formToMatrix(out));
|
||
|
ctx.save();
|
||
|
ctx.transform(m[0], m[3], m[1], m[4], m[2], m[5]);
|
||
|
matrices.push(m);
|
||
|
|
||
|
var alpha = (alphas[0] || 1) * out.alpha;
|
||
|
alphas.unshift(alpha);
|
||
|
ctx.globalAlpha = alpha;
|
||
|
}
|
||
|
return out;
|
||
|
}
|
||
|
function transforms()
|
||
|
{
|
||
|
return matrices;
|
||
|
}
|
||
|
function alpha()
|
||
|
{
|
||
|
return alphas[0] || 1;
|
||
|
}
|
||
|
return {
|
||
|
peekNext: peekNext,
|
||
|
next: next,
|
||
|
transforms: transforms,
|
||
|
alpha: alpha
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function makeCanvas(w,h)
|
||
|
{
|
||
|
var canvas = NativeElement.createNode('canvas');
|
||
|
canvas.style.width = w + 'px';
|
||
|
canvas.style.height = h + 'px';
|
||
|
canvas.style.display = "block";
|
||
|
canvas.style.position = "absolute";
|
||
|
var ratio = window.devicePixelRatio || 1;
|
||
|
canvas.width = w * ratio;
|
||
|
canvas.height = h * ratio;
|
||
|
return canvas;
|
||
|
}
|
||
|
|
||
|
function render(model)
|
||
|
{
|
||
|
var div = NativeElement.createNode('div');
|
||
|
div.style.overflow = 'hidden';
|
||
|
div.style.position = 'relative';
|
||
|
update(div, model, model);
|
||
|
return div;
|
||
|
}
|
||
|
|
||
|
function nodeStepper(w,h,div)
|
||
|
{
|
||
|
var kids = div.childNodes;
|
||
|
var i = 0;
|
||
|
var ratio = window.devicePixelRatio || 1;
|
||
|
|
||
|
function transform(transforms, ctx)
|
||
|
{
|
||
|
ctx.translate( w / 2 * ratio, h / 2 * ratio );
|
||
|
ctx.scale( ratio, -ratio );
|
||
|
var len = transforms.length;
|
||
|
for (var i = 0; i < len; ++i)
|
||
|
{
|
||
|
var m = transforms[i];
|
||
|
ctx.save();
|
||
|
ctx.transform(m[0], m[3], m[1], m[4], m[2], m[5]);
|
||
|
}
|
||
|
return ctx;
|
||
|
}
|
||
|
function nextContext(transforms)
|
||
|
{
|
||
|
while (i < kids.length)
|
||
|
{
|
||
|
var node = kids[i];
|
||
|
if (node.getContext)
|
||
|
{
|
||
|
node.width = w * ratio;
|
||
|
node.height = h * ratio;
|
||
|
node.style.width = w + 'px';
|
||
|
node.style.height = h + 'px';
|
||
|
++i;
|
||
|
return transform(transforms, node.getContext('2d'));
|
||
|
}
|
||
|
div.removeChild(node);
|
||
|
}
|
||
|
var canvas = makeCanvas(w,h);
|
||
|
div.appendChild(canvas);
|
||
|
// we have added a new node, so we must step our position
|
||
|
++i;
|
||
|
return transform(transforms, canvas.getContext('2d'));
|
||
|
}
|
||
|
function addElement(matrices, alpha, form)
|
||
|
{
|
||
|
var kid = kids[i];
|
||
|
var elem = form.form._0;
|
||
|
|
||
|
var node = (!kid || kid.getContext)
|
||
|
? NativeElement.render(elem)
|
||
|
: NativeElement.update(kid, kid.oldElement, elem);
|
||
|
|
||
|
node.style.position = 'absolute';
|
||
|
node.style.opacity = alpha * form.alpha * elem.props.opacity;
|
||
|
NativeElement.addTransform(node.style, makeTransform(w, h, form, matrices));
|
||
|
node.oldElement = elem;
|
||
|
++i;
|
||
|
if (!kid)
|
||
|
{
|
||
|
div.appendChild(node);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
div.insertBefore(node, kid);
|
||
|
}
|
||
|
}
|
||
|
function clearRest()
|
||
|
{
|
||
|
while (i < kids.length)
|
||
|
{
|
||
|
div.removeChild(kids[i]);
|
||
|
}
|
||
|
}
|
||
|
return {
|
||
|
nextContext: nextContext,
|
||
|
addElement: addElement,
|
||
|
clearRest: clearRest
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
function update(div, _, model)
|
||
|
{
|
||
|
var w = model.w;
|
||
|
var h = model.h;
|
||
|
|
||
|
var forms = formStepper(model.forms);
|
||
|
var nodes = nodeStepper(w,h,div);
|
||
|
var ctx = null;
|
||
|
var formType = '';
|
||
|
|
||
|
while (formType = forms.peekNext())
|
||
|
{
|
||
|
// make sure we have context if we need it
|
||
|
if (ctx === null && formType !== 'FElement')
|
||
|
{
|
||
|
ctx = nodes.nextContext(forms.transforms());
|
||
|
ctx.globalAlpha = forms.alpha();
|
||
|
}
|
||
|
|
||
|
var form = forms.next(ctx);
|
||
|
// if it is FGroup, all updates are made within formStepper when next is called.
|
||
|
if (formType === 'FElement')
|
||
|
{
|
||
|
// update or insert an element, get a new context
|
||
|
nodes.addElement(forms.transforms(), forms.alpha(), form);
|
||
|
ctx = null;
|
||
|
}
|
||
|
else if (formType !== 'FGroup')
|
||
|
{
|
||
|
renderForm(function() { update(div, model, model); }, ctx, form);
|
||
|
}
|
||
|
}
|
||
|
nodes.clearRest();
|
||
|
return div;
|
||
|
}
|
||
|
|
||
|
|
||
|
function collage(w,h,forms)
|
||
|
{
|
||
|
return A3(NativeElement.newElement, w, h, {
|
||
|
ctor: 'Custom',
|
||
|
type: 'Collage',
|
||
|
render: render,
|
||
|
update: update,
|
||
|
model: {w:w, h:h, forms:forms}
|
||
|
});
|
||
|
}
|
||
|
|
||
|
return localRuntime.Native.Graphics.Collage.values = {
|
||
|
collage: F3(collage)
|
||
|
};
|
||
|
|
||
|
};
|
||
|
|
||
|
|
||
|
// setup
|
||
|
Elm.Native = Elm.Native || {};
|
||
|
Elm.Native.Graphics = Elm.Native.Graphics || {};
|
||
|
Elm.Native.Graphics.Element = Elm.Native.Graphics.Element || {};
|
||
|
|
||
|
// definition
|
||
|
Elm.Native.Graphics.Element.make = function(localRuntime) {
|
||
|
'use strict';
|
||
|
|
||
|
// attempt to short-circuit
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Graphics = localRuntime.Native.Graphics || {};
|
||
|
localRuntime.Native.Graphics.Element = localRuntime.Native.Graphics.Element || {};
|
||
|
if ('values' in localRuntime.Native.Graphics.Element)
|
||
|
{
|
||
|
return localRuntime.Native.Graphics.Element.values;
|
||
|
}
|
||
|
|
||
|
var Color = Elm.Native.Color.make(localRuntime);
|
||
|
var List = Elm.Native.List.make(localRuntime);
|
||
|
var Maybe = Elm.Maybe.make(localRuntime);
|
||
|
var Text = Elm.Native.Text.make(localRuntime);
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
|
||
|
// CREATION
|
||
|
|
||
|
function createNode(elementType)
|
||
|
{
|
||
|
var node = document.createElement(elementType);
|
||
|
node.style.padding = "0";
|
||
|
node.style.margin = "0";
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
|
||
|
function newElement(width, height, elementPrim)
|
||
|
{
|
||
|
return {
|
||
|
_: {},
|
||
|
element: elementPrim,
|
||
|
props: {
|
||
|
_: {},
|
||
|
id: Utils.guid(),
|
||
|
width: width,
|
||
|
height: height,
|
||
|
opacity: 1,
|
||
|
color: Maybe.Nothing,
|
||
|
href: "",
|
||
|
tag: "",
|
||
|
hover: Utils.Tuple0,
|
||
|
click: Utils.Tuple0
|
||
|
}
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
// PROPERTIES
|
||
|
|
||
|
function setProps(elem, node)
|
||
|
{
|
||
|
var props = elem.props;
|
||
|
|
||
|
var element = elem.element;
|
||
|
var width = props.width - (element.adjustWidth || 0);
|
||
|
var height = props.height - (element.adjustHeight || 0);
|
||
|
node.style.width = (width |0) + 'px';
|
||
|
node.style.height = (height|0) + 'px';
|
||
|
|
||
|
if (props.opacity !== 1)
|
||
|
{
|
||
|
node.style.opacity = props.opacity;
|
||
|
}
|
||
|
|
||
|
if (props.color.ctor === 'Just')
|
||
|
{
|
||
|
node.style.backgroundColor = Color.toCss(props.color._0);
|
||
|
}
|
||
|
|
||
|
if (props.tag !== '')
|
||
|
{
|
||
|
node.id = props.tag;
|
||
|
}
|
||
|
|
||
|
if (props.hover.ctor !== '_Tuple0')
|
||
|
{
|
||
|
addHover(node, props.hover);
|
||
|
}
|
||
|
|
||
|
if (props.click.ctor !== '_Tuple0')
|
||
|
{
|
||
|
addClick(node, props.click);
|
||
|
}
|
||
|
|
||
|
if (props.href !== '')
|
||
|
{
|
||
|
var anchor = createNode('a');
|
||
|
anchor.href = props.href;
|
||
|
anchor.style.display = 'block';
|
||
|
anchor.style.pointerEvents = 'auto';
|
||
|
anchor.appendChild(node);
|
||
|
node = anchor;
|
||
|
}
|
||
|
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
function addClick(e, handler)
|
||
|
{
|
||
|
e.style.pointerEvents = 'auto';
|
||
|
e.elm_click_handler = handler;
|
||
|
function trigger(ev)
|
||
|
{
|
||
|
e.elm_click_handler(Utils.Tuple0);
|
||
|
ev.stopPropagation();
|
||
|
}
|
||
|
e.elm_click_trigger = trigger;
|
||
|
e.addEventListener('click', trigger);
|
||
|
}
|
||
|
|
||
|
function removeClick(e, handler)
|
||
|
{
|
||
|
if (e.elm_click_trigger)
|
||
|
{
|
||
|
e.removeEventListener('click', e.elm_click_trigger);
|
||
|
e.elm_click_trigger = null;
|
||
|
e.elm_click_handler = null;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function addHover(e, handler)
|
||
|
{
|
||
|
e.style.pointerEvents = 'auto';
|
||
|
e.elm_hover_handler = handler;
|
||
|
e.elm_hover_count = 0;
|
||
|
|
||
|
function over(evt)
|
||
|
{
|
||
|
if (e.elm_hover_count++ > 0) return;
|
||
|
e.elm_hover_handler(true);
|
||
|
evt.stopPropagation();
|
||
|
}
|
||
|
function out(evt)
|
||
|
{
|
||
|
if (e.contains(evt.toElement || evt.relatedTarget)) return;
|
||
|
e.elm_hover_count = 0;
|
||
|
e.elm_hover_handler(false);
|
||
|
evt.stopPropagation();
|
||
|
}
|
||
|
e.elm_hover_over = over;
|
||
|
e.elm_hover_out = out;
|
||
|
e.addEventListener('mouseover', over);
|
||
|
e.addEventListener('mouseout', out);
|
||
|
}
|
||
|
|
||
|
function removeHover(e)
|
||
|
{
|
||
|
e.elm_hover_handler = null;
|
||
|
if (e.elm_hover_over)
|
||
|
{
|
||
|
e.removeEventListener('mouseover', e.elm_hover_over);
|
||
|
e.elm_hover_over = null;
|
||
|
}
|
||
|
if (e.elm_hover_out)
|
||
|
{
|
||
|
e.removeEventListener('mouseout', e.elm_hover_out);
|
||
|
e.elm_hover_out = null;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// IMAGES
|
||
|
|
||
|
function image(props, img)
|
||
|
{
|
||
|
switch (img._0.ctor)
|
||
|
{
|
||
|
case 'Plain':
|
||
|
return plainImage(img._3);
|
||
|
|
||
|
case 'Fitted':
|
||
|
return fittedImage(props.width, props.height, img._3);
|
||
|
|
||
|
case 'Cropped':
|
||
|
return croppedImage(img,props.width,props.height,img._3);
|
||
|
|
||
|
case 'Tiled':
|
||
|
return tiledImage(img._3);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function plainImage(src)
|
||
|
{
|
||
|
var img = createNode('img');
|
||
|
img.src = src;
|
||
|
img.name = src;
|
||
|
img.style.display = "block";
|
||
|
return img;
|
||
|
}
|
||
|
|
||
|
function tiledImage(src)
|
||
|
{
|
||
|
var div = createNode('div');
|
||
|
div.style.backgroundImage = 'url(' + src + ')';
|
||
|
return div;
|
||
|
}
|
||
|
|
||
|
function fittedImage(w, h, src)
|
||
|
{
|
||
|
var div = createNode('div');
|
||
|
div.style.background = 'url(' + src + ') no-repeat center';
|
||
|
div.style.webkitBackgroundSize = 'cover';
|
||
|
div.style.MozBackgroundSize = 'cover';
|
||
|
div.style.OBackgroundSize = 'cover';
|
||
|
div.style.backgroundSize = 'cover';
|
||
|
return div;
|
||
|
}
|
||
|
|
||
|
function croppedImage(elem, w, h, src)
|
||
|
{
|
||
|
var pos = elem._0._0;
|
||
|
var e = createNode('div');
|
||
|
e.style.overflow = "hidden";
|
||
|
|
||
|
var img = createNode('img');
|
||
|
img.onload = function() {
|
||
|
var sw = w / elem._1, sh = h / elem._2;
|
||
|
img.style.width = ((this.width * sw)|0) + 'px';
|
||
|
img.style.height = ((this.height * sh)|0) + 'px';
|
||
|
img.style.marginLeft = ((- pos._0 * sw)|0) + 'px';
|
||
|
img.style.marginTop = ((- pos._1 * sh)|0) + 'px';
|
||
|
};
|
||
|
img.src = src;
|
||
|
img.name = src;
|
||
|
e.appendChild(img);
|
||
|
return e;
|
||
|
}
|
||
|
|
||
|
|
||
|
// FLOW
|
||
|
|
||
|
function goOut(node)
|
||
|
{
|
||
|
node.style.position = 'absolute';
|
||
|
return node;
|
||
|
}
|
||
|
function goDown(node)
|
||
|
{
|
||
|
return node;
|
||
|
}
|
||
|
function goRight(node)
|
||
|
{
|
||
|
node.style.styleFloat = 'left';
|
||
|
node.style.cssFloat = 'left';
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
var directionTable = {
|
||
|
DUp : goDown,
|
||
|
DDown : goDown,
|
||
|
DLeft : goRight,
|
||
|
DRight : goRight,
|
||
|
DIn : goOut,
|
||
|
DOut : goOut
|
||
|
};
|
||
|
function needsReversal(dir)
|
||
|
{
|
||
|
return dir == 'DUp' || dir == 'DLeft' || dir == 'DIn';
|
||
|
}
|
||
|
|
||
|
function flow(dir,elist)
|
||
|
{
|
||
|
var array = List.toArray(elist);
|
||
|
var container = createNode('div');
|
||
|
var goDir = directionTable[dir];
|
||
|
if (goDir == goOut)
|
||
|
{
|
||
|
container.style.pointerEvents = 'none';
|
||
|
}
|
||
|
if (needsReversal(dir))
|
||
|
{
|
||
|
array.reverse();
|
||
|
}
|
||
|
var len = array.length;
|
||
|
for (var i = 0; i < len; ++i)
|
||
|
{
|
||
|
container.appendChild(goDir(render(array[i])));
|
||
|
}
|
||
|
return container;
|
||
|
}
|
||
|
|
||
|
|
||
|
// CONTAINER
|
||
|
|
||
|
function toPos(pos)
|
||
|
{
|
||
|
return pos.ctor === "Absolute"
|
||
|
? pos._0 + "px"
|
||
|
: (pos._0 * 100) + "%";
|
||
|
}
|
||
|
|
||
|
// must clear right, left, top, bottom, and transform
|
||
|
// before calling this function
|
||
|
function setPos(pos,elem,e)
|
||
|
{
|
||
|
var element = elem.element;
|
||
|
var props = elem.props;
|
||
|
var w = props.width + (element.adjustWidth ? element.adjustWidth : 0);
|
||
|
var h = props.height + (element.adjustHeight ? element.adjustHeight : 0);
|
||
|
|
||
|
e.style.position = 'absolute';
|
||
|
e.style.margin = 'auto';
|
||
|
var transform = '';
|
||
|
|
||
|
switch (pos.horizontal.ctor)
|
||
|
{
|
||
|
case 'P':
|
||
|
e.style.right = toPos(pos.x);
|
||
|
e.style.removeProperty('left');
|
||
|
break;
|
||
|
|
||
|
case 'Z':
|
||
|
transform = 'translateX(' + ((-w/2)|0) + 'px) ';
|
||
|
|
||
|
case 'N':
|
||
|
e.style.left = toPos(pos.x);
|
||
|
e.style.removeProperty('right');
|
||
|
break;
|
||
|
}
|
||
|
switch (pos.vertical.ctor)
|
||
|
{
|
||
|
case 'N':
|
||
|
e.style.bottom = toPos(pos.y);
|
||
|
e.style.removeProperty('top');
|
||
|
break;
|
||
|
|
||
|
case 'Z':
|
||
|
transform += 'translateY(' + ((-h/2)|0) + 'px)';
|
||
|
|
||
|
case 'P':
|
||
|
e.style.top = toPos(pos.y);
|
||
|
e.style.removeProperty('bottom');
|
||
|
break;
|
||
|
}
|
||
|
if (transform !== '')
|
||
|
{
|
||
|
addTransform(e.style, transform);
|
||
|
}
|
||
|
return e;
|
||
|
}
|
||
|
|
||
|
function addTransform(style, transform)
|
||
|
{
|
||
|
style.transform = transform;
|
||
|
style.msTransform = transform;
|
||
|
style.MozTransform = transform;
|
||
|
style.webkitTransform = transform;
|
||
|
style.OTransform = transform;
|
||
|
}
|
||
|
|
||
|
function container(pos,elem)
|
||
|
{
|
||
|
var e = render(elem);
|
||
|
setPos(pos, elem, e);
|
||
|
var div = createNode('div');
|
||
|
div.style.position = 'relative';
|
||
|
div.style.overflow = 'hidden';
|
||
|
div.appendChild(e);
|
||
|
return div;
|
||
|
}
|
||
|
|
||
|
|
||
|
function rawHtml(elem)
|
||
|
{
|
||
|
var html = elem.html;
|
||
|
var guid = elem.guid;
|
||
|
var align = elem.align;
|
||
|
|
||
|
var div = createNode('div');
|
||
|
div.innerHTML = html;
|
||
|
div.style.visibility = "hidden";
|
||
|
if (align)
|
||
|
{
|
||
|
div.style.textAlign = align;
|
||
|
}
|
||
|
div.style.visibility = 'visible';
|
||
|
div.style.pointerEvents = 'auto';
|
||
|
return div;
|
||
|
}
|
||
|
|
||
|
|
||
|
// RENDER
|
||
|
|
||
|
function render(elem)
|
||
|
{
|
||
|
return setProps(elem, makeElement(elem));
|
||
|
}
|
||
|
function makeElement(e)
|
||
|
{
|
||
|
var elem = e.element;
|
||
|
switch(elem.ctor)
|
||
|
{
|
||
|
case 'Image':
|
||
|
return image(e.props, elem);
|
||
|
|
||
|
case 'Flow':
|
||
|
return flow(elem._0.ctor, elem._1);
|
||
|
|
||
|
case 'Container':
|
||
|
return container(elem._0, elem._1);
|
||
|
|
||
|
case 'Spacer':
|
||
|
return createNode('div');
|
||
|
|
||
|
case 'RawHtml':
|
||
|
return rawHtml(elem);
|
||
|
|
||
|
case 'Custom':
|
||
|
return elem.render(elem.model);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function updateAndReplace(node, curr, next)
|
||
|
{
|
||
|
var newNode = update(node, curr, next);
|
||
|
if (newNode !== node)
|
||
|
{
|
||
|
node.parentNode.replaceChild(newNode, node);
|
||
|
}
|
||
|
return newNode;
|
||
|
}
|
||
|
|
||
|
|
||
|
// UPDATE
|
||
|
|
||
|
function update(node, curr, next)
|
||
|
{
|
||
|
var rootNode = node;
|
||
|
if (node.tagName === 'A')
|
||
|
{
|
||
|
node = node.firstChild;
|
||
|
}
|
||
|
if (curr.props.id === next.props.id)
|
||
|
{
|
||
|
updateProps(node, curr, next);
|
||
|
return rootNode;
|
||
|
}
|
||
|
if (curr.element.ctor !== next.element.ctor)
|
||
|
{
|
||
|
return render(next);
|
||
|
}
|
||
|
var nextE = next.element;
|
||
|
var currE = curr.element;
|
||
|
switch(nextE.ctor)
|
||
|
{
|
||
|
case "Spacer":
|
||
|
updateProps(node, curr, next);
|
||
|
return rootNode;
|
||
|
|
||
|
case "RawHtml":
|
||
|
if(currE.html.valueOf() !== nextE.html.valueOf())
|
||
|
{
|
||
|
node.innerHTML = nextE.html;
|
||
|
}
|
||
|
updateProps(node, curr, next);
|
||
|
return rootNode;
|
||
|
|
||
|
case "Image":
|
||
|
if (nextE._0.ctor === 'Plain')
|
||
|
{
|
||
|
if (nextE._3 !== currE._3)
|
||
|
{
|
||
|
node.src = nextE._3;
|
||
|
}
|
||
|
}
|
||
|
else if (!Utils.eq(nextE,currE)
|
||
|
|| next.props.width !== curr.props.width
|
||
|
|| next.props.height !== curr.props.height)
|
||
|
{
|
||
|
return render(next);
|
||
|
}
|
||
|
updateProps(node, curr, next);
|
||
|
return rootNode;
|
||
|
|
||
|
case "Flow":
|
||
|
var arr = List.toArray(nextE._1);
|
||
|
for (var i = arr.length; i--; )
|
||
|
{
|
||
|
arr[i] = arr[i].element.ctor;
|
||
|
}
|
||
|
if (nextE._0.ctor !== currE._0.ctor)
|
||
|
{
|
||
|
return render(next);
|
||
|
}
|
||
|
var nexts = List.toArray(nextE._1);
|
||
|
var kids = node.childNodes;
|
||
|
if (nexts.length !== kids.length)
|
||
|
{
|
||
|
return render(next);
|
||
|
}
|
||
|
var currs = List.toArray(currE._1);
|
||
|
var dir = nextE._0.ctor;
|
||
|
var goDir = directionTable[dir];
|
||
|
var toReverse = needsReversal(dir);
|
||
|
var len = kids.length;
|
||
|
for (var i = len; i-- ;)
|
||
|
{
|
||
|
var subNode = kids[toReverse ? len - i - 1 : i];
|
||
|
goDir(updateAndReplace(subNode, currs[i], nexts[i]));
|
||
|
}
|
||
|
updateProps(node, curr, next);
|
||
|
return rootNode;
|
||
|
|
||
|
case "Container":
|
||
|
var subNode = node.firstChild;
|
||
|
var newSubNode = updateAndReplace(subNode, currE._1, nextE._1);
|
||
|
setPos(nextE._0, nextE._1, newSubNode);
|
||
|
updateProps(node, curr, next);
|
||
|
return rootNode;
|
||
|
|
||
|
case "Custom":
|
||
|
if (currE.type === nextE.type)
|
||
|
{
|
||
|
var updatedNode = nextE.update(node, currE.model, nextE.model);
|
||
|
updateProps(updatedNode, curr, next);
|
||
|
return updatedNode;
|
||
|
}
|
||
|
return render(next);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function updateProps(node, curr, next)
|
||
|
{
|
||
|
var nextProps = next.props;
|
||
|
var currProps = curr.props;
|
||
|
|
||
|
var element = next.element;
|
||
|
var width = nextProps.width - (element.adjustWidth || 0);
|
||
|
var height = nextProps.height - (element.adjustHeight || 0);
|
||
|
if (width !== currProps.width)
|
||
|
{
|
||
|
node.style.width = (width|0) + 'px';
|
||
|
}
|
||
|
if (height !== currProps.height)
|
||
|
{
|
||
|
node.style.height = (height|0) + 'px';
|
||
|
}
|
||
|
|
||
|
if (nextProps.opacity !== currProps.opacity)
|
||
|
{
|
||
|
node.style.opacity = nextProps.opacity;
|
||
|
}
|
||
|
|
||
|
var nextColor = nextProps.color.ctor === 'Just'
|
||
|
? Color.toCss(nextProps.color._0)
|
||
|
: '';
|
||
|
if (node.style.backgroundColor !== nextColor)
|
||
|
{
|
||
|
node.style.backgroundColor = nextColor;
|
||
|
}
|
||
|
|
||
|
if (nextProps.tag !== currProps.tag)
|
||
|
{
|
||
|
node.id = nextProps.tag;
|
||
|
}
|
||
|
|
||
|
if (nextProps.href !== currProps.href)
|
||
|
{
|
||
|
if (currProps.href === '')
|
||
|
{
|
||
|
// add a surrounding href
|
||
|
var anchor = createNode('a');
|
||
|
anchor.href = nextProps.href;
|
||
|
anchor.style.display = 'block';
|
||
|
anchor.style.pointerEvents = 'auto';
|
||
|
|
||
|
node.parentNode.replaceChild(anchor, node);
|
||
|
anchor.appendChild(node);
|
||
|
}
|
||
|
else if (nextProps.href === '')
|
||
|
{
|
||
|
// remove the surrounding href
|
||
|
var anchor = node.parentNode;
|
||
|
anchor.parentNode.replaceChild(node, anchor);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// just update the link
|
||
|
node.parentNode.href = nextProps.href;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// update click and hover handlers
|
||
|
var removed = false;
|
||
|
|
||
|
// update hover handlers
|
||
|
if (currProps.hover.ctor === '_Tuple0')
|
||
|
{
|
||
|
if (nextProps.hover.ctor !== '_Tuple0')
|
||
|
{
|
||
|
addHover(node, nextProps.hover);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (nextProps.hover.ctor === '_Tuple0')
|
||
|
{
|
||
|
removed = true;
|
||
|
removeHover(node);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
node.elm_hover_handler = nextProps.hover;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// update click handlers
|
||
|
if (currProps.click.ctor === '_Tuple0')
|
||
|
{
|
||
|
if (nextProps.click.ctor !== '_Tuple0')
|
||
|
{
|
||
|
addClick(node, nextProps.click);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (nextProps.click.ctor === '_Tuple0')
|
||
|
{
|
||
|
removed = true;
|
||
|
removeClick(node);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
node.elm_click_handler = nextProps.click;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// stop capturing clicks if
|
||
|
if (removed
|
||
|
&& nextProps.hover.ctor === '_Tuple0'
|
||
|
&& nextProps.click.ctor === '_Tuple0')
|
||
|
{
|
||
|
node.style.pointerEvents = 'none';
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// TEXT
|
||
|
|
||
|
function block(align)
|
||
|
{
|
||
|
return function(text)
|
||
|
{
|
||
|
var raw = {
|
||
|
ctor :'RawHtml',
|
||
|
html : Text.renderHtml(text),
|
||
|
align: align
|
||
|
};
|
||
|
var pos = htmlHeight(0, raw);
|
||
|
return newElement(pos._0, pos._1, raw);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function markdown(text)
|
||
|
{
|
||
|
var raw = {
|
||
|
ctor:'RawHtml',
|
||
|
html: text,
|
||
|
align: null
|
||
|
};
|
||
|
var pos = htmlHeight(0, raw);
|
||
|
return newElement(pos._0, pos._1, raw);
|
||
|
}
|
||
|
|
||
|
function htmlHeight(width, rawHtml)
|
||
|
{
|
||
|
// create dummy node
|
||
|
var temp = document.createElement('div');
|
||
|
temp.innerHTML = rawHtml.html;
|
||
|
if (width > 0)
|
||
|
{
|
||
|
temp.style.width = width + "px";
|
||
|
}
|
||
|
temp.style.visibility = "hidden";
|
||
|
temp.style.styleFloat = "left";
|
||
|
temp.style.cssFloat = "left";
|
||
|
|
||
|
document.body.appendChild(temp);
|
||
|
|
||
|
// get dimensions
|
||
|
var style = window.getComputedStyle(temp, null);
|
||
|
var w = Math.ceil(style.getPropertyValue("width").slice(0,-2) - 0);
|
||
|
var h = Math.ceil(style.getPropertyValue("height").slice(0,-2) - 0);
|
||
|
document.body.removeChild(temp);
|
||
|
return Utils.Tuple2(w,h);
|
||
|
}
|
||
|
|
||
|
|
||
|
return localRuntime.Native.Graphics.Element.values = {
|
||
|
render: render,
|
||
|
update: update,
|
||
|
updateAndReplace: updateAndReplace,
|
||
|
|
||
|
createNode: createNode,
|
||
|
newElement: F3(newElement),
|
||
|
addTransform: addTransform,
|
||
|
htmlHeight: F2(htmlHeight),
|
||
|
guid: Utils.guid,
|
||
|
|
||
|
block: block,
|
||
|
markdown: markdown
|
||
|
};
|
||
|
|
||
|
};
|
||
|
|
||
|
// setup
|
||
|
Elm.Native = Elm.Native || {};
|
||
|
Elm.Native.Graphics = Elm.Native.Graphics || {};
|
||
|
Elm.Native.Graphics.Input = Elm.Native.Graphics.Input || {};
|
||
|
|
||
|
// definition
|
||
|
Elm.Native.Graphics.Input.make = function(localRuntime) {
|
||
|
'use strict';
|
||
|
|
||
|
// attempt to short-circuit
|
||
|
if ('values' in Elm.Native.Graphics.Input) {
|
||
|
return Elm.Native.Graphics.Input.values;
|
||
|
}
|
||
|
|
||
|
var Color = Elm.Native.Color.make(localRuntime);
|
||
|
var List = Elm.Native.List.make(localRuntime);
|
||
|
var Signal = Elm.Native.Signal.make(localRuntime);
|
||
|
var Text = Elm.Native.Text.make(localRuntime);
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
var Element = Elm.Native.Graphics.Element.make(localRuntime);
|
||
|
|
||
|
|
||
|
function renderDropDown(model)
|
||
|
{
|
||
|
var drop = Element.createNode('select');
|
||
|
drop.style.border = '0 solid';
|
||
|
drop.style.pointerEvents = 'auto';
|
||
|
drop.style.display = 'block';
|
||
|
|
||
|
drop.elm_values = List.toArray(model.values);
|
||
|
drop.elm_handler = model.handler;
|
||
|
var values = drop.elm_values;
|
||
|
|
||
|
for (var i = 0; i < values.length; ++i)
|
||
|
{
|
||
|
var option = Element.createNode('option');
|
||
|
var name = values[i]._0;
|
||
|
option.value = name;
|
||
|
option.innerHTML = name;
|
||
|
drop.appendChild(option);
|
||
|
}
|
||
|
drop.addEventListener('change', function() {
|
||
|
Signal.sendMessage(drop.elm_handler(drop.elm_values[drop.selectedIndex]._1));
|
||
|
});
|
||
|
|
||
|
return drop;
|
||
|
}
|
||
|
|
||
|
function updateDropDown(node, oldModel, newModel)
|
||
|
{
|
||
|
node.elm_values = List.toArray(newModel.values);
|
||
|
node.elm_handler = newModel.handler;
|
||
|
|
||
|
var values = node.elm_values;
|
||
|
var kids = node.childNodes;
|
||
|
var kidsLength = kids.length;
|
||
|
|
||
|
var i = 0;
|
||
|
for (; i < kidsLength && i < values.length; ++i)
|
||
|
{
|
||
|
var option = kids[i];
|
||
|
var name = values[i]._0;
|
||
|
option.value = name;
|
||
|
option.innerHTML = name;
|
||
|
}
|
||
|
for (; i < kidsLength; ++i)
|
||
|
{
|
||
|
node.removeChild(node.lastChild);
|
||
|
}
|
||
|
for (; i < values.length; ++i)
|
||
|
{
|
||
|
var option = Element.createNode('option');
|
||
|
var name = values[i]._0;
|
||
|
option.value = name;
|
||
|
option.innerHTML = name;
|
||
|
node.appendChild(option);
|
||
|
}
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
function dropDown(handler, values)
|
||
|
{
|
||
|
return A3(Element.newElement, 100, 24, {
|
||
|
ctor: 'Custom',
|
||
|
type: 'DropDown',
|
||
|
render: renderDropDown,
|
||
|
update: updateDropDown,
|
||
|
model: {
|
||
|
values: values,
|
||
|
handler: handler
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
|
||
|
function renderButton(model)
|
||
|
{
|
||
|
var node = Element.createNode('button');
|
||
|
node.style.display = 'block';
|
||
|
node.style.pointerEvents = 'auto';
|
||
|
node.elm_message = model.message;
|
||
|
function click()
|
||
|
{
|
||
|
Signal.sendMessage(node.elm_message);
|
||
|
}
|
||
|
node.addEventListener('click', click);
|
||
|
node.innerHTML = model.text;
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
function updateButton(node, oldModel, newModel)
|
||
|
{
|
||
|
node.elm_message = newModel.message;
|
||
|
var txt = newModel.text;
|
||
|
if (oldModel.text !== txt)
|
||
|
{
|
||
|
node.innerHTML = txt;
|
||
|
}
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
function button(message, text)
|
||
|
{
|
||
|
return A3(Element.newElement, 100, 40, {
|
||
|
ctor: 'Custom',
|
||
|
type: 'Button',
|
||
|
render: renderButton,
|
||
|
update: updateButton,
|
||
|
model: {
|
||
|
message: message,
|
||
|
text:text
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
|
||
|
function renderCustomButton(model)
|
||
|
{
|
||
|
var btn = Element.createNode('div');
|
||
|
btn.style.pointerEvents = 'auto';
|
||
|
btn.elm_message = model.message;
|
||
|
|
||
|
btn.elm_up = Element.render(model.up);
|
||
|
btn.elm_hover = Element.render(model.hover);
|
||
|
btn.elm_down = Element.render(model.down);
|
||
|
|
||
|
btn.elm_up.style.display = 'block';
|
||
|
btn.elm_hover.style.display = 'none';
|
||
|
btn.elm_down.style.display = 'none';
|
||
|
|
||
|
btn.appendChild(btn.elm_up);
|
||
|
btn.appendChild(btn.elm_hover);
|
||
|
btn.appendChild(btn.elm_down);
|
||
|
|
||
|
function swap(visibleNode, hiddenNode1, hiddenNode2)
|
||
|
{
|
||
|
visibleNode.style.display = 'block';
|
||
|
hiddenNode1.style.display = 'none';
|
||
|
hiddenNode2.style.display = 'none';
|
||
|
}
|
||
|
|
||
|
var overCount = 0;
|
||
|
function over(e)
|
||
|
{
|
||
|
if (overCount++ > 0) return;
|
||
|
swap(btn.elm_hover, btn.elm_down, btn.elm_up);
|
||
|
}
|
||
|
function out(e)
|
||
|
{
|
||
|
if (btn.contains(e.toElement || e.relatedTarget)) return;
|
||
|
overCount = 0;
|
||
|
swap(btn.elm_up, btn.elm_down, btn.elm_hover);
|
||
|
}
|
||
|
function up()
|
||
|
{
|
||
|
swap(btn.elm_hover, btn.elm_down, btn.elm_up);
|
||
|
Signal.sendMessage(btn.elm_message);
|
||
|
}
|
||
|
function down()
|
||
|
{
|
||
|
swap(btn.elm_down, btn.elm_hover, btn.elm_up);
|
||
|
}
|
||
|
|
||
|
btn.addEventListener('mouseover', over);
|
||
|
btn.addEventListener('mouseout' , out);
|
||
|
btn.addEventListener('mousedown', down);
|
||
|
btn.addEventListener('mouseup' , up);
|
||
|
|
||
|
return btn;
|
||
|
}
|
||
|
|
||
|
function updateCustomButton(node, oldModel, newModel)
|
||
|
{
|
||
|
node.elm_message = newModel.message;
|
||
|
|
||
|
var kids = node.childNodes;
|
||
|
var styleUp = kids[0].style.display;
|
||
|
var styleHover = kids[1].style.display;
|
||
|
var styleDown = kids[2].style.display;
|
||
|
|
||
|
Element.updateAndReplace(kids[0], oldModel.up, newModel.up);
|
||
|
Element.updateAndReplace(kids[1], oldModel.hover, newModel.hover);
|
||
|
Element.updateAndReplace(kids[2], oldModel.down, newModel.down);
|
||
|
|
||
|
var kids = node.childNodes;
|
||
|
kids[0].style.display = styleUp;
|
||
|
kids[1].style.display = styleHover;
|
||
|
kids[2].style.display = styleDown;
|
||
|
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
function max3(a,b,c)
|
||
|
{
|
||
|
var ab = a > b ? a : b;
|
||
|
return ab > c ? ab : c;
|
||
|
}
|
||
|
|
||
|
function customButton(message, up, hover, down)
|
||
|
{
|
||
|
return A3(Element.newElement,
|
||
|
max3(up.props.width, hover.props.width, down.props.width),
|
||
|
max3(up.props.height, hover.props.height, down.props.height),
|
||
|
{ ctor: 'Custom',
|
||
|
type: 'CustomButton',
|
||
|
render: renderCustomButton,
|
||
|
update: updateCustomButton,
|
||
|
model: {
|
||
|
message: message,
|
||
|
up: up,
|
||
|
hover: hover,
|
||
|
down: down
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
|
||
|
function renderCheckbox(model)
|
||
|
{
|
||
|
var node = Element.createNode('input');
|
||
|
node.type = 'checkbox';
|
||
|
node.checked = model.checked;
|
||
|
node.style.display = 'block';
|
||
|
node.style.pointerEvents = 'auto';
|
||
|
node.elm_handler = model.handler;
|
||
|
function change()
|
||
|
{
|
||
|
Signal.sendMessage(node.elm_handler(node.checked));
|
||
|
}
|
||
|
node.addEventListener('change', change);
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
function updateCheckbox(node, oldModel, newModel)
|
||
|
{
|
||
|
node.elm_handler = newModel.handler;
|
||
|
node.checked = newModel.checked;
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
function checkbox(handler, checked)
|
||
|
{
|
||
|
return A3(Element.newElement, 13, 13, {
|
||
|
ctor: 'Custom',
|
||
|
type: 'CheckBox',
|
||
|
render: renderCheckbox,
|
||
|
update: updateCheckbox,
|
||
|
model: { handler:handler, checked:checked }
|
||
|
});
|
||
|
}
|
||
|
|
||
|
function setRange(node, start, end, dir)
|
||
|
{
|
||
|
if (node.parentNode)
|
||
|
{
|
||
|
node.setSelectionRange(start, end, dir);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
setTimeout(function(){node.setSelectionRange(start, end, dir);}, 0);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function updateIfNeeded(css, attribute, latestAttribute)
|
||
|
{
|
||
|
if (css[attribute] !== latestAttribute)
|
||
|
{
|
||
|
css[attribute] = latestAttribute;
|
||
|
}
|
||
|
}
|
||
|
function cssDimensions(dimensions)
|
||
|
{
|
||
|
return dimensions.top + 'px ' +
|
||
|
dimensions.right + 'px ' +
|
||
|
dimensions.bottom + 'px ' +
|
||
|
dimensions.left + 'px';
|
||
|
}
|
||
|
function updateFieldStyle(css, style)
|
||
|
{
|
||
|
updateIfNeeded(css, 'padding', cssDimensions(style.padding));
|
||
|
|
||
|
var outline = style.outline;
|
||
|
updateIfNeeded(css, 'border-width', cssDimensions(outline.width));
|
||
|
updateIfNeeded(css, 'border-color', Color.toCss(outline.color));
|
||
|
updateIfNeeded(css, 'border-radius', outline.radius + 'px');
|
||
|
|
||
|
var highlight = style.highlight;
|
||
|
if (highlight.width === 0)
|
||
|
{
|
||
|
css.outline = 'none';
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
updateIfNeeded(css, 'outline-width', highlight.width + 'px');
|
||
|
updateIfNeeded(css, 'outline-color', Color.toCss(highlight.color));
|
||
|
}
|
||
|
|
||
|
var textStyle = style.style;
|
||
|
updateIfNeeded(css, 'color', Color.toCss(textStyle.color));
|
||
|
if (textStyle.typeface.ctor !== '[]')
|
||
|
{
|
||
|
updateIfNeeded(css, 'font-family', Text.toTypefaces(textStyle.typeface));
|
||
|
}
|
||
|
if (textStyle.height.ctor !== "Nothing")
|
||
|
{
|
||
|
updateIfNeeded(css, 'font-size', textStyle.height._0 + 'px');
|
||
|
}
|
||
|
updateIfNeeded(css, 'font-weight', textStyle.bold ? 'bold' : 'normal');
|
||
|
updateIfNeeded(css, 'font-style', textStyle.italic ? 'italic' : 'normal');
|
||
|
if (textStyle.line.ctor !== 'Nothing')
|
||
|
{
|
||
|
updateIfNeeded(css, 'text-decoration', Text.toLine(textStyle.line._0));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function renderField(model)
|
||
|
{
|
||
|
var field = Element.createNode('input');
|
||
|
updateFieldStyle(field.style, model.style);
|
||
|
field.style.borderStyle = 'solid';
|
||
|
field.style.pointerEvents = 'auto';
|
||
|
|
||
|
field.type = model.type;
|
||
|
field.placeholder = model.placeHolder;
|
||
|
field.value = model.content.string;
|
||
|
|
||
|
field.elm_handler = model.handler;
|
||
|
field.elm_old_value = field.value;
|
||
|
|
||
|
function inputUpdate(event)
|
||
|
{
|
||
|
var curr = field.elm_old_value;
|
||
|
var next = field.value;
|
||
|
if (curr === next)
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
var direction = field.selectionDirection === 'forward' ? 'Forward' : 'Backward';
|
||
|
var start = field.selectionStart;
|
||
|
var end = field.selectionEnd;
|
||
|
field.value = field.elm_old_value;
|
||
|
|
||
|
Signal.sendMessage(field.elm_handler({
|
||
|
_:{},
|
||
|
string: next,
|
||
|
selection: {
|
||
|
_:{},
|
||
|
start: start,
|
||
|
end: end,
|
||
|
direction: { ctor: direction }
|
||
|
}
|
||
|
}));
|
||
|
}
|
||
|
|
||
|
field.addEventListener('input', inputUpdate);
|
||
|
field.addEventListener('focus', function() {
|
||
|
field.elm_hasFocus = true;
|
||
|
});
|
||
|
field.addEventListener('blur', function() {
|
||
|
field.elm_hasFocus = false;
|
||
|
});
|
||
|
|
||
|
return field;
|
||
|
}
|
||
|
|
||
|
function updateField(field, oldModel, newModel)
|
||
|
{
|
||
|
if (oldModel.style !== newModel.style)
|
||
|
{
|
||
|
updateFieldStyle(field.style, newModel.style);
|
||
|
}
|
||
|
field.elm_handler = newModel.handler;
|
||
|
|
||
|
field.type = newModel.type;
|
||
|
field.placeholder = newModel.placeHolder;
|
||
|
var value = newModel.content.string;
|
||
|
field.value = value;
|
||
|
field.elm_old_value = value;
|
||
|
if (field.elm_hasFocus)
|
||
|
{
|
||
|
var selection = newModel.content.selection;
|
||
|
var direction = selection.direction.ctor === 'Forward' ? 'forward' : 'backward';
|
||
|
setRange(field, selection.start, selection.end, direction);
|
||
|
}
|
||
|
return field;
|
||
|
}
|
||
|
|
||
|
function mkField(type)
|
||
|
{
|
||
|
function field(style, handler, placeHolder, content)
|
||
|
{
|
||
|
var padding = style.padding;
|
||
|
var outline = style.outline.width;
|
||
|
var adjustWidth = padding.left + padding.right + outline.left + outline.right;
|
||
|
var adjustHeight = padding.top + padding.bottom + outline.top + outline.bottom;
|
||
|
return A3(Element.newElement, 200, 30, {
|
||
|
ctor: 'Custom',
|
||
|
type: type + 'Field',
|
||
|
adjustWidth: adjustWidth,
|
||
|
adjustHeight: adjustHeight,
|
||
|
render: renderField,
|
||
|
update: updateField,
|
||
|
model: {
|
||
|
handler:handler,
|
||
|
placeHolder:placeHolder,
|
||
|
content:content,
|
||
|
style:style,
|
||
|
type:type
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
return F4(field);
|
||
|
}
|
||
|
|
||
|
function hoverable(handler, elem)
|
||
|
{
|
||
|
function onHover(bool)
|
||
|
{
|
||
|
Signal.sendMessage(handler(bool));
|
||
|
}
|
||
|
var props = Utils.replace([['hover',onHover]], elem.props);
|
||
|
return {
|
||
|
props: props,
|
||
|
element: elem.element
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function clickable(message, elem)
|
||
|
{
|
||
|
function onClick()
|
||
|
{
|
||
|
Signal.sendMessage(message);
|
||
|
}
|
||
|
var props = Utils.replace([['click',onClick]], elem.props);
|
||
|
return {
|
||
|
props: props,
|
||
|
element: elem.element
|
||
|
};
|
||
|
}
|
||
|
|
||
|
return Elm.Native.Graphics.Input.values = {
|
||
|
button: F2(button),
|
||
|
customButton: F4(customButton),
|
||
|
checkbox: F2(checkbox),
|
||
|
dropDown: F2(dropDown),
|
||
|
field: mkField('text'),
|
||
|
email: mkField('email'),
|
||
|
password: mkField('password'),
|
||
|
hoverable: F2(hoverable),
|
||
|
clickable: F2(clickable)
|
||
|
};
|
||
|
|
||
|
};
|
||
|
|
||
|
Elm.Native.Json = {};
|
||
|
Elm.Native.Json.make = function(localRuntime) {
|
||
|
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Json = localRuntime.Native.Json || {};
|
||
|
if (localRuntime.Native.Json.values) {
|
||
|
return localRuntime.Native.Json.values;
|
||
|
}
|
||
|
|
||
|
var ElmArray = Elm.Native.Array.make(localRuntime);
|
||
|
var List = Elm.Native.List.make(localRuntime);
|
||
|
var Maybe = Elm.Maybe.make(localRuntime);
|
||
|
var Result = Elm.Result.make(localRuntime);
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
|
||
|
function crash(expected, actual) {
|
||
|
throw new Error(
|
||
|
'expecting ' + expected + ' but got ' + JSON.stringify(actual)
|
||
|
);
|
||
|
}
|
||
|
|
||
|
|
||
|
// PRIMITIVE VALUES
|
||
|
|
||
|
function decodeNull(successValue) {
|
||
|
return function(value) {
|
||
|
if (value === null) {
|
||
|
return successValue;
|
||
|
}
|
||
|
crash('null', value);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
function decodeString(value) {
|
||
|
if (typeof value === 'string' || value instanceof String) {
|
||
|
return value;
|
||
|
}
|
||
|
crash('a String', value);
|
||
|
}
|
||
|
|
||
|
|
||
|
function decodeFloat(value) {
|
||
|
if (typeof value === 'number') {
|
||
|
return value;
|
||
|
}
|
||
|
crash('a Float', value);
|
||
|
}
|
||
|
|
||
|
|
||
|
function decodeInt(value) {
|
||
|
if (typeof value === 'number' && (value|0) === value) {
|
||
|
return value;
|
||
|
}
|
||
|
crash('an Int', value);
|
||
|
}
|
||
|
|
||
|
|
||
|
function decodeBool(value) {
|
||
|
if (typeof value === 'boolean') {
|
||
|
return value;
|
||
|
}
|
||
|
crash('a Bool', value);
|
||
|
}
|
||
|
|
||
|
|
||
|
// ARRAY
|
||
|
|
||
|
function decodeArray(decoder) {
|
||
|
return function(value) {
|
||
|
if (value instanceof Array) {
|
||
|
var len = value.length;
|
||
|
var array = new Array(len);
|
||
|
for (var i = len; i-- ; ) {
|
||
|
array[i] = decoder(value[i]);
|
||
|
}
|
||
|
return ElmArray.fromJSArray(array);
|
||
|
}
|
||
|
crash('an Array', value);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
// LIST
|
||
|
|
||
|
function decodeList(decoder) {
|
||
|
return function(value) {
|
||
|
if (value instanceof Array) {
|
||
|
var len = value.length;
|
||
|
var list = List.Nil;
|
||
|
for (var i = len; i-- ; ) {
|
||
|
list = List.Cons( decoder(value[i]), list );
|
||
|
}
|
||
|
return list;
|
||
|
}
|
||
|
crash('a List', value);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
// MAYBE
|
||
|
|
||
|
function decodeMaybe(decoder) {
|
||
|
return function(value) {
|
||
|
try {
|
||
|
return Maybe.Just(decoder(value));
|
||
|
} catch(e) {
|
||
|
return Maybe.Nothing;
|
||
|
}
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
// FIELDS
|
||
|
|
||
|
function decodeField(field, decoder) {
|
||
|
return function(value) {
|
||
|
var subValue = value[field];
|
||
|
if (subValue !== undefined) {
|
||
|
return decoder(subValue);
|
||
|
}
|
||
|
crash("an object with field '" + field + "'", value);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
// OBJECTS
|
||
|
|
||
|
function decodeKeyValuePairs(decoder) {
|
||
|
return function(value) {
|
||
|
var isObject =
|
||
|
typeof value === 'object'
|
||
|
&& value !== null
|
||
|
&& !(value instanceof Array);
|
||
|
|
||
|
if (isObject) {
|
||
|
var keyValuePairs = List.Nil;
|
||
|
for (var key in value) {
|
||
|
var elmValue = decoder(value[key]);
|
||
|
var pair = Utils.Tuple2(key, elmValue);
|
||
|
keyValuePairs = List.Cons(pair, keyValuePairs);
|
||
|
}
|
||
|
return keyValuePairs;
|
||
|
}
|
||
|
|
||
|
crash("an object", value);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function decodeObject1(f, d1) {
|
||
|
return function(value) {
|
||
|
return f(d1(value));
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function decodeObject2(f, d1, d2) {
|
||
|
return function(value) {
|
||
|
return A2( f, d1(value), d2(value) );
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function decodeObject3(f, d1, d2, d3) {
|
||
|
return function(value) {
|
||
|
return A3( f, d1(value), d2(value), d3(value) );
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function decodeObject4(f, d1, d2, d3, d4) {
|
||
|
return function(value) {
|
||
|
return A4( f, d1(value), d2(value), d3(value), d4(value) );
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function decodeObject5(f, d1, d2, d3, d4, d5) {
|
||
|
return function(value) {
|
||
|
return A5( f, d1(value), d2(value), d3(value), d4(value), d5(value) );
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function decodeObject6(f, d1, d2, d3, d4, d5, d6) {
|
||
|
return function(value) {
|
||
|
return A6( f,
|
||
|
d1(value),
|
||
|
d2(value),
|
||
|
d3(value),
|
||
|
d4(value),
|
||
|
d5(value),
|
||
|
d6(value)
|
||
|
);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function decodeObject7(f, d1, d2, d3, d4, d5, d6, d7) {
|
||
|
return function(value) {
|
||
|
return A7( f,
|
||
|
d1(value),
|
||
|
d2(value),
|
||
|
d3(value),
|
||
|
d4(value),
|
||
|
d5(value),
|
||
|
d6(value),
|
||
|
d7(value)
|
||
|
);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function decodeObject8(f, d1, d2, d3, d4, d5, d6, d7, d8) {
|
||
|
return function(value) {
|
||
|
return A8( f,
|
||
|
d1(value),
|
||
|
d2(value),
|
||
|
d3(value),
|
||
|
d4(value),
|
||
|
d5(value),
|
||
|
d6(value),
|
||
|
d7(value),
|
||
|
d8(value)
|
||
|
);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
// TUPLES
|
||
|
|
||
|
function decodeTuple1(f, d1) {
|
||
|
return function(value) {
|
||
|
if ( !(value instanceof Array) || value.length !== 1 ) {
|
||
|
crash('a Tuple of length 1', value);
|
||
|
}
|
||
|
return f( d1(value[0]) );
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function decodeTuple2(f, d1, d2) {
|
||
|
return function(value) {
|
||
|
if ( !(value instanceof Array) || value.length !== 2 ) {
|
||
|
crash('a Tuple of length 2', value);
|
||
|
}
|
||
|
return A2( f, d1(value[0]), d2(value[1]) );
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function decodeTuple3(f, d1, d2, d3) {
|
||
|
return function(value) {
|
||
|
if ( !(value instanceof Array) || value.length !== 3 ) {
|
||
|
crash('a Tuple of length 3', value);
|
||
|
}
|
||
|
return A3( f, d1(value[0]), d2(value[1]), d3(value[2]) );
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
function decodeTuple4(f, d1, d2, d3, d4) {
|
||
|
return function(value) {
|
||
|
if ( !(value instanceof Array) || value.length !== 4 ) {
|
||
|
crash('a Tuple of length 4', value);
|
||
|
}
|
||
|
return A4( f, d1(value[0]), d2(value[1]), d3(value[2]), d4(value[3]) );
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
function decodeTuple5(f, d1, d2, d3, d4, d5) {
|
||
|
return function(value) {
|
||
|
if ( !(value instanceof Array) || value.length !== 5 ) {
|
||
|
crash('a Tuple of length 5', value);
|
||
|
}
|
||
|
return A5( f,
|
||
|
d1(value[0]),
|
||
|
d2(value[1]),
|
||
|
d3(value[2]),
|
||
|
d4(value[3]),
|
||
|
d5(value[4])
|
||
|
);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
function decodeTuple6(f, d1, d2, d3, d4, d5, d6) {
|
||
|
return function(value) {
|
||
|
if ( !(value instanceof Array) || value.length !== 6 ) {
|
||
|
crash('a Tuple of length 6', value);
|
||
|
}
|
||
|
return A6( f,
|
||
|
d1(value[0]),
|
||
|
d2(value[1]),
|
||
|
d3(value[2]),
|
||
|
d4(value[3]),
|
||
|
d5(value[4]),
|
||
|
d6(value[5])
|
||
|
);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function decodeTuple7(f, d1, d2, d3, d4, d5, d6, d7) {
|
||
|
return function(value) {
|
||
|
if ( !(value instanceof Array) || value.length !== 7 ) {
|
||
|
crash('a Tuple of length 7', value);
|
||
|
}
|
||
|
return A7( f,
|
||
|
d1(value[0]),
|
||
|
d2(value[1]),
|
||
|
d3(value[2]),
|
||
|
d4(value[3]),
|
||
|
d5(value[4]),
|
||
|
d6(value[5]),
|
||
|
d7(value[6])
|
||
|
);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
function decodeTuple8(f, d1, d2, d3, d4, d5, d6, d7, d8) {
|
||
|
return function(value) {
|
||
|
if ( !(value instanceof Array) || value.length !== 8 ) {
|
||
|
crash('a Tuple of length 8', value);
|
||
|
}
|
||
|
return A8( f,
|
||
|
d1(value[0]),
|
||
|
d2(value[1]),
|
||
|
d3(value[2]),
|
||
|
d4(value[3]),
|
||
|
d5(value[4]),
|
||
|
d6(value[5]),
|
||
|
d7(value[6]),
|
||
|
d8(value[7])
|
||
|
);
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
// CUSTOM DECODERS
|
||
|
|
||
|
function decodeValue(value) {
|
||
|
return value;
|
||
|
}
|
||
|
|
||
|
function runDecoderValue(decoder, value) {
|
||
|
try {
|
||
|
return Result.Ok(decoder(value));
|
||
|
} catch(e) {
|
||
|
return Result.Err(e.message);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function customDecoder(decoder, callback) {
|
||
|
return function(value) {
|
||
|
var result = callback(decoder(value));
|
||
|
if (result.ctor === 'Err') {
|
||
|
throw new Error('custom decoder failed: ' + result._0);
|
||
|
}
|
||
|
return result._0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function andThen(decode, callback) {
|
||
|
return function(value) {
|
||
|
var result = decode(value);
|
||
|
return callback(result)(value);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function fail(msg) {
|
||
|
return function(value) {
|
||
|
throw new Error(msg);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function succeed(successValue) {
|
||
|
return function(value) {
|
||
|
return successValue;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// ONE OF MANY
|
||
|
|
||
|
function oneOf(decoders) {
|
||
|
return function(value) {
|
||
|
var errors = [];
|
||
|
var temp = decoders;
|
||
|
while (temp.ctor !== '[]') {
|
||
|
try {
|
||
|
return temp._0(value);
|
||
|
} catch(e) {
|
||
|
errors.push(e.message);
|
||
|
}
|
||
|
temp = temp._1;
|
||
|
}
|
||
|
throw new Error('expecting one of the following:\n ' + errors.join('\n '));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function get(decoder, value) {
|
||
|
try {
|
||
|
return Result.Ok(decoder(value));
|
||
|
} catch(e) {
|
||
|
return Result.Err(e.message);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// ENCODE / DECODE
|
||
|
|
||
|
function runDecoderString(decoder, string) {
|
||
|
try {
|
||
|
return Result.Ok(decoder(JSON.parse(string)));
|
||
|
} catch(e) {
|
||
|
return Result.Err(e.message);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function encode(indentLevel, value) {
|
||
|
return JSON.stringify(value, null, indentLevel);
|
||
|
}
|
||
|
|
||
|
function identity(value) {
|
||
|
return value;
|
||
|
}
|
||
|
|
||
|
function encodeObject(keyValuePairs) {
|
||
|
var obj = {};
|
||
|
while (keyValuePairs.ctor !== '[]') {
|
||
|
var pair = keyValuePairs._0;
|
||
|
obj[pair._0] = pair._1;
|
||
|
keyValuePairs = keyValuePairs._1;
|
||
|
}
|
||
|
return obj;
|
||
|
}
|
||
|
|
||
|
return localRuntime.Native.Json.values = {
|
||
|
encode: F2(encode),
|
||
|
runDecoderString: F2(runDecoderString),
|
||
|
runDecoderValue: F2(runDecoderValue),
|
||
|
|
||
|
get: F2(get),
|
||
|
oneOf: oneOf,
|
||
|
|
||
|
decodeNull: decodeNull,
|
||
|
decodeInt: decodeInt,
|
||
|
decodeFloat: decodeFloat,
|
||
|
decodeString: decodeString,
|
||
|
decodeBool: decodeBool,
|
||
|
|
||
|
decodeMaybe: decodeMaybe,
|
||
|
|
||
|
decodeList: decodeList,
|
||
|
decodeArray: decodeArray,
|
||
|
|
||
|
decodeField: F2(decodeField),
|
||
|
|
||
|
decodeObject1: F2(decodeObject1),
|
||
|
decodeObject2: F3(decodeObject2),
|
||
|
decodeObject3: F4(decodeObject3),
|
||
|
decodeObject4: F5(decodeObject4),
|
||
|
decodeObject5: F6(decodeObject5),
|
||
|
decodeObject6: F7(decodeObject6),
|
||
|
decodeObject7: F8(decodeObject7),
|
||
|
decodeObject8: F9(decodeObject8),
|
||
|
decodeKeyValuePairs: decodeKeyValuePairs,
|
||
|
|
||
|
decodeTuple1: F2(decodeTuple1),
|
||
|
decodeTuple2: F3(decodeTuple2),
|
||
|
decodeTuple3: F4(decodeTuple3),
|
||
|
decodeTuple4: F5(decodeTuple4),
|
||
|
decodeTuple5: F6(decodeTuple5),
|
||
|
decodeTuple6: F7(decodeTuple6),
|
||
|
decodeTuple7: F8(decodeTuple7),
|
||
|
decodeTuple8: F9(decodeTuple8),
|
||
|
|
||
|
andThen: F2(andThen),
|
||
|
decodeValue: decodeValue,
|
||
|
customDecoder: F2(customDecoder),
|
||
|
fail: fail,
|
||
|
succeed: succeed,
|
||
|
|
||
|
identity: identity,
|
||
|
encodeNull: null,
|
||
|
encodeArray: ElmArray.toJSArray,
|
||
|
encodeList: List.toArray,
|
||
|
encodeObject: encodeObject
|
||
|
|
||
|
};
|
||
|
|
||
|
};
|
||
|
|
||
|
Elm.Native.List = {};
|
||
|
Elm.Native.List.make = function(localRuntime) {
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.List = localRuntime.Native.List || {};
|
||
|
if (localRuntime.Native.List.values)
|
||
|
{
|
||
|
return localRuntime.Native.List.values;
|
||
|
}
|
||
|
if ('values' in Elm.Native.List)
|
||
|
{
|
||
|
return localRuntime.Native.List.values = Elm.Native.List.values;
|
||
|
}
|
||
|
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
var Nil = Utils.Nil;
|
||
|
var Cons = Utils.Cons;
|
||
|
|
||
|
function toArray(xs)
|
||
|
{
|
||
|
var out = [];
|
||
|
while (xs.ctor !== '[]')
|
||
|
{
|
||
|
out.push(xs._0);
|
||
|
xs = xs._1;
|
||
|
}
|
||
|
return out;
|
||
|
}
|
||
|
|
||
|
function fromArray(arr)
|
||
|
{
|
||
|
var out = Nil;
|
||
|
for (var i = arr.length; i--; )
|
||
|
{
|
||
|
out = Cons(arr[i], out);
|
||
|
}
|
||
|
return out;
|
||
|
}
|
||
|
|
||
|
function range(lo,hi)
|
||
|
{
|
||
|
var lst = Nil;
|
||
|
if (lo <= hi)
|
||
|
{
|
||
|
do { lst = Cons(hi,lst) } while (hi-->lo);
|
||
|
}
|
||
|
return lst
|
||
|
}
|
||
|
|
||
|
// f defined similarly for both foldl and foldr (NB: different from Haskell)
|
||
|
// ie, foldl : (a -> b -> b) -> b -> [a] -> b
|
||
|
function foldl(f, b, xs)
|
||
|
{
|
||
|
var acc = b;
|
||
|
while (xs.ctor !== '[]')
|
||
|
{
|
||
|
acc = A2(f, xs._0, acc);
|
||
|
xs = xs._1;
|
||
|
}
|
||
|
return acc;
|
||
|
}
|
||
|
|
||
|
function foldr(f, b, xs)
|
||
|
{
|
||
|
var arr = toArray(xs);
|
||
|
var acc = b;
|
||
|
for (var i = arr.length; i--; )
|
||
|
{
|
||
|
acc = A2(f, arr[i], acc);
|
||
|
}
|
||
|
return acc;
|
||
|
}
|
||
|
|
||
|
function any(pred, xs)
|
||
|
{
|
||
|
while (xs.ctor !== '[]')
|
||
|
{
|
||
|
if (pred(xs._0))
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
xs = xs._1;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
function map2(f, xs, ys)
|
||
|
{
|
||
|
var arr = [];
|
||
|
while (xs.ctor !== '[]' && ys.ctor !== '[]')
|
||
|
{
|
||
|
arr.push(A2(f, xs._0, ys._0));
|
||
|
xs = xs._1;
|
||
|
ys = ys._1;
|
||
|
}
|
||
|
return fromArray(arr);
|
||
|
}
|
||
|
|
||
|
function map3(f, xs, ys, zs)
|
||
|
{
|
||
|
var arr = [];
|
||
|
while (xs.ctor !== '[]' && ys.ctor !== '[]' && zs.ctor !== '[]')
|
||
|
{
|
||
|
arr.push(A3(f, xs._0, ys._0, zs._0));
|
||
|
xs = xs._1;
|
||
|
ys = ys._1;
|
||
|
zs = zs._1;
|
||
|
}
|
||
|
return fromArray(arr);
|
||
|
}
|
||
|
|
||
|
function map4(f, ws, xs, ys, zs)
|
||
|
{
|
||
|
var arr = [];
|
||
|
while ( ws.ctor !== '[]'
|
||
|
&& xs.ctor !== '[]'
|
||
|
&& ys.ctor !== '[]'
|
||
|
&& zs.ctor !== '[]')
|
||
|
{
|
||
|
arr.push(A4(f, ws._0, xs._0, ys._0, zs._0));
|
||
|
ws = ws._1;
|
||
|
xs = xs._1;
|
||
|
ys = ys._1;
|
||
|
zs = zs._1;
|
||
|
}
|
||
|
return fromArray(arr);
|
||
|
}
|
||
|
|
||
|
function map5(f, vs, ws, xs, ys, zs)
|
||
|
{
|
||
|
var arr = [];
|
||
|
while ( vs.ctor !== '[]'
|
||
|
&& ws.ctor !== '[]'
|
||
|
&& xs.ctor !== '[]'
|
||
|
&& ys.ctor !== '[]'
|
||
|
&& zs.ctor !== '[]')
|
||
|
{
|
||
|
arr.push(A5(f, vs._0, ws._0, xs._0, ys._0, zs._0));
|
||
|
vs = vs._1;
|
||
|
ws = ws._1;
|
||
|
xs = xs._1;
|
||
|
ys = ys._1;
|
||
|
zs = zs._1;
|
||
|
}
|
||
|
return fromArray(arr);
|
||
|
}
|
||
|
|
||
|
function sortBy(f, xs)
|
||
|
{
|
||
|
return fromArray(toArray(xs).sort(function(a,b){
|
||
|
return Utils.cmp(f(a), f(b));
|
||
|
}));
|
||
|
}
|
||
|
|
||
|
function sortWith(f, xs)
|
||
|
{
|
||
|
return fromArray(toArray(xs).sort(function(a,b){
|
||
|
var ord = f(a)(b).ctor;
|
||
|
return ord === 'EQ' ? 0 : ord === 'LT' ? -1 : 1;
|
||
|
}));
|
||
|
}
|
||
|
|
||
|
function take(n, xs)
|
||
|
{
|
||
|
var arr = [];
|
||
|
while (xs.ctor !== '[]' && n > 0)
|
||
|
{
|
||
|
arr.push(xs._0);
|
||
|
xs = xs._1;
|
||
|
--n;
|
||
|
}
|
||
|
return fromArray(arr);
|
||
|
}
|
||
|
|
||
|
function drop(n, xs)
|
||
|
{
|
||
|
while (xs.ctor !== '[]' && n > 0)
|
||
|
{
|
||
|
xs = xs._1;
|
||
|
--n;
|
||
|
}
|
||
|
return xs;
|
||
|
}
|
||
|
|
||
|
function repeat(n, x)
|
||
|
{
|
||
|
var arr = [];
|
||
|
var pattern = [x];
|
||
|
while (n > 0)
|
||
|
{
|
||
|
if (n & 1)
|
||
|
{
|
||
|
arr = arr.concat(pattern);
|
||
|
}
|
||
|
n >>= 1, pattern = pattern.concat(pattern);
|
||
|
}
|
||
|
return fromArray(arr);
|
||
|
}
|
||
|
|
||
|
|
||
|
Elm.Native.List.values = {
|
||
|
Nil:Nil,
|
||
|
Cons:Cons,
|
||
|
cons:F2(Cons),
|
||
|
toArray:toArray,
|
||
|
fromArray:fromArray,
|
||
|
range:range,
|
||
|
|
||
|
foldl:F3(foldl),
|
||
|
foldr:F3(foldr),
|
||
|
|
||
|
any:F2(any),
|
||
|
map2:F3(map2),
|
||
|
map3:F4(map3),
|
||
|
map4:F5(map4),
|
||
|
map5:F6(map5),
|
||
|
sortBy:F2(sortBy),
|
||
|
sortWith:F2(sortWith),
|
||
|
take:F2(take),
|
||
|
drop:F2(drop),
|
||
|
repeat:F2(repeat)
|
||
|
};
|
||
|
return localRuntime.Native.List.values = Elm.Native.List.values;
|
||
|
|
||
|
};
|
||
|
|
||
|
|
||
|
// setup
|
||
|
Elm.Native = Elm.Native || {};
|
||
|
Elm.Native.Markdown = Elm.Native.Markdown || {};
|
||
|
|
||
|
// definition
|
||
|
Elm.Native.Markdown.make = function(localRuntime) {
|
||
|
'use strict';
|
||
|
|
||
|
// attempt to short-circuit
|
||
|
if ('values' in Elm.Native.Markdown)
|
||
|
{
|
||
|
return Elm.Native.Markdown.values;
|
||
|
}
|
||
|
|
||
|
var Element = Elm.Native.Graphics.Element.make(localRuntime);
|
||
|
|
||
|
/**
|
||
|
* marked - a markdown parser
|
||
|
* Copyright (c) 2011-2014, Christopher Jeffrey. (MIT Licensed)
|
||
|
* https://github.com/chjj/marked
|
||
|
*/
|
||
|
(function(){var block={newline:/^\n+/,code:/^( {4}[^\n]+\n*)+/,fences:noop,hr:/^( *[-*_]){3,} *(?:\n+|$)/,heading:/^ *(#{1,6}) *([^\n]+?) *#* *(?:\n+|$)/,nptable:noop,lheading:/^([^\n]+)\n *(=|-){2,} *(?:\n+|$)/,blockquote:/^( *>[^\n]+(\n(?!def)[^\n]+)*\n*)+/,list:/^( *)(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?!\1bull )\n*|\s*$)/,html:/^ *(?:comment|closed|closing) *(?:\n{2,}|\s*$)/,def:/^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +["(]([^\n]+)[")])? *(?:\n+|$)/,table:noop,paragraph:/^((?:[^\n]+\n?(?!hr|heading|lheading|blockquote|tag|def))+)\n*/,text:/^[^\n]+/};block.bullet=/(?:[*+-]|\d+\.)/;block.item=/^( *)(bull) [^\n]*(?:\n(?!\1bull )[^\n]*)*/;block.item=replace(block.item,"gm")(/bull/g,block.bullet)();block.list=replace(block.list)(/bull/g,block.bullet)("hr","\\n+(?=\\1?(?:[-*_] *){3,}(?:\\n+|$))")("def","\\n+(?="+block.def.source+")")();block.blockquote=replace(block.blockquote)("def",block.def)();block._tag="(?!(?:"+"a|em|strong|small|s|cite|q|dfn|abbr|data|time|code"+"|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo"+"|span|br|wbr|ins|del|img)\\b)\\w+(?!:/|[^\\w\\s@]*@)\\b";block.html=replace(block.html)("comment",/<!--[\s\S]*?-->/)("closed",/<(tag)[\s\S]+?<\/\1>/)("closing",/<tag(?:"[^"]*"|'[^']*'|[^'">])*?>/)(/tag/g,block._tag)();block.paragraph=replace(block.paragraph)("hr",block.hr)("heading",block.heading)("lheading",block.lheading)("blockquote",block.blockquote)("tag","<"+block._tag)("def",block.def)();block.normal=merge({},block);block.gfm=merge({},block.normal,{fences:/^ *(`{3,}|~{3,}) *(\S+)? *\n([\s\S]+?)\s*\1 *(?:\n+|$)/,paragraph:/^/});block.gfm.paragraph=replace(block.paragraph)("(?!","(?!"+block.gfm.fences.source.replace("\\1","\\2")+"|"+block.list.source.replace("\\1","\\3")+"|")();block.tables=merge({},block.gfm,{nptable:/^ *(\S.*\|.*)\n *([-:]+ *\|[-| :]*)\n((?:.*\|.*(?:\n|$))*)\n*/,table:/^ *\|(.+)\n *\|( *[-:]+[-| :]*)\n((?: *\|.*(?:\n|$))*)\n*/});function Lexer(options){this.tokens=[];this.tokens.links={};this.options=options||marked.defaults;this.rules=block.normal;if(this.options.gfm){if(this.options.tables){this.rules=block.tables}else{this.rules=block.gfm}}}Lexer.rules=block;Lexer.lex=function(src,options){var lexer=new Lexer(options);return lexer.lex(src)};Lexer.prototype.lex=function(src){src=src.replace(/\r\n|\r/g,"\n").replace(/\t/g," ").replace(/\u00a0/g," ").replace(/\u2424/g,"\n");return this.token(src,true)};Lexer.prototype.token=function(src,top,bq){var src=src.replace(/^ +$/gm,""),next,loose,cap,bull,b,item,space,i,l;while(src){if(cap=this.rules.newline.exec(src)){src=src.substring(cap[0].length);if(cap[0].length>1){this.tokens.push({type:"space"})}}if(cap=this.rules.code.exec(src)){src=src.substring(cap[0].length);cap=cap[0].replace(/^ {4}/gm,"");this.tokens.push({type:"code",text:!this.options.pedantic?cap.replace(/\n+$/,""):cap});continue}if(cap=this.rules.fences.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"code",lang:cap[2],text:cap[3]});continue}if(cap=this.rules.heading.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"heading",depth:cap[1].length,text:cap[2]});continue}if(top&&(cap=this.rules.nptable.exec(src))){src=src.substring(cap[0].length);item={type:"table",header:cap[1].replace(/^ *| *\| *$/g,"").split(/ *\| */),align:cap[2].replace(/^ *|\| *$/g,"").split(/ *\| */),cells:cap[3].replace(/\n$/,"").split("\n")};for(i=0;i<item.align.length;i++){if(/^ *-+: *$/.test(item.align[i])){item.align[i]="right"}else if(/^ *:-+: *$/.test(item.align[i])){item.align[i]="center"}else if(/^ *:-+ *$/.test(item.align[i])){item.align[i]="left"}else{item.align[i]=null}}for(i=0;i<item.cells.length;i++){item.cells[i]=item.cells[i].split(/ *\| */)}this.tokens.push(item);continue}if(cap=this.rules.lheading.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"heading",depth:cap[2]==="="?1:2,text:cap[1]});continue}if(cap=this.rules.hr.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"hr"});continue}if(cap=this.rules.blockquote.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"blockquote_start"});cap=cap[0
|
||
|
|
||
|
marked.setOptions({
|
||
|
highlight: function (code, lang) {
|
||
|
if (typeof hljs !== 'undefined'
|
||
|
&& lang
|
||
|
&& hljs.listLanguages().indexOf(lang) >= 0)
|
||
|
{
|
||
|
return hljs.highlight(lang, code, true).value;
|
||
|
}
|
||
|
return code;
|
||
|
}
|
||
|
});
|
||
|
|
||
|
function formatOptions(options) {
|
||
|
var gfm = options.githubFlavored;
|
||
|
if (gfm.ctor === 'Just')
|
||
|
{
|
||
|
return {
|
||
|
gfm: true,
|
||
|
tables: gfm.tables,
|
||
|
breaks: gfm.breaks,
|
||
|
sanitize: options.sanitize,
|
||
|
smartypants: options.smartypants
|
||
|
};
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return {
|
||
|
gfm: false,
|
||
|
tables: false,
|
||
|
breaks: false,
|
||
|
sanitize: options.sanitize,
|
||
|
smartypants: options.smartypants
|
||
|
};
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function toHtmlWith(options, rawMarkdown) {
|
||
|
var widget = {
|
||
|
type: "Widget",
|
||
|
|
||
|
init: function () {
|
||
|
var html = marked(rawMarkdown, formatOptions(options));
|
||
|
var div = document.createElement('div');
|
||
|
div.innerHTML = html;
|
||
|
return div;
|
||
|
},
|
||
|
|
||
|
update: function (previous, node) {
|
||
|
var html = marked(rawMarkdown, formatOptions(options));
|
||
|
node.innerHTML = html;
|
||
|
return node;
|
||
|
}
|
||
|
};
|
||
|
return widget;
|
||
|
}
|
||
|
|
||
|
function toElementWith(options, rawMarkdown) {
|
||
|
return Element.markdown(marked(rawMarkdown, formatOptions(options)));
|
||
|
}
|
||
|
|
||
|
return Elm.Native.Markdown.values = {
|
||
|
toHtmlWith: F2(toHtmlWith),
|
||
|
toElementWith: F2(toElementWith)
|
||
|
};
|
||
|
};
|
||
|
Elm.Native.Port = {};
|
||
|
Elm.Native.Port.make = function(localRuntime) {
|
||
|
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Port = localRuntime.Native.Port || {};
|
||
|
if (localRuntime.Native.Port.values)
|
||
|
{
|
||
|
return localRuntime.Native.Port.values;
|
||
|
}
|
||
|
|
||
|
var NS;
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
|
||
|
// INBOUND
|
||
|
|
||
|
function inbound(name, type, converter)
|
||
|
{
|
||
|
if (!localRuntime.argsTracker[name])
|
||
|
{
|
||
|
throw new Error(
|
||
|
"Port Error:\n" +
|
||
|
"No argument was given for the port named '" + name + "' with type:\n\n" +
|
||
|
" " + type.split('\n').join('\n ') + "\n\n" +
|
||
|
"You need to provide an initial value!\n\n" +
|
||
|
"Find out more about ports here <http://elm-lang.org/learn/Ports.elm>"
|
||
|
);
|
||
|
}
|
||
|
var arg = localRuntime.argsTracker[name];
|
||
|
arg.used = true;
|
||
|
|
||
|
return jsToElm(name, type, converter, arg.value);
|
||
|
}
|
||
|
|
||
|
|
||
|
function inboundSignal(name, type, converter)
|
||
|
{
|
||
|
var initialValue = inbound(name, type, converter);
|
||
|
|
||
|
if (!NS)
|
||
|
{
|
||
|
NS = Elm.Native.Signal.make(localRuntime);
|
||
|
}
|
||
|
var signal = NS.input('inbound-port-' + name, initialValue);
|
||
|
|
||
|
function send(jsValue)
|
||
|
{
|
||
|
var elmValue = jsToElm(name, type, converter, jsValue);
|
||
|
setTimeout(function() {
|
||
|
localRuntime.notify(signal.id, elmValue);
|
||
|
}, 0);
|
||
|
}
|
||
|
|
||
|
localRuntime.ports[name] = { send: send };
|
||
|
|
||
|
return signal;
|
||
|
}
|
||
|
|
||
|
|
||
|
function jsToElm(name, type, converter, value)
|
||
|
{
|
||
|
try
|
||
|
{
|
||
|
return converter(value);
|
||
|
}
|
||
|
catch(e)
|
||
|
{
|
||
|
throw new Error(
|
||
|
"Port Error:\n" +
|
||
|
"Regarding the port named '" + name + "' with type:\n\n" +
|
||
|
" " + type.split('\n').join('\n ') + "\n\n" +
|
||
|
"You just sent the value:\n\n" +
|
||
|
" " + JSON.stringify(arg.value) + "\n\n" +
|
||
|
"but it cannot be converted to the necessary type.\n" +
|
||
|
e.message
|
||
|
);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// OUTBOUND
|
||
|
|
||
|
function outbound(name, converter, elmValue)
|
||
|
{
|
||
|
localRuntime.ports[name] = converter(elmValue);
|
||
|
}
|
||
|
|
||
|
|
||
|
function outboundSignal(name, converter, signal)
|
||
|
{
|
||
|
var subscribers = [];
|
||
|
|
||
|
function subscribe(handler)
|
||
|
{
|
||
|
subscribers.push(handler);
|
||
|
}
|
||
|
function unsubscribe(handler)
|
||
|
{
|
||
|
subscribers.pop(subscribers.indexOf(handler));
|
||
|
}
|
||
|
|
||
|
function notify(elmValue)
|
||
|
{
|
||
|
var jsValue = converter(elmValue);
|
||
|
var len = subscribers.length;
|
||
|
for (var i = 0; i < len; ++i)
|
||
|
{
|
||
|
subscribers[i](jsValue);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (!NS)
|
||
|
{
|
||
|
NS = Elm.Native.Signal.make(localRuntime);
|
||
|
}
|
||
|
NS.output('outbound-port-' + name, notify, signal);
|
||
|
|
||
|
localRuntime.ports[name] = {
|
||
|
subscribe: subscribe,
|
||
|
unsubscribe: unsubscribe
|
||
|
};
|
||
|
|
||
|
return signal;
|
||
|
}
|
||
|
|
||
|
|
||
|
return localRuntime.Native.Port.values = {
|
||
|
inbound: inbound,
|
||
|
outbound: outbound,
|
||
|
inboundSignal: inboundSignal,
|
||
|
outboundSignal: outboundSignal
|
||
|
};
|
||
|
};
|
||
|
|
||
|
|
||
|
if (!Elm.fullscreen) {
|
||
|
|
||
|
(function() {
|
||
|
'use strict';
|
||
|
|
||
|
var Display = {
|
||
|
FULLSCREEN: 0,
|
||
|
COMPONENT: 1,
|
||
|
NONE: 2
|
||
|
};
|
||
|
|
||
|
Elm.fullscreen = function(module, args)
|
||
|
{
|
||
|
var container = document.createElement('div');
|
||
|
document.body.appendChild(container);
|
||
|
return init(Display.FULLSCREEN, container, module, args || {});
|
||
|
};
|
||
|
|
||
|
Elm.embed = function(module, container, args)
|
||
|
{
|
||
|
var tag = container.tagName;
|
||
|
if (tag !== 'DIV')
|
||
|
{
|
||
|
throw new Error('Elm.node must be given a DIV, not a ' + tag + '.');
|
||
|
}
|
||
|
return init(Display.COMPONENT, container, module, args || {});
|
||
|
};
|
||
|
|
||
|
Elm.worker = function(module, args)
|
||
|
{
|
||
|
return init(Display.NONE, {}, module, args || {});
|
||
|
};
|
||
|
|
||
|
function init(display, container, module, args, moduleToReplace)
|
||
|
{
|
||
|
// defining state needed for an instance of the Elm RTS
|
||
|
var inputs = [];
|
||
|
|
||
|
/* OFFSET
|
||
|
* Elm's time traveling debugger lets you pause time. This means
|
||
|
* "now" may be shifted a bit into the past. By wrapping Date.now()
|
||
|
* we can manage this.
|
||
|
*/
|
||
|
var timer = {
|
||
|
programStart: Date.now(),
|
||
|
now: function()
|
||
|
{
|
||
|
return Date.now();
|
||
|
}
|
||
|
};
|
||
|
|
||
|
var updateInProgress = false;
|
||
|
function notify(id, v)
|
||
|
{
|
||
|
if (updateInProgress)
|
||
|
{
|
||
|
throw new Error(
|
||
|
'The notify function has been called synchronously!\n' +
|
||
|
'This can lead to frames being dropped.\n' +
|
||
|
'Definitely report this to <https://github.com/elm-lang/Elm/issues>\n');
|
||
|
}
|
||
|
updateInProgress = true;
|
||
|
var timestep = timer.now();
|
||
|
for (var i = inputs.length; i--; )
|
||
|
{
|
||
|
inputs[i].notify(timestep, id, v);
|
||
|
}
|
||
|
updateInProgress = false;
|
||
|
}
|
||
|
function setTimeout(func, delay)
|
||
|
{
|
||
|
return window.setTimeout(func, delay);
|
||
|
}
|
||
|
|
||
|
var listeners = [];
|
||
|
function addListener(relevantInputs, domNode, eventName, func)
|
||
|
{
|
||
|
domNode.addEventListener(eventName, func);
|
||
|
var listener = {
|
||
|
relevantInputs: relevantInputs,
|
||
|
domNode: domNode,
|
||
|
eventName: eventName,
|
||
|
func: func
|
||
|
};
|
||
|
listeners.push(listener);
|
||
|
}
|
||
|
|
||
|
var argsTracker = {};
|
||
|
for (var name in args)
|
||
|
{
|
||
|
argsTracker[name] = {
|
||
|
value: args[name],
|
||
|
used: false
|
||
|
};
|
||
|
}
|
||
|
|
||
|
// create the actual RTS. Any impure modules will attach themselves to this
|
||
|
// object. This permits many Elm programs to be embedded per document.
|
||
|
var elm = {
|
||
|
notify: notify,
|
||
|
setTimeout: setTimeout,
|
||
|
node: container,
|
||
|
addListener: addListener,
|
||
|
inputs: inputs,
|
||
|
timer: timer,
|
||
|
argsTracker: argsTracker,
|
||
|
ports: {},
|
||
|
|
||
|
isFullscreen: function() { return display === Display.FULLSCREEN; },
|
||
|
isEmbed: function() { return display === Display.COMPONENT; },
|
||
|
isWorker: function() { return display === Display.NONE; }
|
||
|
};
|
||
|
|
||
|
function swap(newModule)
|
||
|
{
|
||
|
removeListeners(listeners);
|
||
|
var div = document.createElement('div');
|
||
|
var newElm = init(display, div, newModule, args, elm);
|
||
|
inputs = [];
|
||
|
// elm.swap = newElm.swap;
|
||
|
return newElm;
|
||
|
}
|
||
|
|
||
|
function dispose()
|
||
|
{
|
||
|
removeListeners(listeners);
|
||
|
inputs = [];
|
||
|
}
|
||
|
|
||
|
var Module = {};
|
||
|
try
|
||
|
{
|
||
|
Module = module.make(elm);
|
||
|
checkInputs(elm);
|
||
|
}
|
||
|
catch (error)
|
||
|
{
|
||
|
if (typeof container.appendChild == 'undefined')
|
||
|
{
|
||
|
console.log(error.message);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
container.appendChild(errorNode(error.message));
|
||
|
}
|
||
|
throw error;
|
||
|
}
|
||
|
|
||
|
if (display !== Display.NONE)
|
||
|
{
|
||
|
var graphicsNode = initGraphics(elm, Module);
|
||
|
}
|
||
|
|
||
|
var rootNode = { kids: inputs };
|
||
|
trimDeadNodes(rootNode);
|
||
|
inputs = rootNode.kids;
|
||
|
filterListeners(inputs, listeners);
|
||
|
|
||
|
addReceivers(elm.ports);
|
||
|
|
||
|
if (typeof moduleToReplace !== 'undefined')
|
||
|
{
|
||
|
hotSwap(moduleToReplace, elm);
|
||
|
|
||
|
// rerender scene if graphics are enabled.
|
||
|
if (typeof graphicsNode !== 'undefined')
|
||
|
{
|
||
|
graphicsNode.notify(0, true, 0);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return {
|
||
|
swap: swap,
|
||
|
ports: elm.ports,
|
||
|
dispose: dispose
|
||
|
};
|
||
|
};
|
||
|
|
||
|
function checkInputs(elm)
|
||
|
{
|
||
|
var argsTracker = elm.argsTracker;
|
||
|
for (var name in argsTracker)
|
||
|
{
|
||
|
if (!argsTracker[name].used)
|
||
|
{
|
||
|
throw new Error(
|
||
|
"Port Error:\nYou provided an argument named '" + name +
|
||
|
"' but there is no corresponding port!\n\n" +
|
||
|
"Maybe add a port '" + name + "' to your Elm module?\n" +
|
||
|
"Maybe remove the '" + name + "' argument from your initialization code in JS?"
|
||
|
);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function errorNode(message)
|
||
|
{
|
||
|
var code = document.createElement('code');
|
||
|
|
||
|
var lines = message.split('\n');
|
||
|
code.appendChild(document.createTextNode(lines[0]));
|
||
|
code.appendChild(document.createElement('br'));
|
||
|
code.appendChild(document.createElement('br'));
|
||
|
for (var i = 1; i < lines.length; ++i)
|
||
|
{
|
||
|
code.appendChild(document.createTextNode('\u00A0 \u00A0 ' + lines[i].replace(/ /g, '\u00A0 ')));
|
||
|
code.appendChild(document.createElement('br'));
|
||
|
}
|
||
|
code.appendChild(document.createElement('br'));
|
||
|
code.appendChild(document.createTextNode("Open the developer console for more details."));
|
||
|
return code;
|
||
|
}
|
||
|
|
||
|
|
||
|
//// FILTER SIGNALS ////
|
||
|
|
||
|
// TODO: move this code into the signal module and create a function
|
||
|
// Signal.initializeGraph that actually instantiates everything.
|
||
|
|
||
|
function filterListeners(inputs, listeners)
|
||
|
{
|
||
|
loop:
|
||
|
for (var i = listeners.length; i--; )
|
||
|
{
|
||
|
var listener = listeners[i];
|
||
|
for (var j = inputs.length; j--; )
|
||
|
{
|
||
|
if (listener.relevantInputs.indexOf(inputs[j].id) >= 0)
|
||
|
{
|
||
|
continue loop;
|
||
|
}
|
||
|
}
|
||
|
listener.domNode.removeEventListener(listener.eventName, listener.func);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function removeListeners(listeners)
|
||
|
{
|
||
|
for (var i = listeners.length; i--; )
|
||
|
{
|
||
|
var listener = listeners[i];
|
||
|
listener.domNode.removeEventListener(listener.eventName, listener.func);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// add receivers for built-in ports if they are defined
|
||
|
function addReceivers(ports)
|
||
|
{
|
||
|
if ('title' in ports)
|
||
|
{
|
||
|
if (typeof ports.title === 'string')
|
||
|
{
|
||
|
document.title = ports.title;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
ports.title.subscribe(function(v) { document.title = v; });
|
||
|
}
|
||
|
}
|
||
|
if ('redirect' in ports)
|
||
|
{
|
||
|
ports.redirect.subscribe(function(v) {
|
||
|
if (v.length > 0)
|
||
|
{
|
||
|
window.location = v;
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// returns a boolean representing whether the node is alive or not.
|
||
|
function trimDeadNodes(node)
|
||
|
{
|
||
|
if (node.isOutput)
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
var liveKids = [];
|
||
|
for (var i = node.kids.length; i--; )
|
||
|
{
|
||
|
var kid = node.kids[i];
|
||
|
if (trimDeadNodes(kid))
|
||
|
{
|
||
|
liveKids.push(kid);
|
||
|
}
|
||
|
}
|
||
|
node.kids = liveKids;
|
||
|
|
||
|
return liveKids.length > 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
//// RENDERING ////
|
||
|
|
||
|
function initGraphics(elm, Module)
|
||
|
{
|
||
|
if (!('main' in Module))
|
||
|
{
|
||
|
throw new Error("'main' is missing! What do I display?!");
|
||
|
}
|
||
|
|
||
|
var signalGraph = Module.main;
|
||
|
|
||
|
// make sure the signal graph is actually a signal & extract the visual model
|
||
|
if (!('notify' in signalGraph))
|
||
|
{
|
||
|
signalGraph = Elm.Signal.make(elm).constant(signalGraph);
|
||
|
}
|
||
|
var initialScene = signalGraph.value;
|
||
|
|
||
|
// Figure out what the render functions should be
|
||
|
var render;
|
||
|
var update;
|
||
|
if (initialScene.props)
|
||
|
{
|
||
|
var Element = Elm.Native.Graphics.Element.make(elm);
|
||
|
render = Element.render;
|
||
|
update = Element.updateAndReplace;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
var VirtualDom = Elm.Native.VirtualDom.make(elm);
|
||
|
render = VirtualDom.render;
|
||
|
update = VirtualDom.updateAndReplace;
|
||
|
}
|
||
|
|
||
|
// Add the initialScene to the DOM
|
||
|
var container = elm.node;
|
||
|
var node = render(initialScene);
|
||
|
while (container.firstChild)
|
||
|
{
|
||
|
container.removeChild(container.firstChild);
|
||
|
}
|
||
|
container.appendChild(node);
|
||
|
|
||
|
var _requestAnimationFrame =
|
||
|
typeof requestAnimationFrame !== 'undefined'
|
||
|
? requestAnimationFrame
|
||
|
: function(cb) { setTimeout(cb, 1000/60); }
|
||
|
;
|
||
|
|
||
|
// domUpdate is called whenever the main Signal changes.
|
||
|
//
|
||
|
// domUpdate and drawCallback implement a small state machine in order
|
||
|
// to schedule only 1 draw per animation frame. This enforces that
|
||
|
// once draw has been called, it will not be called again until the
|
||
|
// next frame.
|
||
|
//
|
||
|
// drawCallback is scheduled whenever
|
||
|
// 1. The state transitions from PENDING_REQUEST to EXTRA_REQUEST, or
|
||
|
// 2. The state transitions from NO_REQUEST to PENDING_REQUEST
|
||
|
//
|
||
|
// Invariants:
|
||
|
// 1. In the NO_REQUEST state, there is never a scheduled drawCallback.
|
||
|
// 2. In the PENDING_REQUEST and EXTRA_REQUEST states, there is always exactly 1
|
||
|
// scheduled drawCallback.
|
||
|
var NO_REQUEST = 0;
|
||
|
var PENDING_REQUEST = 1;
|
||
|
var EXTRA_REQUEST = 2;
|
||
|
var state = NO_REQUEST;
|
||
|
var savedScene = initialScene;
|
||
|
var scheduledScene = initialScene;
|
||
|
|
||
|
function domUpdate(newScene)
|
||
|
{
|
||
|
scheduledScene = newScene;
|
||
|
|
||
|
switch (state)
|
||
|
{
|
||
|
case NO_REQUEST:
|
||
|
_requestAnimationFrame(drawCallback);
|
||
|
state = PENDING_REQUEST;
|
||
|
return;
|
||
|
case PENDING_REQUEST:
|
||
|
state = PENDING_REQUEST;
|
||
|
return;
|
||
|
case EXTRA_REQUEST:
|
||
|
state = PENDING_REQUEST;
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function drawCallback()
|
||
|
{
|
||
|
switch (state)
|
||
|
{
|
||
|
case NO_REQUEST:
|
||
|
// This state should not be possible. How can there be no
|
||
|
// request, yet somehow we are actively fulfilling a
|
||
|
// request?
|
||
|
throw new Error(
|
||
|
"Unexpected draw callback.\n" +
|
||
|
"Please report this to <https://github.com/elm-lang/core/issues>."
|
||
|
);
|
||
|
|
||
|
case PENDING_REQUEST:
|
||
|
// At this point, we do not *know* that another frame is
|
||
|
// needed, but we make an extra request to rAF just in
|
||
|
// case. It's possible to drop a frame if rAF is called
|
||
|
// too late, so we just do it preemptively.
|
||
|
_requestAnimationFrame(drawCallback);
|
||
|
state = EXTRA_REQUEST;
|
||
|
|
||
|
// There's also stuff we definitely need to draw.
|
||
|
draw();
|
||
|
return;
|
||
|
|
||
|
case EXTRA_REQUEST:
|
||
|
// Turns out the extra request was not needed, so we will
|
||
|
// stop calling rAF. No reason to call it all the time if
|
||
|
// no one needs it.
|
||
|
state = NO_REQUEST;
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function draw()
|
||
|
{
|
||
|
update(elm.node.firstChild, savedScene, scheduledScene);
|
||
|
if (elm.Native.Window)
|
||
|
{
|
||
|
elm.Native.Window.values.resizeIfNeeded();
|
||
|
}
|
||
|
savedScene = scheduledScene;
|
||
|
}
|
||
|
|
||
|
var renderer = Elm.Native.Signal.make(elm).output('main', domUpdate, signalGraph);
|
||
|
|
||
|
// must check for resize after 'renderer' is created so
|
||
|
// that changes show up.
|
||
|
if (elm.Native.Window)
|
||
|
{
|
||
|
elm.Native.Window.values.resizeIfNeeded();
|
||
|
}
|
||
|
|
||
|
return renderer;
|
||
|
}
|
||
|
|
||
|
//// HOT SWAPPING ////
|
||
|
|
||
|
// Returns boolean indicating if the swap was successful.
|
||
|
// Requires that the two signal graphs have exactly the same
|
||
|
// structure.
|
||
|
function hotSwap(from, to)
|
||
|
{
|
||
|
function similar(nodeOld,nodeNew)
|
||
|
{
|
||
|
if (nodeOld.id !== nodeNew.id)
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
if (nodeOld.isOutput)
|
||
|
{
|
||
|
return nodeNew.isOutput;
|
||
|
}
|
||
|
return nodeOld.kids.length === nodeNew.kids.length;
|
||
|
}
|
||
|
function swap(nodeOld,nodeNew)
|
||
|
{
|
||
|
nodeNew.value = nodeOld.value;
|
||
|
return true;
|
||
|
}
|
||
|
var canSwap = depthFirstTraversals(similar, from.inputs, to.inputs);
|
||
|
if (canSwap)
|
||
|
{
|
||
|
depthFirstTraversals(swap, from.inputs, to.inputs);
|
||
|
}
|
||
|
from.node.parentNode.replaceChild(to.node, from.node);
|
||
|
|
||
|
return canSwap;
|
||
|
}
|
||
|
|
||
|
// Returns false if the node operation f ever fails.
|
||
|
function depthFirstTraversals(f, queueOld, queueNew)
|
||
|
{
|
||
|
if (queueOld.length !== queueNew.length)
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
queueOld = queueOld.slice(0);
|
||
|
queueNew = queueNew.slice(0);
|
||
|
|
||
|
var seen = [];
|
||
|
while (queueOld.length > 0 && queueNew.length > 0)
|
||
|
{
|
||
|
var nodeOld = queueOld.pop();
|
||
|
var nodeNew = queueNew.pop();
|
||
|
if (seen.indexOf(nodeOld.id) < 0)
|
||
|
{
|
||
|
if (!f(nodeOld, nodeNew))
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
queueOld = queueOld.concat(nodeOld.kids || []);
|
||
|
queueNew = queueNew.concat(nodeNew.kids || []);
|
||
|
seen.push(nodeOld.id);
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
}());
|
||
|
|
||
|
function F2(fun)
|
||
|
{
|
||
|
function wrapper(a) { return function(b) { return fun(a,b) } }
|
||
|
wrapper.arity = 2;
|
||
|
wrapper.func = fun;
|
||
|
return wrapper;
|
||
|
}
|
||
|
|
||
|
function F3(fun)
|
||
|
{
|
||
|
function wrapper(a) {
|
||
|
return function(b) { return function(c) { return fun(a,b,c) }}
|
||
|
}
|
||
|
wrapper.arity = 3;
|
||
|
wrapper.func = fun;
|
||
|
return wrapper;
|
||
|
}
|
||
|
|
||
|
function F4(fun)
|
||
|
{
|
||
|
function wrapper(a) { return function(b) { return function(c) {
|
||
|
return function(d) { return fun(a,b,c,d) }}}
|
||
|
}
|
||
|
wrapper.arity = 4;
|
||
|
wrapper.func = fun;
|
||
|
return wrapper;
|
||
|
}
|
||
|
|
||
|
function F5(fun)
|
||
|
{
|
||
|
function wrapper(a) { return function(b) { return function(c) {
|
||
|
return function(d) { return function(e) { return fun(a,b,c,d,e) }}}}
|
||
|
}
|
||
|
wrapper.arity = 5;
|
||
|
wrapper.func = fun;
|
||
|
return wrapper;
|
||
|
}
|
||
|
|
||
|
function F6(fun)
|
||
|
{
|
||
|
function wrapper(a) { return function(b) { return function(c) {
|
||
|
return function(d) { return function(e) { return function(f) {
|
||
|
return fun(a,b,c,d,e,f) }}}}}
|
||
|
}
|
||
|
wrapper.arity = 6;
|
||
|
wrapper.func = fun;
|
||
|
return wrapper;
|
||
|
}
|
||
|
|
||
|
function F7(fun)
|
||
|
{
|
||
|
function wrapper(a) { return function(b) { return function(c) {
|
||
|
return function(d) { return function(e) { return function(f) {
|
||
|
return function(g) { return fun(a,b,c,d,e,f,g) }}}}}}
|
||
|
}
|
||
|
wrapper.arity = 7;
|
||
|
wrapper.func = fun;
|
||
|
return wrapper;
|
||
|
}
|
||
|
|
||
|
function F8(fun)
|
||
|
{
|
||
|
function wrapper(a) { return function(b) { return function(c) {
|
||
|
return function(d) { return function(e) { return function(f) {
|
||
|
return function(g) { return function(h) {
|
||
|
return fun(a,b,c,d,e,f,g,h)}}}}}}}
|
||
|
}
|
||
|
wrapper.arity = 8;
|
||
|
wrapper.func = fun;
|
||
|
return wrapper;
|
||
|
}
|
||
|
|
||
|
function F9(fun)
|
||
|
{
|
||
|
function wrapper(a) { return function(b) { return function(c) {
|
||
|
return function(d) { return function(e) { return function(f) {
|
||
|
return function(g) { return function(h) { return function(i) {
|
||
|
return fun(a,b,c,d,e,f,g,h,i) }}}}}}}}
|
||
|
}
|
||
|
wrapper.arity = 9;
|
||
|
wrapper.func = fun;
|
||
|
return wrapper;
|
||
|
}
|
||
|
|
||
|
function A2(fun,a,b)
|
||
|
{
|
||
|
return fun.arity === 2
|
||
|
? fun.func(a,b)
|
||
|
: fun(a)(b);
|
||
|
}
|
||
|
function A3(fun,a,b,c)
|
||
|
{
|
||
|
return fun.arity === 3
|
||
|
? fun.func(a,b,c)
|
||
|
: fun(a)(b)(c);
|
||
|
}
|
||
|
function A4(fun,a,b,c,d)
|
||
|
{
|
||
|
return fun.arity === 4
|
||
|
? fun.func(a,b,c,d)
|
||
|
: fun(a)(b)(c)(d);
|
||
|
}
|
||
|
function A5(fun,a,b,c,d,e)
|
||
|
{
|
||
|
return fun.arity === 5
|
||
|
? fun.func(a,b,c,d,e)
|
||
|
: fun(a)(b)(c)(d)(e);
|
||
|
}
|
||
|
function A6(fun,a,b,c,d,e,f)
|
||
|
{
|
||
|
return fun.arity === 6
|
||
|
? fun.func(a,b,c,d,e,f)
|
||
|
: fun(a)(b)(c)(d)(e)(f);
|
||
|
}
|
||
|
function A7(fun,a,b,c,d,e,f,g)
|
||
|
{
|
||
|
return fun.arity === 7
|
||
|
? fun.func(a,b,c,d,e,f,g)
|
||
|
: fun(a)(b)(c)(d)(e)(f)(g);
|
||
|
}
|
||
|
function A8(fun,a,b,c,d,e,f,g,h)
|
||
|
{
|
||
|
return fun.arity === 8
|
||
|
? fun.func(a,b,c,d,e,f,g,h)
|
||
|
: fun(a)(b)(c)(d)(e)(f)(g)(h);
|
||
|
}
|
||
|
function A9(fun,a,b,c,d,e,f,g,h,i)
|
||
|
{
|
||
|
return fun.arity === 9
|
||
|
? fun.func(a,b,c,d,e,f,g,h,i)
|
||
|
: fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
||
|
/*!
|
||
|
* The buffer module from node.js, for the browser.
|
||
|
*
|
||
|
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
|
||
|
* @license MIT
|
||
|
*/
|
||
|
|
||
|
var base64 = require('base64-js')
|
||
|
var ieee754 = require('ieee754')
|
||
|
var isArray = require('is-array')
|
||
|
|
||
|
exports.Buffer = Buffer
|
||
|
exports.SlowBuffer = SlowBuffer
|
||
|
exports.INSPECT_MAX_BYTES = 50
|
||
|
Buffer.poolSize = 8192 // not used by this implementation
|
||
|
|
||
|
var kMaxLength = 0x3fffffff
|
||
|
var rootParent = {}
|
||
|
|
||
|
/**
|
||
|
* If `Buffer.TYPED_ARRAY_SUPPORT`:
|
||
|
* === true Use Uint8Array implementation (fastest)
|
||
|
* === false Use Object implementation (most compatible, even IE6)
|
||
|
*
|
||
|
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
|
||
|
* Opera 11.6+, iOS 4.2+.
|
||
|
*
|
||
|
* Note:
|
||
|
*
|
||
|
* - Implementation must support adding new properties to `Uint8Array` instances.
|
||
|
* Firefox 4-29 lacked support, fixed in Firefox 30+.
|
||
|
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
|
||
|
*
|
||
|
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
|
||
|
*
|
||
|
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
|
||
|
* incorrect length in some situations.
|
||
|
*
|
||
|
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they will
|
||
|
* get the Object implementation, which is slower but will work correctly.
|
||
|
*/
|
||
|
Buffer.TYPED_ARRAY_SUPPORT = (function () {
|
||
|
try {
|
||
|
var buf = new ArrayBuffer(0)
|
||
|
var arr = new Uint8Array(buf)
|
||
|
arr.foo = function () { return 42 }
|
||
|
return arr.foo() === 42 && // typed array instances can be augmented
|
||
|
typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
|
||
|
new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
|
||
|
} catch (e) {
|
||
|
return false
|
||
|
}
|
||
|
})()
|
||
|
|
||
|
/**
|
||
|
* Class: Buffer
|
||
|
* =============
|
||
|
*
|
||
|
* The Buffer constructor returns instances of `Uint8Array` that are augmented
|
||
|
* with function properties for all the node `Buffer` API functions. We use
|
||
|
* `Uint8Array` so that square bracket notation works as expected -- it returns
|
||
|
* a single octet.
|
||
|
*
|
||
|
* By augmenting the instances, we can avoid modifying the `Uint8Array`
|
||
|
* prototype.
|
||
|
*/
|
||
|
function Buffer (arg) {
|
||
|
if (!(this instanceof Buffer)) {
|
||
|
// Avoid going through an ArgumentsAdaptorTrampoline in the common case.
|
||
|
if (arguments.length > 1) return new Buffer(arg, arguments[1])
|
||
|
return new Buffer(arg)
|
||
|
}
|
||
|
|
||
|
this.length = 0
|
||
|
this.parent = undefined
|
||
|
|
||
|
// Common case.
|
||
|
if (typeof arg === 'number') {
|
||
|
return fromNumber(this, arg)
|
||
|
}
|
||
|
|
||
|
// Slightly less common case.
|
||
|
if (typeof arg === 'string') {
|
||
|
return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')
|
||
|
}
|
||
|
|
||
|
// Unusual.
|
||
|
return fromObject(this, arg)
|
||
|
}
|
||
|
|
||
|
function fromNumber (that, length) {
|
||
|
that = allocate(that, length < 0 ? 0 : checked(length) | 0)
|
||
|
if (!Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
for (var i = 0; i < length; i++) {
|
||
|
that[i] = 0
|
||
|
}
|
||
|
}
|
||
|
return that
|
||
|
}
|
||
|
|
||
|
function fromString (that, string, encoding) {
|
||
|
if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'
|
||
|
|
||
|
// Assumption: byteLength() return value is always < kMaxLength.
|
||
|
var length = byteLength(string, encoding) | 0
|
||
|
that = allocate(that, length)
|
||
|
|
||
|
that.write(string, encoding)
|
||
|
return that
|
||
|
}
|
||
|
|
||
|
function fromObject (that, object) {
|
||
|
if (Buffer.isBuffer(object)) return fromBuffer(that, object)
|
||
|
|
||
|
if (isArray(object)) return fromArray(that, object)
|
||
|
|
||
|
if (object == null) {
|
||
|
throw new TypeError('must start with number, buffer, array or string')
|
||
|
}
|
||
|
|
||
|
if (typeof ArrayBuffer !== 'undefined' && object.buffer instanceof ArrayBuffer) {
|
||
|
return fromTypedArray(that, object)
|
||
|
}
|
||
|
|
||
|
if (object.length) return fromArrayLike(that, object)
|
||
|
|
||
|
return fromJsonObject(that, object)
|
||
|
}
|
||
|
|
||
|
function fromBuffer (that, buffer) {
|
||
|
var length = checked(buffer.length) | 0
|
||
|
that = allocate(that, length)
|
||
|
buffer.copy(that, 0, 0, length)
|
||
|
return that
|
||
|
}
|
||
|
|
||
|
function fromArray (that, array) {
|
||
|
var length = checked(array.length) | 0
|
||
|
that = allocate(that, length)
|
||
|
for (var i = 0; i < length; i += 1) {
|
||
|
that[i] = array[i] & 255
|
||
|
}
|
||
|
return that
|
||
|
}
|
||
|
|
||
|
// Duplicate of fromArray() to keep fromArray() monomorphic.
|
||
|
function fromTypedArray (that, array) {
|
||
|
var length = checked(array.length) | 0
|
||
|
that = allocate(that, length)
|
||
|
// Truncating the elements is probably not what people expect from typed
|
||
|
// arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior
|
||
|
// of the old Buffer constructor.
|
||
|
for (var i = 0; i < length; i += 1) {
|
||
|
that[i] = array[i] & 255
|
||
|
}
|
||
|
return that
|
||
|
}
|
||
|
|
||
|
function fromArrayLike (that, array) {
|
||
|
var length = checked(array.length) | 0
|
||
|
that = allocate(that, length)
|
||
|
for (var i = 0; i < length; i += 1) {
|
||
|
that[i] = array[i] & 255
|
||
|
}
|
||
|
return that
|
||
|
}
|
||
|
|
||
|
// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.
|
||
|
// Returns a zero-length buffer for inputs that don't conform to the spec.
|
||
|
function fromJsonObject (that, object) {
|
||
|
var array
|
||
|
var length = 0
|
||
|
|
||
|
if (object.type === 'Buffer' && isArray(object.data)) {
|
||
|
array = object.data
|
||
|
length = checked(array.length) | 0
|
||
|
}
|
||
|
that = allocate(that, length)
|
||
|
|
||
|
for (var i = 0; i < length; i += 1) {
|
||
|
that[i] = array[i] & 255
|
||
|
}
|
||
|
return that
|
||
|
}
|
||
|
|
||
|
function allocate (that, length) {
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
// Return an augmented `Uint8Array` instance, for best performance
|
||
|
that = Buffer._augment(new Uint8Array(length))
|
||
|
} else {
|
||
|
// Fallback: Return an object instance of the Buffer class
|
||
|
that.length = length
|
||
|
that._isBuffer = true
|
||
|
}
|
||
|
|
||
|
var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1
|
||
|
if (fromPool) that.parent = rootParent
|
||
|
|
||
|
return that
|
||
|
}
|
||
|
|
||
|
function checked (length) {
|
||
|
// Note: cannot use `length < kMaxLength` here because that fails when
|
||
|
// length is NaN (which is otherwise coerced to zero.)
|
||
|
if (length >= kMaxLength) {
|
||
|
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
|
||
|
'size: 0x' + kMaxLength.toString(16) + ' bytes')
|
||
|
}
|
||
|
return length | 0
|
||
|
}
|
||
|
|
||
|
function SlowBuffer (subject, encoding) {
|
||
|
if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)
|
||
|
|
||
|
var buf = new Buffer(subject, encoding)
|
||
|
delete buf.parent
|
||
|
return buf
|
||
|
}
|
||
|
|
||
|
Buffer.isBuffer = function isBuffer (b) {
|
||
|
return !!(b != null && b._isBuffer)
|
||
|
}
|
||
|
|
||
|
Buffer.compare = function compare (a, b) {
|
||
|
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
|
||
|
throw new TypeError('Arguments must be Buffers')
|
||
|
}
|
||
|
|
||
|
if (a === b) return 0
|
||
|
|
||
|
var x = a.length
|
||
|
var y = b.length
|
||
|
|
||
|
var i = 0
|
||
|
var len = Math.min(x, y)
|
||
|
while (i < len) {
|
||
|
if (a[i] !== b[i]) break
|
||
|
|
||
|
++i
|
||
|
}
|
||
|
|
||
|
if (i !== len) {
|
||
|
x = a[i]
|
||
|
y = b[i]
|
||
|
}
|
||
|
|
||
|
if (x < y) return -1
|
||
|
if (y < x) return 1
|
||
|
return 0
|
||
|
}
|
||
|
|
||
|
Buffer.isEncoding = function isEncoding (encoding) {
|
||
|
switch (String(encoding).toLowerCase()) {
|
||
|
case 'hex':
|
||
|
case 'utf8':
|
||
|
case 'utf-8':
|
||
|
case 'ascii':
|
||
|
case 'binary':
|
||
|
case 'base64':
|
||
|
case 'raw':
|
||
|
case 'ucs2':
|
||
|
case 'ucs-2':
|
||
|
case 'utf16le':
|
||
|
case 'utf-16le':
|
||
|
return true
|
||
|
default:
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Buffer.concat = function concat (list, length) {
|
||
|
if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')
|
||
|
|
||
|
if (list.length === 0) {
|
||
|
return new Buffer(0)
|
||
|
} else if (list.length === 1) {
|
||
|
return list[0]
|
||
|
}
|
||
|
|
||
|
var i
|
||
|
if (length === undefined) {
|
||
|
length = 0
|
||
|
for (i = 0; i < list.length; i++) {
|
||
|
length += list[i].length
|
||
|
}
|
||
|
}
|
||
|
|
||
|
var buf = new Buffer(length)
|
||
|
var pos = 0
|
||
|
for (i = 0; i < list.length; i++) {
|
||
|
var item = list[i]
|
||
|
item.copy(buf, pos)
|
||
|
pos += item.length
|
||
|
}
|
||
|
return buf
|
||
|
}
|
||
|
|
||
|
function byteLength (string, encoding) {
|
||
|
if (typeof string !== 'string') string = String(string)
|
||
|
|
||
|
if (string.length === 0) return 0
|
||
|
|
||
|
switch (encoding || 'utf8') {
|
||
|
case 'ascii':
|
||
|
case 'binary':
|
||
|
case 'raw':
|
||
|
return string.length
|
||
|
case 'ucs2':
|
||
|
case 'ucs-2':
|
||
|
case 'utf16le':
|
||
|
case 'utf-16le':
|
||
|
return string.length * 2
|
||
|
case 'hex':
|
||
|
return string.length >>> 1
|
||
|
case 'utf8':
|
||
|
case 'utf-8':
|
||
|
return utf8ToBytes(string).length
|
||
|
case 'base64':
|
||
|
return base64ToBytes(string).length
|
||
|
default:
|
||
|
return string.length
|
||
|
}
|
||
|
}
|
||
|
Buffer.byteLength = byteLength
|
||
|
|
||
|
// pre-set for values that may exist in the future
|
||
|
Buffer.prototype.length = undefined
|
||
|
Buffer.prototype.parent = undefined
|
||
|
|
||
|
// toString(encoding, start=0, end=buffer.length)
|
||
|
Buffer.prototype.toString = function toString (encoding, start, end) {
|
||
|
var loweredCase = false
|
||
|
|
||
|
start = start | 0
|
||
|
end = end === undefined || end === Infinity ? this.length : end | 0
|
||
|
|
||
|
if (!encoding) encoding = 'utf8'
|
||
|
if (start < 0) start = 0
|
||
|
if (end > this.length) end = this.length
|
||
|
if (end <= start) return ''
|
||
|
|
||
|
while (true) {
|
||
|
switch (encoding) {
|
||
|
case 'hex':
|
||
|
return hexSlice(this, start, end)
|
||
|
|
||
|
case 'utf8':
|
||
|
case 'utf-8':
|
||
|
return utf8Slice(this, start, end)
|
||
|
|
||
|
case 'ascii':
|
||
|
return asciiSlice(this, start, end)
|
||
|
|
||
|
case 'binary':
|
||
|
return binarySlice(this, start, end)
|
||
|
|
||
|
case 'base64':
|
||
|
return base64Slice(this, start, end)
|
||
|
|
||
|
case 'ucs2':
|
||
|
case 'ucs-2':
|
||
|
case 'utf16le':
|
||
|
case 'utf-16le':
|
||
|
return utf16leSlice(this, start, end)
|
||
|
|
||
|
default:
|
||
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
||
|
encoding = (encoding + '').toLowerCase()
|
||
|
loweredCase = true
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.equals = function equals (b) {
|
||
|
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
|
||
|
if (this === b) return true
|
||
|
return Buffer.compare(this, b) === 0
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.inspect = function inspect () {
|
||
|
var str = ''
|
||
|
var max = exports.INSPECT_MAX_BYTES
|
||
|
if (this.length > 0) {
|
||
|
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
|
||
|
if (this.length > max) str += ' ... '
|
||
|
}
|
||
|
return '<Buffer ' + str + '>'
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.compare = function compare (b) {
|
||
|
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
|
||
|
if (this === b) return 0
|
||
|
return Buffer.compare(this, b)
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.indexOf = function indexOf (val, byteOffset) {
|
||
|
if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff
|
||
|
else if (byteOffset < -0x80000000) byteOffset = -0x80000000
|
||
|
byteOffset >>= 0
|
||
|
|
||
|
if (this.length === 0) return -1
|
||
|
if (byteOffset >= this.length) return -1
|
||
|
|
||
|
// Negative offsets start from the end of the buffer
|
||
|
if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)
|
||
|
|
||
|
if (typeof val === 'string') {
|
||
|
if (val.length === 0) return -1 // special case: looking for empty string always fails
|
||
|
return String.prototype.indexOf.call(this, val, byteOffset)
|
||
|
}
|
||
|
if (Buffer.isBuffer(val)) {
|
||
|
return arrayIndexOf(this, val, byteOffset)
|
||
|
}
|
||
|
if (typeof val === 'number') {
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {
|
||
|
return Uint8Array.prototype.indexOf.call(this, val, byteOffset)
|
||
|
}
|
||
|
return arrayIndexOf(this, [ val ], byteOffset)
|
||
|
}
|
||
|
|
||
|
function arrayIndexOf (arr, val, byteOffset) {
|
||
|
var foundIndex = -1
|
||
|
for (var i = 0; byteOffset + i < arr.length; i++) {
|
||
|
if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {
|
||
|
if (foundIndex === -1) foundIndex = i
|
||
|
if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex
|
||
|
} else {
|
||
|
foundIndex = -1
|
||
|
}
|
||
|
}
|
||
|
return -1
|
||
|
}
|
||
|
|
||
|
throw new TypeError('val must be string, number or Buffer')
|
||
|
}
|
||
|
|
||
|
// `get` will be removed in Node 0.13+
|
||
|
Buffer.prototype.get = function get (offset) {
|
||
|
console.log('.get() is deprecated. Access using array indexes instead.')
|
||
|
return this.readUInt8(offset)
|
||
|
}
|
||
|
|
||
|
// `set` will be removed in Node 0.13+
|
||
|
Buffer.prototype.set = function set (v, offset) {
|
||
|
console.log('.set() is deprecated. Access using array indexes instead.')
|
||
|
return this.writeUInt8(v, offset)
|
||
|
}
|
||
|
|
||
|
function hexWrite (buf, string, offset, length) {
|
||
|
offset = Number(offset) || 0
|
||
|
var remaining = buf.length - offset
|
||
|
if (!length) {
|
||
|
length = remaining
|
||
|
} else {
|
||
|
length = Number(length)
|
||
|
if (length > remaining) {
|
||
|
length = remaining
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// must be an even number of digits
|
||
|
var strLen = string.length
|
||
|
if (strLen % 2 !== 0) throw new Error('Invalid hex string')
|
||
|
|
||
|
if (length > strLen / 2) {
|
||
|
length = strLen / 2
|
||
|
}
|
||
|
for (var i = 0; i < length; i++) {
|
||
|
var parsed = parseInt(string.substr(i * 2, 2), 16)
|
||
|
if (isNaN(parsed)) throw new Error('Invalid hex string')
|
||
|
buf[offset + i] = parsed
|
||
|
}
|
||
|
return i
|
||
|
}
|
||
|
|
||
|
function utf8Write (buf, string, offset, length) {
|
||
|
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
|
||
|
}
|
||
|
|
||
|
function asciiWrite (buf, string, offset, length) {
|
||
|
return blitBuffer(asciiToBytes(string), buf, offset, length)
|
||
|
}
|
||
|
|
||
|
function binaryWrite (buf, string, offset, length) {
|
||
|
return asciiWrite(buf, string, offset, length)
|
||
|
}
|
||
|
|
||
|
function base64Write (buf, string, offset, length) {
|
||
|
return blitBuffer(base64ToBytes(string), buf, offset, length)
|
||
|
}
|
||
|
|
||
|
function ucs2Write (buf, string, offset, length) {
|
||
|
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.write = function write (string, offset, length, encoding) {
|
||
|
// Buffer#write(string)
|
||
|
if (offset === undefined) {
|
||
|
encoding = 'utf8'
|
||
|
length = this.length
|
||
|
offset = 0
|
||
|
// Buffer#write(string, encoding)
|
||
|
} else if (length === undefined && typeof offset === 'string') {
|
||
|
encoding = offset
|
||
|
length = this.length
|
||
|
offset = 0
|
||
|
// Buffer#write(string, offset[, length][, encoding])
|
||
|
} else if (isFinite(offset)) {
|
||
|
offset = offset | 0
|
||
|
if (isFinite(length)) {
|
||
|
length = length | 0
|
||
|
if (encoding === undefined) encoding = 'utf8'
|
||
|
} else {
|
||
|
encoding = length
|
||
|
length = undefined
|
||
|
}
|
||
|
// legacy write(string, encoding, offset, length) - remove in v0.13
|
||
|
} else {
|
||
|
var swap = encoding
|
||
|
encoding = offset
|
||
|
offset = length | 0
|
||
|
length = swap
|
||
|
}
|
||
|
|
||
|
var remaining = this.length - offset
|
||
|
if (length === undefined || length > remaining) length = remaining
|
||
|
|
||
|
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
|
||
|
throw new RangeError('attempt to write outside buffer bounds')
|
||
|
}
|
||
|
|
||
|
if (!encoding) encoding = 'utf8'
|
||
|
|
||
|
var loweredCase = false
|
||
|
for (;;) {
|
||
|
switch (encoding) {
|
||
|
case 'hex':
|
||
|
return hexWrite(this, string, offset, length)
|
||
|
|
||
|
case 'utf8':
|
||
|
case 'utf-8':
|
||
|
return utf8Write(this, string, offset, length)
|
||
|
|
||
|
case 'ascii':
|
||
|
return asciiWrite(this, string, offset, length)
|
||
|
|
||
|
case 'binary':
|
||
|
return binaryWrite(this, string, offset, length)
|
||
|
|
||
|
case 'base64':
|
||
|
// Warning: maxLength not taken into account in base64Write
|
||
|
return base64Write(this, string, offset, length)
|
||
|
|
||
|
case 'ucs2':
|
||
|
case 'ucs-2':
|
||
|
case 'utf16le':
|
||
|
case 'utf-16le':
|
||
|
return ucs2Write(this, string, offset, length)
|
||
|
|
||
|
default:
|
||
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
||
|
encoding = ('' + encoding).toLowerCase()
|
||
|
loweredCase = true
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.toJSON = function toJSON () {
|
||
|
return {
|
||
|
type: 'Buffer',
|
||
|
data: Array.prototype.slice.call(this._arr || this, 0)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function base64Slice (buf, start, end) {
|
||
|
if (start === 0 && end === buf.length) {
|
||
|
return base64.fromByteArray(buf)
|
||
|
} else {
|
||
|
return base64.fromByteArray(buf.slice(start, end))
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function utf8Slice (buf, start, end) {
|
||
|
var res = ''
|
||
|
var tmp = ''
|
||
|
end = Math.min(buf.length, end)
|
||
|
|
||
|
for (var i = start; i < end; i++) {
|
||
|
if (buf[i] <= 0x7F) {
|
||
|
res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
|
||
|
tmp = ''
|
||
|
} else {
|
||
|
tmp += '%' + buf[i].toString(16)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return res + decodeUtf8Char(tmp)
|
||
|
}
|
||
|
|
||
|
function asciiSlice (buf, start, end) {
|
||
|
var ret = ''
|
||
|
end = Math.min(buf.length, end)
|
||
|
|
||
|
for (var i = start; i < end; i++) {
|
||
|
ret += String.fromCharCode(buf[i] & 0x7F)
|
||
|
}
|
||
|
return ret
|
||
|
}
|
||
|
|
||
|
function binarySlice (buf, start, end) {
|
||
|
var ret = ''
|
||
|
end = Math.min(buf.length, end)
|
||
|
|
||
|
for (var i = start; i < end; i++) {
|
||
|
ret += String.fromCharCode(buf[i])
|
||
|
}
|
||
|
return ret
|
||
|
}
|
||
|
|
||
|
function hexSlice (buf, start, end) {
|
||
|
var len = buf.length
|
||
|
|
||
|
if (!start || start < 0) start = 0
|
||
|
if (!end || end < 0 || end > len) end = len
|
||
|
|
||
|
var out = ''
|
||
|
for (var i = start; i < end; i++) {
|
||
|
out += toHex(buf[i])
|
||
|
}
|
||
|
return out
|
||
|
}
|
||
|
|
||
|
function utf16leSlice (buf, start, end) {
|
||
|
var bytes = buf.slice(start, end)
|
||
|
var res = ''
|
||
|
for (var i = 0; i < bytes.length; i += 2) {
|
||
|
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
|
||
|
}
|
||
|
return res
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.slice = function slice (start, end) {
|
||
|
var len = this.length
|
||
|
start = ~~start
|
||
|
end = end === undefined ? len : ~~end
|
||
|
|
||
|
if (start < 0) {
|
||
|
start += len
|
||
|
if (start < 0) start = 0
|
||
|
} else if (start > len) {
|
||
|
start = len
|
||
|
}
|
||
|
|
||
|
if (end < 0) {
|
||
|
end += len
|
||
|
if (end < 0) end = 0
|
||
|
} else if (end > len) {
|
||
|
end = len
|
||
|
}
|
||
|
|
||
|
if (end < start) end = start
|
||
|
|
||
|
var newBuf
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
newBuf = Buffer._augment(this.subarray(start, end))
|
||
|
} else {
|
||
|
var sliceLen = end - start
|
||
|
newBuf = new Buffer(sliceLen, undefined)
|
||
|
for (var i = 0; i < sliceLen; i++) {
|
||
|
newBuf[i] = this[i + start]
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (newBuf.length) newBuf.parent = this.parent || this
|
||
|
|
||
|
return newBuf
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Need to make sure that buffer isn't trying to write out of bounds.
|
||
|
*/
|
||
|
function checkOffset (offset, ext, length) {
|
||
|
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
|
||
|
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
|
||
|
offset = offset | 0
|
||
|
byteLength = byteLength | 0
|
||
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
||
|
|
||
|
var val = this[offset]
|
||
|
var mul = 1
|
||
|
var i = 0
|
||
|
while (++i < byteLength && (mul *= 0x100)) {
|
||
|
val += this[offset + i] * mul
|
||
|
}
|
||
|
|
||
|
return val
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
|
||
|
offset = offset | 0
|
||
|
byteLength = byteLength | 0
|
||
|
if (!noAssert) {
|
||
|
checkOffset(offset, byteLength, this.length)
|
||
|
}
|
||
|
|
||
|
var val = this[offset + --byteLength]
|
||
|
var mul = 1
|
||
|
while (byteLength > 0 && (mul *= 0x100)) {
|
||
|
val += this[offset + --byteLength] * mul
|
||
|
}
|
||
|
|
||
|
return val
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 1, this.length)
|
||
|
return this[offset]
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
||
|
return this[offset] | (this[offset + 1] << 8)
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
||
|
return (this[offset] << 8) | this[offset + 1]
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
|
|
||
|
return ((this[offset]) |
|
||
|
(this[offset + 1] << 8) |
|
||
|
(this[offset + 2] << 16)) +
|
||
|
(this[offset + 3] * 0x1000000)
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
|
|
||
|
return (this[offset] * 0x1000000) +
|
||
|
((this[offset + 1] << 16) |
|
||
|
(this[offset + 2] << 8) |
|
||
|
this[offset + 3])
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
|
||
|
offset = offset | 0
|
||
|
byteLength = byteLength | 0
|
||
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
||
|
|
||
|
var val = this[offset]
|
||
|
var mul = 1
|
||
|
var i = 0
|
||
|
while (++i < byteLength && (mul *= 0x100)) {
|
||
|
val += this[offset + i] * mul
|
||
|
}
|
||
|
mul *= 0x80
|
||
|
|
||
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
|
||
|
|
||
|
return val
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
|
||
|
offset = offset | 0
|
||
|
byteLength = byteLength | 0
|
||
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
||
|
|
||
|
var i = byteLength
|
||
|
var mul = 1
|
||
|
var val = this[offset + --i]
|
||
|
while (i > 0 && (mul *= 0x100)) {
|
||
|
val += this[offset + --i] * mul
|
||
|
}
|
||
|
mul *= 0x80
|
||
|
|
||
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
|
||
|
|
||
|
return val
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 1, this.length)
|
||
|
if (!(this[offset] & 0x80)) return (this[offset])
|
||
|
return ((0xff - this[offset] + 1) * -1)
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
||
|
var val = this[offset] | (this[offset + 1] << 8)
|
||
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
||
|
var val = this[offset + 1] | (this[offset] << 8)
|
||
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
|
|
||
|
return (this[offset]) |
|
||
|
(this[offset + 1] << 8) |
|
||
|
(this[offset + 2] << 16) |
|
||
|
(this[offset + 3] << 24)
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
|
|
||
|
return (this[offset] << 24) |
|
||
|
(this[offset + 1] << 16) |
|
||
|
(this[offset + 2] << 8) |
|
||
|
(this[offset + 3])
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
|
return ieee754.read(this, offset, true, 23, 4)
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
|
return ieee754.read(this, offset, false, 23, 4)
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 8, this.length)
|
||
|
return ieee754.read(this, offset, true, 52, 8)
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
|
||
|
if (!noAssert) checkOffset(offset, 8, this.length)
|
||
|
return ieee754.read(this, offset, false, 52, 8)
|
||
|
}
|
||
|
|
||
|
function checkInt (buf, value, offset, ext, max, min) {
|
||
|
if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
|
||
|
if (value > max || value < min) throw new RangeError('value is out of bounds')
|
||
|
if (offset + ext > buf.length) throw new RangeError('index out of range')
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
byteLength = byteLength | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
|
||
|
|
||
|
var mul = 1
|
||
|
var i = 0
|
||
|
this[offset] = value & 0xFF
|
||
|
while (++i < byteLength && (mul *= 0x100)) {
|
||
|
this[offset + i] = (value / mul) & 0xFF
|
||
|
}
|
||
|
|
||
|
return offset + byteLength
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
byteLength = byteLength | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
|
||
|
|
||
|
var i = byteLength - 1
|
||
|
var mul = 1
|
||
|
this[offset + i] = value & 0xFF
|
||
|
while (--i >= 0 && (mul *= 0x100)) {
|
||
|
this[offset + i] = (value / mul) & 0xFF
|
||
|
}
|
||
|
|
||
|
return offset + byteLength
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
|
||
|
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
|
||
|
this[offset] = value
|
||
|
return offset + 1
|
||
|
}
|
||
|
|
||
|
function objectWriteUInt16 (buf, value, offset, littleEndian) {
|
||
|
if (value < 0) value = 0xffff + value + 1
|
||
|
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
|
||
|
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
|
||
|
(littleEndian ? i : 1 - i) * 8
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
this[offset] = value
|
||
|
this[offset + 1] = (value >>> 8)
|
||
|
} else {
|
||
|
objectWriteUInt16(this, value, offset, true)
|
||
|
}
|
||
|
return offset + 2
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
this[offset] = (value >>> 8)
|
||
|
this[offset + 1] = value
|
||
|
} else {
|
||
|
objectWriteUInt16(this, value, offset, false)
|
||
|
}
|
||
|
return offset + 2
|
||
|
}
|
||
|
|
||
|
function objectWriteUInt32 (buf, value, offset, littleEndian) {
|
||
|
if (value < 0) value = 0xffffffff + value + 1
|
||
|
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
|
||
|
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
this[offset + 3] = (value >>> 24)
|
||
|
this[offset + 2] = (value >>> 16)
|
||
|
this[offset + 1] = (value >>> 8)
|
||
|
this[offset] = value
|
||
|
} else {
|
||
|
objectWriteUInt32(this, value, offset, true)
|
||
|
}
|
||
|
return offset + 4
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
this[offset] = (value >>> 24)
|
||
|
this[offset + 1] = (value >>> 16)
|
||
|
this[offset + 2] = (value >>> 8)
|
||
|
this[offset + 3] = value
|
||
|
} else {
|
||
|
objectWriteUInt32(this, value, offset, false)
|
||
|
}
|
||
|
return offset + 4
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) {
|
||
|
var limit = Math.pow(2, 8 * byteLength - 1)
|
||
|
|
||
|
checkInt(this, value, offset, byteLength, limit - 1, -limit)
|
||
|
}
|
||
|
|
||
|
var i = 0
|
||
|
var mul = 1
|
||
|
var sub = value < 0 ? 1 : 0
|
||
|
this[offset] = value & 0xFF
|
||
|
while (++i < byteLength && (mul *= 0x100)) {
|
||
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
|
||
|
}
|
||
|
|
||
|
return offset + byteLength
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) {
|
||
|
var limit = Math.pow(2, 8 * byteLength - 1)
|
||
|
|
||
|
checkInt(this, value, offset, byteLength, limit - 1, -limit)
|
||
|
}
|
||
|
|
||
|
var i = byteLength - 1
|
||
|
var mul = 1
|
||
|
var sub = value < 0 ? 1 : 0
|
||
|
this[offset + i] = value & 0xFF
|
||
|
while (--i >= 0 && (mul *= 0x100)) {
|
||
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
|
||
|
}
|
||
|
|
||
|
return offset + byteLength
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
|
||
|
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
|
||
|
if (value < 0) value = 0xff + value + 1
|
||
|
this[offset] = value
|
||
|
return offset + 1
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
this[offset] = value
|
||
|
this[offset + 1] = (value >>> 8)
|
||
|
} else {
|
||
|
objectWriteUInt16(this, value, offset, true)
|
||
|
}
|
||
|
return offset + 2
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
this[offset] = (value >>> 8)
|
||
|
this[offset + 1] = value
|
||
|
} else {
|
||
|
objectWriteUInt16(this, value, offset, false)
|
||
|
}
|
||
|
return offset + 2
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
this[offset] = value
|
||
|
this[offset + 1] = (value >>> 8)
|
||
|
this[offset + 2] = (value >>> 16)
|
||
|
this[offset + 3] = (value >>> 24)
|
||
|
} else {
|
||
|
objectWriteUInt32(this, value, offset, true)
|
||
|
}
|
||
|
return offset + 4
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
|
||
|
value = +value
|
||
|
offset = offset | 0
|
||
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
|
||
|
if (value < 0) value = 0xffffffff + value + 1
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
this[offset] = (value >>> 24)
|
||
|
this[offset + 1] = (value >>> 16)
|
||
|
this[offset + 2] = (value >>> 8)
|
||
|
this[offset + 3] = value
|
||
|
} else {
|
||
|
objectWriteUInt32(this, value, offset, false)
|
||
|
}
|
||
|
return offset + 4
|
||
|
}
|
||
|
|
||
|
function checkIEEE754 (buf, value, offset, ext, max, min) {
|
||
|
if (value > max || value < min) throw new RangeError('value is out of bounds')
|
||
|
if (offset + ext > buf.length) throw new RangeError('index out of range')
|
||
|
if (offset < 0) throw new RangeError('index out of range')
|
||
|
}
|
||
|
|
||
|
function writeFloat (buf, value, offset, littleEndian, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
|
||
|
}
|
||
|
ieee754.write(buf, value, offset, littleEndian, 23, 4)
|
||
|
return offset + 4
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
|
||
|
return writeFloat(this, value, offset, true, noAssert)
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
|
||
|
return writeFloat(this, value, offset, false, noAssert)
|
||
|
}
|
||
|
|
||
|
function writeDouble (buf, value, offset, littleEndian, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
|
||
|
}
|
||
|
ieee754.write(buf, value, offset, littleEndian, 52, 8)
|
||
|
return offset + 8
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
|
||
|
return writeDouble(this, value, offset, true, noAssert)
|
||
|
}
|
||
|
|
||
|
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
|
||
|
return writeDouble(this, value, offset, false, noAssert)
|
||
|
}
|
||
|
|
||
|
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
|
||
|
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
|
||
|
if (!start) start = 0
|
||
|
if (!end && end !== 0) end = this.length
|
||
|
if (targetStart >= target.length) targetStart = target.length
|
||
|
if (!targetStart) targetStart = 0
|
||
|
if (end > 0 && end < start) end = start
|
||
|
|
||
|
// Copy 0 bytes; we're done
|
||
|
if (end === start) return 0
|
||
|
if (target.length === 0 || this.length === 0) return 0
|
||
|
|
||
|
// Fatal error conditions
|
||
|
if (targetStart < 0) {
|
||
|
throw new RangeError('targetStart out of bounds')
|
||
|
}
|
||
|
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
|
||
|
if (end < 0) throw new RangeError('sourceEnd out of bounds')
|
||
|
|
||
|
// Are we oob?
|
||
|
if (end > this.length) end = this.length
|
||
|
if (target.length - targetStart < end - start) {
|
||
|
end = target.length - targetStart + start
|
||
|
}
|
||
|
|
||
|
var len = end - start
|
||
|
|
||
|
if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
for (var i = 0; i < len; i++) {
|
||
|
target[i + targetStart] = this[i + start]
|
||
|
}
|
||
|
} else {
|
||
|
target._set(this.subarray(start, start + len), targetStart)
|
||
|
}
|
||
|
|
||
|
return len
|
||
|
}
|
||
|
|
||
|
// fill(value, start=0, end=buffer.length)
|
||
|
Buffer.prototype.fill = function fill (value, start, end) {
|
||
|
if (!value) value = 0
|
||
|
if (!start) start = 0
|
||
|
if (!end) end = this.length
|
||
|
|
||
|
if (end < start) throw new RangeError('end < start')
|
||
|
|
||
|
// Fill 0 bytes; we're done
|
||
|
if (end === start) return
|
||
|
if (this.length === 0) return
|
||
|
|
||
|
if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')
|
||
|
if (end < 0 || end > this.length) throw new RangeError('end out of bounds')
|
||
|
|
||
|
var i
|
||
|
if (typeof value === 'number') {
|
||
|
for (i = start; i < end; i++) {
|
||
|
this[i] = value
|
||
|
}
|
||
|
} else {
|
||
|
var bytes = utf8ToBytes(value.toString())
|
||
|
var len = bytes.length
|
||
|
for (i = start; i < end; i++) {
|
||
|
this[i] = bytes[i % len]
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
|
||
|
* Added in Node 0.12. Only available in browsers that support ArrayBuffer.
|
||
|
*/
|
||
|
Buffer.prototype.toArrayBuffer = function toArrayBuffer () {
|
||
|
if (typeof Uint8Array !== 'undefined') {
|
||
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
|
return (new Buffer(this)).buffer
|
||
|
} else {
|
||
|
var buf = new Uint8Array(this.length)
|
||
|
for (var i = 0, len = buf.length; i < len; i += 1) {
|
||
|
buf[i] = this[i]
|
||
|
}
|
||
|
return buf.buffer
|
||
|
}
|
||
|
} else {
|
||
|
throw new TypeError('Buffer.toArrayBuffer not supported in this browser')
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// HELPER FUNCTIONS
|
||
|
// ================
|
||
|
|
||
|
var BP = Buffer.prototype
|
||
|
|
||
|
/**
|
||
|
* Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
|
||
|
*/
|
||
|
Buffer._augment = function _augment (arr) {
|
||
|
arr.constructor = Buffer
|
||
|
arr._isBuffer = true
|
||
|
|
||
|
// save reference to original Uint8Array set method before overwriting
|
||
|
arr._set = arr.set
|
||
|
|
||
|
// deprecated, will be removed in node 0.13+
|
||
|
arr.get = BP.get
|
||
|
arr.set = BP.set
|
||
|
|
||
|
arr.write = BP.write
|
||
|
arr.toString = BP.toString
|
||
|
arr.toLocaleString = BP.toString
|
||
|
arr.toJSON = BP.toJSON
|
||
|
arr.equals = BP.equals
|
||
|
arr.compare = BP.compare
|
||
|
arr.indexOf = BP.indexOf
|
||
|
arr.copy = BP.copy
|
||
|
arr.slice = BP.slice
|
||
|
arr.readUIntLE = BP.readUIntLE
|
||
|
arr.readUIntBE = BP.readUIntBE
|
||
|
arr.readUInt8 = BP.readUInt8
|
||
|
arr.readUInt16LE = BP.readUInt16LE
|
||
|
arr.readUInt16BE = BP.readUInt16BE
|
||
|
arr.readUInt32LE = BP.readUInt32LE
|
||
|
arr.readUInt32BE = BP.readUInt32BE
|
||
|
arr.readIntLE = BP.readIntLE
|
||
|
arr.readIntBE = BP.readIntBE
|
||
|
arr.readInt8 = BP.readInt8
|
||
|
arr.readInt16LE = BP.readInt16LE
|
||
|
arr.readInt16BE = BP.readInt16BE
|
||
|
arr.readInt32LE = BP.readInt32LE
|
||
|
arr.readInt32BE = BP.readInt32BE
|
||
|
arr.readFloatLE = BP.readFloatLE
|
||
|
arr.readFloatBE = BP.readFloatBE
|
||
|
arr.readDoubleLE = BP.readDoubleLE
|
||
|
arr.readDoubleBE = BP.readDoubleBE
|
||
|
arr.writeUInt8 = BP.writeUInt8
|
||
|
arr.writeUIntLE = BP.writeUIntLE
|
||
|
arr.writeUIntBE = BP.writeUIntBE
|
||
|
arr.writeUInt16LE = BP.writeUInt16LE
|
||
|
arr.writeUInt16BE = BP.writeUInt16BE
|
||
|
arr.writeUInt32LE = BP.writeUInt32LE
|
||
|
arr.writeUInt32BE = BP.writeUInt32BE
|
||
|
arr.writeIntLE = BP.writeIntLE
|
||
|
arr.writeIntBE = BP.writeIntBE
|
||
|
arr.writeInt8 = BP.writeInt8
|
||
|
arr.writeInt16LE = BP.writeInt16LE
|
||
|
arr.writeInt16BE = BP.writeInt16BE
|
||
|
arr.writeInt32LE = BP.writeInt32LE
|
||
|
arr.writeInt32BE = BP.writeInt32BE
|
||
|
arr.writeFloatLE = BP.writeFloatLE
|
||
|
arr.writeFloatBE = BP.writeFloatBE
|
||
|
arr.writeDoubleLE = BP.writeDoubleLE
|
||
|
arr.writeDoubleBE = BP.writeDoubleBE
|
||
|
arr.fill = BP.fill
|
||
|
arr.inspect = BP.inspect
|
||
|
arr.toArrayBuffer = BP.toArrayBuffer
|
||
|
|
||
|
return arr
|
||
|
}
|
||
|
|
||
|
var INVALID_BASE64_RE = /[^+\/0-9A-z\-]/g
|
||
|
|
||
|
function base64clean (str) {
|
||
|
// Node strips out invalid characters like \n and \t from the string, base64-js does not
|
||
|
str = stringtrim(str).replace(INVALID_BASE64_RE, '')
|
||
|
// Node converts strings with length < 2 to ''
|
||
|
if (str.length < 2) return ''
|
||
|
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
|
||
|
while (str.length % 4 !== 0) {
|
||
|
str = str + '='
|
||
|
}
|
||
|
return str
|
||
|
}
|
||
|
|
||
|
function stringtrim (str) {
|
||
|
if (str.trim) return str.trim()
|
||
|
return str.replace(/^\s+|\s+$/g, '')
|
||
|
}
|
||
|
|
||
|
function toHex (n) {
|
||
|
if (n < 16) return '0' + n.toString(16)
|
||
|
return n.toString(16)
|
||
|
}
|
||
|
|
||
|
function utf8ToBytes (string, units) {
|
||
|
units = units || Infinity
|
||
|
var codePoint
|
||
|
var length = string.length
|
||
|
var leadSurrogate = null
|
||
|
var bytes = []
|
||
|
var i = 0
|
||
|
|
||
|
for (; i < length; i++) {
|
||
|
codePoint = string.charCodeAt(i)
|
||
|
|
||
|
// is surrogate component
|
||
|
if (codePoint > 0xD7FF && codePoint < 0xE000) {
|
||
|
// last char was a lead
|
||
|
if (leadSurrogate) {
|
||
|
// 2 leads in a row
|
||
|
if (codePoint < 0xDC00) {
|
||
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
||
|
leadSurrogate = codePoint
|
||
|
continue
|
||
|
} else {
|
||
|
// valid surrogate pair
|
||
|
codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000
|
||
|
leadSurrogate = null
|
||
|
}
|
||
|
} else {
|
||
|
// no lead yet
|
||
|
|
||
|
if (codePoint > 0xDBFF) {
|
||
|
// unexpected trail
|
||
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
||
|
continue
|
||
|
} else if (i + 1 === length) {
|
||
|
// unpaired lead
|
||
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
||
|
continue
|
||
|
} else {
|
||
|
// valid lead
|
||
|
leadSurrogate = codePoint
|
||
|
continue
|
||
|
}
|
||
|
}
|
||
|
} else if (leadSurrogate) {
|
||
|
// valid bmp char, but last char was a lead
|
||
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
||
|
leadSurrogate = null
|
||
|
}
|
||
|
|
||
|
// encode utf8
|
||
|
if (codePoint < 0x80) {
|
||
|
if ((units -= 1) < 0) break
|
||
|
bytes.push(codePoint)
|
||
|
} else if (codePoint < 0x800) {
|
||
|
if ((units -= 2) < 0) break
|
||
|
bytes.push(
|
||
|
codePoint >> 0x6 | 0xC0,
|
||
|
codePoint & 0x3F | 0x80
|
||
|
)
|
||
|
} else if (codePoint < 0x10000) {
|
||
|
if ((units -= 3) < 0) break
|
||
|
bytes.push(
|
||
|
codePoint >> 0xC | 0xE0,
|
||
|
codePoint >> 0x6 & 0x3F | 0x80,
|
||
|
codePoint & 0x3F | 0x80
|
||
|
)
|
||
|
} else if (codePoint < 0x200000) {
|
||
|
if ((units -= 4) < 0) break
|
||
|
bytes.push(
|
||
|
codePoint >> 0x12 | 0xF0,
|
||
|
codePoint >> 0xC & 0x3F | 0x80,
|
||
|
codePoint >> 0x6 & 0x3F | 0x80,
|
||
|
codePoint & 0x3F | 0x80
|
||
|
)
|
||
|
} else {
|
||
|
throw new Error('Invalid code point')
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return bytes
|
||
|
}
|
||
|
|
||
|
function asciiToBytes (str) {
|
||
|
var byteArray = []
|
||
|
for (var i = 0; i < str.length; i++) {
|
||
|
// Node's code seems to be doing this and not & 0x7F..
|
||
|
byteArray.push(str.charCodeAt(i) & 0xFF)
|
||
|
}
|
||
|
return byteArray
|
||
|
}
|
||
|
|
||
|
function utf16leToBytes (str, units) {
|
||
|
var c, hi, lo
|
||
|
var byteArray = []
|
||
|
for (var i = 0; i < str.length; i++) {
|
||
|
if ((units -= 2) < 0) break
|
||
|
|
||
|
c = str.charCodeAt(i)
|
||
|
hi = c >> 8
|
||
|
lo = c % 256
|
||
|
byteArray.push(lo)
|
||
|
byteArray.push(hi)
|
||
|
}
|
||
|
|
||
|
return byteArray
|
||
|
}
|
||
|
|
||
|
function base64ToBytes (str) {
|
||
|
return base64.toByteArray(base64clean(str))
|
||
|
}
|
||
|
|
||
|
function blitBuffer (src, dst, offset, length) {
|
||
|
for (var i = 0; i < length; i++) {
|
||
|
if ((i + offset >= dst.length) || (i >= src.length)) break
|
||
|
dst[i + offset] = src[i]
|
||
|
}
|
||
|
return i
|
||
|
}
|
||
|
|
||
|
function decodeUtf8Char (str) {
|
||
|
try {
|
||
|
return decodeURIComponent(str)
|
||
|
} catch (err) {
|
||
|
return String.fromCharCode(0xFFFD) // UTF 8 invalid char
|
||
|
}
|
||
|
}
|
||
|
|
||
|
},{"base64-js":2,"ieee754":3,"is-array":4}],2:[function(require,module,exports){
|
||
|
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
||
|
|
||
|
;(function (exports) {
|
||
|
'use strict';
|
||
|
|
||
|
var Arr = (typeof Uint8Array !== 'undefined')
|
||
|
? Uint8Array
|
||
|
: Array
|
||
|
|
||
|
var PLUS = '+'.charCodeAt(0)
|
||
|
var SLASH = '/'.charCodeAt(0)
|
||
|
var NUMBER = '0'.charCodeAt(0)
|
||
|
var LOWER = 'a'.charCodeAt(0)
|
||
|
var UPPER = 'A'.charCodeAt(0)
|
||
|
var PLUS_URL_SAFE = '-'.charCodeAt(0)
|
||
|
var SLASH_URL_SAFE = '_'.charCodeAt(0)
|
||
|
|
||
|
function decode (elt) {
|
||
|
var code = elt.charCodeAt(0)
|
||
|
if (code === PLUS ||
|
||
|
code === PLUS_URL_SAFE)
|
||
|
return 62 // '+'
|
||
|
if (code === SLASH ||
|
||
|
code === SLASH_URL_SAFE)
|
||
|
return 63 // '/'
|
||
|
if (code < NUMBER)
|
||
|
return -1 //no match
|
||
|
if (code < NUMBER + 10)
|
||
|
return code - NUMBER + 26 + 26
|
||
|
if (code < UPPER + 26)
|
||
|
return code - UPPER
|
||
|
if (code < LOWER + 26)
|
||
|
return code - LOWER + 26
|
||
|
}
|
||
|
|
||
|
function b64ToByteArray (b64) {
|
||
|
var i, j, l, tmp, placeHolders, arr
|
||
|
|
||
|
if (b64.length % 4 > 0) {
|
||
|
throw new Error('Invalid string. Length must be a multiple of 4')
|
||
|
}
|
||
|
|
||
|
// the number of equal signs (place holders)
|
||
|
// if there are two placeholders, than the two characters before it
|
||
|
// represent one byte
|
||
|
// if there is only one, then the three characters before it represent 2 bytes
|
||
|
// this is just a cheap hack to not do indexOf twice
|
||
|
var len = b64.length
|
||
|
placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
|
||
|
|
||
|
// base64 is 4/3 + up to two characters of the original data
|
||
|
arr = new Arr(b64.length * 3 / 4 - placeHolders)
|
||
|
|
||
|
// if there are placeholders, only get up to the last complete 4 chars
|
||
|
l = placeHolders > 0 ? b64.length - 4 : b64.length
|
||
|
|
||
|
var L = 0
|
||
|
|
||
|
function push (v) {
|
||
|
arr[L++] = v
|
||
|
}
|
||
|
|
||
|
for (i = 0, j = 0; i < l; i += 4, j += 3) {
|
||
|
tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
|
||
|
push((tmp & 0xFF0000) >> 16)
|
||
|
push((tmp & 0xFF00) >> 8)
|
||
|
push(tmp & 0xFF)
|
||
|
}
|
||
|
|
||
|
if (placeHolders === 2) {
|
||
|
tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
|
||
|
push(tmp & 0xFF)
|
||
|
} else if (placeHolders === 1) {
|
||
|
tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
|
||
|
push((tmp >> 8) & 0xFF)
|
||
|
push(tmp & 0xFF)
|
||
|
}
|
||
|
|
||
|
return arr
|
||
|
}
|
||
|
|
||
|
function uint8ToBase64 (uint8) {
|
||
|
var i,
|
||
|
extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
|
||
|
output = "",
|
||
|
temp, length
|
||
|
|
||
|
function encode (num) {
|
||
|
return lookup.charAt(num)
|
||
|
}
|
||
|
|
||
|
function tripletToBase64 (num) {
|
||
|
return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
|
||
|
}
|
||
|
|
||
|
// go through the array every three bytes, we'll deal with trailing stuff later
|
||
|
for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
|
||
|
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
|
||
|
output += tripletToBase64(temp)
|
||
|
}
|
||
|
|
||
|
// pad the end with zeros, but make sure to not forget the extra bytes
|
||
|
switch (extraBytes) {
|
||
|
case 1:
|
||
|
temp = uint8[uint8.length - 1]
|
||
|
output += encode(temp >> 2)
|
||
|
output += encode((temp << 4) & 0x3F)
|
||
|
output += '=='
|
||
|
break
|
||
|
case 2:
|
||
|
temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
|
||
|
output += encode(temp >> 10)
|
||
|
output += encode((temp >> 4) & 0x3F)
|
||
|
output += encode((temp << 2) & 0x3F)
|
||
|
output += '='
|
||
|
break
|
||
|
}
|
||
|
|
||
|
return output
|
||
|
}
|
||
|
|
||
|
exports.toByteArray = b64ToByteArray
|
||
|
exports.fromByteArray = uint8ToBase64
|
||
|
}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
|
||
|
|
||
|
},{}],3:[function(require,module,exports){
|
||
|
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
|
||
|
var e, m,
|
||
|
eLen = nBytes * 8 - mLen - 1,
|
||
|
eMax = (1 << eLen) - 1,
|
||
|
eBias = eMax >> 1,
|
||
|
nBits = -7,
|
||
|
i = isLE ? (nBytes - 1) : 0,
|
||
|
d = isLE ? -1 : 1,
|
||
|
s = buffer[offset + i]
|
||
|
|
||
|
i += d
|
||
|
|
||
|
e = s & ((1 << (-nBits)) - 1)
|
||
|
s >>= (-nBits)
|
||
|
nBits += eLen
|
||
|
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
||
|
|
||
|
m = e & ((1 << (-nBits)) - 1)
|
||
|
e >>= (-nBits)
|
||
|
nBits += mLen
|
||
|
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
||
|
|
||
|
if (e === 0) {
|
||
|
e = 1 - eBias
|
||
|
} else if (e === eMax) {
|
||
|
return m ? NaN : ((s ? -1 : 1) * Infinity)
|
||
|
} else {
|
||
|
m = m + Math.pow(2, mLen)
|
||
|
e = e - eBias
|
||
|
}
|
||
|
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
|
||
|
}
|
||
|
|
||
|
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
|
||
|
var e, m, c,
|
||
|
eLen = nBytes * 8 - mLen - 1,
|
||
|
eMax = (1 << eLen) - 1,
|
||
|
eBias = eMax >> 1,
|
||
|
rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
|
||
|
i = isLE ? 0 : (nBytes - 1),
|
||
|
d = isLE ? 1 : -1,
|
||
|
s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
|
||
|
|
||
|
value = Math.abs(value)
|
||
|
|
||
|
if (isNaN(value) || value === Infinity) {
|
||
|
m = isNaN(value) ? 1 : 0
|
||
|
e = eMax
|
||
|
} else {
|
||
|
e = Math.floor(Math.log(value) / Math.LN2)
|
||
|
if (value * (c = Math.pow(2, -e)) < 1) {
|
||
|
e--
|
||
|
c *= 2
|
||
|
}
|
||
|
if (e + eBias >= 1) {
|
||
|
value += rt / c
|
||
|
} else {
|
||
|
value += rt * Math.pow(2, 1 - eBias)
|
||
|
}
|
||
|
if (value * c >= 2) {
|
||
|
e++
|
||
|
c /= 2
|
||
|
}
|
||
|
|
||
|
if (e + eBias >= eMax) {
|
||
|
m = 0
|
||
|
e = eMax
|
||
|
} else if (e + eBias >= 1) {
|
||
|
m = (value * c - 1) * Math.pow(2, mLen)
|
||
|
e = e + eBias
|
||
|
} else {
|
||
|
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
|
||
|
e = 0
|
||
|
}
|
||
|
}
|
||
|
|
||
|
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
|
||
|
|
||
|
e = (e << mLen) | m
|
||
|
eLen += mLen
|
||
|
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
|
||
|
|
||
|
buffer[offset + i - d] |= s * 128
|
||
|
}
|
||
|
|
||
|
},{}],4:[function(require,module,exports){
|
||
|
|
||
|
/**
|
||
|
* isArray
|
||
|
*/
|
||
|
|
||
|
var isArray = Array.isArray;
|
||
|
|
||
|
/**
|
||
|
* toString
|
||
|
*/
|
||
|
|
||
|
var str = Object.prototype.toString;
|
||
|
|
||
|
/**
|
||
|
* Whether or not the given `val`
|
||
|
* is an array.
|
||
|
*
|
||
|
* example:
|
||
|
*
|
||
|
* isArray([]);
|
||
|
* // > true
|
||
|
* isArray(arguments);
|
||
|
* // > false
|
||
|
* isArray('');
|
||
|
* // > false
|
||
|
*
|
||
|
* @param {mixed} val
|
||
|
* @return {bool}
|
||
|
*/
|
||
|
|
||
|
module.exports = isArray || function (val) {
|
||
|
return !! val && '[object Array]' == str.call(val);
|
||
|
};
|
||
|
|
||
|
},{}],5:[function(require,module,exports){
|
||
|
(function (Buffer){
|
||
|
//prototype class for hash functions
|
||
|
function Hash (blockSize, finalSize) {
|
||
|
this._block = new Buffer(blockSize) //new Uint32Array(blockSize/4)
|
||
|
this._finalSize = finalSize
|
||
|
this._blockSize = blockSize
|
||
|
this._len = 0
|
||
|
this._s = 0
|
||
|
}
|
||
|
|
||
|
Hash.prototype.update = function (data, enc) {
|
||
|
if ("string" === typeof data) {
|
||
|
enc = enc || "utf8"
|
||
|
data = new Buffer(data, enc)
|
||
|
}
|
||
|
|
||
|
var l = this._len += data.length
|
||
|
var s = this._s || 0
|
||
|
var f = 0
|
||
|
var buffer = this._block
|
||
|
|
||
|
while (s < l) {
|
||
|
var t = Math.min(data.length, f + this._blockSize - (s % this._blockSize))
|
||
|
var ch = (t - f)
|
||
|
|
||
|
for (var i = 0; i < ch; i++) {
|
||
|
buffer[(s % this._blockSize) + i] = data[i + f]
|
||
|
}
|
||
|
|
||
|
s += ch
|
||
|
f += ch
|
||
|
|
||
|
if ((s % this._blockSize) === 0) {
|
||
|
this._update(buffer)
|
||
|
}
|
||
|
}
|
||
|
this._s = s
|
||
|
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
Hash.prototype.digest = function (enc) {
|
||
|
// Suppose the length of the message M, in bits, is l
|
||
|
var l = this._len * 8
|
||
|
|
||
|
// Append the bit 1 to the end of the message
|
||
|
this._block[this._len % this._blockSize] = 0x80
|
||
|
|
||
|
// and then k zero bits, where k is the smallest non-negative solution to the equation (l + 1 + k) === finalSize mod blockSize
|
||
|
this._block.fill(0, this._len % this._blockSize + 1)
|
||
|
|
||
|
if (l % (this._blockSize * 8) >= this._finalSize * 8) {
|
||
|
this._update(this._block)
|
||
|
this._block.fill(0)
|
||
|
}
|
||
|
|
||
|
// to this append the block which is equal to the number l written in binary
|
||
|
// TODO: handle case where l is > Math.pow(2, 29)
|
||
|
this._block.writeInt32BE(l, this._blockSize - 4)
|
||
|
|
||
|
var hash = this._update(this._block) || this._hash()
|
||
|
|
||
|
return enc ? hash.toString(enc) : hash
|
||
|
}
|
||
|
|
||
|
Hash.prototype._update = function () {
|
||
|
throw new Error('_update must be implemented by subclass')
|
||
|
}
|
||
|
|
||
|
module.exports = Hash
|
||
|
|
||
|
}).call(this,require("buffer").Buffer)
|
||
|
},{"buffer":1}],6:[function(require,module,exports){
|
||
|
var exports = module.exports = function (alg) {
|
||
|
var Alg = exports[alg.toLowerCase()]
|
||
|
if(!Alg) throw new Error(alg + ' is not supported (we accept pull requests)')
|
||
|
return new Alg()
|
||
|
}
|
||
|
|
||
|
|
||
|
exports.sha = require('./sha')
|
||
|
exports.sha1 = require('./sha1')
|
||
|
exports.sha224 = require('./sha224')
|
||
|
exports.sha256 = require('./sha256')
|
||
|
exports.sha384 = require('./sha384')
|
||
|
exports.sha512 = require('./sha512')
|
||
|
|
||
|
},{"./sha":8,"./sha1":9,"./sha224":10,"./sha256":11,"./sha384":12,"./sha512":13}],7:[function(require,module,exports){
|
||
|
if (typeof Object.create === 'function') {
|
||
|
// implementation from standard node.js 'util' module
|
||
|
module.exports = function inherits(ctor, superCtor) {
|
||
|
ctor.super_ = superCtor
|
||
|
ctor.prototype = Object.create(superCtor.prototype, {
|
||
|
constructor: {
|
||
|
value: ctor,
|
||
|
enumerable: false,
|
||
|
writable: true,
|
||
|
configurable: true
|
||
|
}
|
||
|
});
|
||
|
};
|
||
|
} else {
|
||
|
// old school shim for old browsers
|
||
|
module.exports = function inherits(ctor, superCtor) {
|
||
|
ctor.super_ = superCtor
|
||
|
var TempCtor = function () {}
|
||
|
TempCtor.prototype = superCtor.prototype
|
||
|
ctor.prototype = new TempCtor()
|
||
|
ctor.prototype.constructor = ctor
|
||
|
}
|
||
|
}
|
||
|
|
||
|
},{}],8:[function(require,module,exports){
|
||
|
(function (Buffer){
|
||
|
/*
|
||
|
* A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
|
||
|
* in FIPS PUB 180-1
|
||
|
* This source code is derived from sha1.js of the same repository.
|
||
|
* The difference between SHA-0 and SHA-1 is just a bitwise rotate left
|
||
|
* operation was added.
|
||
|
*/
|
||
|
|
||
|
var inherits = require('inherits')
|
||
|
var Hash = require('./hash')
|
||
|
|
||
|
var W = new Array(80)
|
||
|
|
||
|
function Sha() {
|
||
|
this.init()
|
||
|
this._w = W
|
||
|
|
||
|
Hash.call(this, 64, 56)
|
||
|
}
|
||
|
|
||
|
inherits(Sha, Hash)
|
||
|
|
||
|
Sha.prototype.init = function () {
|
||
|
this._a = 0x67452301
|
||
|
this._b = 0xefcdab89
|
||
|
this._c = 0x98badcfe
|
||
|
this._d = 0x10325476
|
||
|
this._e = 0xc3d2e1f0
|
||
|
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Bitwise rotate a 32-bit number to the left.
|
||
|
*/
|
||
|
function rol(num, cnt) {
|
||
|
return (num << cnt) | (num >>> (32 - cnt));
|
||
|
}
|
||
|
|
||
|
Sha.prototype._update = function (M) {
|
||
|
var W = this._w
|
||
|
|
||
|
var a = this._a
|
||
|
var b = this._b
|
||
|
var c = this._c
|
||
|
var d = this._d
|
||
|
var e = this._e
|
||
|
|
||
|
var j = 0, k
|
||
|
|
||
|
/*
|
||
|
* SHA-1 has a bitwise rotate left operation. But, SHA is not
|
||
|
* function calcW() { return rol(W[j - 3] ^ W[j - 8] ^ W[j - 14] ^ W[j - 16], 1) }
|
||
|
*/
|
||
|
function calcW() { return W[j - 3] ^ W[j - 8] ^ W[j - 14] ^ W[j - 16] }
|
||
|
function loop(w, f) {
|
||
|
W[j] = w
|
||
|
|
||
|
var t = rol(a, 5) + f + e + w + k
|
||
|
|
||
|
e = d
|
||
|
d = c
|
||
|
c = rol(b, 30)
|
||
|
b = a
|
||
|
a = t
|
||
|
j++
|
||
|
}
|
||
|
|
||
|
k = 1518500249
|
||
|
while (j < 16) loop(M.readInt32BE(j * 4), (b & c) | ((~b) & d))
|
||
|
while (j < 20) loop(calcW(), (b & c) | ((~b) & d))
|
||
|
k = 1859775393
|
||
|
while (j < 40) loop(calcW(), b ^ c ^ d)
|
||
|
k = -1894007588
|
||
|
while (j < 60) loop(calcW(), (b & c) | (b & d) | (c & d))
|
||
|
k = -899497514
|
||
|
while (j < 80) loop(calcW(), b ^ c ^ d)
|
||
|
|
||
|
this._a = (a + this._a) | 0
|
||
|
this._b = (b + this._b) | 0
|
||
|
this._c = (c + this._c) | 0
|
||
|
this._d = (d + this._d) | 0
|
||
|
this._e = (e + this._e) | 0
|
||
|
}
|
||
|
|
||
|
Sha.prototype._hash = function () {
|
||
|
var H = new Buffer(20)
|
||
|
|
||
|
H.writeInt32BE(this._a|0, 0)
|
||
|
H.writeInt32BE(this._b|0, 4)
|
||
|
H.writeInt32BE(this._c|0, 8)
|
||
|
H.writeInt32BE(this._d|0, 12)
|
||
|
H.writeInt32BE(this._e|0, 16)
|
||
|
|
||
|
return H
|
||
|
}
|
||
|
|
||
|
module.exports = Sha
|
||
|
|
||
|
|
||
|
}).call(this,require("buffer").Buffer)
|
||
|
},{"./hash":5,"buffer":1,"inherits":7}],9:[function(require,module,exports){
|
||
|
(function (Buffer){
|
||
|
/*
|
||
|
* A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
|
||
|
* in FIPS PUB 180-1
|
||
|
* Version 2.1a Copyright Paul Johnston 2000 - 2002.
|
||
|
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
|
||
|
* Distributed under the BSD License
|
||
|
* See http://pajhome.org.uk/crypt/md5 for details.
|
||
|
*/
|
||
|
|
||
|
var inherits = require('inherits')
|
||
|
var Hash = require('./hash')
|
||
|
|
||
|
var W = new Array(80)
|
||
|
|
||
|
function Sha1() {
|
||
|
this.init()
|
||
|
this._w = W
|
||
|
|
||
|
Hash.call(this, 64, 56)
|
||
|
}
|
||
|
|
||
|
inherits(Sha1, Hash)
|
||
|
|
||
|
Sha1.prototype.init = function () {
|
||
|
this._a = 0x67452301
|
||
|
this._b = 0xefcdab89
|
||
|
this._c = 0x98badcfe
|
||
|
this._d = 0x10325476
|
||
|
this._e = 0xc3d2e1f0
|
||
|
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Bitwise rotate a 32-bit number to the left.
|
||
|
*/
|
||
|
function rol(num, cnt) {
|
||
|
return (num << cnt) | (num >>> (32 - cnt));
|
||
|
}
|
||
|
|
||
|
Sha1.prototype._update = function (M) {
|
||
|
var W = this._w
|
||
|
|
||
|
var a = this._a
|
||
|
var b = this._b
|
||
|
var c = this._c
|
||
|
var d = this._d
|
||
|
var e = this._e
|
||
|
|
||
|
var j = 0, k
|
||
|
|
||
|
function calcW() { return rol(W[j - 3] ^ W[j - 8] ^ W[j - 14] ^ W[j - 16], 1) }
|
||
|
function loop(w, f) {
|
||
|
W[j] = w
|
||
|
|
||
|
var t = rol(a, 5) + f + e + w + k
|
||
|
|
||
|
e = d
|
||
|
d = c
|
||
|
c = rol(b, 30)
|
||
|
b = a
|
||
|
a = t
|
||
|
j++
|
||
|
}
|
||
|
|
||
|
k = 1518500249
|
||
|
while (j < 16) loop(M.readInt32BE(j * 4), (b & c) | ((~b) & d))
|
||
|
while (j < 20) loop(calcW(), (b & c) | ((~b) & d))
|
||
|
k = 1859775393
|
||
|
while (j < 40) loop(calcW(), b ^ c ^ d)
|
||
|
k = -1894007588
|
||
|
while (j < 60) loop(calcW(), (b & c) | (b & d) | (c & d))
|
||
|
k = -899497514
|
||
|
while (j < 80) loop(calcW(), b ^ c ^ d)
|
||
|
|
||
|
this._a = (a + this._a) | 0
|
||
|
this._b = (b + this._b) | 0
|
||
|
this._c = (c + this._c) | 0
|
||
|
this._d = (d + this._d) | 0
|
||
|
this._e = (e + this._e) | 0
|
||
|
}
|
||
|
|
||
|
Sha1.prototype._hash = function () {
|
||
|
var H = new Buffer(20)
|
||
|
|
||
|
H.writeInt32BE(this._a|0, 0)
|
||
|
H.writeInt32BE(this._b|0, 4)
|
||
|
H.writeInt32BE(this._c|0, 8)
|
||
|
H.writeInt32BE(this._d|0, 12)
|
||
|
H.writeInt32BE(this._e|0, 16)
|
||
|
|
||
|
return H
|
||
|
}
|
||
|
|
||
|
module.exports = Sha1
|
||
|
|
||
|
|
||
|
}).call(this,require("buffer").Buffer)
|
||
|
},{"./hash":5,"buffer":1,"inherits":7}],10:[function(require,module,exports){
|
||
|
(function (Buffer){
|
||
|
/**
|
||
|
* A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
|
||
|
* in FIPS 180-2
|
||
|
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
|
||
|
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
|
||
|
*
|
||
|
*/
|
||
|
|
||
|
var inherits = require('inherits')
|
||
|
var SHA256 = require('./sha256')
|
||
|
var Hash = require('./hash')
|
||
|
|
||
|
var W = new Array(64)
|
||
|
|
||
|
function Sha224() {
|
||
|
this.init()
|
||
|
|
||
|
this._w = W // new Array(64)
|
||
|
|
||
|
Hash.call(this, 64, 56)
|
||
|
}
|
||
|
|
||
|
inherits(Sha224, SHA256)
|
||
|
|
||
|
Sha224.prototype.init = function () {
|
||
|
this._a = 0xc1059ed8|0
|
||
|
this._b = 0x367cd507|0
|
||
|
this._c = 0x3070dd17|0
|
||
|
this._d = 0xf70e5939|0
|
||
|
this._e = 0xffc00b31|0
|
||
|
this._f = 0x68581511|0
|
||
|
this._g = 0x64f98fa7|0
|
||
|
this._h = 0xbefa4fa4|0
|
||
|
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
Sha224.prototype._hash = function () {
|
||
|
var H = new Buffer(28)
|
||
|
|
||
|
H.writeInt32BE(this._a, 0)
|
||
|
H.writeInt32BE(this._b, 4)
|
||
|
H.writeInt32BE(this._c, 8)
|
||
|
H.writeInt32BE(this._d, 12)
|
||
|
H.writeInt32BE(this._e, 16)
|
||
|
H.writeInt32BE(this._f, 20)
|
||
|
H.writeInt32BE(this._g, 24)
|
||
|
|
||
|
return H
|
||
|
}
|
||
|
|
||
|
module.exports = Sha224
|
||
|
|
||
|
}).call(this,require("buffer").Buffer)
|
||
|
},{"./hash":5,"./sha256":11,"buffer":1,"inherits":7}],11:[function(require,module,exports){
|
||
|
(function (Buffer){
|
||
|
/**
|
||
|
* A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
|
||
|
* in FIPS 180-2
|
||
|
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
|
||
|
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
|
||
|
*
|
||
|
*/
|
||
|
|
||
|
var inherits = require('inherits')
|
||
|
var Hash = require('./hash')
|
||
|
|
||
|
var K = [
|
||
|
0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
|
||
|
0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
|
||
|
0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
|
||
|
0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
|
||
|
0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
|
||
|
0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
|
||
|
0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
|
||
|
0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
|
||
|
0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
|
||
|
0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
|
||
|
0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
|
||
|
0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
|
||
|
0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
|
||
|
0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
|
||
|
0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
|
||
|
0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
|
||
|
]
|
||
|
|
||
|
var W = new Array(64)
|
||
|
|
||
|
function Sha256() {
|
||
|
this.init()
|
||
|
|
||
|
this._w = W // new Array(64)
|
||
|
|
||
|
Hash.call(this, 64, 56)
|
||
|
}
|
||
|
|
||
|
inherits(Sha256, Hash)
|
||
|
|
||
|
Sha256.prototype.init = function () {
|
||
|
this._a = 0x6a09e667|0
|
||
|
this._b = 0xbb67ae85|0
|
||
|
this._c = 0x3c6ef372|0
|
||
|
this._d = 0xa54ff53a|0
|
||
|
this._e = 0x510e527f|0
|
||
|
this._f = 0x9b05688c|0
|
||
|
this._g = 0x1f83d9ab|0
|
||
|
this._h = 0x5be0cd19|0
|
||
|
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
function S (X, n) {
|
||
|
return (X >>> n) | (X << (32 - n));
|
||
|
}
|
||
|
|
||
|
function R (X, n) {
|
||
|
return (X >>> n);
|
||
|
}
|
||
|
|
||
|
function Ch (x, y, z) {
|
||
|
return ((x & y) ^ ((~x) & z));
|
||
|
}
|
||
|
|
||
|
function Maj (x, y, z) {
|
||
|
return ((x & y) ^ (x & z) ^ (y & z));
|
||
|
}
|
||
|
|
||
|
function Sigma0256 (x) {
|
||
|
return (S(x, 2) ^ S(x, 13) ^ S(x, 22));
|
||
|
}
|
||
|
|
||
|
function Sigma1256 (x) {
|
||
|
return (S(x, 6) ^ S(x, 11) ^ S(x, 25));
|
||
|
}
|
||
|
|
||
|
function Gamma0256 (x) {
|
||
|
return (S(x, 7) ^ S(x, 18) ^ R(x, 3));
|
||
|
}
|
||
|
|
||
|
function Gamma1256 (x) {
|
||
|
return (S(x, 17) ^ S(x, 19) ^ R(x, 10));
|
||
|
}
|
||
|
|
||
|
Sha256.prototype._update = function(M) {
|
||
|
var W = this._w
|
||
|
|
||
|
var a = this._a | 0
|
||
|
var b = this._b | 0
|
||
|
var c = this._c | 0
|
||
|
var d = this._d | 0
|
||
|
var e = this._e | 0
|
||
|
var f = this._f | 0
|
||
|
var g = this._g | 0
|
||
|
var h = this._h | 0
|
||
|
|
||
|
var j = 0
|
||
|
|
||
|
function calcW() { return Gamma1256(W[j - 2]) + W[j - 7] + Gamma0256(W[j - 15]) + W[j - 16] }
|
||
|
function loop(w) {
|
||
|
W[j] = w
|
||
|
|
||
|
var T1 = h + Sigma1256(e) + Ch(e, f, g) + K[j] + w
|
||
|
var T2 = Sigma0256(a) + Maj(a, b, c);
|
||
|
|
||
|
h = g;
|
||
|
g = f;
|
||
|
f = e;
|
||
|
e = d + T1;
|
||
|
d = c;
|
||
|
c = b;
|
||
|
b = a;
|
||
|
a = T1 + T2;
|
||
|
|
||
|
j++
|
||
|
}
|
||
|
|
||
|
while (j < 16) loop(M.readInt32BE(j * 4))
|
||
|
while (j < 64) loop(calcW())
|
||
|
|
||
|
this._a = (a + this._a) | 0
|
||
|
this._b = (b + this._b) | 0
|
||
|
this._c = (c + this._c) | 0
|
||
|
this._d = (d + this._d) | 0
|
||
|
this._e = (e + this._e) | 0
|
||
|
this._f = (f + this._f) | 0
|
||
|
this._g = (g + this._g) | 0
|
||
|
this._h = (h + this._h) | 0
|
||
|
};
|
||
|
|
||
|
Sha256.prototype._hash = function () {
|
||
|
var H = new Buffer(32)
|
||
|
|
||
|
H.writeInt32BE(this._a, 0)
|
||
|
H.writeInt32BE(this._b, 4)
|
||
|
H.writeInt32BE(this._c, 8)
|
||
|
H.writeInt32BE(this._d, 12)
|
||
|
H.writeInt32BE(this._e, 16)
|
||
|
H.writeInt32BE(this._f, 20)
|
||
|
H.writeInt32BE(this._g, 24)
|
||
|
H.writeInt32BE(this._h, 28)
|
||
|
|
||
|
return H
|
||
|
}
|
||
|
|
||
|
module.exports = Sha256
|
||
|
|
||
|
}).call(this,require("buffer").Buffer)
|
||
|
},{"./hash":5,"buffer":1,"inherits":7}],12:[function(require,module,exports){
|
||
|
(function (Buffer){
|
||
|
var inherits = require('inherits')
|
||
|
var SHA512 = require('./sha512');
|
||
|
var Hash = require('./hash')
|
||
|
|
||
|
var W = new Array(160)
|
||
|
|
||
|
function Sha384() {
|
||
|
this.init()
|
||
|
this._w = W
|
||
|
|
||
|
Hash.call(this, 128, 112)
|
||
|
}
|
||
|
|
||
|
inherits(Sha384, SHA512)
|
||
|
|
||
|
Sha384.prototype.init = function () {
|
||
|
this._a = 0xcbbb9d5d|0
|
||
|
this._b = 0x629a292a|0
|
||
|
this._c = 0x9159015a|0
|
||
|
this._d = 0x152fecd8|0
|
||
|
this._e = 0x67332667|0
|
||
|
this._f = 0x8eb44a87|0
|
||
|
this._g = 0xdb0c2e0d|0
|
||
|
this._h = 0x47b5481d|0
|
||
|
|
||
|
this._al = 0xc1059ed8|0
|
||
|
this._bl = 0x367cd507|0
|
||
|
this._cl = 0x3070dd17|0
|
||
|
this._dl = 0xf70e5939|0
|
||
|
this._el = 0xffc00b31|0
|
||
|
this._fl = 0x68581511|0
|
||
|
this._gl = 0x64f98fa7|0
|
||
|
this._hl = 0xbefa4fa4|0
|
||
|
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
Sha384.prototype._hash = function () {
|
||
|
var H = new Buffer(48)
|
||
|
|
||
|
function writeInt64BE(h, l, offset) {
|
||
|
H.writeInt32BE(h, offset)
|
||
|
H.writeInt32BE(l, offset + 4)
|
||
|
}
|
||
|
|
||
|
writeInt64BE(this._a, this._al, 0)
|
||
|
writeInt64BE(this._b, this._bl, 8)
|
||
|
writeInt64BE(this._c, this._cl, 16)
|
||
|
writeInt64BE(this._d, this._dl, 24)
|
||
|
writeInt64BE(this._e, this._el, 32)
|
||
|
writeInt64BE(this._f, this._fl, 40)
|
||
|
|
||
|
return H
|
||
|
}
|
||
|
|
||
|
module.exports = Sha384
|
||
|
|
||
|
}).call(this,require("buffer").Buffer)
|
||
|
},{"./hash":5,"./sha512":13,"buffer":1,"inherits":7}],13:[function(require,module,exports){
|
||
|
(function (Buffer){
|
||
|
var inherits = require('inherits')
|
||
|
var Hash = require('./hash')
|
||
|
|
||
|
var K = [
|
||
|
0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
|
||
|
0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
|
||
|
0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
|
||
|
0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
|
||
|
0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
|
||
|
0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
|
||
|
0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
|
||
|
0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
|
||
|
0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
|
||
|
0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
|
||
|
0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
|
||
|
0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
|
||
|
0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
|
||
|
0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
|
||
|
0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
|
||
|
0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
|
||
|
0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
|
||
|
0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
|
||
|
0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
|
||
|
0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
|
||
|
0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
|
||
|
0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
|
||
|
0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
|
||
|
0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
|
||
|
0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
|
||
|
0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
|
||
|
0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
|
||
|
0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
|
||
|
0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
|
||
|
0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
|
||
|
0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
|
||
|
0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
|
||
|
0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
|
||
|
0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
|
||
|
0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
|
||
|
0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
|
||
|
0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
|
||
|
0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
|
||
|
0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
|
||
|
0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
|
||
|
]
|
||
|
|
||
|
var W = new Array(160)
|
||
|
|
||
|
function Sha512() {
|
||
|
this.init()
|
||
|
this._w = W
|
||
|
|
||
|
Hash.call(this, 128, 112)
|
||
|
}
|
||
|
|
||
|
inherits(Sha512, Hash)
|
||
|
|
||
|
Sha512.prototype.init = function () {
|
||
|
this._a = 0x6a09e667|0
|
||
|
this._b = 0xbb67ae85|0
|
||
|
this._c = 0x3c6ef372|0
|
||
|
this._d = 0xa54ff53a|0
|
||
|
this._e = 0x510e527f|0
|
||
|
this._f = 0x9b05688c|0
|
||
|
this._g = 0x1f83d9ab|0
|
||
|
this._h = 0x5be0cd19|0
|
||
|
|
||
|
this._al = 0xf3bcc908|0
|
||
|
this._bl = 0x84caa73b|0
|
||
|
this._cl = 0xfe94f82b|0
|
||
|
this._dl = 0x5f1d36f1|0
|
||
|
this._el = 0xade682d1|0
|
||
|
this._fl = 0x2b3e6c1f|0
|
||
|
this._gl = 0xfb41bd6b|0
|
||
|
this._hl = 0x137e2179|0
|
||
|
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
function S (X, Xl, n) {
|
||
|
return (X >>> n) | (Xl << (32 - n))
|
||
|
}
|
||
|
|
||
|
function Ch (x, y, z) {
|
||
|
return ((x & y) ^ ((~x) & z));
|
||
|
}
|
||
|
|
||
|
function Maj (x, y, z) {
|
||
|
return ((x & y) ^ (x & z) ^ (y & z));
|
||
|
}
|
||
|
|
||
|
Sha512.prototype._update = function(M) {
|
||
|
var W = this._w
|
||
|
|
||
|
var a = this._a | 0
|
||
|
var b = this._b | 0
|
||
|
var c = this._c | 0
|
||
|
var d = this._d | 0
|
||
|
var e = this._e | 0
|
||
|
var f = this._f | 0
|
||
|
var g = this._g | 0
|
||
|
var h = this._h | 0
|
||
|
|
||
|
var al = this._al | 0
|
||
|
var bl = this._bl | 0
|
||
|
var cl = this._cl | 0
|
||
|
var dl = this._dl | 0
|
||
|
var el = this._el | 0
|
||
|
var fl = this._fl | 0
|
||
|
var gl = this._gl | 0
|
||
|
var hl = this._hl | 0
|
||
|
|
||
|
var i = 0, j = 0
|
||
|
var Wi, Wil
|
||
|
function calcW() {
|
||
|
var x = W[j - 15*2]
|
||
|
var xl = W[j - 15*2 + 1]
|
||
|
var gamma0 = S(x, xl, 1) ^ S(x, xl, 8) ^ (x >>> 7)
|
||
|
var gamma0l = S(xl, x, 1) ^ S(xl, x, 8) ^ S(xl, x, 7)
|
||
|
|
||
|
x = W[j - 2*2]
|
||
|
xl = W[j - 2*2 + 1]
|
||
|
var gamma1 = S(x, xl, 19) ^ S(xl, x, 29) ^ (x >>> 6)
|
||
|
var gamma1l = S(xl, x, 19) ^ S(x, xl, 29) ^ S(xl, x, 6)
|
||
|
|
||
|
// W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
|
||
|
var Wi7 = W[j - 7*2]
|
||
|
var Wi7l = W[j - 7*2 + 1]
|
||
|
|
||
|
var Wi16 = W[j - 16*2]
|
||
|
var Wi16l = W[j - 16*2 + 1]
|
||
|
|
||
|
Wil = gamma0l + Wi7l
|
||
|
Wi = gamma0 + Wi7 + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0)
|
||
|
Wil = Wil + gamma1l
|
||
|
Wi = Wi + gamma1 + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0)
|
||
|
Wil = Wil + Wi16l
|
||
|
Wi = Wi + Wi16 + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0)
|
||
|
}
|
||
|
|
||
|
function loop() {
|
||
|
W[j] = Wi
|
||
|
W[j + 1] = Wil
|
||
|
|
||
|
var maj = Maj(a, b, c)
|
||
|
var majl = Maj(al, bl, cl)
|
||
|
|
||
|
var sigma0h = S(a, al, 28) ^ S(al, a, 2) ^ S(al, a, 7)
|
||
|
var sigma0l = S(al, a, 28) ^ S(a, al, 2) ^ S(a, al, 7)
|
||
|
var sigma1h = S(e, el, 14) ^ S(e, el, 18) ^ S(el, e, 9)
|
||
|
var sigma1l = S(el, e, 14) ^ S(el, e, 18) ^ S(e, el, 9)
|
||
|
|
||
|
// t1 = h + sigma1 + ch + K[i] + W[i]
|
||
|
var Ki = K[j]
|
||
|
var Kil = K[j + 1]
|
||
|
|
||
|
var ch = Ch(e, f, g)
|
||
|
var chl = Ch(el, fl, gl)
|
||
|
|
||
|
var t1l = hl + sigma1l
|
||
|
var t1 = h + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0)
|
||
|
t1l = t1l + chl
|
||
|
t1 = t1 + ch + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0)
|
||
|
t1l = t1l + Kil
|
||
|
t1 = t1 + Ki + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0)
|
||
|
t1l = t1l + Wil
|
||
|
t1 = t1 + Wi + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0)
|
||
|
|
||
|
// t2 = sigma0 + maj
|
||
|
var t2l = sigma0l + majl
|
||
|
var t2 = sigma0h + maj + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0)
|
||
|
|
||
|
h = g
|
||
|
hl = gl
|
||
|
g = f
|
||
|
gl = fl
|
||
|
f = e
|
||
|
fl = el
|
||
|
el = (dl + t1l) | 0
|
||
|
e = (d + t1 + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0
|
||
|
d = c
|
||
|
dl = cl
|
||
|
c = b
|
||
|
cl = bl
|
||
|
b = a
|
||
|
bl = al
|
||
|
al = (t1l + t2l) | 0
|
||
|
a = (t1 + t2 + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0
|
||
|
|
||
|
i++
|
||
|
j += 2
|
||
|
}
|
||
|
|
||
|
while (i < 16) {
|
||
|
Wi = M.readInt32BE(j * 4)
|
||
|
Wil = M.readInt32BE(j * 4 + 4)
|
||
|
|
||
|
loop()
|
||
|
}
|
||
|
|
||
|
while (i < 80) {
|
||
|
calcW()
|
||
|
loop()
|
||
|
}
|
||
|
|
||
|
this._al = (this._al + al) | 0
|
||
|
this._bl = (this._bl + bl) | 0
|
||
|
this._cl = (this._cl + cl) | 0
|
||
|
this._dl = (this._dl + dl) | 0
|
||
|
this._el = (this._el + el) | 0
|
||
|
this._fl = (this._fl + fl) | 0
|
||
|
this._gl = (this._gl + gl) | 0
|
||
|
this._hl = (this._hl + hl) | 0
|
||
|
|
||
|
this._a = (this._a + a + ((this._al >>> 0) < (al >>> 0) ? 1 : 0)) | 0
|
||
|
this._b = (this._b + b + ((this._bl >>> 0) < (bl >>> 0) ? 1 : 0)) | 0
|
||
|
this._c = (this._c + c + ((this._cl >>> 0) < (cl >>> 0) ? 1 : 0)) | 0
|
||
|
this._d = (this._d + d + ((this._dl >>> 0) < (dl >>> 0) ? 1 : 0)) | 0
|
||
|
this._e = (this._e + e + ((this._el >>> 0) < (el >>> 0) ? 1 : 0)) | 0
|
||
|
this._f = (this._f + f + ((this._fl >>> 0) < (fl >>> 0) ? 1 : 0)) | 0
|
||
|
this._g = (this._g + g + ((this._gl >>> 0) < (gl >>> 0) ? 1 : 0)) | 0
|
||
|
this._h = (this._h + h + ((this._hl >>> 0) < (hl >>> 0) ? 1 : 0)) | 0
|
||
|
}
|
||
|
|
||
|
Sha512.prototype._hash = function () {
|
||
|
var H = new Buffer(64)
|
||
|
|
||
|
function writeInt64BE(h, l, offset) {
|
||
|
H.writeInt32BE(h, offset)
|
||
|
H.writeInt32BE(l, offset + 4)
|
||
|
}
|
||
|
|
||
|
writeInt64BE(this._a, this._al, 0)
|
||
|
writeInt64BE(this._b, this._bl, 8)
|
||
|
writeInt64BE(this._c, this._cl, 16)
|
||
|
writeInt64BE(this._d, this._dl, 24)
|
||
|
writeInt64BE(this._e, this._el, 32)
|
||
|
writeInt64BE(this._f, this._fl, 40)
|
||
|
writeInt64BE(this._g, this._gl, 48)
|
||
|
writeInt64BE(this._h, this._hl, 56)
|
||
|
|
||
|
return H
|
||
|
}
|
||
|
|
||
|
module.exports = Sha512
|
||
|
|
||
|
}).call(this,require("buffer").Buffer)
|
||
|
},{"./hash":5,"buffer":1,"inherits":7}],14:[function(require,module,exports){
|
||
|
Elm.Native.Sha = {};
|
||
|
Elm.Native.Sha.make = function(elm) {
|
||
|
elm.Native = elm.Native || {};
|
||
|
elm.Native.Sha = elm.Native.Sha || {};
|
||
|
if (elm.Native.Sha.values) {
|
||
|
return elm.Native.Sha.values;
|
||
|
}
|
||
|
|
||
|
function update(data, inputEncoding, algorithm) {
|
||
|
return algorithm.update(data, inputEncoding);
|
||
|
}
|
||
|
|
||
|
function digest(encoding, hash) {
|
||
|
return hash.digest(encoding);
|
||
|
}
|
||
|
|
||
|
return Elm.Native.Sha.values = {
|
||
|
createHash: require('sha.js'),
|
||
|
update: F3(update),
|
||
|
digest: F2(digest)
|
||
|
};
|
||
|
};
|
||
|
},{"sha.js":6}]},{},[14]);
|
||
|
;
|
||
|
|
||
|
Elm.Native.Show = {};
|
||
|
Elm.Native.Show.make = function(localRuntime) {
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Show = localRuntime.Native.Show || {};
|
||
|
if (localRuntime.Native.Show.values)
|
||
|
{
|
||
|
return localRuntime.Native.Show.values;
|
||
|
}
|
||
|
|
||
|
var _Array;
|
||
|
var Dict;
|
||
|
var List;
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
var toString = function(v)
|
||
|
{
|
||
|
var type = typeof v;
|
||
|
if (type === "function")
|
||
|
{
|
||
|
var name = v.func ? v.func.name : v.name;
|
||
|
return '<function' + (name === '' ? '' : ': ') + name + '>';
|
||
|
}
|
||
|
else if (type === "boolean")
|
||
|
{
|
||
|
return v ? "True" : "False";
|
||
|
}
|
||
|
else if (type === "number")
|
||
|
{
|
||
|
return v + "";
|
||
|
}
|
||
|
else if ((v instanceof String) && v.isChar)
|
||
|
{
|
||
|
return "'" + addSlashes(v, true) + "'";
|
||
|
}
|
||
|
else if (type === "string")
|
||
|
{
|
||
|
return '"' + addSlashes(v, false) + '"';
|
||
|
}
|
||
|
else if (type === "object" && '_' in v && probablyPublic(v))
|
||
|
{
|
||
|
var output = [];
|
||
|
for (var k in v._)
|
||
|
{
|
||
|
for (var i = v._[k].length; i--; )
|
||
|
{
|
||
|
output.push(k + " = " + toString(v._[k][i]));
|
||
|
}
|
||
|
}
|
||
|
for (var k in v)
|
||
|
{
|
||
|
if (k === '_') continue;
|
||
|
output.push(k + " = " + toString(v[k]));
|
||
|
}
|
||
|
if (output.length === 0)
|
||
|
{
|
||
|
return "{}";
|
||
|
}
|
||
|
return "{ " + output.join(", ") + " }";
|
||
|
}
|
||
|
else if (type === "object" && 'ctor' in v)
|
||
|
{
|
||
|
if (v.ctor.substring(0,6) === "_Tuple")
|
||
|
{
|
||
|
var output = [];
|
||
|
for (var k in v)
|
||
|
{
|
||
|
if (k === 'ctor') continue;
|
||
|
output.push(toString(v[k]));
|
||
|
}
|
||
|
return "(" + output.join(",") + ")";
|
||
|
}
|
||
|
else if (v.ctor === "_Array")
|
||
|
{
|
||
|
if (!_Array)
|
||
|
{
|
||
|
_Array = Elm.Array.make(localRuntime);
|
||
|
}
|
||
|
var list = _Array.toList(v);
|
||
|
return "Array.fromList " + toString(list);
|
||
|
}
|
||
|
else if (v.ctor === "::")
|
||
|
{
|
||
|
var output = '[' + toString(v._0);
|
||
|
v = v._1;
|
||
|
while (v.ctor === "::")
|
||
|
{
|
||
|
output += "," + toString(v._0);
|
||
|
v = v._1;
|
||
|
}
|
||
|
return output + ']';
|
||
|
}
|
||
|
else if (v.ctor === "[]")
|
||
|
{
|
||
|
return "[]";
|
||
|
}
|
||
|
else if (v.ctor === "RBNode" || v.ctor === "RBEmpty")
|
||
|
{
|
||
|
if (!Dict)
|
||
|
{
|
||
|
Dict = Elm.Dict.make(localRuntime);
|
||
|
}
|
||
|
if (!List)
|
||
|
{
|
||
|
List = Elm.List.make(localRuntime);
|
||
|
}
|
||
|
var list = Dict.toList(v);
|
||
|
var name = "Dict";
|
||
|
if (list.ctor === "::" && list._0._1.ctor === "_Tuple0")
|
||
|
{
|
||
|
name = "Set";
|
||
|
list = A2(List.map, function(x){return x._0}, list);
|
||
|
}
|
||
|
return name + ".fromList " + toString(list);
|
||
|
}
|
||
|
else if (v.ctor.slice(0,5) === "Text:")
|
||
|
{
|
||
|
return '<text>'
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
var output = "";
|
||
|
for (var i in v)
|
||
|
{
|
||
|
if (i === 'ctor') continue;
|
||
|
var str = toString(v[i]);
|
||
|
var parenless = str[0] === '{' || str[0] === '<' || str.indexOf(' ') < 0;
|
||
|
output += ' ' + (parenless ? str : '(' + str + ')');
|
||
|
}
|
||
|
return v.ctor + output;
|
||
|
}
|
||
|
}
|
||
|
if (type === 'object' && 'notify' in v && 'id' in v)
|
||
|
{
|
||
|
return 'initialValue' in v
|
||
|
? '<Signal>'
|
||
|
: '<Stream>';
|
||
|
}
|
||
|
return "<internal structure>";
|
||
|
};
|
||
|
|
||
|
function addSlashes(str, isChar)
|
||
|
{
|
||
|
var s = str.replace(/\\/g, '\\\\')
|
||
|
.replace(/\n/g, '\\n')
|
||
|
.replace(/\t/g, '\\t')
|
||
|
.replace(/\r/g, '\\r')
|
||
|
.replace(/\v/g, '\\v')
|
||
|
.replace(/\0/g, '\\0');
|
||
|
if (isChar)
|
||
|
{
|
||
|
return s.replace(/\'/g, "\\'")
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return s.replace(/\"/g, '\\"');
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function probablyPublic(v)
|
||
|
{
|
||
|
var keys = Object.keys(v);
|
||
|
var len = keys.length;
|
||
|
if (len === 3
|
||
|
&& 'props' in v
|
||
|
&& 'element' in v)
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
else if (len === 5
|
||
|
&& 'horizontal' in v
|
||
|
&& 'vertical' in v
|
||
|
&& 'x' in v
|
||
|
&& 'y' in v)
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
else if (len === 7
|
||
|
&& 'theta' in v
|
||
|
&& 'scale' in v
|
||
|
&& 'x' in v
|
||
|
&& 'y' in v
|
||
|
&& 'alpha' in v
|
||
|
&& 'form' in v)
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
return localRuntime.Native.Show.values = {
|
||
|
toString: toString
|
||
|
};
|
||
|
};
|
||
|
|
||
|
Elm.Native.Signal = {};
|
||
|
Elm.Native.Signal.make = function(localRuntime) {
|
||
|
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Signal = localRuntime.Native.Signal || {};
|
||
|
if (localRuntime.Native.Signal.values)
|
||
|
{
|
||
|
return localRuntime.Native.Signal.values;
|
||
|
}
|
||
|
|
||
|
|
||
|
var Task = Elm.Native.Task.make(localRuntime);
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
|
||
|
function broadcastToKids(node, timestamp, update)
|
||
|
{
|
||
|
var kids = node.kids;
|
||
|
for (var i = kids.length; i--; )
|
||
|
{
|
||
|
kids[i].notify(timestamp, update, node.id);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// INPUT
|
||
|
|
||
|
function input(name, base)
|
||
|
{
|
||
|
var node = {
|
||
|
id: Utils.guid(),
|
||
|
name: 'input-' + name,
|
||
|
value: base,
|
||
|
parents: [],
|
||
|
kids: []
|
||
|
};
|
||
|
|
||
|
node.notify = function(timestamp, targetId, value) {
|
||
|
var update = targetId === node.id;
|
||
|
if (update)
|
||
|
{
|
||
|
node.value = value;
|
||
|
}
|
||
|
broadcastToKids(node, timestamp, update);
|
||
|
return update;
|
||
|
};
|
||
|
|
||
|
localRuntime.inputs.push(node);
|
||
|
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
function constant(value)
|
||
|
{
|
||
|
return input('constant', value);
|
||
|
}
|
||
|
|
||
|
|
||
|
// MAILBOX
|
||
|
|
||
|
function mailbox(base)
|
||
|
{
|
||
|
var signal = input('mailbox', base);
|
||
|
|
||
|
function send(value) {
|
||
|
return Task.asyncFunction(function(callback) {
|
||
|
localRuntime.setTimeout(function() {
|
||
|
localRuntime.notify(signal.id, value);
|
||
|
}, 0);
|
||
|
callback(Task.succeed(Utils.Tuple0));
|
||
|
});
|
||
|
}
|
||
|
|
||
|
return {
|
||
|
_: {},
|
||
|
signal: signal,
|
||
|
address: {
|
||
|
ctor: 'Address',
|
||
|
_0: send
|
||
|
}
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function sendMessage(message)
|
||
|
{
|
||
|
Task.perform(message._0);
|
||
|
}
|
||
|
|
||
|
|
||
|
// OUTPUT
|
||
|
|
||
|
function output(name, handler, parent)
|
||
|
{
|
||
|
var node = {
|
||
|
id: Utils.guid(),
|
||
|
name: 'output-' + name,
|
||
|
parents: [parent],
|
||
|
isOutput: true
|
||
|
};
|
||
|
|
||
|
node.notify = function(timestamp, parentUpdate, parentID)
|
||
|
{
|
||
|
if (parentUpdate)
|
||
|
{
|
||
|
handler(parent.value);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
parent.kids.push(node);
|
||
|
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
|
||
|
// MAP
|
||
|
|
||
|
function mapMany(refreshValue, args)
|
||
|
{
|
||
|
var node = {
|
||
|
id: Utils.guid(),
|
||
|
name: 'map' + args.length,
|
||
|
value: refreshValue(),
|
||
|
parents: args,
|
||
|
kids: []
|
||
|
};
|
||
|
|
||
|
var numberOfParents = args.length;
|
||
|
var count = 0;
|
||
|
var update = false;
|
||
|
|
||
|
node.notify = function(timestamp, parentUpdate, parentID)
|
||
|
{
|
||
|
++count;
|
||
|
|
||
|
update = update || parentUpdate;
|
||
|
|
||
|
if (count === numberOfParents)
|
||
|
{
|
||
|
if (update)
|
||
|
{
|
||
|
node.value = refreshValue();
|
||
|
}
|
||
|
broadcastToKids(node, timestamp, update);
|
||
|
update = false;
|
||
|
count = 0;
|
||
|
}
|
||
|
};
|
||
|
|
||
|
for (var i = numberOfParents; i--; )
|
||
|
{
|
||
|
args[i].kids.push(node);
|
||
|
}
|
||
|
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
|
||
|
function map(func, a)
|
||
|
{
|
||
|
function refreshValue()
|
||
|
{
|
||
|
return func(a.value);
|
||
|
}
|
||
|
return mapMany(refreshValue, [a]);
|
||
|
}
|
||
|
|
||
|
|
||
|
function map2(func, a, b)
|
||
|
{
|
||
|
function refreshValue()
|
||
|
{
|
||
|
return A2( func, a.value, b.value );
|
||
|
}
|
||
|
return mapMany(refreshValue, [a,b]);
|
||
|
}
|
||
|
|
||
|
|
||
|
function map3(func, a, b, c)
|
||
|
{
|
||
|
function refreshValue()
|
||
|
{
|
||
|
return A3( func, a.value, b.value, c.value );
|
||
|
}
|
||
|
return mapMany(refreshValue, [a,b,c]);
|
||
|
}
|
||
|
|
||
|
|
||
|
function map4(func, a, b, c, d)
|
||
|
{
|
||
|
function refreshValue()
|
||
|
{
|
||
|
return A4( func, a.value, b.value, c.value, d.value );
|
||
|
}
|
||
|
return mapMany(refreshValue, [a,b,c,d]);
|
||
|
}
|
||
|
|
||
|
|
||
|
function map5(func, a, b, c, d, e)
|
||
|
{
|
||
|
function refreshValue()
|
||
|
{
|
||
|
return A5( func, a.value, b.value, c.value, d.value, e.value );
|
||
|
}
|
||
|
return mapMany(refreshValue, [a,b,c,d,e]);
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
// FOLD
|
||
|
|
||
|
function foldp(update, state, signal)
|
||
|
{
|
||
|
var node = {
|
||
|
id: Utils.guid(),
|
||
|
name: 'foldp',
|
||
|
parents: [signal],
|
||
|
kids: [],
|
||
|
value: state
|
||
|
};
|
||
|
|
||
|
node.notify = function(timestamp, parentUpdate, parentID)
|
||
|
{
|
||
|
if (parentUpdate)
|
||
|
{
|
||
|
node.value = A2( update, signal.value, node.value );
|
||
|
}
|
||
|
broadcastToKids(node, timestamp, parentUpdate);
|
||
|
};
|
||
|
|
||
|
signal.kids.push(node);
|
||
|
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
|
||
|
// TIME
|
||
|
|
||
|
function timestamp(signal)
|
||
|
{
|
||
|
var node = {
|
||
|
id: Utils.guid(),
|
||
|
name: 'timestamp',
|
||
|
value: Utils.Tuple2(localRuntime.timer.programStart, signal.value),
|
||
|
parents: [signal],
|
||
|
kids: []
|
||
|
};
|
||
|
|
||
|
node.notify = function(timestamp, parentUpdate, parentID)
|
||
|
{
|
||
|
if (parentUpdate)
|
||
|
{
|
||
|
node.value = Utils.Tuple2(timestamp, signal.value);
|
||
|
}
|
||
|
broadcastToKids(node, timestamp, parentUpdate);
|
||
|
};
|
||
|
|
||
|
signal.kids.push(node);
|
||
|
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
|
||
|
function delay(time, signal)
|
||
|
{
|
||
|
var delayed = input('delay-input-' + time, signal.value);
|
||
|
|
||
|
function handler(value)
|
||
|
{
|
||
|
setTimeout(function() {
|
||
|
localRuntime.notify(delayed.id, value);
|
||
|
}, time);
|
||
|
}
|
||
|
|
||
|
output('delay-output-' + time, handler, signal);
|
||
|
|
||
|
return delayed;
|
||
|
}
|
||
|
|
||
|
|
||
|
// MERGING
|
||
|
|
||
|
function genericMerge(tieBreaker, leftStream, rightStream)
|
||
|
{
|
||
|
var node = {
|
||
|
id: Utils.guid(),
|
||
|
name: 'merge',
|
||
|
value: A2(tieBreaker, leftStream.value, rightStream.value),
|
||
|
parents: [leftStream, rightStream],
|
||
|
kids: []
|
||
|
};
|
||
|
|
||
|
var left = { touched: false, update: false, value: null };
|
||
|
var right = { touched: false, update: false, value: null };
|
||
|
|
||
|
node.notify = function(timestamp, parentUpdate, parentID)
|
||
|
{
|
||
|
if (parentID === leftStream.id)
|
||
|
{
|
||
|
left.touched = true;
|
||
|
left.update = parentUpdate;
|
||
|
left.value = leftStream.value;
|
||
|
}
|
||
|
if (parentID === rightStream.id)
|
||
|
{
|
||
|
right.touched = true;
|
||
|
right.update = parentUpdate;
|
||
|
right.value = rightStream.value;
|
||
|
}
|
||
|
|
||
|
if (left.touched && right.touched)
|
||
|
{
|
||
|
var update = false;
|
||
|
if (left.update && right.update)
|
||
|
{
|
||
|
node.value = A2(tieBreaker, left.value, right.value);
|
||
|
update = true;
|
||
|
}
|
||
|
else if (left.update)
|
||
|
{
|
||
|
node.value = left.value;
|
||
|
update = true;
|
||
|
}
|
||
|
else if (right.update)
|
||
|
{
|
||
|
node.value = right.value;
|
||
|
update = true;
|
||
|
}
|
||
|
left.touched = false;
|
||
|
right.touched = false;
|
||
|
|
||
|
broadcastToKids(node, timestamp, update);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
leftStream.kids.push(node);
|
||
|
rightStream.kids.push(node);
|
||
|
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
|
||
|
// FILTERING
|
||
|
|
||
|
function filterMap(toMaybe, base, signal)
|
||
|
{
|
||
|
var maybe = toMaybe(signal.value);
|
||
|
var node = {
|
||
|
id: Utils.guid(),
|
||
|
name: 'filterMap',
|
||
|
value: maybe.ctor === 'Nothing' ? base : maybe._0,
|
||
|
parents: [signal],
|
||
|
kids: []
|
||
|
};
|
||
|
|
||
|
node.notify = function(timestamp, parentUpdate, parentID)
|
||
|
{
|
||
|
var update = false;
|
||
|
if (parentUpdate)
|
||
|
{
|
||
|
var maybe = toMaybe(signal.value);
|
||
|
if (maybe.ctor === 'Just')
|
||
|
{
|
||
|
update = true;
|
||
|
node.value = maybe._0;
|
||
|
}
|
||
|
}
|
||
|
broadcastToKids(node, timestamp, update);
|
||
|
};
|
||
|
|
||
|
signal.kids.push(node);
|
||
|
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
|
||
|
// SAMPLING
|
||
|
|
||
|
function sampleOn(ticker, signal)
|
||
|
{
|
||
|
var node = {
|
||
|
id: Utils.guid(),
|
||
|
name: 'sampleOn',
|
||
|
value: signal.value,
|
||
|
parents: [ticker, signal],
|
||
|
kids: []
|
||
|
};
|
||
|
|
||
|
var signalTouch = false;
|
||
|
var tickerTouch = false;
|
||
|
var tickerUpdate = false;
|
||
|
|
||
|
node.notify = function(timestamp, parentUpdate, parentID)
|
||
|
{
|
||
|
if (parentID === ticker.id)
|
||
|
{
|
||
|
tickerTouch = true;
|
||
|
tickerUpdate = parentUpdate;
|
||
|
}
|
||
|
if (parentID === signal.id)
|
||
|
{
|
||
|
signalTouch = true;
|
||
|
}
|
||
|
|
||
|
if (tickerTouch && signalTouch)
|
||
|
{
|
||
|
if (tickerUpdate)
|
||
|
{
|
||
|
node.value = signal.value;
|
||
|
}
|
||
|
tickerTouch = false;
|
||
|
signalTouch = false;
|
||
|
|
||
|
broadcastToKids(node, timestamp, tickerUpdate);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
ticker.kids.push(node);
|
||
|
signal.kids.push(node);
|
||
|
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
|
||
|
// DROP REPEATS
|
||
|
|
||
|
function dropRepeats(signal)
|
||
|
{
|
||
|
var node = {
|
||
|
id: Utils.guid(),
|
||
|
name: 'dropRepeats',
|
||
|
value: signal.value,
|
||
|
parents: [signal],
|
||
|
kids: []
|
||
|
};
|
||
|
|
||
|
node.notify = function(timestamp, parentUpdate, parentID)
|
||
|
{
|
||
|
var update = false;
|
||
|
if (parentUpdate && !Utils.eq(node.value, signal.value))
|
||
|
{
|
||
|
node.value = signal.value;
|
||
|
update = true;
|
||
|
}
|
||
|
broadcastToKids(node, timestamp, update);
|
||
|
};
|
||
|
|
||
|
signal.kids.push(node);
|
||
|
|
||
|
return node;
|
||
|
}
|
||
|
|
||
|
|
||
|
return localRuntime.Native.Signal.values = {
|
||
|
input: input,
|
||
|
constant: constant,
|
||
|
mailbox: mailbox,
|
||
|
sendMessage: sendMessage,
|
||
|
output: output,
|
||
|
map: F2(map),
|
||
|
map2: F3(map2),
|
||
|
map3: F4(map3),
|
||
|
map4: F5(map4),
|
||
|
map5: F6(map5),
|
||
|
foldp: F3(foldp),
|
||
|
genericMerge: F3(genericMerge),
|
||
|
filterMap: F3(filterMap),
|
||
|
sampleOn: F2(sampleOn),
|
||
|
dropRepeats: dropRepeats,
|
||
|
timestamp: timestamp,
|
||
|
delay: F2(delay)
|
||
|
};
|
||
|
};
|
||
|
|
||
|
Elm.Native.String = {};
|
||
|
Elm.Native.String.make = function(localRuntime) {
|
||
|
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.String = localRuntime.Native.String || {};
|
||
|
if (localRuntime.Native.String.values)
|
||
|
{
|
||
|
return localRuntime.Native.String.values;
|
||
|
}
|
||
|
if ('values' in Elm.Native.String)
|
||
|
{
|
||
|
return localRuntime.Native.String.values = Elm.Native.String.values;
|
||
|
}
|
||
|
|
||
|
|
||
|
var Char = Elm.Char.make(localRuntime);
|
||
|
var List = Elm.Native.List.make(localRuntime);
|
||
|
var Maybe = Elm.Maybe.make(localRuntime);
|
||
|
var Result = Elm.Result.make(localRuntime);
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
function isEmpty(str)
|
||
|
{
|
||
|
return str.length === 0;
|
||
|
}
|
||
|
function cons(chr,str)
|
||
|
{
|
||
|
return chr + str;
|
||
|
}
|
||
|
function uncons(str)
|
||
|
{
|
||
|
var hd;
|
||
|
return (hd = str[0])
|
||
|
? Maybe.Just(Utils.Tuple2(Utils.chr(hd), str.slice(1)))
|
||
|
: Maybe.Nothing;
|
||
|
}
|
||
|
function append(a,b)
|
||
|
{
|
||
|
return a + b;
|
||
|
}
|
||
|
function concat(strs)
|
||
|
{
|
||
|
return List.toArray(strs).join('');
|
||
|
}
|
||
|
function length(str)
|
||
|
{
|
||
|
return str.length;
|
||
|
}
|
||
|
function map(f,str)
|
||
|
{
|
||
|
var out = str.split('');
|
||
|
for (var i = out.length; i--; )
|
||
|
{
|
||
|
out[i] = f(Utils.chr(out[i]));
|
||
|
}
|
||
|
return out.join('');
|
||
|
}
|
||
|
function filter(pred,str)
|
||
|
{
|
||
|
return str.split('').map(Utils.chr).filter(pred).join('');
|
||
|
}
|
||
|
function reverse(str)
|
||
|
{
|
||
|
return str.split('').reverse().join('');
|
||
|
}
|
||
|
function foldl(f,b,str)
|
||
|
{
|
||
|
var len = str.length;
|
||
|
for (var i = 0; i < len; ++i)
|
||
|
{
|
||
|
b = A2(f, Utils.chr(str[i]), b);
|
||
|
}
|
||
|
return b;
|
||
|
}
|
||
|
function foldr(f,b,str)
|
||
|
{
|
||
|
for (var i = str.length; i--; )
|
||
|
{
|
||
|
b = A2(f, Utils.chr(str[i]), b);
|
||
|
}
|
||
|
return b;
|
||
|
}
|
||
|
|
||
|
function split(sep, str)
|
||
|
{
|
||
|
return List.fromArray(str.split(sep));
|
||
|
}
|
||
|
function join(sep, strs)
|
||
|
{
|
||
|
return List.toArray(strs).join(sep);
|
||
|
}
|
||
|
function repeat(n, str)
|
||
|
{
|
||
|
var result = '';
|
||
|
while (n > 0)
|
||
|
{
|
||
|
if (n & 1)
|
||
|
{
|
||
|
result += str;
|
||
|
}
|
||
|
n >>= 1, str += str;
|
||
|
}
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
function slice(start, end, str)
|
||
|
{
|
||
|
return str.slice(start,end);
|
||
|
}
|
||
|
function left(n, str)
|
||
|
{
|
||
|
return n < 1 ? "" : str.slice(0,n);
|
||
|
}
|
||
|
function right(n, str)
|
||
|
{
|
||
|
return n < 1 ? "" : str.slice(-n);
|
||
|
}
|
||
|
function dropLeft(n, str)
|
||
|
{
|
||
|
return n < 1 ? str : str.slice(n);
|
||
|
}
|
||
|
function dropRight(n, str)
|
||
|
{
|
||
|
return n < 1 ? str : str.slice(0,-n);
|
||
|
}
|
||
|
|
||
|
function pad(n,chr,str)
|
||
|
{
|
||
|
var half = (n - str.length) / 2;
|
||
|
return repeat(Math.ceil(half),chr) + str + repeat(half|0,chr);
|
||
|
}
|
||
|
function padRight(n,chr,str)
|
||
|
{
|
||
|
return str + repeat(n - str.length, chr);
|
||
|
}
|
||
|
function padLeft(n,chr,str)
|
||
|
{
|
||
|
return repeat(n - str.length, chr) + str;
|
||
|
}
|
||
|
|
||
|
function trim(str)
|
||
|
{
|
||
|
return str.trim();
|
||
|
}
|
||
|
function trimLeft(str)
|
||
|
{
|
||
|
return str.trimLeft();
|
||
|
}
|
||
|
function trimRight(str)
|
||
|
{
|
||
|
return str.trimRight();
|
||
|
}
|
||
|
|
||
|
function words(str)
|
||
|
{
|
||
|
return List.fromArray(str.trim().split(/\s+/g));
|
||
|
}
|
||
|
function lines(str)
|
||
|
{
|
||
|
return List.fromArray(str.split(/\r\n|\r|\n/g));
|
||
|
}
|
||
|
|
||
|
function toUpper(str)
|
||
|
{
|
||
|
return str.toUpperCase();
|
||
|
}
|
||
|
function toLower(str)
|
||
|
{
|
||
|
return str.toLowerCase();
|
||
|
}
|
||
|
|
||
|
function any(pred, str)
|
||
|
{
|
||
|
for (var i = str.length; i--; )
|
||
|
{
|
||
|
if (pred(Utils.chr(str[i])))
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
function all(pred, str)
|
||
|
{
|
||
|
for (var i = str.length; i--; )
|
||
|
{
|
||
|
if (!pred(Utils.chr(str[i])))
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
function contains(sub, str)
|
||
|
{
|
||
|
return str.indexOf(sub) > -1;
|
||
|
}
|
||
|
function startsWith(sub, str)
|
||
|
{
|
||
|
return str.indexOf(sub) === 0;
|
||
|
}
|
||
|
function endsWith(sub, str)
|
||
|
{
|
||
|
return str.length >= sub.length &&
|
||
|
str.lastIndexOf(sub) === str.length - sub.length;
|
||
|
}
|
||
|
function indexes(sub, str)
|
||
|
{
|
||
|
var subLen = sub.length;
|
||
|
var i = 0;
|
||
|
var is = [];
|
||
|
while ((i = str.indexOf(sub, i)) > -1)
|
||
|
{
|
||
|
is.push(i);
|
||
|
i = i + subLen;
|
||
|
}
|
||
|
return List.fromArray(is);
|
||
|
}
|
||
|
|
||
|
function toInt(s)
|
||
|
{
|
||
|
var len = s.length;
|
||
|
if (len === 0)
|
||
|
{
|
||
|
return Result.Err("could not convert string '" + s + "' to an Int" );
|
||
|
}
|
||
|
var start = 0;
|
||
|
if (s[0] == '-')
|
||
|
{
|
||
|
if (len === 1)
|
||
|
{
|
||
|
return Result.Err("could not convert string '" + s + "' to an Int" );
|
||
|
}
|
||
|
start = 1;
|
||
|
}
|
||
|
for (var i = start; i < len; ++i)
|
||
|
{
|
||
|
if (!Char.isDigit(s[i]))
|
||
|
{
|
||
|
return Result.Err("could not convert string '" + s + "' to an Int" );
|
||
|
}
|
||
|
}
|
||
|
return Result.Ok(parseInt(s, 10));
|
||
|
}
|
||
|
|
||
|
function toFloat(s)
|
||
|
{
|
||
|
var len = s.length;
|
||
|
if (len === 0)
|
||
|
{
|
||
|
return Result.Err("could not convert string '" + s + "' to a Float" );
|
||
|
}
|
||
|
var start = 0;
|
||
|
if (s[0] == '-')
|
||
|
{
|
||
|
if (len === 1)
|
||
|
{
|
||
|
return Result.Err("could not convert string '" + s + "' to a Float" );
|
||
|
}
|
||
|
start = 1;
|
||
|
}
|
||
|
var dotCount = 0;
|
||
|
for (var i = start; i < len; ++i)
|
||
|
{
|
||
|
if (Char.isDigit(s[i]))
|
||
|
{
|
||
|
continue;
|
||
|
}
|
||
|
if (s[i] === '.')
|
||
|
{
|
||
|
dotCount += 1;
|
||
|
if (dotCount <= 1)
|
||
|
{
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
return Result.Err("could not convert string '" + s + "' to a Float" );
|
||
|
}
|
||
|
return Result.Ok(parseFloat(s));
|
||
|
}
|
||
|
|
||
|
function toList(str)
|
||
|
{
|
||
|
return List.fromArray(str.split('').map(Utils.chr));
|
||
|
}
|
||
|
function fromList(chars)
|
||
|
{
|
||
|
return List.toArray(chars).join('');
|
||
|
}
|
||
|
|
||
|
return Elm.Native.String.values = {
|
||
|
isEmpty: isEmpty,
|
||
|
cons: F2(cons),
|
||
|
uncons: uncons,
|
||
|
append: F2(append),
|
||
|
concat: concat,
|
||
|
length: length,
|
||
|
map: F2(map),
|
||
|
filter: F2(filter),
|
||
|
reverse: reverse,
|
||
|
foldl: F3(foldl),
|
||
|
foldr: F3(foldr),
|
||
|
|
||
|
split: F2(split),
|
||
|
join: F2(join),
|
||
|
repeat: F2(repeat),
|
||
|
|
||
|
slice: F3(slice),
|
||
|
left: F2(left),
|
||
|
right: F2(right),
|
||
|
dropLeft: F2(dropLeft),
|
||
|
dropRight: F2(dropRight),
|
||
|
|
||
|
pad: F3(pad),
|
||
|
padLeft: F3(padLeft),
|
||
|
padRight: F3(padRight),
|
||
|
|
||
|
trim: trim,
|
||
|
trimLeft: trimLeft,
|
||
|
trimRight: trimRight,
|
||
|
|
||
|
words: words,
|
||
|
lines: lines,
|
||
|
|
||
|
toUpper: toUpper,
|
||
|
toLower: toLower,
|
||
|
|
||
|
any: F2(any),
|
||
|
all: F2(all),
|
||
|
|
||
|
contains: F2(contains),
|
||
|
startsWith: F2(startsWith),
|
||
|
endsWith: F2(endsWith),
|
||
|
indexes: F2(indexes),
|
||
|
|
||
|
toInt: toInt,
|
||
|
toFloat: toFloat,
|
||
|
toList: toList,
|
||
|
fromList: fromList
|
||
|
};
|
||
|
};
|
||
|
|
||
|
Elm.Native.Task = {};
|
||
|
Elm.Native.Task.make = function(localRuntime) {
|
||
|
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Task = localRuntime.Native.Task || {};
|
||
|
if (localRuntime.Native.Task.values)
|
||
|
{
|
||
|
return localRuntime.Native.Task.values;
|
||
|
}
|
||
|
|
||
|
var Result = Elm.Result.make(localRuntime);
|
||
|
var Signal;
|
||
|
var Utils = Elm.Native.Utils.make(localRuntime);
|
||
|
|
||
|
|
||
|
// CONSTRUCTORS
|
||
|
|
||
|
function succeed(value)
|
||
|
{
|
||
|
return {
|
||
|
tag: 'Succeed',
|
||
|
value: value
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function fail(error)
|
||
|
{
|
||
|
return {
|
||
|
tag: 'Fail',
|
||
|
value: error
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function asyncFunction(func)
|
||
|
{
|
||
|
return {
|
||
|
tag: 'Async',
|
||
|
asyncFunction: func
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function andThen(task, callback)
|
||
|
{
|
||
|
return {
|
||
|
tag: 'AndThen',
|
||
|
task: task,
|
||
|
callback: callback
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function catch_(task, callback)
|
||
|
{
|
||
|
return {
|
||
|
tag: 'Catch',
|
||
|
task: task,
|
||
|
callback: callback
|
||
|
};
|
||
|
}
|
||
|
|
||
|
|
||
|
// RUNNER
|
||
|
|
||
|
function perform(task) {
|
||
|
runTask({ task: task }, function() {});
|
||
|
}
|
||
|
|
||
|
function performSignal(name, signal)
|
||
|
{
|
||
|
var workQueue = [];
|
||
|
|
||
|
function onComplete()
|
||
|
{
|
||
|
workQueue.shift();
|
||
|
|
||
|
setTimeout(function() {
|
||
|
if (workQueue.length > 0)
|
||
|
{
|
||
|
runTask(workQueue[0], onComplete);
|
||
|
}
|
||
|
}, 0);
|
||
|
}
|
||
|
|
||
|
function register(task)
|
||
|
{
|
||
|
var root = { task: task };
|
||
|
workQueue.push(root);
|
||
|
if (workQueue.length === 1)
|
||
|
{
|
||
|
runTask(root, onComplete);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (!Signal)
|
||
|
{
|
||
|
Signal = Elm.Native.Signal.make(localRuntime);
|
||
|
}
|
||
|
Signal.output('perform-tasks-' + name, register, signal);
|
||
|
|
||
|
register(signal.value);
|
||
|
|
||
|
return signal;
|
||
|
}
|
||
|
|
||
|
function mark(status, task)
|
||
|
{
|
||
|
return { status: status, task: task };
|
||
|
}
|
||
|
|
||
|
function runTask(root, onComplete)
|
||
|
{
|
||
|
var result = mark('runnable', root.task);
|
||
|
while (result.status === 'runnable')
|
||
|
{
|
||
|
result = stepTask(onComplete, root, result.task);
|
||
|
}
|
||
|
|
||
|
if (result.status === 'done')
|
||
|
{
|
||
|
root.task = result.task;
|
||
|
onComplete();
|
||
|
}
|
||
|
|
||
|
if (result.status === 'blocked')
|
||
|
{
|
||
|
root.task = result.task;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function stepTask(onComplete, root, task)
|
||
|
{
|
||
|
var tag = task.tag;
|
||
|
|
||
|
if (tag === 'Succeed' || tag === 'Fail')
|
||
|
{
|
||
|
return mark('done', task);
|
||
|
}
|
||
|
|
||
|
if (tag === 'Async')
|
||
|
{
|
||
|
var placeHolder = {};
|
||
|
var couldBeSync = true;
|
||
|
var wasSync = false;
|
||
|
|
||
|
task.asyncFunction(function(result) {
|
||
|
placeHolder.tag = result.tag;
|
||
|
placeHolder.value = result.value;
|
||
|
if (couldBeSync)
|
||
|
{
|
||
|
wasSync = true;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
runTask(root, onComplete);
|
||
|
}
|
||
|
});
|
||
|
couldBeSync = false;
|
||
|
return mark(wasSync ? 'done' : 'blocked', placeHolder);
|
||
|
}
|
||
|
|
||
|
if (tag === 'AndThen' || tag === 'Catch')
|
||
|
{
|
||
|
var result = mark('runnable', task.task);
|
||
|
while (result.status === 'runnable')
|
||
|
{
|
||
|
result = stepTask(onComplete, root, result.task);
|
||
|
}
|
||
|
|
||
|
if (result.status === 'done')
|
||
|
{
|
||
|
var activeTask = result.task;
|
||
|
var activeTag = activeTask.tag;
|
||
|
|
||
|
var succeedChain = activeTag === 'Succeed' && tag === 'AndThen';
|
||
|
var failChain = activeTag === 'Fail' && tag === 'Catch';
|
||
|
|
||
|
return (succeedChain || failChain)
|
||
|
? mark('runnable', task.callback(activeTask.value))
|
||
|
: mark('runnable', activeTask);
|
||
|
}
|
||
|
if (result.status === 'blocked')
|
||
|
{
|
||
|
return mark('blocked', {
|
||
|
tag: tag,
|
||
|
task: result.task,
|
||
|
callback: task.callback
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// THREADS
|
||
|
|
||
|
function sleep(time) {
|
||
|
return asyncFunction(function(callback) {
|
||
|
setTimeout(function() {
|
||
|
callback(succeed(Utils.Tuple0));
|
||
|
}, time);
|
||
|
});
|
||
|
}
|
||
|
|
||
|
function spawn(task) {
|
||
|
return asyncFunction(function(callback) {
|
||
|
var id = setTimeout(function() {
|
||
|
perform(task);
|
||
|
}, 0);
|
||
|
callback(succeed(id));
|
||
|
});
|
||
|
}
|
||
|
|
||
|
|
||
|
return localRuntime.Native.Task.values = {
|
||
|
succeed: succeed,
|
||
|
fail: fail,
|
||
|
asyncFunction: asyncFunction,
|
||
|
andThen: F2(andThen),
|
||
|
catch_: F2(catch_),
|
||
|
perform: perform,
|
||
|
performSignal: performSignal,
|
||
|
spawn: spawn,
|
||
|
sleep: sleep
|
||
|
};
|
||
|
};
|
||
|
|
||
|
Elm.Native.Text = {};
|
||
|
Elm.Native.Text.make = function(localRuntime) {
|
||
|
localRuntime.Native = localRuntime.Native || {};
|
||
|
localRuntime.Native.Text = localRuntime.Native.Text || {};
|
||
|
if (localRuntime.Native.Text.values)
|
||
|
{
|
||
|
return localRuntime.Native.Text.values;
|
||
|
}
|
||
|
|
||
|
var toCss = Elm.Native.Color.make(localRuntime).toCss;
|
||
|
var List = Elm.Native.List.make(localRuntime);
|
||
|
|
||
|
|
||
|
// CONSTRUCTORS
|
||
|
|
||
|
function fromString(str)
|
||
|
{
|
||
|
return {
|
||
|
ctor: 'Text:Text',
|
||
|
_0: str
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function append(a, b)
|
||
|
{
|
||
|
return {
|
||
|
ctor: 'Text:Append',
|
||
|
_0: a,
|
||
|
_1: b
|
||
|
};
|
||
|
}
|
||
|
|
||
|
function addMeta(field, value, text)
|
||
|
{
|
||
|
var newProps = {};
|
||
|
var newText = {
|
||
|
ctor: 'Text:Meta',
|
||
|
_0: newProps,
|
||
|
_1: text
|
||
|
};
|
||
|
|
||
|
if (text.ctor === 'Text:Meta')
|
||
|
{
|
||
|
newText._1 = text._1;
|
||
|
var props = text._0;
|
||
|
for (var i = metaKeys.length; i--; )
|
||
|
{
|
||
|
var key = metaKeys[i];
|
||
|
var val = props[key];
|
||
|
if (val)
|
||
|
{
|
||
|
newProps[key] = val;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
newProps[field] = value;
|
||
|
return newText;
|
||
|
}
|
||
|
|
||
|
var metaKeys = [
|
||
|
'font-size',
|
||
|
'font-family',
|
||
|
'font-style',
|
||
|
'font-weight',
|
||
|
'href',
|
||
|
'text-decoration',
|
||
|
'color'
|
||
|
];
|
||
|
|
||
|
|
||
|
// conversions from Elm values to CSS
|
||
|
|
||
|
function toTypefaces(list)
|
||
|
{
|
||
|
var typefaces = List.toArray(list);
|
||
|
for (var i = typefaces.length; i--; )
|
||
|
{
|
||
|
var typeface = typefaces[i];
|
||
|
if (typeface.indexOf(' ') > -1)
|
||
|
{
|
||
|
typefaces[i] = "'" + typeface + "'";
|
||
|
}
|
||
|
}
|
||
|
return typefaces.join(',');
|
||
|
}
|
||
|
|
||
|
function toLine(line)
|
||
|
{
|
||
|
var ctor = line.ctor;
|
||
|
return ctor === 'Under'
|
||
|
? 'underline'
|
||
|
: ctor === 'Over'
|
||
|
? 'overline'
|
||
|
: 'line-through';
|
||
|
}
|
||
|
|
||
|
// setting styles of Text
|
||
|
|
||
|
function style(style, text)
|
||
|
{
|
||
|
var newText = addMeta('color', toCss(style.color), text);
|
||
|
var props = newText._0;
|
||
|
|
||
|
if (style.typeface.ctor !== '[]')
|
||
|
{
|
||
|
props['font-family'] = toTypefaces(style.typeface);
|
||
|
}
|
||
|
if (style.height.ctor !== "Nothing")
|
||
|
{
|
||
|
props['font-size'] = style.height._0 + 'px';
|
||
|
}
|
||
|
if (style.bold)
|
||
|
{
|
||
|
props['font-weight'] = 'bold';
|
||
|
}
|
||
|
if (style.italic)
|
||
|
{
|
||
|
props['font-style'] = 'italic';
|
||
|
}
|
||
|
if (style.line.ctor !== 'Nothing')
|
||
|
{
|
||
|
props['text-decoration'] = toLine(style.line._0);
|
||
|
}
|
||
|
return newText;
|
||
|
}
|
||
|
|
||
|
function height(px, text)
|
||
|
{
|
||
|
return addMeta('font-size', px + 'px', text);
|
||
|
}
|
||
|
|
||
|
function typeface(names, text)
|
||
|
{
|
||
|
return addMeta('font-family', toTypefaces(names), text);
|
||
|
}
|
||
|
|
||
|
function monospace(text)
|
||
|
{
|
||
|
return addMeta('font-family', 'monospace', text);
|
||
|
}
|
||
|
|
||
|
function italic(text)
|
||
|
{
|
||
|
return addMeta('font-style', 'italic', text);
|
||
|
}
|
||
|
|
||
|
function bold(text)
|
||
|
{
|
||
|
return addMeta('font-weight', 'bold', text);
|
||
|
}
|
||
|
|
||
|
function link(href, text)
|
||
|
{
|
||
|
return addMeta('href', href, text);
|
||
|
}
|
||
|
|
||
|
function line(line, text)
|
||
|
{
|
||
|
return addMeta('text-decoration', toLine(line), text);
|
||
|
}
|
||
|
|
||
|
function color(color, text)
|
||
|
{
|
||
|
return addMeta('color', toCss(color), text);;
|
||
|
}
|
||
|
|
||
|
|
||
|
// RENDER
|
||
|
|
||
|
function renderHtml(text)
|
||
|
{
|
||
|
var tag = text.ctor;
|
||
|
if (tag === 'Text:Append')
|
||
|
{
|
||
|
return renderHtml(text._0) + renderHtml(text._1);
|
||
|
}
|
||
|
if (tag === 'Text:Text')
|
||
|
{
|
||
|
return properEscape(text._0);
|
||
|
}
|
||
|
if (tag === 'Text:Meta')
|
||
|
{
|
||
|
return renderMeta(text._0, renderHtml(text._1));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function renderMeta(metas, string)
|
||
|
{
|
||
|
var href = metas['href'];
|
||
|
if (href)
|
||
|
{
|
||
|
string = '<a href="' + href + '">' + string + '</a>';
|
||
|
}
|
||
|
var styles = '';
|
||
|
for (var key in metas)
|
||
|
{
|
||
|
if (key === 'href')
|
||
|
{
|
||
|
continue;
|
||
|
}
|
||
|
styles += key + ':' + metas[key] + ';';
|
||
|
}
|
||
|
if (styles)
|
||
|
{
|
||
|
string = '<span style="' + styles + '">' + string + '</span>';
|
||
|
}
|
||
|
return string;
|
||
|
}
|
||
|
|
||
|
function properEscape(str)
|
||
|
{
|
||
|
if (str.length == 0)
|
||
|
{
|
||
|
return str;
|
||
|
}
|
||
|
str = str //.replace(/&/g, "&")
|
||
|
.replace(/"/g, '"')
|
||
|
.replace(/'/g, "'")
|
||
|
.replace(/</g, "<")
|
||
|
.replace(/>/g, ">");
|
||
|
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] = " "
|
||
|
}
|
||
|
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] = ' ';
|
||
|
}
|
||
|
arr[i] = spaces.join('');
|
||
|
}
|
||
|
}
|
||
|
arr = arr.join('');
|
||
|
if (arr[arr.length-1] === " ")
|
||
|
{
|
||
|
return arr.slice(0,-1) + ' ';
|
||
|
}
|
||
|
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;
|
||
|
};
|