git.iko.soy/elk
on master help sign in
Remove core-js/ directory. This branching thing is nice, I agree now :P
8fc0e24evancz
core-js/Automaton.jsdeleted−221
compare with master
unifiedsplit
@@ -1,221 +0,0 @@
1−
2−(function() {
3−try{
4−
5−var $op={};
6−for(this['i'] in Elm){eval('var '+this['i']+'=Elm[this.i];');}
7−if (Elm.Automaton) throw new Error("Module name collision, 'Automaton' is already defined.");
8−Elm.Automaton=function(){
9− try{
10− if (!(Elm.Prelude instanceof Object)) throw 'module not found';
11− } catch(e) {
12− throw ("Module 'Prelude' is missing. Compile with --make flag or load missing module in a separate JavaScript file.");
13− }
14− var hiddenVars={};
15− for (this['i'] in Elm.Prelude) {
16− if (hiddenVars[this['i']]) continue;
17− eval('var ' + this['i'] + ' = Elm.Prelude[this.i];');}
18− function Automaton_0(a1){
19− return ["Automaton",a1];}
20− var Listen_8=["Listen"];
21− var Ignore_9=["Ignore"];
22− function DragFrom_10(a1){
23− return ["DragFrom",a1];}
24− $op['>>>'] = function(a1_24){
25− return function(a2_25){
26− return function(){
27− var Automaton$m1_26=a1_24;
28− var m1_27=function(){
29− switch(Automaton$m1_26[0]){
30− case "Automaton":
31− return Automaton$m1_26[1];
32− }
33− throw new Error("Non-exhaustive pattern match in case");}();
34− var Automaton$m2_28=a2_25;
35− var m2_29=function(){
36− switch(Automaton$m2_28[0]){
37− case "Automaton":
38− return Automaton$m2_28[1];
39− }
40− throw new Error("Non-exhaustive pattern match in case");}();
41− return Automaton_0(function(a_32){
42− return function(){
43− var Tuple2$bm1__33=m1_27(a_32);
44− var b_34=function(){
45− switch(Tuple2$bm1__33[0]){
46− case "Tuple2":
47− return Tuple2$bm1__33[1];
48− }
49− throw new Error("Non-exhaustive pattern match in case");}();
50− var m1__35=function(){
51− switch(Tuple2$bm1__33[0]){
52− case "Tuple2":
53− return Tuple2$bm1__33[2];
54− }
55− throw new Error("Non-exhaustive pattern match in case");}();
56− return function(){
57− var Tuple2$cm2__40=m2_29(b_34);
58− var c_41=function(){
59− switch(Tuple2$cm2__40[0]){
60− case "Tuple2":
61− return Tuple2$cm2__40[1];
62− }
63− throw new Error("Non-exhaustive pattern match in case");}();
64− var m2__42=function(){
65− switch(Tuple2$cm2__40[0]){
66− case "Tuple2":
67− return Tuple2$cm2__40[2];
68− }
69− throw new Error("Non-exhaustive pattern match in case");}();
70− return ["Tuple2",c_41,$op['>>>'](m1__35)(m2__42)];}();}();});}();};};
71− $op['<<<'] = function(a2_47){
72− return function(a1_48){
73− return $op['>>>'](a1_48)(a2_47);};};
74− $op['^>>'] = function(f_49){
75− return function(a_50){
76− return $op['>>>'](pure_4(f_49))(a_50);};};
77− $op['>>^'] = function(a_51){
78− return function(f_52){
79− return $op['>>>'](a_51)(pure_4(f_52));};};
80− $op['^<<'] = function(f_53){
81− return function(a_54){
82− return $op['>>>'](a_54)(pure_4(f_53));};};
83− $op['<<^'] = function(a_55){
84− return function(f_56){
85− return $op['>>>'](pure_4(f_56))(a_55);};};
86− var count_7=init_5(0)(function(__84){
87− return function(c_85){
88− return (1+c_85);};});
89− function run_1(Automaton$m0_14){
90− return function(input_15){
91− return function(){
92− switch(Automaton$m0_14[0]){
93− case "Automaton":
94− return lift(fst)(foldp$(function(a_17){
95− return function(Tuple2$bAutomaton$m_18){
96− return function(){
97− switch(Tuple2$bAutomaton$m_18[0]){
98− case "Tuple2":
99− switch(Tuple2$bAutomaton$m_18[2][0]){
100− case "Automaton":
101− return Tuple2$bAutomaton$m_18[2][1](a_17);
102− }break;
103− }
104− throw new Error("Non-exhaustive pattern match in case");}();};})(Automaton$m0_14[1])(input_15));
105− }
106− throw new Error("Non-exhaustive pattern match in case");}();};}
107− function step_2(Automaton$m_21){
108− return function(a_22){
109− return function(){
110− switch(Automaton$m_21[0]){
111− case "Automaton":
112− return Automaton$m_21[1](a_22);
113− }
114− throw new Error("Non-exhaustive pattern match in case");}();};}
115− function combine_3(autos_57){
116− return Automaton_0(function(a_58){
117− return function(){
118− var Tuple2$bsautos__59=unzip(map(function(Automaton$m_62){
119− return function(){
120− switch(Automaton$m_62[0]){
121− case "Automaton":
122− return Automaton$m_62[1](a_58);
123− }
124− throw new Error("Non-exhaustive pattern match in case");}();})(autos_57));
125− var bs_60=function(){
126− switch(Tuple2$bsautos__59[0]){
127− case "Tuple2":
128− return Tuple2$bsautos__59[1];
129− }
130− throw new Error("Non-exhaustive pattern match in case");}();
131− var autos__61=function(){
132− switch(Tuple2$bsautos__59[0]){
133− case "Tuple2":
134− return Tuple2$bsautos__59[2];
135− }
136− throw new Error("Non-exhaustive pattern match in case");}();
137− return ["Tuple2",bs_60,combine_3(autos__61)];}();});}
138− function pure_4(f_68){
139− return Automaton_0(function(x_69){
140− return ["Tuple2",f_68(x_69),pure_4(f_68)];});}
141− function init_5(s_70){
142− return function(step_71){
143− return Automaton_0(function(a_72){
144− return function(){
145− var s__73=step_71(a_72)(s_70);
146− return ["Tuple2",s__73,init_5(s__73)(step_71)];}();});};}
147− function init__6(s_74){
148− return function(step_75){
149− return Automaton_0(function(a_76){
150− return function(){
151− var Tuple2$bs__77=step_75(a_76)(s_74);
152− var b_78=function(){
153− switch(Tuple2$bs__77[0]){
154− case "Tuple2":
155− return Tuple2$bs__77[1];
156− }
157− throw new Error("Non-exhaustive pattern match in case");}();
158− var s__79=function(){
159− switch(Tuple2$bs__77[0]){
160− case "Tuple2":
161− return Tuple2$bs__77[2];
162− }
163− throw new Error("Non-exhaustive pattern match in case");}();
164− return ["Tuple2",b_78,init__6(s__79)(step_75)];}();});};}
165− function vecSub_11(Tuple2$x1y1_86){
166− return function(Tuple2$x2y2_87){
167− return function(){
168− switch(Tuple2$x1y1_86[0]){
169− case "Tuple2":
170− return function(){
171− switch(Tuple2$x2y2_87[0]){
172− case "Tuple2":
173− return ["Tuple2",(Tuple2$x1y1_86[1]-Tuple2$x2y2_87[1]),(Tuple2$x1y1_86[2]-Tuple2$x2y2_87[2])];
174− }
175− throw new Error("Non-exhaustive pattern match in case");}();
176− }
177− throw new Error("Non-exhaustive pattern match in case");}();};}
178− function stepDrag_12(Tuple2$presspos_92){
179− return function(Tuple2$dsform_93){
180− return function(){
181− switch(Tuple2$presspos_92[0]){
182− case "Tuple2":
183− return function(){
184− switch(Tuple2$dsform_93[0]){
185− case "Tuple2":
186− return function(){
187− function wrap_98(ds__99){
188− return ["Tuple2",Tuple2$dsform_93[2],["Tuple2",ds__99,Tuple2$dsform_93[2]]];}
189− return function(){
190− switch(Tuple2$dsform_93[1][0]){
191− case "DragFrom":
192− return (Tuple2$presspos_92[1]?["Tuple2",uncurry(move)(vecSub_11(Tuple2$presspos_92[2])(Tuple2$dsform_93[1][1]))(Tuple2$dsform_93[2]),["Tuple2",DragFrom_10(Tuple2$dsform_93[1][1]),Tuple2$dsform_93[2]]]:function(){
193− var form__101=uncurry(move)(vecSub_11(Tuple2$presspos_92[2])(Tuple2$dsform_93[1][1]))(Tuple2$dsform_93[2]);
194− return ["Tuple2",form__101,["Tuple2",Listen_8,form__101]];}());
195− case "Ignore":
196− return wrap_98((Tuple2$presspos_92[1]?Ignore_9:Listen_8));
197− case "Listen":
198− return wrap_98((not(Tuple2$presspos_92[1])?Listen_8:(isWithin(Tuple2$presspos_92[2])(Tuple2$dsform_93[2])?DragFrom_10(Tuple2$presspos_92[2]):Ignore_9)));
199− }
200− throw new Error("Non-exhaustive pattern match in case");}();}();
201− }
202− throw new Error("Non-exhaustive pattern match in case");}();
203− }
204− throw new Error("Non-exhaustive pattern match in case");}();};}
205− function draggable_13(form_102){
206− return init__6(["Tuple2",Listen_8,form_102])(stepDrag_12);}
207− return {$op : {'>>>' : $op['>>>'], '<<<' : $op['<<<'], '^>>' : $op['^>>'], '>>^' : $op['>>^'], '^<<' : $op['^<<'], '<<^' : $op['<<^']},
208− run:run_1,
209− step:step_2,
210− combine:combine_3,
211− pure:pure_4,
212− init:init_5,
213− init$:init__6,
214− count:count_7,
215− draggable:draggable_13};}();
216−Elm.main=function(){
217− return Elm.Automaton.main;};
218−} catch (e) {
219−Elm.main=function() {
220−var msg = ('<br/><h2>Your browser may not be supported. Are you using a modern browser?</h2>' + '<br/><span style="color:grey">Runtime Error in Automaton module:<br/>' + e + '</span>');
221−document.body.innerHTML = Elm.Text.monospace(msg);throw e;};}}());
core-js/Char.jsdeleted−64
@@ -1,64 +0,0 @@
1−/*! Char !*/
2−
3−/*[Classification]*/
4−
5−/** isUpper : Char -> Bool
6− Selects upper case letters.
7−**/
8−/** isLower : Char -> Bool
9− Selects lower case letters.
10−**/
11−/** isDigit : Char -> Bool
12− Selects ASCII digits (0..9).
13−**/
14−/** isOctDigit : Char -> Bool
15− Selects ASCII octal digits (0..7).
16−**/
17−/** isHexDigit : Char -> Bool
18− Selects ASCII hexadecimal digits (0..9a..fA..F).
19−**/
20−
21−/*[Conversion]*/
22−
23−/** toUpper : Char -> Char
24− Convert to upper case.
25−**/
26−/** toLower : Char -> Char
27− Convert to lower case.
28−**/
29−/** toLocaleUpper : Char -> Char
30− Convert to upper case, according to any locale-specific case mappings.
31−**/
32−/** toLocaleLower : Char -> Char
33− Convert to lower case, according to any locale-specific case mappings.
34−**/
35−/** toCode : Char -> Int
36− Convert to unicode.
37−**/
38−/** fromCode : Int -> Char
39− Convert from unicode.
40−**/
41−
42−Elm.Char = function() {
43− function isBetween(lo,hi) { return function(chr) {
44− var c = chr.charCodeAt(0);
45− return lo <= c && c <= hi;
46− };
47− }
48− var isDigit = isBetween('0'.charCodeAt(0),'9'.charCodeAt(0));
49− var chk1 = isBetween('a'.charCodeAt(0),'f'.charCodeAt(0));
50− var chk2 = isBetween('A'.charCodeAt(0),'F'.charCodeAt(0));
51−
52− return {fromCode : function(c) { return String.fromCharCode(c); },
53− toCode : function(c) { return c.charCodeAt(0); },
54− toUpper : function(c) { return c.toUpperCase(); },
55− toLower : function(c) { return c.toLowerCase(); },
56− toLocaleUpper : function(c) { return c.toLocaleUpperCase(); },
57− toLocaleLower : function(c) { return c.toLocaleLowerCase(); },
58− isLower : isBetween('a'.charCodeAt(0),'z'.charCodeAt(0)),
59− isUpper : isBetween('A'.charCodeAt(0),'Z'.charCodeAt(0)),
60− isDigit : isDigit,
61− isOctDigit : isBetween('0'.charCodeAt(0),'7'.charCodeAt(0)),
62− isHexDigit : function(c) { return isDigit(c) || chk1(c) || chk2(c); }
63− };
64−}();
core-js/Date.jsdeleted−32
@@ -1,32 +0,0 @@
1−
2−Elm.Date = function() {
3−
4− function dateNow() { return new window.Date; }
5− function readDate(str) {
6− var d = new window.Date(Elm.JavaScript.castStringToJSString(str));
7− if (isNaN(d.getTime())) return ["Nothing"];
8− return ["Just",d];
9− }
10−
11− var dayTable = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
12− var monthTable = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
13− "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
14−
15− return {
16− read : readDate,
17− year : function(d) { return d.getFullYear(); },
18− month : function(d) { return [monthTable[d.getMonth()]]; },
19− day : function(d) { return d.getDate(); },
20− hour : function(d) { return d.getHours(); },
21− minute : function(d) { return d.getMinutes(); },
22− second : function(d) { return d.getSeconds(); },
23− dayOfWeek : function(d) { return [dayTable[d.getDay()]]; },
24− toTime : function(d) { return d.getTime(); },
25− Mon : ["Mon"], Tue : ["Tue"], Wed : ["Wed"],
26− Thu : ["Thu"], Fri : ["Fri"], Sat : ["Sat"], Sun : ["Sun"],
27− Jan : ["Jan"], Feb : ["Feb"], Mar : ["Mar"], Apr : ["Apr"],
28− May : ["May"], Jun : ["Jun"], Jul : ["Jul"], Aug : ["Aug"],
29− Sep : ["Sep"], Oct : ["Oct"], Nov : ["Nov"], Dec : ["Dec"]
30− };
31−
32−}();
core-js/Dict.jsdeleted−485
@@ -1,485 +0,0 @@
1−
2−Elm.Dict=function(){
3− var compare = Elm.Prelude.compare;
4− var uncurry = Elm.Prelude.uncurry;
5− var Nothing = Elm.Prelude.Nothing;
6− var Just = Elm.Prelude.Just;
7− var not = Elm.Prelude.not;
8− var eq = Elm.Prelude.eq;
9− var isJust=Elm.Maybe.isJust;
10− var Red_0=['Red'];
11− var Black_1=['Black'];
12− function RBNode_2(a1){
13− return function(a2){
14− return function(a3){
15− return function(a4){
16− return function(a5){
17− return ['RBNode',a1,a2,a3,a4,a5];};};};};}
18− var RBEmpty_3=['RBEmpty'];
19− function min_6(t_42){
20− return function(){
21− switch(t_42[0]){
22− case 'RBEmpty':
23− throw '(min RBEmpty) is not defined';
24− case 'RBNode':
25− switch(t_42[4][0]){
26− case 'RBEmpty':
27− return ['Tuple2',t_42[2],t_42[3]];
28− }
29− return min_6(t_42[4]);
30− }
31− throw new Error("Non-exhaustive pattern match in case");}();}
32− function lookup_7(k_46){
33− return function(t_47){
34− return function(){
35− switch(t_47[0]){
36− case 'RBEmpty':
37− return Nothing;
38− case 'RBNode':
39− return function(){
40− var case12=compare(k_46)(t_47[2]);
41− switch(case12[0]){
42− case 'EQ':
43− return Just(t_47[3]);
44− case 'GT':
45− return lookup_7(k_46)(t_47[5]);
46− case 'LT':
47− return lookup_7(k_46)(t_47[4]);
48− }
49− throw new Error("Non-exhaustive pattern match in case");}();
50− }
51− throw new Error("Non-exhaustive pattern match in case");}();};}
52− function findWithDefault_8(base_52){
53− return function(k_53){
54− return function(t_54){
55− return function(){
56− switch(t_54[0]){
57− case 'RBEmpty':
58− return base_52;
59− case 'RBNode':
60− return function(){
61− var case19=compare(k_53)(t_54[2]);
62− switch(case19[0]){
63− case 'EQ':
64− return t_54[3];
65− case 'GT':
66− return findWithDefault_8(base_52)(k_53)(t_54[5]);
67− case 'LT':
68− return findWithDefault_8(base_52)(k_53)(t_54[4]);
69− }
70− throw new Error("Non-exhaustive pattern match in case");}();
71− }
72− throw new Error("Non-exhaustive pattern match in case");}();};};}
73− function member_9(k_59){
74− return function(t_60){
75− return isJust(lookup_7(k_59)(t_60));};}
76− function rotateLeft_10(t_61){
77− return function(){
78− switch(t_61[0]){
79− case 'RBNode':
80− switch(t_61[5][0]){
81− case 'RBNode':
82− return RBNode_2(t_61[1])(t_61[5][2])(t_61[5][3])(RBNode_2(Red_0)(t_61[2])(t_61[3])(t_61[4])(t_61[5][4]))(t_61[5][5]);
83− }break;
84− }
85− throw 'rotateLeft of a node without enough children';}();}
86− function rotateRight_11(t_71){
87− return function(){
88− switch(t_71[0]){
89− case 'RBNode':
90− switch(t_71[4][0]){
91− case 'RBNode':
92− return RBNode_2(t_71[1])(t_71[4][2])(t_71[4][3])(t_71[4][4])(RBNode_2(Red_0)(t_71[2])(t_71[3])(t_71[4][5])(t_71[5]));
93− }break;
94− }
95− throw 'rotateRight of a node without enough children';}();}
96− function rotateLeftIfNeeded_12(t_81){
97− return function(){
98− switch(t_81[0]){
99− case 'RBNode':
100− switch(t_81[5][0]){
101− case 'RBNode':
102− switch(t_81[5][1][0]){
103− case 'Red':
104− return rotateLeft_10(t_81);
105− }break;
106− }break;
107− }
108− return t_81;}();}
109− function rotateRightIfNeeded_13(t_82){
110− return function(){
111− switch(t_82[0]){
112− case 'RBNode':
113− switch(t_82[4][0]){
114− case 'RBNode':
115− switch(t_82[4][1][0]){
116− case 'Red':
117− switch(t_82[4][4][0]){
118− case 'RBNode':
119− switch(t_82[4][4][1][0]){
120− case 'Red':
121− return rotateRight_11(t_82);
122− }break;
123− }break;
124− }break;
125− }break;
126− }
127− return t_82;}();}
128− function otherColor_14(c_83){
129− return function(){
130− switch(c_83[0]){
131− case 'Black':
132− return Red_0;
133− case 'Red':
134− return Black_1;
135− }
136− throw new Error("Non-exhaustive pattern match in case");}();}
137− function color_flip_15(t_84){
138− return function(){
139− switch(t_84[0]){
140− case 'RBNode':
141− switch(t_84[4][0]){
142− case 'RBNode':
143− switch(t_84[5][0]){
144− case 'RBNode':
145− return RBNode_2(otherColor_14(t_84[1]))(t_84[2])(t_84[3])(RBNode_2(otherColor_14(t_84[4][1]))(t_84[4][2])(t_84[4][3])(t_84[4][4])(t_84[4][5]))(RBNode_2(otherColor_14(t_84[5][1]))(t_84[5][2])(t_84[5][3])(t_84[5][4])(t_84[5][5]));
146− }break;
147− }break;
148− }
149− throw 'color_flip called on a RBEmpty or RBNode with a RBEmpty child';}();}
150− function color_flipIfNeeded_16(t_98){
151− return function(){
152− switch(t_98[0]){
153− case 'RBNode':
154− switch(t_98[4][0]){
155− case 'RBNode':
156− switch(t_98[4][1][0]){
157− case 'Red':
158− switch(t_98[5][0]){
159− case 'RBNode':
160− switch(t_98[5][1][0]){
161− case 'Red':
162− return color_flip_15(t_98);
163− }break;
164− }break;
165− }break;
166− }break;
167− }
168− return t_98;}();}
169− function fixUp_17(t_99){
170− return color_flipIfNeeded_16(rotateRightIfNeeded_13(rotateLeftIfNeeded_12(t_99)));}
171− function ensureBlackRoot_18(t_100){
172− return function(){
173− switch(t_100[0]){
174− case 'RBNode':
175− switch(t_100[1][0]){
176− case 'Red':
177− return RBNode_2(Black_1)(t_100[2])(t_100[3])(t_100[4])(t_100[5]);
178− }break;
179− }
180− return t_100;}();}
181− function insert_19(k_105){
182− return function(v_106){
183− return function(t_107){
184− return function(){
185− function ins_108(t_109){
186− return function(){
187− switch(t_109[0]){
188− case 'RBEmpty':
189− return RBNode_2(Red_0)(k_105)(v_106)(RBEmpty_3)(RBEmpty_3);
190− case 'RBNode':
191− return function(){
192− var h_115=function(){
193− var case114=compare(k_105)(t_109[2]);
194− switch(case114[0]){
195− case 'EQ':
196− return RBNode_2(t_109[1])(t_109[2])(v_106)(t_109[4])(t_109[5]);
197− case 'GT':
198− return RBNode_2(t_109[1])(t_109[2])(t_109[3])(t_109[4])(ins_108(t_109[5]));
199− case 'LT':
200− return RBNode_2(t_109[1])(t_109[2])(t_109[3])(ins_108(t_109[4]))(t_109[5]);
201− }
202− throw new Error("Non-exhaustive pattern match in case");}();
203− return fixUp_17(h_115);}();
204− }
205− throw new Error("Non-exhaustive pattern match in case");}();}
206− return ensureBlackRoot_18(ins_108(t_107));}();};};}
207− function singleton_20(k_116){
208− return function(v_117){
209− return insert_19(k_116)(v_117)(RBEmpty_3);};}
210− function isRed_21(t_118){
211− return function(){
212− switch(t_118[0]){
213− case 'RBNode':
214− switch(t_118[1][0]){
215− case 'Red':
216− return true;
217− }break;
218− }
219− return false;}();}
220− function isRedLeft_22(t_119){
221− return function(){
222− switch(t_119[0]){
223− case 'RBNode':
224− switch(t_119[4][0]){
225− case 'RBNode':
226− switch(t_119[4][1][0]){
227− case 'Red':
228− return true;
229− }break;
230− }break;
231− }
232− return false;}();}
233− function isRedLeftLeft_23(t_120){
234− return function(){
235− switch(t_120[0]){
236− case 'RBNode':
237− switch(t_120[4][0]){
238− case 'RBNode':
239− switch(t_120[4][4][0]){
240− case 'RBNode':
241− switch(t_120[4][4][1][0]){
242− case 'Red':
243− return true;
244− }break;
245− }break;
246− }break;
247− }
248− return false;}();}
249− function isRedRight_24(t_121){
250− return function(){
251− switch(t_121[0]){
252− case 'RBNode':
253− switch(t_121[5][0]){
254− case 'RBNode':
255− switch(t_121[5][1][0]){
256− case 'Red':
257− return true;
258− }break;
259− }break;
260− }
261− return false;}();}
262− function isRedRightLeft_25(t_122){
263− return function(){
264− switch(t_122[0]){
265− case 'RBNode':
266− switch(t_122[5][0]){
267− case 'RBNode':
268− switch(t_122[5][4][0]){
269− case 'RBNode':
270− switch(t_122[5][4][1][0]){
271− case 'Red':
272− return true;
273− }break;
274− }break;
275− }break;
276− }
277− return false;}();}
278− function moveRedLeft_26(t_123){
279− return function(){
280− var t__124=color_flip_15(t_123);
281− return function(){
282− switch(t__124[0]){
283− case 'RBNode':
284− return function(){
285− switch(t__124[5][0]){
286− case 'RBNode':
287− switch(t__124[5][4][0]){
288− case 'RBNode':
289− switch(t__124[5][4][1][0]){
290− case 'Red':
291− return color_flip_15(rotateLeft_10(RBNode_2(t__124[1])(t__124[2])(t__124[3])(t__124[4])(rotateRight_11(t__124[5]))));
292− }break;
293− }break;
294− }
295− return t__124;}();
296− }
297− return t__124;}();}();}
298− function moveRedRight_27(t_130){
299− return function(){
300− var t__131=color_flip_15(t_130);
301− return (isRedLeftLeft_23(t__131)?color_flip_15(rotateRight_11(t__131)):t__131);}();}
302− function moveRedLeftIfNeeded_28(t_132){
303− return ((not(isRedLeft_22(t_132))&&not(isRedLeftLeft_23(t_132)))?moveRedLeft_26(t_132):t_132);}
304− function moveRedRightIfNeeded_29(t_133){
305− return ((not(isRedRight_24(t_133))&&not(isRedRightLeft_25(t_133)))?moveRedRight_27(t_133):t_133);}
306− function deleteMin_30(t_134){
307− return function(){
308− function del_135(t_136){
309− return function(){
310− switch(t_136[0]){
311− case 'RBNode':
312− switch(t_136[4][0]){
313− case 'RBEmpty':
314− return RBEmpty_3;
315− }break;
316− }
317− return function(){
318− var case198=moveRedLeftIfNeeded_28(t_136);
319− switch(case198[0]){
320− case 'RBEmpty':
321− return RBEmpty_3;
322− case 'RBNode':
323− return fixUp_17(RBNode_2(case198[1])(case198[2])(case198[3])(del_135(case198[4]))(case198[5]));
324− }
325− throw new Error("Non-exhaustive pattern match in case");}();}();}
326− return ensureBlackRoot_18(del_135(t_134));}();}
327− function remove_31(k_142){
328− return function(t_143){
329− return function(){
330− function eq_and_noRightNode_144(t_150){
331− return function(){
332− switch(t_150[0]){
333− case 'RBNode':
334− switch(t_150[5][0]){
335− case 'RBEmpty':
336− return eq(k_142,t_150[2]);
337− }break;
338− }
339− return false;}();}
340− function eq_145(t_152){
341− return function(){
342− switch(t_152[0]){
343− case 'RBNode':
344− return eq(k_142,t_152[2]);
345− }
346− return false;}();}
347− function delLT_146(t_154){
348− return function(){
349− var case216=moveRedLeftIfNeeded_28(t_154);
350− switch(case216[0]){
351− case 'RBEmpty':
352− throw 'delLT on RBEmpty';
353− case 'RBNode':
354− return fixUp_17(RBNode_2(case216[1])(case216[2])(case216[3])(del_149(case216[4]))(case216[5]));
355− }
356− throw new Error("Non-exhaustive pattern match in case");}();}
357− function delEQ_147(t_160){
358− return function(){
359− switch(t_160[0]){
360− case 'RBEmpty':
361− throw 'delEQ called on a RBEmpty';
362− case 'RBNode':
363− return function(){
364− var Tuple2$k_v__164=min_6(t_160[5]);
365− var k__165=function(){
366− switch(Tuple2$k_v__164[0]){
367− case 'Tuple2':
368− return Tuple2$k_v__164[1];
369− }
370− throw new Error("Non-exhaustive pattern match in case");}();
371− var v__166=function(){
372− switch(Tuple2$k_v__164[0]){
373− case 'Tuple2':
374− return Tuple2$k_v__164[2];
375− }
376− throw new Error("Non-exhaustive pattern match in case");}();
377− return fixUp_17(RBNode_2(t_160[1])(k__165)(v__166)(t_160[4])(deleteMin_30(t_160[5])));}();
378− }
379− throw new Error("Non-exhaustive pattern match in case");}();}
380− function delGT_148(t_171){
381− return function(){
382− switch(t_171[0]){
383− case 'RBEmpty':
384− throw 'delGT called on a RBEmpty';
385− case 'RBNode':
386− return fixUp_17(RBNode_2(t_171[1])(t_171[2])(t_171[3])(t_171[4])(del_149(t_171[5])));
387− }
388− throw new Error("Non-exhaustive pattern match in case");}();}
389− function del_149(t_177){
390− return function(){
391− switch(t_177[0]){
392− case 'RBEmpty':
393− return RBEmpty_3;
394− case 'RBNode':
395− return ((compare(k_142)(t_177[2])[0] === 'LT')?delLT_146(t_177):function(){
396− var u_179=(isRedLeft_22(t_177)?rotateRight_11(t_177):t_177);
397− return (eq_and_noRightNode_144(u_179)?u_179[4]:function(){
398− var t__180=moveRedRightIfNeeded_29(t_177);
399− return (eq_145(t__180)?delEQ_147(t__180):delGT_148(t__180));}());}());
400− }
401− throw new Error("Non-exhaustive pattern match in case");}();}
402− return (member_9(k_142)(t_143)?ensureBlackRoot_18(del_149(t_143)):t_143);}();};}
403− function map_32(f_181){
404− return function(t_182){
405− return function(){
406− switch(t_182[0]){
407− case 'RBEmpty':
408− return RBEmpty_3;
409− case 'RBNode':
410− return RBNode_2(t_182[1])(t_182[2])(f_181(t_182[3]))(map_32(f_181)(t_182[4]))(map_32(f_181)(t_182[5]));
411− }
412− throw new Error("Non-exhaustive pattern match in case");}();};}
413− function foldl_33(f_188){
414− return function(acc_189){
415− return function(t_190){
416− return function(){
417− switch(t_190[0]){
418− case 'RBEmpty':
419− return acc_189;
420− case 'RBNode':
421− return foldl_33(f_188)(f_188(t_190[2])(t_190[3])(foldl_33(f_188)(acc_189)(t_190[4])))(t_190[5]);
422− }
423− throw new Error("Non-exhaustive pattern match in case");}();};};}
424− function foldr_34(f_195){
425− return function(acc_196){
426− return function(t_197){
427− return function(){
428− switch(t_197[0]){
429− case 'RBEmpty':
430− return acc_196;
431− case 'RBNode':
432− return foldr_34(f_195)(f_195(t_197[2])(t_197[3])(foldr_34(f_195)(acc_196)(t_197[5])))(t_197[4]);
433− }
434− throw new Error("Non-exhaustive pattern match in case");}();};};}
435− function union_35(t1_202){
436− return function(t2_203){
437− return foldl_33(insert_19)(t2_203)(t1_202);};}
438− function intersect_36(t1_204){
439− return function(t2_205){
440− return foldl_33(function(k_206){
441− return function(v_207){
442− return function(t_208){
443− return (member_9(k_206)(t2_205)?insert_19(k_206)(v_207)(t_208):t_208);};};})(empty_4)(t1_204);};}
444− function diff_37(t1_209){
445− return function(t2_210){
446− return foldl_33(function(k_211){
447− return function(v_212){
448− return function(t_213){
449− return remove_31(k_211)(t_213);};};})(t1_209)(t2_210);};}
450− function keys_38(t_214){
451− return foldr_34(function(k_215){
452− return function(v_216){
453− return function(acc_217){
454− return ['Cons',k_215,acc_217];};};})(['Nil'])(t_214);}
455− function values_39(t_218){
456− return foldr_34(function(k_219){
457− return function(v_220){
458− return function(acc_221){
459− return ['Cons',v_220,acc_221];};};})(['Nil'])(t_218);}
460− function toList_40(t_222){
461− return foldr_34(function(k_223){
462− return function(v_224){
463− return function(acc_225){
464− return ['Cons',['Tuple2',k_223,v_224],acc_225];};};})(['Nil'])(t_222);}
465− function fromList_41(assocs_226){
466− return Elm.List.foldl(uncurry(insert_19))(empty_4)(assocs_226);}
467− var empty_4=RBEmpty_3;
468− return {$op : {},
469− empty:empty_4,
470− lookup:lookup_7,
471− findWithDefault:findWithDefault_8,
472− member:member_9,
473− insert:insert_19,
474− singleton:singleton_20,
475− remove:remove_31,
476− map:map_32,
477− foldl:foldl_33,
478− foldr:foldr_34,
479− union:union_35,
480− intersect:intersect_36,
481− diff:diff_37,
482− keys:keys_38,
483− values:values_39,
484− toList:toList_40,
485− fromList:fromList_41};}();
core-js/Either.jsdeleted−75
@@ -1,75 +0,0 @@
1−/*! Either
2−!*/
3−
4−
5−Elm.Either = function() {
6− /*[Definition]*/
7−
8− /** data Either a b = Left a | Right b
9− Represents any data that can take two different types.
10−
11− This can also be used for error handling (`Either String a`) where
12− error messages are stored on the left, and the correct values
13− ("right" values) are stored on the right.
14− **/
15− function Left(a1) { return ['Left',a1]; }
16− function Right(a1){ return ['Right',a1]; }
17−
18− /*[Basics]*/
19−
20− /** either : (a -> c) -> (b -> c) -> Either a b -> c
21− Apply the first function to a `Left` and the second function to a `Right`.
22− This allows the extraction of a value from an `Either`.
23− **/
24− function either(f){ return function(g){ return function(e){
25− switch(e[0]){
26− case 'Left': return f(e[1]);
27− case 'Right': return g(e[1]);
28− }
29− };};}
30−
31− /** isLeft : Either a b -> Bool
32− True if the value is a `Left`.
33− **/
34− function isLeft(e) { return e[0] == 'Left'; }
35−
36− /** isRight : Either a b -> Bool
37− True if the value is a `Right`.
38− **/
39− function isRight(e) { return e[0] == 'Right'; }
40−
41− /*[With Lists]*/
42−
43− function get(es) { return Elm.List.map(function(x){return x[1];})(es); }
44−
45− /** lefts : [Either a b] -> [a]
46− Keep only the values held in `Left` values.
47− **/
48− function lefts(es) { return get(Elm.List.filter(isLeft)(es)); }
49−
50− /** rights : [Either a b] -> [a]
51− Keep only the values held in `Right` values.
52− **/
53− function rights(es) { return get(Elm.List.filter(isRight)(es)); }
54−
55− /** partition : [Either a b] -> ([a],[b])
56− Split into two lists, lefts on the left and rights on the right.
57− So we have the equivalence:
58−
59− partition es == (lefts es, rights es)
60− **/
61− function partition(es) {
62− var lrs = Elm.List.partition(isLeft)(es);
63− lrs[1] = get(lrs[1]);
64− lrs[2] = get(lrs[2]);
65− return lrs;
66− }
67− return {Left:Left,
68− Right:Right,
69− either:either,
70− isLeft:isLeft,
71− isRight:isRight,
72− lefts:lefts,
73− rights:rights,
74− partition:partition};
75−}();
core-js/Graphics/Collage.jsdeleted−317
@@ -1,317 +0,0 @@
1−
2−var Collage = function() {
3−
4−var JS = Elm.JavaScript;
5−
6−function tracePoints(ctx,points) {
7− var i = points.length - 1;
8− if (i <= 0) return;
9− ctx.moveTo(points[i][1], points[i][2]);
10− while (i--) { ctx.lineTo(points[i][1], points[i][2]); }
11−}
12−
13−function solid(ctx,color,points) {
14− tracePoints(ctx,points);
15− ctx.strokeStyle = Elm.Color.extract(color);
16− ctx.stroke();
17−};
18−
19−function filled(ctx,color,points) {
20− tracePoints(ctx,points);
21− ctx.fillStyle = Elm.Color.extract(color);
22− ctx.fill();
23−}
24−
25−function textured(redo,ctx,src,points) {
26− var img = new Image();
27− img.src = JS.castStringToJSString(src);
28− img.onload = redo;
29−
30− tracePoints(ctx,points);
31− ctx.fillStyle = ctx.createPattern(img,'repeat');
32− ctx.fill();
33−}
34−
35−function customLine(pattern,ctx,color,points) {
36− if (pattern.length === 0) { pattern = [8,4]; }
37− customLineHelp(ctx, pattern, points);
38− ctx.strokeStyle = Elm.Color.extract(color);
39− ctx.stroke();
40−};
41−
42−var customLineHelp = function(ctx, pattern, points) {
43− var i = points.length - 1;
44− if (i <= 0) return;
45− var x0 = points[i][1], y0 = points[i][2];
46− var x1=0, y1=0, dx=0, dy=0, remaining=0, nx=0, ny=0;
47− var pindex = 0, plen = pattern.length;
48− var draw = true, segmentLength = pattern[0];
49− ctx.moveTo(x0,y0);
50− while (i--) {
51− x1 = points[i][1]; y1 = points[i][2];
52− dx = x1 - x0; dy = y1 - y0;
53− remaining = Math.sqrt(dx * dx + dy * dy);
54− while (segmentLength <= remaining) {
55− x0 += dx * segmentLength / remaining;
56− y0 += dy * segmentLength / remaining;
57− ctx[draw ? 'lineTo' : 'moveTo'](x0, y0);
58− // update starting position
59− dx = x1 - x0; dy = y1 - y0;
60− remaining = Math.sqrt(dx * dx + dy * dy);
61− // update pattern
62− draw = !draw;
63− pindex = (pindex + 1) % plen;
64− segmentLength = pattern[pindex];
65− }
66− if (remaining > 0) {
67− ctx[draw ? 'lineTo' : 'moveTo'](x1, y1);
68− segmentLength -= remaining;
69− }
70− x0 = x1; y0 = y1;
71− }
72−};
73−
74−function drawLine(ctx,form) {
75− var points = form[3][1];
76− switch(form[1][0]) {
77− case "Solid" : return solid(ctx,form[2],points);
78− case "Dotted": return customLine([3,3],ctx,form[2],points);
79− case "Dashed": return customLine([8,4],ctx,form[2],points);
80− case "Custom": return customLine(form[1][1],ctx,form[2],points);
81− }
82−};
83−
84−function drawShape(redo,ctx,shapeStyle,color,points) {
85− switch(shapeStyle[0]) {
86− case "Filled": return filled(ctx,color,points);
87− case "Outlined": return solid(ctx,color,points);
88− case "Textured": return textured(redo,ctx,shapeStyle[1],points);
89− case "CustomOutline":
90− return customLine(shapeStyle[1],ctx,color,points);
91− }
92−};
93−
94−function drawImage(redo,ctx,w,h,src) {
95− var img = new Image();
96− img.onload = redo;
97− img.src = JS.castStringToJSString(src);
98− ctx.drawImage(img,-w/2,-h/2,w,h);
99−}
100−
101−function renderForm(redo,ctx,theta,scale,x,y,form) {
102− ctx.save();
103− if (x !== 0 || y !== 0) ctx.translate(x,y);
104− if (theta !== ~~theta) ctx.rotate(2*Math.PI*theta);
105− if (scale !== 1) ctx.scale(scale,scale);
106− ctx.beginPath();
107− switch(form[0]) {
108− case "FLine": drawLine(ctx,form); break;
109− case "FShape": drawShape(redo,ctx,form[1],form[2],form[3][1]); break;
110− case "FImage": drawImage(redo,ctx,form[1],form[2],form[3]); break;
111− }
112− ctx.restore();
113−};
114−
115−function renderForms(redo,ctx,w,h,forms) {
116− ctx.clearRect(0,0,w,h);
117− for (var i = forms.length; i--; ) {
118− var f = forms[i];
119− renderForm(redo,ctx,f[1],f[2],f[3][1],f[3][2],f[4]);
120− }
121−}
122−
123−function collageForms(w,h,forms) {
124− var canvas = Render.newElement('canvas');
125− w = ~~w;
126− h = ~~h;
127− canvas.style.width = w + 'px';
128− canvas.style.height = h + 'px';
129− canvas.style.display = "block";
130− canvas.width = w;
131− canvas.height = h;
132− if (canvas.getContext) {
133− var ctx = canvas.getContext('2d');
134− function redo() { renderForms(this,ctx,w,h,forms); }
135− renderForms(redo,ctx,w,h,forms);
136− return canvas;
137− }
138− canvas.innerHTML = "Your browser does not support the canvas element.";
139− return canvas;
140−};
141−
142−function applyTransforms(theta,scale,x,y,w,h,e) {
143− var t = "translate(" + (x - w / 2) + "px,"+ (y - h / 2) + "px)";
144− var r = theta === (~~theta) ? "" : "rotate(" + theta*360 + "deg)";
145− var s = scale === 1 ? "" : "scale(" + scale + "," + scale + ")";
146− var transforms = t + " " + s + " " + r;
147− e.style.transform = transforms;
148− e.style.msTransform = transforms;
149− e.style.MozTransform = transforms;
150− e.style.webkitTransform = transforms;
151− e.style.OTransform = transforms;
152−}
153−
154−function collageElement(w,h,theta,scale,x,y,elem) {
155− var e = Render.render(elem);
156− applyTransforms(theta,scale,x,y,elem[3],elem[4],e);
157− var div = Render.newElement('div');
158− Render.addTo(div,e);
159− div.style.width = (~~w) + "px";
160− div.style.height = (~~h) + "px";
161− div.style.overflow = "hidden";
162− return div;
163−}
164−
165−function collage(w,h,formss) {
166− if (formss.length === 0) { return collageForms(w,h,[]); }
167− var elems = new Array(formss.length);
168− for (var i = formss.length; i--; ) {
169− var f = formss[i];
170− if (typeof f[0] === "string") {
171− elems[i] = collageElement(w,h,f[1],f[2],f[3][1],f[3][2],f[4][1]);
172− } else {
173− elems[i] = collageForms(w,h,f);
174− }
175− }
176− if (formss.length === 1) { return elems[0]; }
177− return Render.flowWith(Render.goIn,function(x){return x},elems);
178−}
179−
180−function updateFormSet(node,currSet,nextSet) {
181− if (Value.eq(nextSet,currSet)) return;
182− var w = node.style.width.slice(0,-2) - 0;
183− var h = node.style.height.slice(0,-2) - 0;
184− if (typeof nextSet[0] === "object") {
185− if (typeof currSet[0] === "object") {
186− if (node.getContext) {
187− var ctx = node.getContext('2d');
188− function redo() { renderForms(this,ctx,w,h,nextSet); }
189− return renderForms(redo,ctx,w,h,nextSet);
190− }
191− }
192− var newNode = collageForms(w,h,nextSet);
193− newNode.style.position = 'absolute';
194− return node.parentNode.replaceChild(newNode,node);
195− }
196− node.style.width = (~~w) + "px";
197− node.style.height = (~~h) + "px";
198− var f = nextSet;
199− var next = nextSet[4][1];
200− Render.update(node.firstChild, currSet[4][1], next);
201− applyTransforms(f[1],f[2],f[3][1],f[3][2],next[3],next[4],node.firstChild);
202−}
203−
204−// assumes that the form sets are the same length.
205−function updateCollage(node,currs,nexts) {
206− if (nexts.length === 1) {
207− return updateFormSet(node,currs[0],nexts[0]);
208− }
209− var kids = node.childNodes;
210− var len = kids.length;
211− for (var i = len; i--; ) {
212− updateFormSet(kids[len-i-1], currs[i], nexts[i]);
213− }
214−}
215−
216−function style(clr,n,list) {
217− return ["Tuple2",
218− '<span style="font-size:100%;color:' + clr + ';">' + n + '</span>',
219− list];
220−}
221−
222−function insideForm(point) { return function(form) {
223− if (!inBoundsOf(point[1],point[2],form)) return false;
224− var hw, hh;
225− switch (form[4][0]) {
226− case "FShape": return insideShape(point,form[1],form[2],form[3],form[4][3][1]);
227− case "FLine": return false;
228− case "FImage":
229− hw = form[4][1] / 2;
230− hh = form[4][2] / 2;
231− break;
232− case "FElement":
233− hw = form[4][1][3] / 2;
234− hh = form[4][1][4] / 2;
235− break;
236− }
237− return insideShape(point,form[1],form[2],form[3],
238− [ [null, hw, hh],
239− [null,-hw, hh],
240− [null,-hw,-hh],
241− [null, hw,-hh],
242− [null, hw, hh] ]);
243− };
244−}
245−
246−function inBoundsOf(px,py,form) {
247− if (form.length < 6) {
248− var fx = form[3][1], fy = form[3][2];
249− var radiusSquared = 0;
250− var scale = form[2];
251− switch (form[4][0]) {
252− case "FShape":
253− var points = form[4][3][1];
254− for (var i = points.length; --i; ) {
255− var p = points[i];
256− radiusSquared = Math.max(radiusSquared, p[1]*p[1] + p[2]*p[2]);
257− }
258− radiusSquared *= scale * scale;
259− break;
260− case "FLine":
261− break;
262− case "FImage":
263− var x = scale * form[4][1] / 2;
264− var y = scale * form[4][2] / 2;
265− radiusSquared = x*x + y*y;
266− break;
267− case "FElement":
268− var x = scale * form[4][1][3] / 2;
269− var y = scale * form[4][1][4] / 2;
270− radiusSquared = x*x + y*y;
271− break;
272− }
273− form.push(function(px,py) {
274− var dx = px - fx;
275− var dy = py - fy;
276− return dx*dx + dy*dy < radiusSquared + 1;
277− });
278− }
279− return form[5](px,py);
280−}
281−
282−function insideShape(point,theta,scale,pos,points) {
283− var counter = 0;
284− var list = ["Nil"];
285− var p1,p2;
286−
287− var x = (point[1] - pos[1]) / scale;
288− var y = (point[2] - pos[2]) / scale;
289− if (theta !== 0) {
290− var t = -2 * Math.PI * theta;
291− var nx = x * Math.cos(t) - y * Math.sin(t);
292− y = x * Math.sin(t) + y * Math.cos(t);
293− x = nx;
294− }
295−
296− if (points.length === 0) { return false; }
297− p1 = points[0];
298− for (var i = points.length - 1; i--; ) {
299− p2 = points[i];
300− var p1x = p1[1], p1y = p1[2], p2x = p2[1], p2y = p2[2];
301−
302− if (p1y < p2y) {var ymin=p1y, ymax=p2y;} else {var ymin=p2y, ymax=p1y;}
303− if (p1x < p2x) {var xmin=p1x, xmax=p2x;} else {var xmin=p2x, xmax=p1x;}
304−
305− if (ymin < y && y <= ymax && x <= xmax) {
306− if (x <= xmin || x <= ((y-p1y)*(p2x-p1x)/(p2y-p1y)+p1x)) {
307− ++counter;
308− }
309− }
310− p1 = p2;
311− }
312− return (counter % 2) === 1;
313−}
314−
315−return {collage:collage, updateCollage:updateCollage, insideForm:insideForm};
316−
317−}();
core-js/Graphics/Color.jsdeleted−86
@@ -1,86 +0,0 @@
1−Elm.Color = function() {
2−
3−function Color_0(a1) {
4− return function(a2) {
5− return function(a3) {
6− return function(a4) {
7− return["Color", a1, a2, a3, a4]
8− }
9− }
10− }
11−}
12−var rgba_1 = Color_0;
13−var red_3 = ["Color",255,0,0,1];
14−var green_4 = ["Color",0,255,0,1];
15−var blue_5 = ["Color",0,0,255,1];
16−var yellow_6 = ["Color",255,255,0,1];
17−var cyan_7 = ["Color",0,255,255,1];
18−var magenta_8 = ["Color",255,0,255,1];
19−var black_9 = ["Color",0,0,0,1];
20−var white_10 = ["Color",255,255,255,1];
21−var gray_11 = ["Color",128,128,128,1];
22−var grey_12 = ["Color",128,128,128,1];
23−function rgb_2(r_13) {
24− return function(g_14) {
25− return function(b_15) {
26− return ["Color",r_13,g_14,b_15,1]
27− }
28− }
29−}
30−function extract(c) {
31− if (c[4] === 1) { return 'rgb(' + c[1] + ',' + c[2] + ',' + c[3] + ')'; }
32− return 'rgba(' + c[1] + ',' + c[2] + ',' + c[3] + ',' + c[4] + ')';
33−}
34−function complement(rgb) {
35− var hsv = toHSV(rgb);
36− hsv.hue = (hsv.hue + 180) % 360;
37− return toRGB(hsv);
38−}
39−
40−function hsva(h) { return function(s) { return function(v) { return function(a) {
41− var clr = toRGB({hue:h, saturation:s, value:v});
42− clr[4] = a;
43− return clr;
44− }; }; };
45−}
46−
47−function hsv(h) { return function(s) { return function(v) {
48− return toRGB({hue:h, saturation:s, value:v}); }; }; }
49−
50−function toHSV(rgb) {
51− var hsv = {};
52− var r = rgb[1] / 255.0, g = rgb[2] / 255.0, b = rgb[3] / 255.0;
53− var M = Math.max(r,g,b);
54− var m = Math.min(r,g,b);
55− var c = M - m;
56−
57− var h = 0;
58− if (c === 0) { h = 0; }
59− else if (M === r) { h = ((g - b) / c) % 6; }
60− else if (M === g) { h = ((b - r) / c) + 2; }
61− else if (M === b) { h = ((r - g) / c) + 4; }
62− h *= 60;
63−
64− return { value : M, hue : h, saturation : (M === 0 ? 0 : c / M) };
65−}
66−
67−function between(lo,hi,x) { return lo <= x && x < hi; }
68−function norm(n) { return Math.round(n*255); }
69−
70−function toRGB(hsv) {
71− var c = hsv.value * hsv.saturation;
72− var hue = hsv.hue / 60;
73− var x = c * (1 - Math.abs((hue % 2) - 1));
74− var r = 0, g = 0, b = 0;
75− if (between(0,1,hue)) { r = c; g = x; b = 0; }
76− else if (between(1,2,hue)) { r = x; g = c; b = 0; }
77− else if (between(2,3,hue)) { r = 0; g = c; b = x; }
78− else if (between(3,4,hue)) { r = 0; g = x; b = c; }
79− else if (between(4,5,hue)) { r = x; g = 0; b = c; }
80− else if (between(5,6,hue)) { r = c; g = 0; b = x; }
81−
82− var m = hsv.value - c;
83− return ["Color", norm(r+m), norm(g+m), norm(b+m), 1 ];
84−}
85− return{rgba:rgba_1, rgb:rgb_2, hsva:hsva, hsv:hsv, red:red_3, green:green_4, blue:blue_5, yellow:yellow_6, cyan:cyan_7, magenta:magenta_8, black:black_9, white:white_10, gray:gray_11, grey:grey_12,complement:complement,extract:extract}
86−}();
core-js/Graphics/Element.jsdeleted−517
@@ -1,517 +0,0 @@
1−Elm.Graphics = function() {
2− for (this['i'] in Elm.List) {
3− eval('var ' + this['i'] + ' = Elm.List[this.i];');
4− }
5− var JS = Elm.JavaScript;
6− var DLeft_0 = ["DLeft"];
7− var DRight_1 = ["DRight"];
8− var DUp_2 = ["DUp"];
9− var DDown_3 = ["DDown"];
10− var DIn_4 = ["DIn"];
11− var DOut_5 = ["DOut"];
12− function Absolute_12(a1) {
13− return["Absolute", a1]
14− }
15− function Relative_13(a1) {
16− return["Relative", a1]
17− }
18− var Near_14 = ["Near"];
19− var Mid_15 = ["Mid"];
20− var Far_16 = ["Far"];
21− function Position_17(a1) {
22− return function(a2) {
23− return["Position", a1, a2]
24− }
25− }
26− function PositionTL_18(a1) {
27− return function(a2) {
28− return["PositionTL", a1, a2]
29− }
30− }
31− function PositionTR_19(a1) {
32− return function(a2) {
33− return["PositionTR", a1, a2]
34− }
35− }
36− function PositionBL_20(a1) {
37− return function(a2) {
38− return["PositionBL", a1, a2]
39− }
40− }
41− function PositionBR_21(a1) {
42− return function(a2) {
43− return["PositionBR", a1, a2]
44− }
45− }
46− function Element_37(id,e,w,h,o,c,l) {
47− return["Element", id, e, w, h, o, c, l ]
48− }
49− function EText_39(a1) {
50− return function(a2) {
51− return["EText", a1, a2]
52− }
53− }
54− function EImage_40(a1) {
55− return["EImage", JS.castStringToJSString(a1)]
56− }
57− function EVideo_41(a1) {
58− return["EVideo", JS.castStringToJSString(a1)]
59− }
60− function EFittedImage_42(a1) {
61− return["EFittedImage", JS.castStringToJSString(a1)]
62− }
63− function EFlow_43(a1) {
64− return function(a2) {
65− return["EFlow", a1, JS.castListToJSArray(a2)]
66− }
67− }
68− function ECollage_44(a1) {
69− return function(a2) {
70− return function(a3) {
71− return["ECollage", a1, a2, Value.groupForms(a3)]
72− }
73− }
74− }
75− var EEmpty_45 = ["EEmpty"];
76− function EContainer_46(a1) {
77− return function(a2) {
78− return["EContainer", a1, a2]
79− }
80− }
81− var Solid_68 = ["Solid"];
82− var Dotted_69 = ["Dotted"];
83− var Dashed_70 = ["Dashed"];
84− function Custom_71(a1) {
85− return["Custom", JS.castListToJSArray(a1)]
86− }
87− var Filled_72 = ["Filled"];
88− var Outlined_73 = ["Outlined"];
89− function CustomOutline_74(a1) {
90− return["CustomOutline", JS.castListToJSArray(a1)]
91− }
92− function Line_75(a1) {
93− return["Line", JS.castListToJSArray(a1)]
94− }
95− function Shape_78(a1) {
96− return function(a2) {
97− var points = JS.castListToJSArray(a1);
98− if (points.length > 0) { points.push(points[0]); }
99− return["Shape", points, a2];
100− }
101− }
102− function Form_84(a1) {
103− return function(a2) {
104− return function(a3) {
105− return function(a4) {
106− return["Form", a1, a2, a3, a4]
107− }
108− }
109− }
110− }
111− function FLine_85(a1) {
112− return function(a2) {
113− return function(a3) {
114− return["FLine", a1, a2, a3]
115− }
116− }
117− }
118− function FShape_86(a1) {
119− return function(a2) {
120− return function(a3) {
121− return["FShape", a1, a2, a3]
122− }
123− }
124− }
125− function FImage_87(a1) {
126− return function(a2) {
127− return function(a3) {
128− return["FImage", a1, a2, JS.castStringToJSString(a3)]
129− }
130− }
131− }
132− function FElement_88(a1) {
133− return["FElement", a1]
134− }
135− var left_6 = DLeft_0;
136− var right_7 = DRight_1;
137− var down_8 = DDown_3;
138− var up_9 = DUp_2;
139− var inward_10 = DIn_4;
140− var outward_11 = DOut_5;
141− var topLeft_22 = Position_17(Near_14)(Near_14);
142− var topRight_23 = Position_17(Far_16)(Near_14);
143− var bottomLeft_24 = Position_17(Near_14)(Far_16);
144− var bottomRight_25 = Position_17(Far_16)(Far_16);
145− var midLeft_26 = Position_17(Near_14)(Mid_15);
146− var midRight_27 = Position_17(Far_16)(Mid_15);
147− var midTop_28 = Position_17(Mid_15)(Near_14);
148− var midBottom_29 = Position_17(Mid_15)(Far_16);
149− var middle_30 = Position_17(Mid_15)(Mid_15);
150− function middleAt(a1) {
151− return function(a2) {
152− return["PositionAt", a1, a2]
153− }
154− }
155− var topLeftAt_31 = PositionTL_18;
156− var topRightAt_32 = PositionTR_19;
157− var bottomLeftAt_33 = PositionBL_20;
158− var bottomRightAt_34 = PositionBR_21;
159− var absolute_35 = Absolute_12;
160− var relative_36 = Relative_13;
161− function newElement_38(e,w,h,o,c,l) { return Element_37(Guid.guid(),e,w,h,o,c,l); }
162− function basicNewElement(e,w,h) { return Element_37(Guid.guid(),e,w,h,1,["Nothing"],["Nothing"]); }
163− var line_76 = Line_75;
164− var polygon_79 = Shape_78;
165− function sprite_96(src) {
166− return function(w) {
167− return function(h) {
168− return function(pos) {
169− return Form_84(0)(1)(pos)(FImage_87(w)(h)(src))
170− }
171− }
172− }
173− }
174− function toForm_97(pos) {
175− return function(e) {
176− return Form_84(0)(1)(pos)(FElement_88(e))
177− }
178− }
179− function width_47(w__101) {
180− return function(e) {
181− var be = e[2];
182− switch(be[0]) {
183− case "EImage":
184− case "EVideo":
185− return newElement_38(e[2],w__101,e[4] * w__101 / e[3], e[5], e[6], e[7]);
186− case "EText":
187− var p = Value.getTextSize(w__101,e[4],be[2]);
188− return newElement_38(e[2], w__101, p[1], e[5], e[6], e[7]);
189− }
190− return newElement_38(e[2], w__101, e[4], e[5], e[6], e[7]);
191− }
192− }
193− function height_48(h__108) {
194− return function(e) {
195− var be = e[2];
196− switch(be[0]) {
197− case "EImage":
198− case "EVideo":
199− return newElement_38(e[2], e[3] * h__108 / e[4], h__108, e[5], e[6], e[7]);
200− }
201− return newElement_38(e[2], e[3], h__108, e[5], e[6], e[7]);
202− }
203− }
204− function size_49(w) {
205− return function(h) {
206− return function(e) {
207− return newElement_38(e[2], w, h, e[5], e[6], e[7]);
208− }
209− }
210− }
211− function opacity_50(o) {
212− return function(e) {
213− return newElement_38(e[2], e[3], e[4], o, e[6], e[7]);
214− }
215− }
216− function color_51(c) {
217− return function(e) {
218− return newElement_38(e[2], e[3], e[4], e[5], ["Just",c], e[7]);
219− }
220− }
221− function link(lnk) {
222− return function(e) {
223− return newElement_38(e[2], e[3], e[4], e[5], e[6], ["Just", JS.castStringToJSString(lnk)]);
224− }
225− }
226− function widthOf_52(e) { return ~~e[3]; }
227− function heightOf_53(e) { return ~~e[4]; }
228− function sizeOf_54(e) { return["Tuple2", ~~e[3], ~~e[4]] }
229− function text_56(txt) {
230− var p = Value.getTextSize(0,0,txt);
231− return basicNewElement(EText_39("left")(txt), p[0], p[1])
232− }
233− function plainText(str) {
234− var txt = Value.toText(str);
235− var p = Value.getTextSize(0,0,txt);
236− return basicNewElement(EText_39("left")(txt),p[0],p[1])
237− }
238− function asText(v) {
239− var txt = Elm.Text.monospace(Value.toText(Value.show(v)));
240− var p = Value.getTextSize(0,0,txt);
241− return basicNewElement(EText_39("left")(txt),p[0],p[1])
242− }
243− function centeredText(txt) {
244− var p = Value.getTextSize(0,0,txt);
245− return basicNewElement(EText_39("center")(txt),p[0],p[1])
246− }
247− function justifiedText(txt) {
248− var p = Value.getTextSize(0,0,txt);
249− return basicNewElement(EText_39("justify")(txt),p[0],p[1])
250− }
251− function rightedText(txt) {
252− var p = Value.getTextSize(0,0,txt);
253− return basicNewElement(EText_39("right")(txt),p[0],p[1])
254− }
255− function image_57(w) {
256− return function(h) {
257− return function(src) {
258− return basicNewElement(EImage_40(src),w,h)
259− }
260− }
261− }
262− function images(srcs) {
263− var pics = Elm.Signal.constant(spacer_66(0)(0));
264− var update = Elm.Signal.lift(function(src) {
265− src = JS.castStringToJSString(src);
266− var img = new Image();
267− img.onload = function() {
268− Dispatcher.notify(pics.id,
269− image_57(this.width)(this.height)(src));
270− };
271− img.src = src;
272− })(srcs);
273− function f(x) { return function(y) { return x; } }
274− var combine = Elm.Signal.lift2(f)(pics)(update);
275− return combine;
276− }
277− function video_58(w) {
278− return function(h) {
279− return function(src) {
280− return basicNewElement(EVideo_41(src),w,h)
281− }
282− }
283− }
284− function fittedImage_59(w_147) {
285− return function(h_148) {
286− return function(s_149) {
287− return basicNewElement(EFittedImage_42(s_149),w_147,h_148)
288− }
289− }
290− }
291− function flow_60(dir_150) {
292− return function(es_151) {
293− return function() {
294− var w_152 = function() {
295− var ws_154 = map(widthOf_52)(es_151);
296− return function(case1) {
297− var case0 = case1;
298− switch(case0[0]) {
299− case "DLeft":
300− return sum(ws_154);
301− case "DRight":
302− return sum(ws_154)
303− }
304− return maximum(ws_154)
305− }(dir_150)
306− }();
307− var h_153 = function() {
308− var hs_155 = map(heightOf_53)(es_151);
309− return function(case3) {
310− var case2 = case3;
311− switch(case2[0]) {
312− case "DDown":
313− return sum(hs_155);
314− case "DUp":
315− return sum(hs_155)
316− }
317− return maximum(hs_155)
318− }(dir_150)
319− }();
320− return basicNewElement(EFlow_43(dir_150)(es_151), w_152, h_153)
321− }()
322− }
323− }
324− function above_61(e1_156) {
325− return function(e2_157) {
326− return basicNewElement(EFlow_43(DDown_3)(["Cons", e1_156, ["Cons", e2_157, ["Nil"]]]), Math.max(widthOf_52(e1_156),widthOf_52(e2_157)), heightOf_53(e1_156) + heightOf_53(e2_157));
327− }
328− }
329− function below_62(e1_158) {
330− return function(e2_159) {
331− return basicNewElement(EFlow_43(DDown_3)(["Cons", e2_159, ["Cons", e1_158, ["Nil"]]]), Math.max(widthOf_52(e1_158),widthOf_52(e2_159)), heightOf_53(e1_158) + heightOf_53(e2_159));
332− }
333− }
334− function beside_63(e1_160) {
335− return function(e2_161) {
336− return basicNewElement(EFlow_43(DRight_1)(["Cons", e1_160, ["Cons", e2_161, ["Nil"]]]), widthOf_52(e1_160) + widthOf_52(e2_161), Math.max(heightOf_53(e1_160),heightOf_53(e2_161)));
337− }
338− }
339− function layers_64(es_162) {
340− return basicNewElement(EFlow_43(DOut_5)(es_162), maximum(map(widthOf_52)(es_162)), maximum(map(heightOf_53)(es_162)))
341− }
342− function collage_65(w_163) {
343− return function(h_164) {
344− return function(forms_165) {
345− return basicNewElement(ECollage_44(w_163)(h_164)(forms_165),w_163,h_164)
346− }
347− }
348− }
349− function spacer_66(w_166) {
350− return function(h_167) {
351− return basicNewElement(EEmpty_45,w_166,h_167)
352− }
353− }
354− function container_67(w_169) {
355− return function(h_170) {
356− return function(pos_168) {
357− return function(e_171) {
358− return basicNewElement(EContainer_46(pos_168)(e_171),w_169,h_170)
359− }
360− }
361− }
362− }
363− function segment_77(p1_172) {
364− return function(p2_173) {
365− return Line_75(["Cons", p1_172, ["Cons", p2_173, ["Nil"]]])
366− }
367− }
368− function rect_80(w_174) {
369− return function(h_175) {
370− return function(pos_176) {
371− return Shape_78(["Cons", ["Tuple2", 0 - w_174 / 2, 0 - h_175 / 2],
372− ["Cons", ["Tuple2", 0 - w_174 / 2, h_175 / 2],
373− ["Cons", ["Tuple2", w_174 / 2, h_175 / 2],
374− ["Cons", ["Tuple2", w_174 / 2, 0 - h_175 / 2], ["Nil"]]]]])(pos_176)
375− }
376− }
377− }
378− function oval_81(w_177) {
379− return function(h_178) {
380− return function(pos_179) {
381− return function() {
382− var n_180 = 50;
383− return function() {
384− function f_181(i_182) {
385− return["Tuple2", w_177 / 2 * Math.cos(2 * (Math.PI / n_180) * i_182), h_178 / 2 * Math.sin(2 * (Math.PI / n_180) * i_182)];
386− }
387− return Shape_78(map(f_181)(function() {
388− var lo = 0;
389− var hi = n_180 - 1;
390− var lst = ["Nil"];
391− if(lo <= hi) {
392− do {
393− lst = ["Cons", hi, lst]
394− }while(hi-- > lo)
395− }
396− return lst
397− }()))(pos_179)
398− }()
399− }()
400− }
401− }
402− }
403− function circle_82(r_183) {
404− return oval_81(2 * r_183)(2 * r_183)
405− }
406− function ngon_83(n_184) {
407− return function(r_185) {
408− return function(pos_186) {
409− return function() {
410− var m_187 = n_184;
411− return function() {
412− function f_188(i_189) {
413− return["Tuple2", r_185 * Math.cos(2 * (Math.PI / m_187) * i_189), r_185 * Math.sin(2 * (Math.PI / m_187) * i_189)];
414− }
415− return Shape_78(map(f_188)(function() {
416− var lo = 0;
417− var hi = n_184 - 1;
418− var lst = ["Nil"];
419− if(lo <= hi) {
420− do {
421− lst = ["Cons", hi, lst]
422− }while(hi-- > lo)
423− }
424− return lst
425− }()))(pos_186)
426− }()
427− }()
428− }
429− }
430− }
431− function solid_89(clr_190) {
432− return function(ln_191) {
433− return Form_84(0)(1)(["Tuple2", 0, 0])(FLine_85(Solid_68)(clr_190)(ln_191))
434− }
435− }
436− function dotted_90(clr_192) {
437− return function(ln_193) {
438− return Form_84(0)(1)(["Tuple2", 0, 0])(FLine_85(Dotted_69)(clr_192)(ln_193))
439− }
440− }
441− function dashed_91(clr_194) {
442− return function(ln_195) {
443− return Form_84(0)(1)(["Tuple2", 0, 0])(FLine_85(Dashed_70)(clr_194)(ln_195))
444− }
445− }
446− function customLine_92(pattern_196) {
447− return function(clr_197) {
448− return function(ln_198) {
449− return Form_84(0)(1)(["Tuple2", 0, 0])(FLine_85(Custom_71(pattern_196))(clr_197)(ln_198))
450− }
451− }
452− }
453− function filled_93(clr) {
454− return function(shape) {
455− return Form_84(0)(1)(shape[2])(FShape_86(Filled_72)(clr)(shape));
456− }
457− }
458− function outlined_94(clr) {
459− return function(shape) {
460− return Form_84(0)(1)(shape[2])(FShape_86(Outlined_73)(clr)(shape));
461− }
462− }
463− function customOutline_95(pattern) {
464− return function(clr) {
465− return function(shape) {
466− return Form_84(0)(1)(shape[2])(FShape_86(CustomOutline_74(pattern))(clr)(shape));
467− }
468− }
469− }
470− function textured(src) {
471− return function(shape) {
472− return Form_84(0)(1)(shape[2])(FShape_86(["Textured",src])(null)(shape));
473− }
474− }
475− function rotate_98(t_212) {
476− return function(Form$thetascaleposform_213) {
477− return function(case5) {
478− var case0 = case5;
479− switch(case0[0]) {
480− case "Form":
481− var case1 = case0[1], case2 = case0[2], case3 = case0[3], case4 = case0[4];
482− return Form_84(t_212 + case1)(case2)(case3)(case4)
483− }
484− throw new Error("Non-exhaustive pattern match in case");
485− }(Form$thetascaleposform_213)
486− }
487− }
488− function scale_99(s) {
489− return function(form) {
490− return Form_84(form[1])(s * form[2])(form[3])(form[4])
491− }
492− }
493− function move_100(x_224) {
494− return function(y_225) {
495− return function(Form$thetascaleTuple2$pxpyform_226) {
496− return function(case7) {
497− var case0 = case7;
498− switch(case0[0]) {
499− case "Form":
500− var case1 = case0[1], case2 = case0[2], case3 = case0[3], case4 = case0[4];
501− switch(case3[0]) {
502− case "Tuple2":
503− var case5 = case3[1], case6 = case3[2];
504− return Form_84(case1)(case2)(["Tuple2", x_224 + case5, y_225 + case6])(case4)
505− }
506− break
507− }
508− throw new Error("Non-exhaustive pattern match in case");
509− }(Form$thetascaleTuple2$pxpyform_226)
510− }
511− }
512− }
513− return{left:left_6, right:right_7, down:down_8, up:up_9, inward:inward_10, outward:outward_11, topLeft:topLeft_22, topRight:topRight_23, bottomLeft:bottomLeft_24, bottomRight:bottomRight_25, midLeft:midLeft_26, midRight:midRight_27, midTop:midTop_28, midBottom:midBottom_29, middle:middle_30, middleAt:middleAt, topLeftAt:topLeftAt_31, topRightAt:topRightAt_32, bottomLeftAt:bottomLeftAt_33, bottomRightAt:bottomRightAt_34, absolute:absolute_35, relative:relative_36, width:width_47, height:height_48, size:size_49, opacity:opacity_50,
514− color:color_51, link:link, widthOf:widthOf_52, heightOf:heightOf_53, sizeOf:sizeOf_54, text:text_56, asText:asText, plainText:plainText, centeredText:centeredText, justifiedText:justifiedText, rightedText:rightedText, image:image_57, images:images, video:video_58, fittedImage:fittedImage_59, flow:flow_60, above:above_61, below:below_62, beside:beside_63, layers:layers_64, collage:collage_65, spacer:spacer_66, container:container_67, line:line_76, segment:segment_77, polygon:polygon_79, rect:rect_80, oval:oval_81, circle:circle_82, ngon:ngon_83, solid:solid_89, dotted:dotted_90, dashed:dashed_91, customLine:customLine_92, filled:filled_93,
515− outlined:outlined_94, customOutline:customOutline_95, textured:textured, sprite:sprite_96, toForm:toForm_97, rotate:rotate_98, scale:scale_99, move:move_100,
516− isWithin: Collage.insideForm}
517−}();
core-js/Graphics/Render.jsdeleted−277
@@ -1,277 +0,0 @@
1−
2−var Render = function(){
3−
4−function newElement(elementType) {
5− var e = document.createElement(elementType);
6− e.style.padding = "0";
7− e.style.margin = "0";
8− return e;
9−};
10−
11−function addTo(container, elem) {
12− container.appendChild(elem);
13−};
14−
15−function makeText(pos,txt) {
16− var e = newElement('div');
17− e.innerHTML = txt;
18− e.style.textAlign = pos;
19− return e;
20−};
21−
22−function image(src) {
23− var img = newElement('img');
24− img.src = src;
25− img.name = src;
26− img.style.display = "block";
27− return img;
28−}
29−
30−function fittedImage(w,h,src) {
31− var e = newElement('div');
32− e.style.width = w + 'px';
33− e.style.height = h + 'px';
34− e.style.position = "relative";
35− e.style.overflow = "hidden";
36−
37− var img = newElement('img');
38− img.onload = function() {
39− img.style.position = 'absolute';
40− img.style.margin = 'auto';
41−
42− var sw = w, sh = h;
43− if (w / h > this.width / this.height) {
44− sh = Math.round(this.height * w / this.width);
45− } else {
46− sw = Math.round(this.width * h / this.height);
47− }
48− img.style.width = sw + 'px';
49− img.style.height = sh + 'px';
50− img.style.left = ((w - sw) / 2) + 'px';
51− img.style.top = ((h - sh) / 2) + 'px';
52− };
53− img.src = src;
54− img.name = src;
55− addTo(e,img);
56− return e;
57−};
58−
59−var video = function(src) {
60− var e = newElement('video');
61− e.controls = "controls";
62− var source = newElement('source');
63− source.src = src;
64− var segs = src.split('.');
65− source.type = "video/" + segs[segs.length-1];
66− addTo(e, source);
67− e.style.display = "block";
68− return e;
69−};
70−
71−function divify(e) {
72− var div = newElement('div');
73− addTo(div, e);
74− return div;
75−};
76−function goDown(e) {
77− return e //.tagName === "DIV" ? e : divify(e);
78−};
79−function goRight(e) {
80− e.style.styleFloat = "left";
81− e.style.cssFloat = "left";
82− return e;
83−};
84−function goIn(e) {
85− e.style.position = 'absolute';
86− return e;
87−};
88−function flowWith(f, prep, elist) {
89− var container = newElement('div');
90− for (var i = elist.length; i--; ) {
91− addTo(container, f(prep(elist[i])));
92− }
93− return container;
94−};
95−
96−function flow(dir,elist) {
97− switch(dir) {
98− case "DDown": elist = elist.slice(0).reverse();
99− case "DUp": return flowWith(goDown,render,elist);
100− case "DRight": elist = elist.slice(0).reverse();
101− case "DLeft": return flowWith(goRight,render,elist);
102− case "DOut": elist = elist.slice(0).reverse();
103− case "DIn": return flowWith(goIn,render,elist);
104− };
105−};
106−
107−function toPos(pos) {
108− switch(pos[0]) {
109− case "Absolute": return pos[1] + "px";
110− case "Relative": return (pos[1] * 100) + "%";
111− }
112−}
113−
114−function setPos(pos,e) {
115− e.style.position = 'absolute';
116− e.style.margin = 'auto';
117− switch(pos[0]) {
118− case "Position":
119− if (pos[1][0] !== "Far") e.style.left = 0;
120− if (pos[1][0] !== "Near") e.style.right = 0;
121− if (pos[2][0] !== "Far") e.style.top = 0;
122− if (pos[2][0] !== "Near") e.style.bottom = 0;
123− break;
124− case "PositionAt":
125− e.style.top = toPos(pos[2]);
126− e.style.left = toPos(pos[1]);
127− var shift = "translate(" + ~~(-e.style.width.slice(0,-2) / 2) + "px," + ~~(-e.style.height.slice(0,-2) / 2) + "px)";
128− e.style.transform = shift;
129− e.style.msTransform = shift;
130− e.style.MozTransform = shift;
131− e.style.webkitTransform = shift;
132− e.style.OTransform = shift;
133− break;
134− default:
135− var p = pos[0].slice(-2);
136− e.style[p[0] === "T" ? 'top' : 'bottom'] = toPos(pos[2]);
137− e.style[p[1] === "L" ? 'left' : 'right'] = toPos(pos[1]);
138− }
139−}
140−
141−function container(pos,elem) {
142− var e = render(elem);
143− setPos(pos,e);
144− var div = newElement('div');
145− div.style.position = "relative";
146− div.style.overflow = "hidden";
147− addTo(div,e);
148− return div;
149−};
150−
151−function render(elem) {
152− var e = {};
153− switch(elem[2][0]) {
154− case "EText": e = makeText(elem[2][1],elem[2][2]); break;
155− case "EImage": e = image(elem[2][1]); break;
156− case "EVideo": e = video(elem[2][1]); break;
157− case "EFittedImage": e = fittedImage(elem[3],elem[4],elem[2][1]); break;
158− case "EFlow": e = flow(elem[2][1][0],elem[2][2]); break;
159− case "ECollage": e = Collage.collage(elem[2][1],elem[2][2],elem[2][3]); break;
160− case "EEmpty": e = newElement('div'); break;
161− case "EContainer": e = container(elem[2][1],elem[2][2]); break;
162− case "EHtml":
163− e = elem[2][1];
164− if (e.type !== 'button') {
165− var p = Value.getExcess(e);
166− elem[3] -= p[0];
167− elem[4] -= p[1];
168− }
169− break;
170− case "EExternalHtml":
171− e = newElement('div');
172− addTo(e, elem[2][1]);
173− break;
174− }
175− e.id = elem[1];
176− e.style.width = (~~elem[3]) + 'px';
177− e.style.height = (~~elem[4]) + 'px';
178− if (elem[5] !== 1) { e.style.opacity = elem[5]; }
179− if (elem[6][0] === "Just") {
180− e.style.backgroundColor = Elm.Color.extract(elem[6][1]);
181− }
182− if (elem[7][0] === "Just") {
183− var a = newElement('a');
184− a.href = elem[7][1];
185− addTo(a,e);
186− return a;
187− }
188− return e;
189−};
190−
191−function update(node,curr,next) {
192− if (node.tagName === 'A') { node = node.firstChild; }
193− if (curr[1] === next[1]) return;
194− if (curr[2][0] !== next[2][0]) {
195− return node.parentNode.replaceChild(render(next),node);
196− }
197− var nextE = next[2], currE = curr[2];
198− switch(nextE[0]) {
199− case "EText":
200− if (nextE[1] !== currE[1]) node.style.textAlign = nextE[1];
201− if (nextE[2] !== currE[2]) node.innerHTML = nextE[2];
202− break;
203− case "EImage":
204− if (nextE[1] !== currE[1]) node.src = nextE[1];
205− break;
206− case "EVideo":
207− case "EFittedImage":
208− if (!Value.eq(nextE,currE) || next[3]!==curr[3] || next[4]!==curr[4]) {
209− return node.parentNode.replaceChild(render(next),node);
210− }
211− break;
212− case "ECollage":
213− if (nextE[1] !== currE[1] || nextE[2] !== currE[2] || nextE[3].length !== currE[3].length) {
214− return node.parentNode.replaceChild(render(next),node);
215− }
216− Collage.updateCollage(node,currE[3],nextE[3]);
217− break;
218− case "EFlow":
219− if (nextE[1] !== currE[1]) {
220− return node.parentNode.replaceChild(render(next),node);
221− }
222− var nexts = nextE[2];
223− var kids = node.childNodes;
224− if (nexts.length !== kids.length) {
225− return node.parentNode.replaceChild(render(next),node);
226− }
227− var currs = currE[2];
228− var goDir = function(x) { return x; };
229− switch(nextE[1][0]) {
230− case "DDown": case "DUp": goDir = goDown; break;
231− case "DRight": case "DLeft": goDir = goRight; break;
232− case "DOut": case "DIn": goDir = goIn; break;
233− }
234− for (var i = kids.length; i-- ;) {
235− update(kids[i],currs[i],nexts[i]);
236− goDir(kids[i]);
237− }
238− break;
239− case "EContainer":
240− update(node.childNodes[0],currE[2],nextE[2]);
241− setPos(nextE[1],node.childNodes[0]);
242− break;
243− case "EEmpty":
244− break;
245− case "EHtml":
246− if (next[1] !== curr[1]) {
247− var e = render(next);
248− node.parentNode.replaceChild(e,node);
249− node = e;
250− }
251− if (e.type !== 'button') {
252− var p = Value.getExcess(node);
253− next[3] -= p[0];
254− next[4] -= p[1];
255− }
256− break;
257− case "EExternalHtml":
258− if (next[1] !== curr[1])
259− node.parentNode.replaceChild(render(next),node);
260− break;
261− }
262− if (next[3] !== curr[3]) node.style.width = (~~next[3]) + 'px';
263− if (next[4] !== curr[4]) node.style.height = (~~next[4]) + 'px';
264− if (next[5] !== curr[5]) node.style.opacity = next[5];
265− if (next[6].length === 2) {
266− var clr = Elm.Color.extract(next[6][1]);
267− if (clr !== node.style.backgroundColor) node.style.backgroundColor = clr;
268− }
269− if (next[7].length === 2) {
270− if (curr[7].length === 1 || next[7][1] !== curr[7][1]) node.parentNode.href = next[7][1];
271− }
272− next[1] = curr[1];
273−}
274−
275−return {render:render,update:update,addTo:addTo,newElement:newElement,flowWith:flowWith,goIn:goIn};
276−
277−}();
core-js/Guid.jsdeleted−8
@@ -1,8 +0,0 @@
1−
2−Elm = {};
3−
4−var Guid = function() {
5− var counter = 0;
6− var guid = function() { counter += 1; return counter; };
7− return {guid : guid};
8−}();
core-js/List.jsdeleted−482
@@ -1,482 +0,0 @@
1−Elm.List = function() {
2−
3− var throwError = function(f) {
4− throw new Error("Function '" + f + "' expecting a list!");
5− }
6−
7− function length(xs) {
8− var out = 0;
9− while (xs[0] === "Cons") {
10− out += 1;
11− xs = xs[2];
12− }
13− return out;
14− };
15− var reverse = foldl(function(x_72) {
16− return function(y_73) {
17− return["Cons", x_72, y_73]
18− }
19− })(["Nil"]);
20− var concat = foldr(function(x_74) {
21− return function(y_75) {
22− return Value.append(x_74, y_75)
23− }
24− })(["Nil"]);
25− var and = foldl(function(x_77) {
26− return function(y_78) {
27− return x_77 && y_78
28− }
29− })(true);
30− var or = foldl(function(x_79) {
31− return function(y_80) {
32− return x_79 || y_80
33− }
34− })(false);
35− var sum = foldl(function(x_89) {
36− return function(y_90) {
37− return x_89 + y_90
38− }
39− })(0);
40− var product = foldl(function(x_91) {
41− return function(y_92) {
42− return x_91 * y_92
43− }
44− })(1);
45− var maximum = foldl1(function(x) { return function(y) { return Math.max(x,y) } });
46− var minimum = foldl1(function(x) { return function(y) { return Math.min(x,y) } });
47− function head(v) {
48− if (v[0] !== "Cons") {
49− throw new Error("Error: 'head' only accepts lists of length greater than one.");
50− }
51− return v[1];
52− }
53− function tail(v) {
54− if (v[0] !== "Cons") {
55− throw new Error("Error: 'tail' only accepts lists of length greater than one.");
56− }
57− return v[2];
58− }
59− function last(v) {
60− if (v[0] !== "Cons") {
61− throw new Error("Error: 'last' only accepts lists of length greater than one.");
62− }
63− var out = v[1];
64− while (v[0] === "Cons") {
65− out = v[1];
66− v = v[2];
67− }
68− return out;
69− }
70− function map(f) {
71− return function(xs) {
72− if (xs[0] === "Nil") { return xs; }
73− if (xs[0] !== "Cons") { throwError('map'); }
74− var root = ["Cons", f(xs[1]), ["Nil"]];
75− var curr = root;
76− xs = xs[2];
77− while (xs[0]==="Cons") {
78− curr[2] = ["Cons", f(xs[1]), ["Nil"]];
79− xs = xs[2];
80− curr = curr[2];
81− }
82− return root;
83− }
84− }
85− function foldl(f) {
86− return function(b) {
87− return function(xs) {
88− var acc = b;
89− if (xs[0] === "Nil") { return acc; }
90− if (xs[0] !== "Cons") { throwError('foldl'); }
91− while (xs[0] === "Cons") {
92− acc = f(xs[1])(acc);
93− xs = xs[2];
94− }
95− return acc;
96− }
97− }
98− }
99− function foldr(f) {
100− return function(b) {
101− return function(xs) {
102− var acc = b;
103− if (xs[0] === "Nil") { return acc; }
104− if (xs[0] !== "Cons") { throwError('foldr'); }
105− var arr = [];
106− while (xs[0] === "Cons") {
107− arr.push(xs[1]);
108− xs = xs[2];
109− }
110− for (var i = arr.length; i--; ) {
111− acc = f(arr[i])(acc);
112− }
113− return acc;
114− }
115− }
116− }
117− function foldl1(f_49) {
118− return function(_temp_50) {
119− return function(v) {
120− if("Cons" !== v[0]) {
121− return undefined
122− }else {
123− var x_51 = v[1];
124− var xs_52 = v[2];
125− return foldl(f_49)(x_51)(xs_52)
126− }
127− }(_temp_50)
128− }
129− }
130− function foldr1(f) {
131− return function(xs) {
132− if (xs[0] === "Nil") { throw new Error("'foldr1' requires an non-empty list.") }
133− if (xs[0] !== "Cons") { throwError('foldr1'); }
134− var arr = [];
135− while (xs[0] === "Cons") {
136− arr.push(xs[1]);
137− xs = xs[2];
138− }
139− var acc = arr.pop();
140− for (var i = arr.length; i--; ) {
141− acc = f(arr[i])(acc);
142− }
143− return acc;
144− }
145− }
146− function scanl(f) {
147− return function(b) {
148− return function(xs) {
149− if (xs[0] === "Nil") { return ["Cons",b,["Nil"]]; }
150− if (xs[0] !== "Cons") { throwError('scanl'); }
151− var arr = [b];
152− while (xs[0] === "Cons") {
153− b = f(xs[1])(b);
154− arr.push(b);
155− xs = xs[2];
156− }
157− var out = ["Nil"];
158− for (var i = arr.length; i--; ) {
159− out = ["Cons", arr[i], out];
160− }
161− return out;
162− }
163− }
164− }
165− function scanl1(f) {
166− return function(xs) {
167− if (xs[0] !== "Cons") {
168− throw new Error("Error: 'scanl1' requires a list of at least length 1.");
169− }
170− return scanl(f)(xs[1])(xs[2]);
171− }
172− }
173− function filter(pred) {
174− return function(xs) {
175− if (xs[0] === "Nil") { return xs; }
176− if (xs[0] !== "Cons") { throwError('filter'); }
177− var arr = [];
178− while (xs[0] === "Cons") {
179− if (pred(xs[1])) { arr.push(xs[1]); }
180− xs = xs[2];
181− }
182− var out = ["Nil"];
183− for (var i = arr.length; i--; ) {
184− out = ["Cons", arr[i], out];
185− }
186− return out;
187− }
188− }
189− function concatMap(f_76) {
190− return function(x) {
191− return concat(map(f_76)(x))
192− }
193− }
194− function all(pred) {
195− return foldl(function(x) { return function(acc) {
196− return acc && pred(x);
197− };})(true);
198− }
199− function any(pred) {
200− return foldl(function(x) { return function(acc) {
201− return acc || pred(x);
202− };})(false);
203− }
204− function partition(pred_93) {
205− return function(lst_94) {
206− return function() {
207− var v = lst_94;
208− var c = [function(v) {
209− if("Nil" !== v[0]) {
210− return undefined
211− }else {
212− return["Tuple2", ["Nil"], ["Nil"]]
213− }
214− }, function(v) {
215− if("Cons" !== v[0]) {
216− return undefined
217− }else {
218− var x_95 = v[1];
219− var xs_96 = v[2];
220− return function(v) {
221− if("Tuple2" !== v[0]) {
222− return undefined
223− }else {
224− var as_97 = v[1];
225− var bs_98 = v[2];
226− return pred_93(x_95) ? ["Tuple2", ["Cons", x_95, as_97], bs_98] : ["Tuple2", as_97, ["Cons", x_95, bs_98]]
227− }
228− }(partition(pred_93)(xs_96))
229− }
230− }];
231− for(var i = c.length;i--;) {
232− var r = c[i](v);
233− if(r !== undefined) {
234− return r
235− }
236− }
237− }()
238− }
239− }
240− function zipWith(f) {
241− return function(listA) {
242− return function(listB) {
243− if (listA[0] === "Nil" || listB[0] === "Nil") { return ["Nil"]; }
244− if (listA[0] !== "Cons" || listB[0] !== "Cons") { throwError('zipWith'); }
245− var arr = [];
246− while (listA[0] === "Cons" && listB[0] === "Cons") {
247− arr.push(f(listA[1])(listB[1]));
248− listA = listA[2];
249− listB = listB[2];
250− }
251− var out = ["Nil"];
252− for (var i = arr.length; i--; ) {
253− out = ["Cons", arr[i], out];
254− }
255− return out;
256− }
257− }
258− }
259− function zip(listA) {
260− return function(listB) {
261− if (listA[0] === "Nil" || listB[0] === "Nil") { return ["Nil"]; }
262− if (listA[0] !== "Cons" || listB[0] !== "Cons") { throwError('zip'); }
263− var arr = [];
264− while (listA[0] === "Cons" && listB[0] === "Cons") {
265− arr.push(["Tuple2", listA[1], listB[1]]);
266− listA = listA[2];
267− listB = listB[2];
268− }
269− var out = ["Nil"];
270− for (var i = arr.length; i--; ) {
271− out = ["Cons", arr[i], out];
272− }
273− return out;
274− }
275− }
276− function unzip(pairs_112) {
277− return function() {
278− var v = pairs_112;
279− var c = [function(v) {
280− if("Nil" !== v[0]) {
281− return undefined
282− }else {
283− return["Tuple2", ["Nil"], ["Nil"]]
284− }
285− }, function(v) {
286− if("Cons" !== v[0]) {
287− return undefined
288− }else {
289− var p_113 = v[1];
290− var ps_114 = v[2];
291− return function(v) {
292− if("Tuple2" !== v[0]) {
293− return undefined
294− }else {
295− if("Tuple2" !== v[1][0]) {
296− return undefined
297− }else {
298− var x_115 = v[1][1];
299− var y_116 = v[1][2];
300− if("Tuple2" !== v[2][0]) {
301− return undefined
302− }else {
303− var xs_117 = v[2][1];
304− var ys_118 = v[2][2];
305− return["Tuple2", ["Cons", x_115, xs_117], ["Cons", y_116, ys_118]]
306− }
307− }
308− }
309− }(["Tuple2", p_113, unzip(ps_114)])
310− }
311− }];
312− for(var i = c.length;i--;) {
313− var r = c[i](v);
314− if(r !== undefined) {
315− return r
316− }
317− }
318− }()
319− }
320− function intersperse(sep_119) {
321− return function(xs_120) {
322− return function() {
323− var v = xs_120;
324− var c = [function(v) {
325− if("Nil" !== v[0]) {
326− return undefined
327− }else {
328− return["Nil"]
329− }
330− }, function(v) {
331− if("Cons" !== v[0]) {
332− return undefined
333− }else {
334− var a_124 = v[1];
335− if("Nil" !== v[2][0]) {
336− return undefined
337− }else {
338− return["Cons", a_124, ["Nil"]]
339− }
340− }
341− }, function(v) {
342− if("Cons" !== v[0]) {
343− return undefined
344− }else {
345− var a_121 = v[1];
346− if("Cons" !== v[2][0]) {
347− return undefined
348− }else {
349− var b_122 = v[2][1];
350− var cs_123 = v[2][2];
351− return["Cons", a_121, ["Cons", sep_119, intersperse(sep_119)(["Cons", b_122, cs_123])]]
352− }
353− }
354− }];
355− for(var i = c.length;i--;) {
356− var r = c[i](v);
357− if(r !== undefined) {
358− return r
359− }
360− }
361− }()
362− }
363− }
364− function intercalate(sep_125) {
365− return function(xs_126) {
366− return function() {
367− var v = xs_126;
368− var c = [function(v) {
369− if("Nil" !== v[0]) {
370− return undefined
371− }else {
372− return["Nil"]
373− }
374− }, function(v) {
375− if("Cons" !== v[0]) {
376− return undefined
377− }else {
378− var a_130 = v[1];
379− if("Nil" !== v[2][0]) {
380− return undefined
381− }else {
382− return a_130
383− }
384− }
385− }, function(v) {
386− if("Cons" !== v[0]) {
387− return undefined
388− }else {
389− var a_127 = v[1];
390− if("Cons" !== v[2][0]) {
391− return undefined
392− }else {
393− var b_128 = v[2][1];
394− var cs_129 = v[2][2];
395− return Value.append(a_127, Value.append(sep_125, intercalate(sep_125)(["Cons", b_128, cs_129])))
396− }
397− }
398− }];
399− for(var i = c.length;i--;) {
400− var r = c[i](v);
401− if(r !== undefined) {
402− return r
403− }
404− }
405− }()
406− }
407− }
408− function sort(xs) {
409− if (xs[0] === "Nil") { return xs; }
410− if (xs[0] !== "Cons") { throwError('sort'); }
411− var arr = [];
412− while (xs[0] === "Cons") {
413− arr.push(xs[1]);
414− xs = xs[2];
415− }
416− arr.sort(function(a,b) { return a - b});
417− var out = ["Nil"];
418− for (var i = arr.length; i--; ) {
419− out = [ "Cons", arr[i], out ];
420− }
421− return out;
422− }
423− function take(n) { return function(xs) {
424− if (n <= 0) { return ["Nil"]; }
425− if (xs[0] === "Nil") { return xs; }
426− if (xs[0] !== "Cons") { throwError('take'); }
427− var out = [ "Cons", xs[1], ["Nil"] ];
428− var temp = out;
429− xs = xs[2];
430− --n;
431− while (xs[0] === "Cons" && n > 0) {
432− temp[2] = [ "Cons", xs[1], ["Nil"] ];
433− temp = temp[2];
434− xs = xs[2];
435− --n;
436− }
437− return out;
438− };
439− }
440− function drop(n) { return function(xs) {
441− if (xs[0] === "Nil") { return xs; }
442− if (xs[0] !== "Cons") { throwError('drop'); }
443− while (xs[0] === "Cons" && n > 0) {
444− xs = xs[2];
445− --n;
446− }
447− return xs;
448− };
449− }
450− return {head:head,
451− tail:tail,
452− last:last,
453− map:map,
454− foldl:foldl,
455− foldr:foldr,
456− foldl1:foldl1,
457− foldr1:foldr1,
458− scanl:scanl,
459− scanl1:scanl1,
460− filter:filter,
461− length:length,
462− reverse:reverse,
463− concat:concat,
464− concatMap:concatMap,
465− and:and,
466− or:or,
467− all:all,
468− any:any,
469− sum:sum,
470− product:product,
471− maximum:maximum,
472− minimum:minimum,
473− partition:partition,
474− zipWith:zipWith,
475− zip:zip,
476− unzip:unzip,
477− intersperse:intersperse,
478− intercalate:intercalate,
479− sort:sort,
480− take:take,
481− drop:drop};
482−}();
core-js/Maybe.jsdeleted−62
@@ -1,62 +0,0 @@
1−/*! Maybe
2−!*/
3−
4−/*[Definition]*/
5−
6−/** data Maybe a = Just a | Nothing
7− The Maybe datatype. Useful when a computation may or may not
8− result in a value (e.g. logarithm is defined only for positive numbers).
9−**/
10−
11−/*[Basic Utilities]*/
12−
13−/** maybe : b -> (a -> b) -> Maybe a -> b
14− Apply a function to the contents of a `Maybe`.
15− Return default when given `Nothing`.
16−**/
17−/** isJust : Maybe a -> Bool
18− Check if constructed with `Just`.
19−**/
20−/** isNothing : Maybe a -> Bool
21− Check if constructed with `Nothing`.
22−**/
23−
24−/*[Maybe with Lists]*/
25−
26−/** cons : Maybe a -> [a] -> [a]
27− If `Just`, adds the value to the front of the list.
28− If `Nothing`, list is unchanged.
29−**/
30−/** justs : [Maybe a] -> [a]
31− Filters out Nothings and extracts the remaining values.
32−**/
33−
34−Elm.Maybe = function() {
35− function consMaybe(x) { return function(xs) {
36− if (x[0] === "Just") return ["Cons", x[1], xs];
37− return xs;
38− };
39− }
40− function mapCons(f) { return function(y) { return function(xs) {
41− var x = f(y);
42− if (x[0] === "Just") return ["Cons", x[1], xs];
43− return xs;
44− };
45− };
46− }
47− function maybe(b) { return function(f) { return function(m) {
48− if (m[0] === "Just") return f(m[1]);
49− return b;
50− };
51− };
52− }
53−
54− return {Just : function(x) { return ["Just",x]; },
55− Nothing : ["Nothing"],
56− justs : Elm.List.foldr(consMaybe)(["Nil"]),
57− isJust : function(m) { return m[0] === "Just"; },
58− isNothing : function(m) { return m[0] === "Nothing"; },
59− cons : consMaybe,
60− maybe : maybe
61− };
62−}();
core-js/Prelude.jsdeleted−243
@@ -1,243 +0,0 @@
1−function elmRecordCopy(r) {
2− var o = {};
3− for (var i in r) { o[i] = r[i]; }
4− return o;
5−}
6−
7−function elmRecordRemove(x,r) {
8− var o = elmRecordCopy(r);
9− if (x in o._) {
10− o[x] = o._[x][0];
11− o._[x] = o._[x].slice(1);
12− if (o._[x].length === 0) { delete o._[x]; }
13− } else {
14− delete o[x];
15− }
16− return o;
17−}
18−
19−function elmRecordReplace(kvs,r) {
20− var o = elmRecordCopy(r);
21− for (var i = kvs.length; i--; ) {
22− kvsi = kvs[i];
23− o[kvsi[0]] = kvsi[1];
24− }
25− return o;
26−}
27−
28−function elmRecordInsert(x,v,r) {
29− var o = elmRecordCopy(r);
30− if (x in o) o._[x] = [o[x]].concat(x in o._ ? o._[x].slice(0) : []);
31− o[x] = v;
32− return o;
33−}
34−
35−Value.addListener(document, 'elm_log', function(e) { console.log(e.value); });
36−Value.addListener(document, 'elm_title', function(e) {document.title = e.value;});
37−Value.addListener(document, 'elm_redirect', function(e) {
38− if (e.value.length > 0) { window.location = e.value; }
39− });
40−Value.addListener(document, 'elm_viewport', function(e) {
41− var node = document.getElementById('elm_viewport');
42− if (!node) {
43− node = document.createElement('meta');
44− node.id = 'elm_viewport';
45− node.name = 'viewport';
46− document.head.appendChild(node);
47− }
48− node.content = e.value;
49− Dispatcher.notify(Elm.Window.dimensions.id,
50− Value.Tuple(window.innerWidth, window.innerHeight));
51− });
52−
53−Elm.Prelude = function() {
54− var mod = function(x) { return function(y) {
55− var r = x % y;
56− var m = x==0 ? 0 : (y>0 ? (x>=0 ? r : r+y) : -mod(-x)(-y));
57− return m == y ? 0 : m;
58− }; };
59−
60− var min = function(x) { return function(y) { return Math.min(x,y); }; };
61− var max = function(x) { return function(y) { return Math.max(x,y); }; };
62−
63− var flip=function(f){return function(x){return function(y){return f(y)(x);};};};
64− var clamp = function(lo) { return function(hi) {
65− return function(x) { return Math.min(hi, Math.max(lo, x)); };
66− };
67− };
68− var curry = function(f) { return function(x) { return function(y) {
69− return f(["Tuple2",x,y]); }; };
70− };
71− var uncurry = function(f) { return function(p) {
72− if (p[0] !== "Tuple2") {
73− throw new Error("Function was uncurry'd but was not given a pair.");
74− }
75− return f(p[1])(p[2]); };
76− };
77−
78− var logBase=function(b){return function(x){return Math.log(x)/Math.log(b);};};
79−
80− function readInt(str) {
81− var s = Elm.JavaScript.castStringToJSString(str);
82− var len = s.length;
83− if (len === 0) { return ["Nothing"]; }
84− var start = 0;
85− if (s[0] == '-') {
86− if (len === 1) { return ["Nothing"]; }
87− start = 1;
88− }
89− for (var i = start; i < len; ++i) {
90− if (!Elm.Char.isDigit(s[i])) { return ["Nothing"]; }
91− }
92− return ["Just", parseInt(s)];
93− }
94−
95− function readFloat(str) {
96− var s = Elm.JavaScript.castStringToJSString(str);
97− var len = s.length;
98− if (len === 0) { return ["Nothing"]; }
99− var start = 0;
100− if (s[0] == '-') {
101− if (len === 1) { return ["Nothing"]; }
102− start = 1;
103− }
104− var dotCount = 0;
105− for (var i = start; i < len; ++i) {
106− if (Elm.Char.isDigit(s[i])) { continue; }
107− if (s[i] === '.') {
108− dotCount += 1;
109− if (dotCount <= 1) { continue; }
110− }
111− return ["Nothing"];
112− }
113− return ["Just", parseFloat(s)];
114− }
115−
116− function compare(x) { return function (y) {
117− if (x instanceof Array && y instanceof Array) {
118− var len = x.length;
119− if (len == y.length) {
120− for (var i = 1; i < len; ++i) {
121− var cmp = compare(x[i])(y[i]);
122− if (cmp[0] === 'EQ') continue;
123− return cmp;
124− }
125− return ['EQ'];
126− }
127− return [ y.length == 1 ? 'GT' : 'LT' ];
128− }
129− return [ x === y ? 'EQ' : (x < y ? 'LT' : 'GT') ];
130− };
131− }
132− return {eq : Value.eq,
133− id : function(x) { return x; },
134− not : function(b) { return !b; },
135− xor : function(x) { return function(y) { return x != y; }; },
136− fst : function(p) { return p[1]; },
137− snd : function(p) { return p[2]; },
138− rem : function(x) { return function(y) { return x % y; }; },
139− div : function(x) { return function(y) { return ~~(x / y); }; },
140− otherwise : true,
141− compare : compare,
142− toFloat : function(x) { return x; },
143− round : function(n) { return Math.round(n); },
144− floor : function(n) { return Math.floor(n); },
145− ceiling : function(n) { return Math.ceil(n); },
146− truncate : function(n) { return ~~n; },
147− readInt : readInt,
148− readFloat : readFloat,
149− sqrt : Math.sqrt,
150− abs : Math.abs,
151− pi : Math.PI,
152− e : Math.E,
153− sin : Math.sin,
154− cos : Math.cos,
155− tan : Math.tan,
156− asin : Math.asin,
157− acos : Math.acos,
158− atan : Math.atan,
159− atan2 : function(y) { return function(x) { return Math.atan2(y,x); }; },
160− mod : mod,
161− min : min,
162− max : max,
163− flip : flip,
164− clamp : clamp,
165− curry : curry,
166− uncurry : uncurry,
167− logBase : logBase,
168− Just : Elm.Maybe.Just,
169− Nothing : Elm.Maybe.Nothing,
170− maybe : Elm.Maybe.maybe,
171− map : Elm.List.map,
172− zip : Elm.List.zip,
173− zipWith : Elm.List.zipWith,
174− filter : Elm.List.filter,
175− head : Elm.List.head,
176− tail : Elm.List.tail,
177− last : Elm.List.last,
178− length : Elm.List.length,
179− reverse : Elm.List.reverse,
180− foldr : Elm.List.foldr,
181− foldr1 : Elm.List.foldr1,
182− foldl : Elm.List.foldl,
183− foldl1 : Elm.List.foldl1,
184− and : Elm.List.and,
185− or : Elm.List.or,
186− all : Elm.List.all,
187− any : Elm.List.any,
188− sum : Elm.List.sum,
189− product : Elm.List.product,
190− concat : Elm.List.concat,
191− concatMap : Elm.List.concatMap,
192− maximum : Elm.List.maximum,
193− minimum : Elm.List.minimum,
194− scanl : Elm.List.scanl,
195− scanl1 : Elm.List.scanl1,
196− take : Elm.List.take,
197− drop : Elm.List.drop,
198− zip : Elm.List.zip,
199− unzip : Elm.List.unzip,
200− lift : Elm.Signal.lift,
201− lift2 : Elm.Signal.lift2,
202− lift3 : Elm.Signal.lift3,
203− lift4 : Elm.Signal.lift4,
204− lift5 : Elm.Signal.lift5,
205− lift6 : Elm.Signal.lift6,
206− lift7 : Elm.Signal.lift7,
207− lift8 : Elm.Signal.lift8,
208− foldp : Elm.Signal.foldp,
209− foldp1 : Elm.Signal.foldp1,
210− foldp$ : Elm.Signal.foldp$,
211− constant : Elm.Signal.constant,
212− merge : Elm.Signal.merge,
213− merges : Elm.Signal.merges,
214− mergeEither : Elm.Signal.mergeEither,
215− count : Elm.Signal.count,
216− countIf : Elm.Signal.countIf,
217− average : Elm.Signal.average,
218− keepIf : Elm.Signal.keepIf,
219− dropIf : Elm.Signal.dropIf,
220− keepWhen : Elm.Signal.keepWhen,
221− dropWhen : Elm.Signal.dropWhen,
222− dropRepeats : Elm.Signal.dropRepeats,
223− sampleOn : Elm.Signal.sampleOn,
224− timestamp : Elm.Signal.timestamp,
225− timeOf : Elm.Signal.timeOf
226− };
227−
228−}();
229−
230−(function() {
231− var include = function(library) {
232− for (var i in library) {
233− Elm.Prelude[i] = library[i];
234− }
235− };
236− include (Elm.Color);
237− include (Elm.Text);
238− include (Elm.Graphics);
239− include (Elm.Time);
240−
241− show = Value.show;
242−
243−}());
core-js/Set.jsdeleted−31
@@ -1,31 +0,0 @@
1−
2−Elm.Set=function(){
3− var empty_0=Elm.Dict.empty;
4− var remove_3=Elm.Dict.remove;
5− var member_4=Elm.Dict.member;
6− var union_5=Elm.Dict.union;
7− var intersect_6=Elm.Dict.intersect;
8− var diff_7=Elm.Dict.diff;
9− var toList_8=Elm.Dict.keys;
10− var fromList_9=Elm.List.foldl(function(k_15){
11− return function(t_16){
12− return Elm.Dict.insert(k_15)(["Tuple0"])(t_16);};})(empty_0);
13− function singleton_1(k_13){
14− return Elm.Dict.singleton(k_13)(["Tuple0"]);};
15− function insert_2(k_14){
16− return Elm.Dict.insert(k_14)(["Tuple0"]);};
17− function foldl_10(f_17){
18− return Elm.Dict.foldl(function(k_18){
19− return function(v_19){
20− return function(b_20){
21− return f_17(k_18)(b_20);};};});};
22− function foldr_11(f_21){
23− return Elm.Dict.foldr(function(k_22){
24− return function(v_23){
25− return function(b_24){
26− return f_21(k_22)(b_24);};};});};
27− function map_12(f_25){
28− return function(t_26){
29− return function(x){
30− return fromList_9(Elm.List.map(f_25)(x));}(toList_8(t_26));};};
31− return {empty:empty_0,singleton:singleton_1,insert:insert_2,remove:remove_3,member:member_4,union:union_5,intersect:intersect_6,diff:diff_7,toList:toList_8,fromList:fromList_9,foldl:foldl_10,foldr:foldr_11,map:map_12};}();
core-js/Signal/HTTP.jsdeleted−111
@@ -1,111 +0,0 @@
1−
2−/*! HTTP
3−A library for asynchronous HTTP requests (AJAX). See the
4−[WebSocket](http://elm-lang.org/docs/WebSocket.elm) library if
5−you have very strict latency requirements.
6−!*/
7−
8−Elm.HTTP = function() {
9− var JS = Elm.JavaScript;
10− var toElmString = Elm.JavaScript.castJSStringToString;
11−
12− /*[Creating Requests]*/
13−
14− /** get : String -> Request String
15− Create a GET request to the given url.
16− **/
17− function get(url) { return request("GET")(url)(null)(["Nil"]); }
18−
19− /** post : String -> String -> Request String
20− Create a POST request to the given url, carrying the given data.
21− **/
22− function post(url) { return function(data) {
23− return request("POST")(url)(data)(["Nil"]); }; }
24−
25− /** request : String -> String -> String -> [(String,String)] -> Request String
26− Create a customized request. Arguments are request type (get, post, put,
27− delete, etc.), target url, data, and a list of additional headers.
28− **/
29− function request(verb) { return function(url) { return function(data) {
30− return function(headers) {
31− return {0 : "Request",
32− length : 1,
33− verb : JS.castStringToJSString(verb),
34− url : JS.castStringToJSString(url),
35− data : data === null ? null : JS.castStringToJSString(data),
36− headers : headers }; }; }; };
37− }
38−
39− function registerReq(queue,responses) { return function(req) {
40− if (req.url !== "") { sendReq(queue,responses,req); }
41− };
42− }
43−
44− function updateQueue(queue,responses) {
45− if (queue.length > 0) {
46− Dispatcher.notify(responses.id, queue[0].value);
47− if (queue[0].value[0] !== "Waiting") {
48− queue.shift();
49− setTimeout(function() { updateQueue(queue,responses); }, 0);
50− }
51− }
52− }
53−
54− function sendReq(queue,responses,req) {
55− var response = { value: ["Waiting"] };
56− queue.push(response);
57−
58− var request = null;
59− if (window.ActiveXObject) { request = new ActiveXObject("Microsoft.XMLHTTP"); }
60− if (window.XMLHttpRequest) { request = new XMLHttpRequest(); }
61− request.onreadystatechange = function(e) {
62− if (request.readyState === 4) {
63− response.value = (request.status === 200
64− ? ["Success", toElmString(request.responseText)]
65− : ["Failure", request.status,
66− toElmString(request.statusText)]);
67− setTimeout(function() { updateQueue(queue,responses); }, 0);
68− }
69− };
70− request.open(req.verb, req.url, true);
71− Elm.List.map(function(pair) {
72− request.setRequestHeader(
73− JS.castStringToJSString(pair[1]),
74− JS.castStringToJSString(pair[2]));
75− })(req.headers);
76− request.send(req.data);
77− return null;
78− }
79−
80− /*[Responses]*/
81−
82− /** data Response a = Waiting | Success a | Failure Int String
83− The datatype for responses. Success contains only the returned message.
84− Failures contain both an error code and an error message.
85− **/
86−
87− /*[Sending Requests]*/
88−
89− /** send : Signal (Request a) -> Signal (Response String)
90− Performs an HTTP request with the given requests. Produces a signal
91− that carries the responses.
92− **/
93− function send(requests) {
94− var responses = Elm.Signal.constant(["Waiting"]);
95− var sender = Elm.Signal.lift(registerReq([],responses))(requests);
96− function f(x) { return function(y) { return x; } }
97− return Elm.Signal.lift2(f)(responses)(sender);
98− }
99−
100− /** sendGet : Signal String -> Signal (Response String)
101− Performs an HTTP GET request with the given urls. Produces a signal
102− that carries the responses.
103− **/
104−
105− return {get : get,
106− post : post,
107− request : request,
108− send : send,
109− sendGet : function(urls){return send(Elm.Signal.lift(get)(urls));}
110− };
111−}();
core-js/Signal/Input.jsdeleted−84
@@ -1,84 +0,0 @@
1−
2−Elm.Input = function() {
3− var JS = Elm.JavaScript;
4− var toElmString = Elm.JavaScript.castJSStringToString;
5− var newTextInput = function(elem, ghostText) {
6− elem.placeholder = JS.castStringToJSString(ghostText);
7− var str = Elm.Signal.constant(["Nil"]);
8− Value.addListener(elem, 'keyup', function(e) {
9− Dispatcher.notify(str.id, toElmString(elem.value));
10− elem.focus();
11− });
12− elem.style.padding = "1px";
13− return Value.Tuple(Value.wrap(elem), str);
14− };
15− var newElement = function(name) {
16− var e = document.createElement(name);
17− e.style.padding = "0";
18− e.style.margin = "0";
19− return e;
20− };
21− var textArea = function(cols) { return function(rows) {
22− var textarea = newElement('textarea');
23− textarea.rows = rows;
24− textarea.cols = cols;
25− return newTextInput(textarea, "");
26− };
27− };
28− var textField = function(ghostText) {
29− var field = newElement('input');
30− field.type = 'text';
31− return newTextInput(field, ghostText);
32− };
33− var password = function(ghostText) {
34− var field = newElement('input');
35− field.type = 'password';
36− return newTextInput(field, ghostText);
37− };
38− var checkbox = function(checked) {
39− var box = newElement('input');
40− box.type = 'checkbox';
41− box.checked = checked;
42− var status = Elm.Signal.constant(checked);
43− Value.addListener(box, 'change', function(e) {
44− Dispatcher.notify(status.id, box.checked);
45− });
46− return Value.Tuple(Value.wrap(box), status);
47− };
48− var dropDown = function(options) {
49− var slct = newElement('select');
50− var opts = [];
51− while (options[0] === "Cons") {
52− var opt = newElement('option');
53− var str = Value.toText(options[1][1]);
54− opt.value = str;
55− opt.innerHTML = str;
56− slct.appendChild(opt);
57− opts.push(options[1][2]);
58− options = options[2];
59− }
60− var status = Elm.Signal.constant(opts[0]);
61− Value.addListener(slct, 'change', function(e) {
62− Dispatcher.notify(status.id, opts[slct.selectedIndex]);
63− });
64− return Value.Tuple(Value.wrap(slct), status);
65− };
66− var stringDropDown = function(opts) {
67− return dropDown(Elm.List.map (function(x) {return Value.Tuple(x,x);}) (opts));
68− };
69− var button = function(name) {
70− var b = newElement('input');
71− b.type = "button";
72− b.value = JS.castStringToJSString(name);
73− var press = Elm.Signal.constant(false);
74− Value.addListener(b, 'click', function(e) {
75− Dispatcher.notify(press.id, true);
76− Dispatcher.notify(press.id, false);
77− });
78− return Value.Tuple(Value.wrap(b),press);
79− };
80− return {textArea:textArea, textField:textField,
81− password:password, checkbox:checkbox,
82− dropDown:dropDown, stringDropDown:stringDropDown,
83− button:button};
84−}();
core-js/Signal/Keyboard.jsdeleted−123
@@ -1,123 +0,0 @@
1−
2−Elm.Keyboard = { Raw : function() {
3− var keysDown = Elm.Signal.constant(["Nil"]);
4− var charPressed = Elm.Signal.constant(["Nothing"]);
5−
6− function remove(x,xs) {
7− if (xs[0] === "Nil") return xs;
8− if (xs[1] === x) return xs[2];
9− return ["Cons", xs[1], remove(x,xs[2])];
10− }
11− function has(x,xs) {
12− while (xs[0] !== "Nil") {
13− if (xs[1] === x) return true;
14− xs = xs[2];
15− }
16− return false;
17− }
18− Value.addListener(document, 'keydown', function(e) {
19− if (has(e.keyCode, keysDown.value)) return;
20− var hasListener = Dispatcher.notify(keysDown.id, ["Cons", e.keyCode, keysDown.value]);
21− if (!hasListener)
22− this.removeEventListener('keydown',arguments.callee,false);
23− });
24− Value.addListener(document, 'keyup', function(e) {
25− var codes = remove(e.keyCode, keysDown.value);
26− var hasListener = Dispatcher.notify(keysDown.id, codes);
27− if (!hasListener)
28− this.removeEventListener('keyup',arguments.callee,false);
29− });
30− Value.addListener(window, 'blur', function(e) {
31− var hasListener = Dispatcher.notify(keysDown.id, ["Nil"]);
32− if (!hasListener)
33− this.removeEventListener('blur',arguments.callee,false);
34− });
35− Value.addListener(document, 'keypress', function(e) {
36− var hasListener = Dispatcher.notify(charPressed.id, ["Just",e.charCode || e.keyCode]);
37− Dispatcher.notify(charPressed.id, ["Nothing"]);
38− if (!hasListener)
39− this.removeEventListener('keypress',arguments.callee,false);
40− });
41− return {keysDown:keysDown,
42− charPressed:charPressed};
43− }()
44−};
45−
46−/*! Keyboard
47−These are nicely curated inputs from the keyboard. See the
48−[Keyboard.Raw library](/docs/Signal/KeyboardRaw.elm) for a
49−lower-level interface that will let you define more complicated behavior.
50−!*/
51−
52−(function() {
53− function keySignal(f) {
54− var signal = Elm.Signal.lift(f)(Elm.Keyboard.Raw.keysDown);
55− Elm.Keyboard.Raw.keysDown.defaultNumberOfKids += 1;
56− signal.defaultNumberOfKids = 0;
57− return signal;
58− }
59−
60− function dir(left,right,up,down) {
61− function f(ks) {
62− var x = 0, y = 0;
63− while (ks[0] == "Cons") {
64− switch (ks[1]) {
65− case left : --x; break;
66− case right: ++x; break;
67− case up : ++y; break;
68− case down : --y; break;
69− }
70− ks = ks[2];
71− }
72− return { _:[true], x:[x], y:[y] };
73− }
74− return keySignal(f);
75− }
76−
77− function is(key) {
78− function f(ks) {
79− while (ks[0] == "Cons") {
80− if (key == ks[1]) return true;
81− ks = ks[2];
82− }
83− return false;
84− }
85− return keySignal(f);
86− }
87−
88− /*[Directions]*/
89−
90− /** arrows : Signal { x:Int, y:Int }
91− A signal of records indicating which arrow keys are pressed.
92−
93− `{ x = 0, y = 0 }` when pressing no arrows.
94− `{ x =-1, y = 0 }` when pressing the left arrow.
95− `{ x = 1, y = 1 }` when pressing the up and right arrows.
96− `{ x = 0, y =-1 }` when pressing the down, left, and right arrows.
97− **/
98− Elm.Keyboard.arrows = dir(37,39,38,40);
99−
100− /** wasd : Signal { x:Int, y:Int }
101− Just like the arrows signal, but this uses keys w, a, s, and d,
102− which are common controls for many computer games.
103− **/
104− Elm.Keyboard.wasd = dir(65,68,87,83);
105−
106− /*[Modifiers]*/
107−
108− /** shift : Signal Bool
109− Whether the shift key is pressed.
110− **/
111− Elm.Keyboard.shift = is(16);
112−
113− /** ctrl : Signal Bool
114− Whether the control key is pressed.
115− **/
116− Elm.Keyboard.ctrl = is(17);
117−
118− /** space : Signal Bool
119− Whether the space key is pressed.
120− **/
121− Elm.Keyboard.space = is(32);
122−
123−}());
core-js/Signal/Mouse.jsdeleted−106
@@ -1,106 +0,0 @@
1−/*! Mouse
2− !*/
3−
4−Elm.Mouse = function() {
5− /*[Position]*/
6−
7− /** position : Signal (Int,Int)
8− The current mouse position.
9− **/
10− var position = Elm.Signal.constant(Value.Tuple(0,0));
11− position.defaultNumberOfKids = 2;
12−
13− /** x : Signal Int
14− The current x-coordinate of the mouse.
15− **/
16− var x = Elm.Signal.lift(function(p){return p[1];})(position);
17− x.defaultNumberOfKids = 0;
18−
19− /** y : Signal Int
20− The current y-coordinate of the mouse.
21− **/
22− var y = Elm.Signal.lift(function(p){return p[2];})(position);
23− y.defaultNumberOfKids = 0;
24−
25− /*[Button Status]*/
26−
27− /** isDown : Signal Bool
28− The current state of the left mouse-button.
29− True when the button is down, and false otherwise.
30− **/
31− var isDown = Elm.Signal.constant(false);
32−
33− /** isClicked : Signal Bool
34− True immediately after the left mouse-button has been clicked,
35− and false otherwise.
36− **/
37− var isClicked = Elm.Signal.constant(false);
38−
39− /** clicks : Signal ()
40− Always equal to unit. Event triggers on every mouse click.
41− **/
42− var clicks = Elm.Signal.constant(Value.Tuple());
43−
44− function getXY(e) {
45− var posx = 0;
46− var posy = 0;
47− if (!e) e = window.event;
48− if (e.pageX || e.pageY) {
49− posx = e.pageX;
50− posy = e.pageY;
51− } else if (e.clientX || e.clientY) {
52− posx = e.clientX + document.body.scrollLeft +
53− document.documentElement.scrollLeft;
54− posy = e.clientY + document.body.scrollTop +
55− document.documentElement.scrollTop;
56− }
57− return Value.Tuple(posx, posy);
58− }
59−
60− Value.addListener(document, 'click', function(e) {
61− var hasListener1 = Dispatcher.notify(isClicked.id, true);
62− var hasListener2 = Dispatcher.notify(clicks.id, Value.Tuple());
63− Dispatcher.notify(isClicked.id, false);
64− if (!hasListener1 && !hasListener2)
65− this.removeEventListener('click',arguments.callee,false);
66− });
67− Value.addListener(document, 'mousedown', function(e) {
68− var hasListener = Dispatcher.notify(isDown.id, true);
69− if (!hasListener)
70− this.removeEventListener('mousedown',arguments.callee,false);
71− });
72− Value.addListener(document, 'mouseup', function(e) {
73− var hasListener = Dispatcher.notify(isDown.id, false);
74− if (!hasListener)
75− this.removeEventListener('mouseup',arguments.callee,false);
76− });
77− Value.addListener(document, 'mousemove', function(e) {
78− var hasListener = Dispatcher.notify(position.id, getXY(e));
79− if (!hasListener)
80− this.removeEventListener('mousemove',arguments.callee,false);
81− });
82−
83− /** isClickedOn : Element -> (Element, Signal Bool)
84− Determine whether an element has been clicked. The resulting pair
85− is a signal of booleans that is true when its paired element has
86− been clicked. The signal is True immediately after the left
87− mouse-button has been clicked, and false otherwise.
88− **/
89− var clickedOn = function(elem) {
90− var node = Render.render(elem);
91− var click = Elm.Signal.constant(false);
92− Value.addListener(node, 'click', function(e) {
93− Dispatcher.notify(click.id, true);
94− Dispatcher.notify(click.id, false);
95− });
96− return Value.Tuple(Value.wrap(node), click);
97− };
98− return {position: position,
99− x:x,
100− y:y,
101− isClicked: isClicked,
102− isDown: isDown,
103− clicks: clicks,
104− isClickedOn: clickedOn
105− };
106− }();
core-js/Signal/Random.jsdeleted−29
@@ -1,29 +0,0 @@
1−/*! Random
2− !*/
3−
4−Elm.Random = function() {
5− /*[In a Range]*/
6−
7− /** inRange : Int -> Int -> Signal Int
8− Given a range from low to high, this produces a random number
9− between 'low' and 'high' inclusive. The value in the signal does
10− not change after the page has loaded.
11− **/
12− var inRange = function(min) { return function(max) {
13− return Elm.Signal.constant(Math.floor(Math.random() * (max-min+1)) + min);
14− };
15− };
16−
17− /** randomize : Int -> Int -> Signal a -> Signal Int
18− Given a range from low to high and a signal of values, this produces
19− a new signal that changes whenever the input signal changes. The new
20− values are random number between 'low' and 'high' inclusive.
21− **/
22− var randomize = function(min) { return function(max) { return function(signal) {
23− function f(x) { return Math.floor(Math.random() * (max-min+1)) + min; }
24− return Elm.Signal.lift(f)(signal);
25− };
26− };
27− };
28− return { inRange:inRange, randomize:randomize };
29−}();
core-js/Signal/Time.jsdeleted−112
@@ -1,112 +0,0 @@
1−/*! Time
2−Library for working with time. Type `Time` represents some number of
3−milliseconds.
4−!*/
5−
6−Elm.Time = function() {
7−
8− /*[Times]*/
9−
10− /** hour, minute, second, ms : Time
11− Units of time, making it easier to specify things like a
12− half-second `(second / 2)`.
13− **/
14−
15− function timeNow() { return (new window.Date).getTime(); }
16−
17− /*[Tickers]*/
18−
19− /** fps : Number -> Signal Time
20− Takes desired number of frames per second (fps). The resulting signal
21− gives a sequence of time deltas as quickly as possible until it reaches
22− the desired FPS. A time delta is the time between the last frame and the
23− current frame.
24− **/
25−
26− /** fpsWhen : Number -> Signal Bool -> Signal Time
27− Same as the fps function, but you can turn it on and off. Allows you
28− to do brief animations based on user input without major ineffeciencies.
29− The first time delta after a pause is always zero, no matter how long
30− the pause was. This way summing the deltas will actually give the amount
31− of time that the output signal has been running.
32− **/
33− function fpsWhen(desiredFPS) { return function (isOn) {
34− var msPerFrame = 1000 / desiredFPS;
35− var prev = timeNow(), curr = prev, diff = 0, wasOn = true;
36− var ticker = Elm.Signal.constant(diff);
37− function tick(zero) { return function() {
38− curr = timeNow();
39− diff = zero ? 0 : curr - prev;
40− prev = curr;
41− Dispatcher.notify(ticker.id, diff);
42− };
43− }
44− var timeoutID = 0;
45− function f(isOn) { return function(t) {
46− if (isOn) {
47− timeoutID = setTimeout(tick(!wasOn && isOn), msPerFrame);
48− } else if (wasOn) {
49− clearTimeout(timeoutID);
50− }
51− wasOn = isOn;
52− return t;
53− };
54− }
55− return Elm.Signal.lift2(f)(isOn)(ticker);
56− };
57− }
58−
59− /** every : Time -> Signal Time
60− Takes a time interval t. The resulting signal is the current time,
61− updated every t.
62− **/
63− function everyWhen(isOn) { return function(t) {
64− var clock = Elm.Signal.constant(timeNow());
65− function tellTime() { Dispatcher.notify(clock.id, timeNow()); }
66− setInterval(tellTime, t);
67− return clock;
68− };
69− }
70−
71− function since(t) { return function(s) {
72− function cmp(a) { return function(b) { return !Value.eq(a,b); }; }
73− var dcount = Elm.Signal.count(Elm.Signal.delay(t)(s));
74− return Elm.Signal.lift2(cmp)(Elm.Signal.count(s))(dcount);
75− };
76− }
77− function after(t) {
78− t *= 1000;
79− var thread = Elm.Signal.constant(false);
80− setTimeout(function() { Dispatcher.notify(thread.id, true); }, t);
81− return thread;
82− }
83− function before(t) {
84− t *= 1000;
85− var thread = Elm.Signal.constant(true);
86− setTimeout(function() { Dispatcher.notify(thread.id, false); }, t);
87− return thread;
88− }
89− function read(s) {
90− var t = window.Date.parse(s);
91− return isNaN(t) ? ["Nothing"] : ["Just",t];
92− }
93− return {fpsWhen : fpsWhen,
94− fps : function(t) { return fpsWhen(t)(Elm.Signal.constant(true)); },
95− every : everyWhen(Elm.Signal.constant(true)),
96− delay : Elm.Signal.delay,
97− since : since,
98− after : after,
99− before : before,
100− hour : 3600000,
101− minute : 60000,
102− second : 1000,
103− ms : 1,
104− inHours : function(t) { return t / 3600000; },
105− inMinutes : function(t) { return t / 60000; },
106− inSeconds : function(t) { return t / 1000; },
107− inMss : function(t) { return t; },
108− toDate : function(t) { return new window.Date(t); },
109− read : read
110− };
111−
112−}();
core-js/Signal/Touch.jsdeleted−109
@@ -1,109 +0,0 @@
1−/*! Touch
2−This is an early version of the touch library. It will likely grow to
3−include gestures that would be useful for both games and web-pages.
4−!*/
5−
6−Elm.Touch = function() {
7−
8− function Dict() {
9− this.keys = [];
10− this.values = [];
11−
12− this.insert = function(key,value) {
13− this.keys.push(key);
14− this.values.push(value);
15− };
16− this.lookup = function(key) {
17− var i = this.keys.indexOf(key)
18− return i >= 0 ? this.values[i] : {x:0,y:0,t:0};
19− };
20− this.remove = function(key) {
21− var i = this.keys.indexOf(key);
22− if (i < 0) return;
23− var t = this.values[i];
24− this.keys.splice(i,1);
25− this.values.splice(i,1);
26− return t;
27− };
28− }
29−
30− var root = Elm.Signal.constant([]),
31− tapTime = 500,
32− hasTap = false,
33− tap = {_:[true],x:[0],y:[0]},
34− dict = new Dict();
35−
36− function touch(t) {
37− var r = dict.lookup(t.identifier);
38− return {_ : [true], id: [t.identifier],
39− x: [t.pageX], y: [t.pageY],
40− x0: [r.x], y0: [r.y],
41− t0: [r.t] };
42− }
43−
44− function start(e) {
45− dict.insert(e.identifier,{x:e.pageX,y:e.pageY,t:Date.now()});
46− }
47− function end(e) {
48− var t = dict.remove(e.identifier);
49− if (Date.now() - t.t < tapTime) {
50− hasTap = true;
51− tap = {_:[true], x:[t.x], y:[t.y]};
52− }
53− }
54−
55− function listen(name, f) {
56− function update(e) {
57− for (var i = e.changedTouches.length; i--; ) { f(e.changedTouches[i]); }
58− var ts = new Array(e.touches.length);
59− for (var i = e.touches.length; i--; ) { ts[i] = touch(e.touches[i]); }
60− var hasListener = Dispatcher.notify(root.id, ts);
61− if (!hasListener) return document.removeEventListener(name, update);
62− e.preventDefault();
63− }
64− Value.addListener(document, name, update);
65− }
66−
67− listen("touchstart", start);
68− listen("touchmove", function(_){});
69− listen("touchend", end);
70− listen("touchcancel", end);
71− listen("touchleave", end);
72−
73− function dependency(f) {
74− var sig = Elm.Signal.lift(f)(root);
75− root.defaultNumberOfKids += 1;
76− sig.defaultNumberOfKids = 0;
77− return sig;
78− }
79−
80− /*[Touches]*/
81−
82− /** touches : Signal [{ x:Int, y:Int, id:Int, x0:Int, y0:Int, t0:Time }]
83− A list of touches. Each ongoing touch is represented by a set of
84− coordinates and an identifier id that allows you to distinguish
85− between different touches. Each touch also contains the coordinates and
86− time of the initial contact (x0, y0, and t0) which helps compute more
87− complicated gestures.
88− **/
89− var touches = dependency(function(ts) {
90− return Elm.JavaScript.castJSArrayToList(ts);
91− });
92−
93− /*[Gestures]*/
94−
95− /** taps : Signal { x:Int, y:Int }
96− The last position that was tapped. Default value is `{x=0,y=0}`.
97− Updates whenever the user taps the screen.
98− **/
99− var taps = function() {
100− var sig = dependency(function(_) { return tap; });
101− sig.defaultNumberOfKids = 1;
102− function pred(_) { var b = hasTap; hasTap = false; return b; }
103− var sig2 = Elm.Signal.keepIf(pred)({_:[true],x:[0],y:[0]})(sig);
104− sig2.defaultNumberOfKids = 0;
105− return sig2;
106− }();
107−
108− return { touches: touches, taps: taps };
109−}();
core-js/Signal/WebSocket.jsdeleted−41
@@ -1,41 +0,0 @@
1−/*! WebSocket
2−A library for low latency HTTP communication. See the HTTP library for standard
3−requests like GET, POST, etc.
4−!*/
5−
6−Elm.WebSocket = function() {
7− var JS = Elm.JavaScript;
8−
9− /** open : String -> Signal String -> Signal String
10− Create a web-socket. The first argument is the URL of the desired
11− web-socket server. The input signal holds the outgoing messages,
12− and the resulting signal contains the incoming ones.
13− **/
14− function open(url) { return function(outgoing) {
15− var incoming = Elm.Signal.constant(["Nil"]);
16− var ws = new window.WebSocket(JS.castStringToJSString(url));
17−
18− var pending = [];
19− var ready = false;
20−
21− ws.onopen = function(e) {
22− var len = pending.length;
23− for (var i = 0; i < len; ++i) { ws.send(pending[i]); }
24− ready = true;
25− };
26− ws.onmessage = function(event) {
27− Dispatcher.notify(incoming.id, JS.castJSStringToString(event.data));
28− };
29−
30− function send(msg) {
31− var s = JS.castStringToJSString(msg);
32− ready ? ws.send(s) : pending.push(s);
33− }
34−
35− function take1(x) { return function(y) { return x; } }
36− return Elm.Signal.lift2(take1)(incoming)(Elm.Signal.lift(send)(outgoing));
37− };
38− }
39−
40− return {open:open};
41−}();
core-js/Signal/Window.jsdeleted−35
@@ -1,35 +0,0 @@
1−/*! Window !*/
2−
3−Elm.Window = function() {
4−
5− /*[Dimensions]*/
6−
7− /** dimensions : Signal (Int,Int)
8− The current dimensions of the window (i.e. the area viewable to the
9− user, not including scroll bars).
10− **/
11− var dimensions = Elm.Signal.constant(Value.Tuple(window.innerWidth,
12− window.innerHeight));
13− dimensions.defaultNumberOfKids = 2;
14−
15− /** width : Signal Int
16− The current width of the window.
17− **/
18− var width = Elm.Signal.lift(function(p){return p[1];})(dimensions);
19− width.defaultNumberOfKids = 0;
20−
21− /** height : Signal Int
22− The current height of the window.
23− **/
24− var height = Elm.Signal.lift(function(p){return p[2];})(dimensions);
25− height.defaultNumberOfKids = 0;
26−
27− Value.addListener(window, 'resize', function(e) {
28− var w = document.getElementById('widthChecker').offsetWidth;
29− var hasListener = Dispatcher.notify(dimensions.id,
30− Value.Tuple(w, window.innerHeight));
31− if (!hasListener)
32− this.removeEventListener('resize',arguments.callee,false);
33− });
34− return {dimensions:dimensions,width:width,height:height};
35−}();
core-js/String.jsdeleted−81
@@ -1,81 +0,0 @@
1−
2−/*
3−var String = function() {
4−
5− function append(s1) { return function(s2) {
6− return s1.concat(s2);
7− };
8− }
9− function map(f) { return function(s) {
10− for (var i = s.length; i--; ) { s[i] = f(s[i]); }
11− };
12− }
13−
14− function intercalate(sep) { return function(ss) {
15− return Value.listToArray(ss).join(sep);
16− };
17− }
18− function intersperse(sep) { return function(s) {
19− return s.split("").join(sep);
20− };
21− }
22−
23− function foldl(f) { return function(b) { return function(s) {
24− var acc = b;
25− for (var i = 0, len = s.length; i < len; ++i) { acc = f(s[i])(acc); }
26− return acc;
27− };
28− };
29− }
30− function foldr(f) { return function(b) { return function(s) {
31− var acc = b;
32− for (var i = s.length; i--; ) { acc = f(s[i])(acc); }
33− return acc;
34− };
35− };
36− }
37−
38− function concatMap(f) { return function(s) {
39− var a = s.split("");
40− for (var i = a.length; i--; ) { a[i] = f(a[i]); }
41− return a.join("");
42− };
43− }
44−
45− function forall(pred) { return function(s) {
46− for (var i = s.length; i--; ) { if (!pred(s[i])) {return false}; }
47− return true;
48− };
49− }
50− function exists(pred) { return function(s) {
51− for (var i = s.length; i--; ) { if (pred(s[i])) {return true}; }
52− return false;
53− };
54− }
55−
56− return {cons : append,
57− snoc : append,
58− head : function(s) { return s[0]; },
59− last : function(s) { return s[s.length-1]; },
60− tail : function(s) { return s.slice(1); },
61− length : function(s) { return s.length; },
62− map : map,
63− intercalate : intercalate,
64− intersperse : intersperse,
65− reverse : function(s) { return s.split("").reverse().join(""); },
66− toLower : function(s) { return s.toLowerCase(); },
67− toUpper : function(s) { return s.toUpperCase(); },
68− foldl : foldl,
69− foldr : foldr,
70− concat : function(ss) { return Value.listToArray(ss).join(""); },
71− concatMap : concatMap,
72− forall : forall,
73− exists : exists,
74− //filter : filter,
75− //take:,
76− //drop:,
77− toText : Value.toText,
78− properEscape : Value.properEscape
79− };
80−}();
81−*/
core-js/Text.jsdeleted−49
@@ -1,49 +0,0 @@
1−
2−Elm.Text = function() {
3− function fromString(s) { return Value.toText(s); }
4−
5− var addTag = function(tag) { return function(text) {
6− return '<' + tag + ' style="padding:0;margin:0">' + text + '</' + tag + '>';
7− };
8− };
9− var addStyle = function(style, value) { return function(text) {
10− return "<span style='" + style + ":" + value + "'>" + text + "</span>";
11− };
12− };
13−
14− var typeface = function(name) {
15− name = Elm.JavaScript.castStringToJSString(name);
16− return addStyle('font-family', name);
17− };
18− var size = function(px) {
19− return addStyle('font-size', px + 'px');
20− };
21− var header = addTag('h1');
22− var height = function(h) { return addStyle('font-size', h+'em'); }
23− var italic = addStyle('font-style', 'italic');
24− var bold = addTag('b');
25− var color = function(c) {
26− return addStyle('color', Elm.Color.extract(c));
27− };
28− var underline = addStyle('text-decoration', 'underline');
29− var overline = addStyle('text-decoration', 'overline');
30− var strikeThrough = addStyle('text-decoration', 'line-through');
31− var link = function(href) { return function(text) {
32− return "<a href='" + fromString(href) + "'>" + text + "</a>";
33− };
34− };
35−
36− return {fromString : fromString,
37− toText: fromString,
38− header : header,
39− height : height,
40− italic : italic,
41− bold : bold,
42− underline : underline,
43− overline : overline,
44− strikeThrough : strikeThrough,
45− monospace : typeface('monospace'),
46− typeface : typeface,
47− color : color,
48− link : link };
49−}();
core-js/Value.jsdeleted−291
@@ -1,291 +0,0 @@
1−
2−var Value = function(){
3−
4− var eq = function(x,y) {
5− if (typeof x === "object") {
6− if (x !== null && '_' in x) {
7− for (var i in x) { if (x[i] != y[i]) return false; }
8− for (var i in y) { if (!(i in x)) return false; }
9− return true;
10− }
11− if (x === y) return true;
12− if (x.length !== y.length) return false;
13− for (var i = x.length; i--; ) {
14− if (!eq(x[i],y[i])) return false;
15− }
16− return true;
17− }
18− return x === y;
19− };
20−
21− var Tuple = function() {
22− var len = arguments.length;
23− var arr = new Array(len+1);
24− arr[0] = "Tuple" + arguments.length;
25− for (var i = len; i--; ) {
26− arr[i+1] = arguments[i];
27− }
28− return arr;
29− };
30−
31− var listToArray = function(list) {
32− var arr = [];
33− while (list[0] === "Cons") {
34− arr.push(list[1]);
35− list = list[2];
36− }
37− return arr;
38− };
39−
40− function makeSpaces(s) {
41− if (s.length == 0) { return s; }
42− var arr = s.split('');
43− if (arr[0] == ' ') { arr[0] = "&nbsp;" }
44− for (var i = arr.length; --i; ) {
45− if (arr[i][0] == ' ' && arr[i-1] == ' ') {
46− arr[i-1] = arr[i-1] + arr[i];
47− arr[i] = '';
48− }
49− }
50− for (var i = arr.length; i--; ) {
51− if (arr[i].length > 1 && arr[i][0] == ' ') {
52− var spaces = arr[i].split('');
53− for (var j = spaces.length - 2; j >= 0; j -= 2) {
54− spaces[j] = '&nbsp;';
55− }
56− arr[i] = spaces.join('');
57− }
58− }
59− arr = arr.join('');
60− if (arr[arr.length-1] === " ") {
61− return arr.slice(0,-1) + '&nbsp;';
62− }
63− return arr;
64− }
65−
66− function properEscape(str) {
67− if (str.length == 0) return str;
68− str = str //.replace(/&/g, "&#38;")
69− .replace(/"/g, /*"*/ "&#34;")
70− .replace(/'/g, /*'*/ "&#39;")
71− .replace(/</g, "&#60;")
72− .replace(/>/g, "&#62;")
73− .replace(/\n/g, "<br/>");
74− var arr = str.split('<br/>');
75− for (var i = arr.length; i--; ) {
76− arr[i] = makeSpaces(arr[i]);
77− }
78− return arr.join('<br/>');
79− }
80−
81− var toText = function(elmList) {
82− if (typeof elmList === "string") return properEscape(elmList);
83− var a = [];
84− while (elmList[0] === "Cons") {
85− a.push(elmList[1]);
86− elmList = elmList[2];
87− }
88− return properEscape(a.join(''));
89− };
90−
91− function getTextSize(w,h,txt) {
92− var t = document.createElement('div');
93− t.innerHTML = txt;
94− t.style.textAlign = 'left';
95− if (w > 0) { t.style.width = w + "px"; }
96−
97− t.style.visibility = "hidden";
98− t.style.styleFloat = "left";
99− t.style.cssFloat = "left";
100−
101− document.body.appendChild(t);
102− var cStyle = window.getComputedStyle(t,null);
103− var realW = cStyle.getPropertyValue("width").slice(0,-2) - 0;
104− var realH = cStyle.getPropertyValue("height").slice(0,-2) - 0;
105− document.body.removeChild(t);
106− //delete t;
107− return [Math.ceil(realW),Math.ceil(Math.max(h,realH))];
108− }
109−
110− function getSize(e) {
111− var t = e.cloneNode(true);
112−
113− t.style.visibility = "hidden";
114− t.style.styleFloat = "left";
115− t.style.cssFloat = "left";
116−
117− document.body.appendChild(t);
118− var w = t.offsetWidth;
119− var h = t.offsetHeight;
120− document.body.removeChild(t);
121− //delete t;
122− return [w,h];
123− }
124−
125− function getExcess(e) {
126− var t = e.cloneNode(true);
127−
128− t.style.visibility = "hidden";
129− t.style.styleFloat = "left";
130− t.style.cssFloat = "left";
131−
132− document.body.appendChild(t);
133− var ow = t.offsetWidth;
134− var oh = t.offsetHeight;
135− var cStyle = window.getComputedStyle(t,null);
136− var w = cStyle.getPropertyValue("width").slice(0,-2) - 0;
137− var h = cStyle.getPropertyValue("height").slice(0,-2) - 0;
138− document.body.removeChild(t);
139− //delete t;
140− return [ow-w,oh-h];
141− }
142−
143−
144− function groupForms(forms) {
145− forms = Elm.JavaScript.castListToJSArray(forms);
146− var groups = [];
147− var arr = [];
148− for (var i = forms.length; i--; ) {
149− var f = forms[i];
150− switch(f[4][0]) {
151− case "FElement":
152− if (arr.length > 0) {
153− groups.push(arr);
154− arr = [];
155− }
156− groups.push(f);
157− break;
158− default:
159− arr.push(f);
160− }
161− }
162− if (arr.length > 0) groups.push(arr);
163− return groups;
164− }
165−
166− var toString = function(v) {
167− if (typeof v === "function") {
168− return "<function>";
169− } else if (typeof v === "boolean") {
170− return v ? "True" : "False";
171− } else if (typeof v === "number") {
172− return v+"";
173− } else if (typeof v === "string" && v.length < 2) {
174− return "'"+v+"'";
175− } else if (typeof v === "object" && ('_' in v)) {
176− var output = [];
177− for (var k in v._) {
178− console.log(k,v._[k]);
179− for (var i = v._[k].length; i--; ) {
180− output.push(k + " = " + toString(v._[k][i]));
181− }
182− }
183− for (var k in v) {
184− if (k === '_') continue;
185− output.push(k + " = " + toString(v[k]));
186− }
187− if (output.length === 0) return "{}";
188− return "{ " + output.join(", ") + " }";
189− } else if (v[0]) {
190− if (v[0].substring(0,5) === "Tuple") {
191− var output = new Array(v.length-1);
192− for (var i = v.length; --i; ) { output[i-1] = toString(v[i]); }
193− return "(" + output.join(",") + ")";
194− } else if (v[0] === "Cons") {
195− var start = (typeof v[1] === "string") ? '"' : "[";
196− var end = (typeof v[1] === "string") ? '"' : "]";
197− var div = (typeof v[1] === "string") ? "" : ",";
198− var f = (typeof v[1] === "string") ? function(x){return x} : toString;
199− var output = start + f(v[1]);
200− v = v[2];
201− while (true) {
202− if (v[0] === "Cons") {
203− output += div + f(v[1]);
204− v = v[2];
205− } else {
206− return output + end;
207− }
208− }
209− } else if (v[0] === "Nil") {
210− return "[]";
211− } else if (v[0] === "JSON") {
212− return "(JSON.fromList " + toString(Elm.JSON.toList(v)) + ")";
213− } else if (v[0] === "RBNode" || v[0] === "RBEmpty") {
214− function cons(k){ return function(v) { return function(acc) { return ["Cons",["Tuple2",k,v],acc]; }; }; }
215− var list = Elm.Dict.foldr(cons)(["Nil"])(v);
216− var name = "Dict";
217− if (list[0] === "Cons" && list[1][2][0] === "Tuple0") {
218− name = "Set";
219− list = Elm.List.map(function(x) { return x[1]; })(list);
220− }
221− return "(" + name + ".fromList " + toString(list) + ")";
222− } else {
223− var output = "";
224− for (var i = v.length; --i; ) { output = ' ' + toString(v[i]) + output; }
225− output = v[0] + output;
226− return (v.length > 1) ? "(" + output + ")" : output;
227− }
228− }
229− return v+"";
230− };
231− var show = function(v) { return str(toString(v)); };
232− var append = function(xs,ys) {
233− if (typeof xs === "string" && typeof ys === "string") {
234− return xs.concat(ys);
235− }
236− if (xs[0] === "Nil") {
237− return ys;
238− }
239− var root = ["Cons", xs[1], ["Nil"]];
240− var curr = root;
241− xs = xs[2];
242− while (xs[0]==="Cons") {
243− curr[2] = ["Cons", xs[1], ["Nil"]];
244− xs = xs[2];
245− curr = curr[2];
246− }
247− curr[2] = ys;
248− return root;
249− };
250−
251− var str = function(s) {
252− var out = ["Nil"];
253− for (var i = s.length; i--; ) {
254− out = ["Cons", s[i], out];
255− }
256− return out;
257− };
258−
259− function wrap(elem) {
260− var p = Value.getSize(elem);
261− return ["Element", Guid.guid(), ["EHtml",elem],
262− p[0], p[1], 1, ["Nothing"], ["Nothing"]];
263− }
264− var addListener = function() {
265− if(document.addEventListener) {
266− return function(element, event, handler) {
267− element.addEventListener(event, handler, false);
268− };
269− } else {
270− return function(element, event, handler) {
271− element.attachEvent('on' + event, handler);
272− };
273− }
274− }();
275−
276− return {eq:eq,
277− str:str,
278− show:show,
279− Tuple:Tuple,
280− append:append,
281− listToArray:listToArray,
282− toText : toText,
283− properEscape : properEscape,
284− getTextSize : getTextSize,
285− getSize : getSize,
286− getExcess : getExcess,
287− groupForms : groupForms,
288− wrap : wrap,
289− addListener : addListener
290− };
291−}();
core-js/cat.batdeleted−5
@@ -1,5 +0,0 @@
1−copy /B Guid.js+foreign\JavaScript.js+foreign\JSON.js+Value.js+List.js+Maybe.js+Either.js+Char.js+Graphics\Color.js+Graphics\Collage.js+Graphics\Element.js+Text.js+Graphics\Render.js+runtime\Signal.js+runtime\Dispatcher.js+Signal\HTTP.js+Signal\WebSocket.js+Signal\Input.js+Signal\Keyboard.js+Signal\Mouse.js+Signal\Random.js+Signal\Time.js+Signal\Window.js+Date.js+Prelude.js+Signal\Touch.js+Dict.js+Set.js+Automaton.js ..\elm-mini.js
2−
3−cd ..\elm
4−
5−copy /B ..\elm-mini.js elm-runtime-0.7.2.js
core-js/cat.shdeleted−33
@@ -1,33 +0,0 @@
1−# I do not use this script, so it may be out of date.
2−# Please make sure that this matches with cat.bat to
3−# avoid confusing "errors".
4−
5−cat \
6− Guid.js\
7− foreign/JavaScript.js\
8− List.js\
9− Maybe.js\
10− foreign/JSON.js\
11− Value.js\
12− Char.js\
13− Graphics/Color.js\
14− Graphics/Collage.js\
15− Graphics/Element.js\
16− Text.js\
17− Graphics/Render.js\
18− runtime/Signal.js\
19− runtime/Dispatcher.js\
20− Signal/HTTP.js\
21− Signal/Input.js\
22− Signal/Keyboard.js\
23− Signal/Mouse.js\
24− Signal/Random.js\
25− Signal/Time.js\
26− Signal/Window.js\
27− Date.js\
28− Prelude.js\
29− Dict.js\
30− Set.js\
31− Automaton.js\
32− Signal/WebSocket.js\
33− > ../elm/elm-runtime.js
core-js/collage/Color.jsdeleted−42
@@ -1,42 +0,0 @@
1−
2−var Color = function() {
3−
4− var create = function(r,g,b,a) {
5− return { r: r,
6− g: g,
7− b: b,
8− a: a };
9− };
10−
11− var extract = function(c) {
12− if (c.a === 1) {
13− return 'rgb(' + c.r + ',' + c.g + ',' + c.b + ')';
14− }
15− return 'rgba(' + c.r + ',' + c.g + ',' + c.b + ',' + c.a + ')';
16− };
17−
18− var rgba = function(r) { return function(g) { return function(b) {
19− return function(a) { return create(r,g,b,a); }; }; };
20− };
21−
22− var rgb = function(r) { return function(g) { return function(b) {
23− return create(r,g,b,1); }; };
24− };
25− return {black: create( 0, 0, 0,1),
26− white: create(255,255,255,1),
27− red : create(255, 0, 0,1),
28− green: create( 0,255, 0,1),
29− blue : create( 0, 0,255,1),
30−
31− gray : create(128,128,128,1),
32− grey : create(128,128,128,1),
33−
34− yellow : create(255,255, 0,1),
35− cyan : create( 0,255,255,1),
36− magenta : create(255, 0,255,1),
37−
38− rgba : rgba,
39− rgb : rgb,
40− Internal : { extract:extract }
41− };
42−}();
core-js/collage/Form.jsdeleted−33
@@ -1,33 +0,0 @@
1−
2−var Form = function() {
3− var move = function(x) { return function(y) { return function(form) {
4− var t = form[1];
5− return [form[0], [[x + t[0][0], y + t[0][1]], t[1], t[2]]];
6− };
7− };
8− };
9− var rotate = function(theta) { return function(form) {
10− var t = form[1];
11− return [form[0], [t[0], t[1] + 2* Math.PI*theta, t[2]]];
12− };
13− };
14− var scale = function(s) { return function(form) {
15− var t = form[1];
16− return [form[0], [t[0], t[1], t[2] * s]];
17− };
18− };
19− var create = function(howToDraw, center) {
20− return [howToDraw, Transforms.create(center, 0, 1)];
21− };
22− var draw = function(form) {
23− ctx.save();
24− var trans = form[1];
25− ctx.translate(trans[0][0], trans[0][1]);
26− ctx.rotate(trans[1]);
27− ctx.scale(trans[2], trans[2]);
28− form[0](ctx);
29− ctx.restore();
30− return ctx;
31− };
32− return {create:create, move:move, rotate:rotate, scale:scale, draw:draw};
33−}();
core-js/collage/Image.jsdeleted−9
@@ -1,9 +0,0 @@
1−
2−var Image = function() {
3− var image = function(src) {
4− var img = new Image(src);
5− img.onload = function() {
6−
7− };
8− };
9−}();
core-js/collage/Line.jsdeleted−103
@@ -1,103 +0,0 @@
1−
2−var Line = function() {
3−
4− var pair = function(a,b) { return [a,b]; };
5−
6− var create = function(center, ps, theta, s) {
7− return { center: center, points: ps, theta: theta, scale: s };
8− };
9−
10−
11− //// Construction ////
12−
13− var line = function(ps) {
14− var parr = [];
15− while (ps[0] === "Cons") {
16− parr.push(pair(ps[1][1], ps[1][2]));
17− ps = ps[2];
18− }
19− return create(pair(0,0), parr, 0, 1);
20− };
21−
22− //// Atomize ////
23−
24− var solid = function(color) { return function(line) { return function(ctx) {
25− ctx.save();
26− ctx.beginPath();
27− ctx.translate(line.center[0], line.center[1]);
28− ctx.rotate(line.theta);
29− ctx.scale(line.scale, line.scale);
30− var points = line.points;
31− var i = points.length;
32− ctx.moveTo(points[i-1][0], points[i-1][1]);
33− while (i--) {
34− ctx.lineTo(points[i][0], points[i][1]);
35− }
36− ctx.strokeStyle = Color.Internal.extract(color);
37− ctx.stroke();
38− ctx.restore();
39− return ctx;
40− };
41− };
42− };
43−
44− var customLine = function(pattern) {
45− return function(color) { return function(line) {
46− if (typeof pattern[0] === "string") {
47− var temp = [];
48− while (pattern[0] === "Cons") {
49− temp.push(pattern[1]);
50− pattern = pattern[2];
51− }
52− pattern = temp;
53− }
54− if (pattern.length === 0) { pattern = [8,4]; }
55− return function(ctx) {
56− ctx.save();
57− ctx.beginPath();
58− ctx.translate(line.center[0], line.center[1]);
59− ctx.rotate(line.theta);
60− ctx.scale(line.scale, line.scale);
61− customLineHelp(ctx, pattern, line.points);
62− ctx.strokeStyle = Color.Internal.extract(color);
63− ctx.stroke();
64− ctx.restore();
65− return ctx;
66− };
67− };
68− };
69− };
70− var customLineHelp = function(ctx, pattern, points) {
71− var i = points.length - 1;
72− var x0 = points[i][0], y0 = points[i][1];
73− var x1=0, y1=0, dx=0, dy=0, remaining=0, nx=0, ny=0;
74− var pindex = 0, plen = pattern.length;
75− var draw = true, segmentLength = pattern[0];
76− ctx.moveTo(x0,y0);
77− while (i--) {
78− x1 = points[i][0]; y1 = points[i][1];
79− dx = x1 - x0; dy = y1 - y0;
80− remaining = Math.sqrt(dx * dx + dy * dy);
81− while (segmentLength <= remaining) {
82− x0 += dx * segmentLength / remaining;
83− y0 += dy * segmentLength / remaining;
84− ctx[draw ? 'lineTo' : 'moveTo'](x0, y0);
85− // update starting position
86− dx = x1 - x0; dy = y1 - y0;
87− remaining = Math.sqrt(dx * dx + dy * dy);
88− // update pattern
89− draw = !draw;
90− pindex = (pindex + 1) % plen;
91− segmentLength = pattern[pindex];
92− }
93− if (remaining > 0) {
94− ctx[draw ? 'lineTo' : 'moveTo'](x1, y1);
95− segmentLength -= remaining;
96− }
97− x0 = x1; y0 = y1;
98− }
99− };
100−
101− return {line:line, customLine:customLine, solid:solid,
102− dashed: customLine([8,4]), dotted: customLine([3,3]) };
103−}();
core-js/collage/Shape.jsdeleted−110
@@ -1,110 +0,0 @@
1−
2−var Shape = function() {
3−
4− var create = function(center, ps, theta, s) {
5− return { center: center, points: ps, theta: theta, scale: s };
6− };
7−
8− //// Construction ////
9−
10− var polygon = function(ps) { return function(center) {
11− var parr = [];
12− while (ps[0] === "Cons") {
13− parr.push([ps[1][1], ps[1][2]]);
14− ps = ps[2];
15− }
16− center = [center[1], center[2]];
17− return create(center, parr, 0, 1);
18− };
19−};
20− var ngon = function(n) { return function(r) { return function(center) {
21− var ps = [];
22− for (var i = n; i--;) {
23− ps.push([r * Math.cos(Math.PI * 2 * i/n),
24− r * Math.sin(Math.PI * 2 * i/n)]);
25− }
26− center = [center[1], center[2]];
27− return create(center, ps, 0, 1);
28− };
29− };
30−};
31− var rect = function(w) { return function(h) { return function(center) {
32− var ps = [[- w/2, - h/2],
33− [ w/2, - h/2],
34− [ w/2, h/2],
35− [- w/2, h/2]];
36− center = [center[1], center[2]];
37− return create(center, ps, 0, 1);
38− };
39− };
40− };
41− var oval = function(w) { return function(h) { return function(center) {
42− var ps = [];
43− for (var theta = 2 * Math.PI; theta > 0; theta -= Math.PI /50) {
44− ps.push([w/2 * Math.cos(theta), h/2 * Math.sin(theta)]);
45− }
46− center = [center[1], center[2]];
47− return create(center, ps, 0, 1);
48− };
49− };
50− };
51−
52−//// Transforms ////
53−
54− var move = function(x) { return function(y) { return function(shape) {
55− var newCenter = [x + shape.center[0],y + shape.center[1]];
56− return create(newCenter, shape.points, shape.theta, shape.scale);
57− };
58− };
59− };
60− var rotate = function(theta) { return function(shape) {
61− var newTheta = shape.theta + 2 * Math.PI * theta;
62− return create(shape.center, shape.points, newTheta, shape.scale);
63− };
64− };
65− var scale = function(s) { return function(shape) {
66− return create(shape.center, shape.points, shape.theta, shape.scale * s);
67− };
68− };
69−
70−
71− //// Atomize ////
72−
73− var draw = function(fill) {
74− return function(color) { return function(shape) { return function(ctx) {
75− ctx.save();
76− ctx.translate(shape.center[0], shape.center[1]);
77− ctx.rotate(shape.theta);
78− ctx.scale(shape.scale, shape.scale);
79− ctx.beginPath();
80− var points = shape.points;
81− ctx.moveTo(points[0][0], points[0][1]);
82− for (var i = points.length; i--; ) {
83− ctx.lineTo(points[i][0], points[i][1]);
84− }
85− ctx.closePath();
86− if (fill) {
87− ctx.fillStyle = Color.Internal.extract(color);
88− ctx.fill();
89− } else {
90− ctx.strokeStyle = Color.Internal.extract(color);
91− ctx.stroke();
92− }
93− ctx.restore();
94− return ctx;
95− };
96− };
97− };
98− };
99−
100− var customOutline = function(p) {
101− return function(c) { return function(shape) {
102− shape.points.push(shape.points[0]);
103− return Line.customLine(p)(c)(shape);
104− };
105− };
106− };
107− return {polygon:polygon, ngon:ngon, rect:rect, oval:oval,
108− move:move, rotate:rotate, scale:scale,
109− filled:draw(true), outlined:draw(false), customOutline:customOutline };
110−}();
core-js/foreign/JSON.jsdeleted−158
@@ -1,158 +0,0 @@
1−
2−var JSjson = window.JSON;
3−Elm.JSON = function() {
4− var JS = Elm.JavaScript;
5− var empty = ['JSON',{}];
6− function singleton(k) { return function(v) {
7− var obj = {};
8− obj[JS.castStringToJSString(k)] = v;
9− return ['JSON', obj ];
10− };
11− }
12− function insert(k) { return function(v) { return function(inObj) {
13− var obj = inObj[1];
14− var outObj = {};
15− for (var i in obj) {
16− outObj[i] = obj[i];
17− }
18− outObj[JS.castStringToJSString(k)] = v;
19− return ['JSON', outObj ];
20− };
21− };
22− }
23−
24− function lookup(key) { return function(obj) {
25− var k = JS.castStringToJSString(key);
26− return (k in obj[1]) ? ["Just", obj[1][k]] : ["Nothing"] ;
27− };
28− }
29− function find(tipe,base) { return function (key) { return function(obj) {
30− var k = JS.castStringToJSString(key);
31− if (k in obj[1]) {
32− var v = obj[1][k];
33− if (v[0] === tipe) { return v[1]; }
34− }
35− return base;
36− };
37− }
38− }
39− function lookupWithDefault(base) { return function(key) { return function(obj) {
40− var k = JS.castStringToJSString(key);
41− return (k in obj[1]) ? obj[1][k] : base ;
42− };
43− };
44− }
45−
46− function remove(k) { return function(inObj) {
47− var obj = inObj[1];
48− var outObj = {};
49− for (var i in obj) {
50− outObj[i] = obj[i];
51− }
52− delete outObj[JS.castStringToJSString(k)];
53− return ['JSON', outObj];
54− };
55− }
56−
57− function JsonString(v) { return [ "JsonString", v ]; }
58− function JsonNumber(v) { return [ "JsonNumber", v ]; }
59− function JsonBool(v) { return [ "JsonBool", v ]; }
60− var JsonNull = [ "JsonNull" ];
61− function JsonArray(v) { return [ "JsonArray", v ]; }
62− function JsonObject(v) { return [ "JsonObject", v ]; }
63−
64− function toList(json) {
65− var obj = json[1];
66− var arr = [];
67− for (var i in obj) {
68− arr.push(Value.Tuple(JS.castJSStringToString(i), obj[i]));
69− }
70− return JS.castJSArrayToList(arr);
71− }
72− function fromList(list) {
73− var arr = JS.castListToJSArray(list);
74− var obj = {};
75− for (var i = arr.length; i--; ) {
76− obj[JS.castStringToJSString(arr[i][1])] = arr[i][2];
77− }
78− return [ "JSON", obj ];
79− }
80−
81− function toPrettyJSString(sep) { return function (obj) {
82− function fromValue(v) {
83− switch (v[0]) {
84− case 'JsonNull' : return null;
85− case 'JsonString' : return JS.castStringToJSString(v[1]);
86− case 'JsonObject' :
87− var o = {};
88− var from = v[1][1];
89− for (var i in from) {
90− o[i] = fromValue(from[i]);
91− }
92− return o;
93− case 'JsonArray' :
94− var a = JS.castListToJSArray(v[1]);
95− for (var i = a.length; i--; ) {
96− a[i] = fromValue(a[i]);
97− }
98− return a;
99− default :
100− return v[1];
101− }
102− }
103− return JSjson.stringify(fromValue([ 'JsonObject', obj ]), null, JS.castStringToJSString(sep));
104− };
105− }
106− function fromJSString(str) {
107− var obj;
108− try {
109− obj = JSjson.parse(str);
110− } catch (e) {
111− return Elm.Maybe.Nothing;
112− }
113− function toValue(v) {
114− switch (typeof v) {
115− case 'string' : return [ "JsonString", JS.castJSStringToString(v) ];
116− case 'number' : return [ "JsonNumber", JS.castJSNumberToFloat(v) ];
117− case 'boolean' : return [ "JsonBool", JS.castJSBoolToBool(v) ];
118− case 'object' :
119− if (v === null) return [ "JsonNull" ];
120− for (var i in v) {
121− v[i] = toValue(v[i]);
122− }
123− if (v instanceof Array) return [ "JsonArray", JS.castJSArrayToList(v) ];
124− return [ "JsonObject", [ "JSON", v ] ];
125− }
126− }
127− for (var i in obj) {
128− obj[i] = toValue(obj[i]);
129− }
130− return Elm.Maybe.Just( ['JSON',obj] );
131− }
132− return {empty : empty,
133− singleton : singleton,
134− insert : insert,
135− lookup : lookup,
136− findNumber : find("JsonNumber",0),
137− findString : find("JsonString",["Nil"]),
138− findObject : find("JsonObject", empty ),
139− findArray : find("JsonArray" ,["Nil"]),
140− findWithDefault : lookupWithDefault,
141− remove : remove,
142− toPrettyJSString : toPrettyJSString,
143− toJSString : toPrettyJSString(''),
144− fromJSString : fromJSString,
145− toPrettyString : function(sep) { return function(v) {
146− return JS.castJSStringToString(toPrettyJSString(sep)(v)); }; },
147− toString : function(v) { return JS.castJSStringToString(toPrettyJSString('')(v)); },
148− fromString : function(v) { return fromJSString(JS.castStringToJSString(v)); },
149− toList : toList,
150− fromList : fromList,
151− JsonString : JsonString,
152− JsonNumber : JsonNumber,
153− JsonBool : JsonBool,
154− JsonNull : JsonNull,
155− JsonArray : JsonArray,
156− JsonObject : JsonObject
157− };
158−}();
core-js/foreign/JavaScript.jsdeleted−69
@@ -1,69 +0,0 @@
1−
2−Elm.JavaScript = function() {
3− function castJSBoolToBool(b) { return b; }
4− function castBoolToJSBool(b) { return b; }
5−
6− function castJSNumberToFloat(n) { return n; }
7− function castFloatToJSNumber(n) { return n; }
8−
9− function castJSNumberToInt(n) { return ~~n; }
10− function castIntToJSNumber(n) { return n; }
11−
12− function castJSElementToElement(w) {
13− return function(h) {
14− return function(node) {
15− return ["Element",Guid.guid(),
16− ["EExternalHtml",node],
17− w,h,1,["Nothing"],["Nothing"]];
18− }
19− }
20− }
21− function castElementToJSElement(elem) { return Render.render(elem); }
22−
23− function castJSArrayToList(arr) {
24− var list = ["Nil"];
25− for (var i = arr.length; i--; ) {
26− list = [ "Cons", arr[i], list ];
27− }
28− return list;
29− }
30− function castListToJSArray(list) {
31− var a = [];
32− while (list[0] === "Cons") {
33− a.push(list[1]);
34− list = list[2];
35− }
36− return a;
37− }
38−
39− var castJSStringToString = castJSArrayToList;
40− function castStringToJSString(str) {
41− if (typeof str === "string") return str;
42− return castListToJSArray(str).join('');
43− }
44−
45− function fromTuple(t) { return t.slice(1); }
46− function toTuple(a) { return ["Tuple" + a.length].concat(a); }
47−
48− return {castJSBoolToBool:castJSBoolToBool,
49− castBoolToJSBool:castBoolToJSBool,
50− castJSNumberToFloat:castJSNumberToFloat,
51− castFloatToJSNumber:castFloatToJSNumber,
52− castJSNumberToInt:castJSNumberToInt,
53− castIntToJSNumber:castIntToJSNumber,
54− Experimental : {castJSElementToElement:castJSElementToElement,
55− castElementToJSElement:castElementToJSElement},
56− castJSArrayToList:castJSArrayToList,
57− castListToJSArray:castListToJSArray,
58− castJSStringToString:castJSStringToString,
59− castStringToJSString:castStringToJSString,
60− castTupleToJSTuple2:fromTuple,
61− castTupleToJSTuple3:fromTuple,
62− castTupleToJSTuple4:fromTuple,
63− castTupleToJSTuple5:fromTuple,
64− castJSTupleToTuple2:toTuple,
65− castJSTupleToTuple3:toTuple,
66− castJSTupleToTuple4:toTuple,
67− castJSTupleToTuple5:toTuple
68− };
69−}();
core-js/runtime/Dispatcher.jsdeleted−58
@@ -1,58 +0,0 @@
1−
2−var Dispatcher = function() {
3− var program = null;
4− var inputs = [];
5− var currentElement = null;
6−
7− var initialize = function() {
8− program = Elm.main();
9− if (!('recv' in program)) {
10− program = Elm.Signal.constant(program);
11− }
12−
13− currentElement = program.value;
14− filterDeadInputs();
15−
16− var content = document.getElementById('content');
17− content.appendChild(Render.render(currentElement));
18− var w = document.getElementById('widthChecker').offsetWidth;
19− if (w !== window.innerWidth) {
20− Dispatcher.notify(Elm.Window.dimensions.id, Value.Tuple(w, window.innerHeight));
21− }
22− program = Elm.Signal.lift(function(value) {
23− var content = document.getElementById('content');
24− Render.update(content.firstChild,currentElement,value);
25− currentElement = value;
26− return value;
27− })(program);
28− };
29− var notify = function(id, v) {
30− var timestep = (new window.Date).getTime();
31− var hasListener = false;
32− for (var i = inputs.length; i--; ) {
33− hasListener = inputs[i].recv(timestep, id, v) || hasListener;
34− }
35− return hasListener;
36− };
37−
38− function isAlive(input) {
39− if (!('defaultNumberOfKids' in input)) return true;
40− var len = input.kids.length;
41− if (len == 0) return false;
42− if (len > input.defaultNumberOfKids) return true;
43− var alive = false;
44− for (var i = len; i--; ) {
45− alive = alive || isAlive(input.kids[i]);
46− }
47− return alive;
48− }
49− function filterDeadInputs() {
50− var temp = [];
51− for (var i = inputs.length; i--; ) {
52− if (isAlive(inputs[i])) temp.push(inputs[i]);
53− }
54− inputs = temp;
55− }
56−
57− return {initialize:initialize, notify:notify, inputs:inputs};
58−}();
core-js/runtime/Signal.jsdeleted−260
@@ -1,260 +0,0 @@
1−
2−Elm.Signal = function() {
3− var send = function(node, timestep, changed) {
4− var kids = node.kids;
5− for (var i = kids.length; i--; ) {
6− kids[i].recv(timestep, changed, node.id);
7− }
8− };
9− function input(base) {
10− this.id = Guid.guid();
11− this.value = base;
12− this.kids = [];
13− this.defaultNumberOfKids = 0;
14− this.recv = function(timestep, eid, v) {
15− var changed = eid === this.id;
16− if (changed) { this.value = v; }
17− send(this, timestep, changed);
18− return changed;
19− };
20− Dispatcher.inputs.push(this);
21− };
22− function lift(func,args) {
23− this.id = Guid.guid();
24− this.value = null;
25− this.kids = [];
26− this.count = 0;
27− this.changed = false;
28−
29− args.reverse();
30− this.recalc = function() {
31− var f = func;
32− for (var i = args.length; i--; ) {
33− f = f(args[i].value);
34− }
35− this.value = f;
36− };
37− this.recalc();
38−
39− this.recv = function(timestep, changed, parentID) {
40− this.count += 1;
41− if (changed) { this.changed = true; }
42− if (this.count == args.length) {
43− if (this.changed) { this.recalc() }
44− send(this, timestep, this.changed);
45− this.changed = false;
46− this.count = 0;
47− }
48− };
49− for (var i = args.length; i--; ) {
50− args[i].kids.push(this);
51− }
52− };
53− function fold(func,base,baseIsFunc,input) {
54− this.id = Guid.guid();
55− this.value = baseIsFunc ? base(input.value) : base;
56− this.kids = [];
57− this.recv = function(timestep, changed, parentID) {
58− if (changed) { this.value = func(input.value)(this.value); }
59− send(this, timestep, changed);
60− };
61− input.kids.push(this);
62− };
63−
64− function dropIf(pred,base,input) {
65− this.id = Guid.guid();
66− this.value = pred(input.value) ? base : input.value;
67− this.kids = [];
68− this.recv = function(timestep, changed, parentID) {
69− var chng = changed && !pred(input.value);
70− if (chng) { this.value = input.value; }
71− send(this, timestep, chng);
72− };
73− input.kids.push(this);
74− };
75−
76− function dropRepeats(input) {
77− this.id = Guid.guid();
78− this.value = input.value;
79− this.kids = [];
80− this.recv = function(timestep, changed, parentID) {
81− var chng = changed && !Value.eq(this.value,input.value);
82− if (chng) { this.value = input.value; }
83− send(this, timestep, chng);
84− };
85− input.kids.push(this);
86− };
87−
88− var dropWhen = function(s1) { return function(b) { return function(s2) {
89− var pairs = new lift(function(x){return function(y){return [x,y];};},[s1,s2]);
90− var dropped = new dropIf(function(p){return p[0];},[true,b],pairs);
91− return new lift(function(p){return p[1];},[dropped]); }; };
92− };
93−
94− function timeIndex(pair,s) {
95− this.id = Guid.guid();
96− var t = (new window.Date).getTime();
97− this.value = pair ? Value.Tuple(t,s.value) : t;
98− this.kids = [];
99− this.recv = function(timestep, changed, parentID) {
100− if (changed) this.value = pair ? Value.Tuple(timestep, s.value) : timestep;
101− send(this, timestep, changed);
102− };
103− s.kids.push(this);
104− }
105−
106− function sampleOn(s1,s2) {
107− this.id = Guid.guid();
108− this.value = s2.value;
109− this.kids = [];
110− this.count = 0;
111− this.changed = false;
112−
113− this.recv = function(timestep, changed, parentID) {
114− if (parentID === s1.id) this.changed = changed;
115− this.count += 1;
116− if (this.count == 2) {
117− if (this.changed) { this.value = s2.value; }
118− send(this, timestep, this.changed);
119− this.count = 0;
120− this.changed = false;
121− }
122− };
123− s1.kids.push(this);
124− s2.kids.push(this);
125− };
126−
127− function delay(t) { return function(s) {
128− var delayed = new input(s.value);
129− var firstEvent = true;
130− function update(v) {
131− if (firstEvent) return;
132− setTimeout(function() { Dispatcher.notify(delayed.id,v); },t);
133− }
134− function first(a) { return function(b) { return a; }; }
135− var out = new sampleOn(delayed,new lift(first, [delayed, new lift(update,[s])]));
136− firstEvent = false;
137− return out;
138− };
139− }
140−
141− function merge(s1,s2) {
142− this.id = Guid.guid();
143− this.value = s1.value;
144− this.kids = [];
145− this.next = null;
146− this.count = 0;
147− this.changed = false;
148−
149− this.recv = function(timestep, changed, parentID) {
150− this.count += 1;
151− if (changed) {
152− this.changed = true;
153− if (parentID == s2.id && this.next === null) { this.next = s2.value; }
154− if (parentID == s1.id) { this.next = s1.value; }
155− }
156−
157− if (this.count == 2) {
158− if (this.changed) {
159− this.value = this.next;
160− this.next = null;
161− }
162− send(this, timestep, this.changed);
163− this.changed = false;
164− this.count = 0;
165− }
166− };
167− s1.kids.push(this);
168− s2.kids.push(this);
169− };
170−
171− function merges(ss) {
172− function mrg(x) { return function(y) { return new merge(x,y); }; }
173− return Elm.List.foldl1(mrg)(ss);
174− }
175−
176− function mergeEither(s1) { return function(s2) {
177− function f(s) { return function(x) { return [s,x]; }; }
178− return new merge(new lift(f('Left'),[s1]), new lift(f('Right'),[s2]));
179− };
180− }
181−
182− function average(sampleSize) { return function(s) {
183− var sample = new Array(sampleSize);
184− var i = sampleSize;
185− while (i--) sample[i] = 0;
186− i = 0;
187− var full = false;
188− var total = 0;
189− function f(n) {
190− total += n - sample[i];
191− sample[i] = n;
192− var avg = total / Math.max(1, full ? sampleSize : i);
193− if (++i == sampleSize) { full = true; i = 0; }
194− return avg;
195− }
196− return new lift(f, [s]);
197− };
198− }
199−
200− return {
201− constant : function(v) { return new input(v); },
202− lift : function(f){return function(e){return new lift(f,[e]);};},
203− lift2 : function(f) {
204− return function(e1) { return function(e2) {
205− return new lift(f, [e1,e2]); };};},
206− lift3 : function(f) {
207− return function(e1) { return function(e2) {
208− return function(e3){return new lift(f,[e1,e2,e3]);};};};},
209− lift4 : function(f) {
210− return function(e1) { return function(e2) {
211− return function(e3) { return function(e4) {
212− return new lift(f, [e1,e2,e3,e4]);};};};};},
213− lift5 : function(f) {
214− return function(e1) { return function(e2) {
215− return function(e3) { return function(e4) {
216− return function(e5) {
217− return new lift(f, [e1,e2,e3,e4,e5]);};};};};};},
218− lift6 : function(f) { return function(e1) { return function(e2) {
219− return function(e3) { return function(e4) {
220− return function(e5) { return function(e6) {
221− return new lift(f, [e1,e2,e3,e4,e5,e6]); };};};};};};},
222− lift7 : function(f) { return function(e1) { return function(e2) {
223− return function(e3) { return function(e4) {
224− return function(e5) { return function(e6) {
225− return function(e7) {
226− return new lift(f, [e1,e2,e3,e4,e5,e6,e7]);};};};};};};};},
227− lift8 : function(f) { return function(e1) { return function(e2) {
228− return function(e3) { return function(e4) {
229− return function(e5) { return function(e6) {
230− return function(e7) { return function(e8) {
231− return new lift(f, [e1,e2,e3,e4,e5,e6,e7,e8]);};};};};};};};};},
232− foldp : function(f) { return function(b) { return function(e) {
233− return new fold(f,b,false,e); }; }; },
234− foldp$ : function(f) { return function(b) { return function(e) {
235− return new fold(f,b,true,e); }; }; },
236− foldp1 : function(f) { return function(e) {
237− return new fold(f,function(x){return x;},true,e); }; },
238− delay : delay,
239− merge : function(s1) { return function(s2) { return new merge(s1,s2)}; },
240− merges : merges,
241− mergeEither : mergeEither,
242− average : average,
243− count : function(sig) {
244− var incr = function(_){return function(c){return c+1;};};
245− return new fold(incr,0,false,sig) },
246− countIf : function(pred) { return function(sig) {
247− var incr = function(x){return function(c){return pred(x) ? c+1 : c;};};
248− return new fold(incr,0,false,sig) }; },
249− keepIf : function(pred) { return function(base) { return function(sig) {
250− return new dropIf(function(x) { return !pred(x)},base,sig); }; }; },
251− dropIf : function(pred) { return function(base) { return function(sig) {
252− return new dropIf(pred,base,sig); }; }; },
253− keepWhen : function(s) { return dropWhen(new lift(function(b){return !b;},[s])); },
254− dropWhen : dropWhen,
255− dropRepeats : function(s) { return new dropRepeats(s);},
256− sampleOn : function(s1){return function(s2){return new sampleOn(s1,s2);};},
257− timestamp : function(s) { return new timeIndex(true, s); },
258− timeOf : function(s) { return new timeIndex(false, s); }
259− };
260−}();