git.iko.soy/elk
on master help sign in
Add Trampoline tests to start
a655ed1Max New
.gitignore+3
compare with master
unifiedsplit
@@ -11,3 +11,6 @@ data
11*/ElmFiles/*
11*/ElmFiles/*
12.DS_Store
12.DS_Store
13*~
13*~
14+tests/elm/build/
15+tests/elm/cache/
16+tests/elm/exe.js
tests/elm/Test.elm+3−1
@@ -9,9 +9,11 @@ import IO.IO (..)
9import IO.Runner (Request, Response)
9import IO.Runner (Request, Response)
10import IO.Runner as Run
10import IO.Runner as Run
11
11
12+import Test.Trampoline as Trampoline
13+
12{- Failing test to get it going -}
14{- Failing test to get it going -}
13tests : [Test]
15tests : [Test]
14−tests = [ 0 `equals` 1 ]
16+tests = Trampoline.tests
15
17
16console : IO ()
18console : IO ()
17console = runDisplay tests
19console = runDisplay tests
tests/elm/Test/Trampoline.elmnew file+24
@@ -0,0 +1,24 @@
1+module Test.Trampoline (tests) where
2+
3+import ElmTest.Test (..)
4+
5+import Trampoline (..)
6+
7+badSum : Int -> Int
8+badSum n =
9+ let loop x acc =
10+ case x of
11+ 0 -> acc
12+ _ -> loop (x-1) (acc+x)
13+ in loop n 0
14+
15+goodSum : Int -> Int
16+goodSum n =
17+ let sumT x acc =
18+ case x of
19+ 0 -> Done acc
20+ _ -> Continue (\_ -> sumT (x-1) (acc+x))
21+ in trampoline <| sumT n 0
22+
23+tests = goodSum 1000000 `equals` 500000500000 :: map (\n -> badSum n `equals` goodSum n) [0..50]
24+
tests/elm/build/Test.htmldeleted−1277
@@ -1,1277 +0,0 @@
1−<!DOCTYPE HTML>
2−<html><head><meta charset="UTF-8"><title>Test</title><script type="text/javascript" src="/home/mnew/code/elm/Elm/data/elm-runtime.js"></script><script type="text/javascript">Elm.Main = Elm.Main || {};
3−Elm.Main.make = function (_elm) {
4− "use strict";
5− _elm.Main = _elm.Main || {};
6− if (_elm.Main.values)
7− return _elm.Main.values;
8− var _N = Elm.Native,
9− _U = _N.Utils.make(_elm),
10− _L = _N.List.make(_elm),
11− _E = _N.Error.make(_elm),
12− $moduleName = "Main";
13− var Basics = Elm.Basics.make(_elm);
14− var Color = Elm.Color.make(_elm);
15− var ElmTest = ElmTest || {};
16− ElmTest.Assertion = Elm.ElmTest.Assertion.make(_elm);
17− var ElmTest = ElmTest || {};
18− ElmTest.Run = Elm.ElmTest.Run.make(_elm);
19− var ElmTest = ElmTest || {};
20− ElmTest.Runner = ElmTest.Runner || {};
21− ElmTest.Runner.Console = Elm.ElmTest.Runner.Console.make(_elm);
22− var ElmTest = ElmTest || {};
23− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
24− var Graphics = Graphics || {};
25− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
26− var Graphics = Graphics || {};
27− Graphics.Element = Elm.Graphics.Element.make(_elm);
28− var IO = IO || {};
29− IO.IO = Elm.IO.IO.make(_elm);
30− var IO = IO || {};
31− IO.Runner = Elm.IO.Runner.make(_elm);
32− var List = Elm.List.make(_elm);
33− var Maybe = Elm.Maybe.make(_elm);
34− var Native = Native || {};
35− Native.Json = Elm.Native.Json.make(_elm);
36− var Native = Native || {};
37− Native.Ports = Elm.Native.Ports.make(_elm);
38− var Signal = Elm.Signal.make(_elm);
39− var String = Elm.String.make(_elm);
40− var Text = Elm.Text.make(_elm);
41− var Time = Elm.Time.make(_elm);
42− var _op = {};
43− var responses = Native.Ports.portIn("responses",
44− Native.Ports.incomingSignal(function (v) {
45− return v === null ? Maybe.Nothing : Maybe.Just(typeof v === "string" || typeof v === "object" && v instanceof String ? v : _E.raise("invalid input, expecting JSString but got " + v));
46− }));
47− var tests = _L.fromArray([A2(ElmTest.Test.equals,
48− 0,
49− 1)]);
50− var console = ElmTest.Runner.Console.runDisplay(tests);
51− var requests = Native.Ports.portOut("requests",
52− Native.Ports.outgoingSignal(function (v) {
53− return _L.toArray(v).map(function (v) {
54− return {mPut: v.mPut.ctor === "Nothing" ? null : v.mPut._0
55− ,mExit: v.mExit.ctor === "Nothing" ? null : v.mExit._0
56− ,mGet: v.mGet};
57− });
58− }),
59− A2(IO.Runner.run,
60− responses,
61− console));
62− _elm.Main.values = {_op: _op
63− ,tests: tests
64− ,console: console};
65− return _elm.Main.values;
66−};Elm.IO = Elm.IO || {};
67−Elm.IO.Runner = Elm.IO.Runner || {};
68−Elm.IO.Runner.make = function (_elm) {
69− "use strict";
70− _elm.IO = _elm.IO || {};
71− _elm.IO.Runner = _elm.IO.Runner || {};
72− if (_elm.IO.Runner.values)
73− return _elm.IO.Runner.values;
74− var _N = Elm.Native,
75− _U = _N.Utils.make(_elm),
76− _L = _N.List.make(_elm),
77− _E = _N.Error.make(_elm),
78− $moduleName = "IO.Runner";
79− var Automaton = Elm.Automaton.make(_elm);
80− var Basics = Elm.Basics.make(_elm);
81− var Color = Elm.Color.make(_elm);
82− var Either = Elm.Either.make(_elm);
83− var Graphics = Graphics || {};
84− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
85− var Graphics = Graphics || {};
86− Graphics.Element = Elm.Graphics.Element.make(_elm);
87− var IO = IO || {};
88− IO.IO = Elm.IO.IO.make(_elm);
89− var List = Elm.List.make(_elm);
90− var Maybe = Elm.Maybe.make(_elm);
91− var Native = Native || {};
92− Native.Json = Elm.Native.Json.make(_elm);
93− var Native = Native || {};
94− Native.Ports = Elm.Native.Ports.make(_elm);
95− var Signal = Elm.Signal.make(_elm);
96− var String = Elm.String.make(_elm);
97− var Text = Elm.Text.make(_elm);
98− var Time = Elm.Time.make(_elm);
99− var _op = {};
100− var put = F2(function (s,_v0) {
101− return function () {
102− return {ctor: "_Tuple2"
103− ,_0: s
104− ,_1: {ctor: "_Tuple0"}};
105− }();
106− });
107− var ask = function (s) {
108− return {ctor: "_Tuple2"
109− ,_0: s
110− ,_1: s};
111− };
112− _op[">>="] = F3(function (f,
113− k,
114− s) {
115− return function () {
116− var $ = f(s),
117− s$ = $._0,
118− y = $._1;
119− return A2(k,y,s$);
120− }();
121− });
122− var pure = F2(function (x,s) {
123− return {ctor: "_Tuple2"
124− ,_0: s
125− ,_1: x};
126− });
127− var empty = {_: {}
128− ,mExit: Maybe.Nothing
129− ,mGet: false
130− ,mPut: Maybe.Nothing};
131− var putS = function (s) {
132− return _U.replace([["mPut"
133− ,Maybe.Just(s)]],
134− empty);
135− };
136− var exit = function (n) {
137− return _U.replace([["mExit"
138− ,Maybe.Just(n)]],
139− empty);
140− };
141− var getS = _U.replace([["mGet"
142− ,true]],
143− empty);
144− var extractRequests = function (io) {
145− return function () {
146− switch (io.ctor)
147− {case "Impure":
148− return function () {
149− switch (io._0.ctor)
150− {case "Exit":
151− return pure({ctor: "_Tuple2"
152− ,_0: _L.fromArray([exit(io._0._0)])
153− ,_1: io});
154− case "GetC":
155− return A2(_op[">>="],
156− ask,
157− function (st) {
158− return function () {
159− var _v10 = String.uncons(st.buffer);
160− switch (_v10.ctor)
161− {case "Just":
162− switch (_v10._0.ctor)
163− {case "_Tuple2":
164− return A2(_op[">>="],
165− put({_: {},buffer: _v10._0._1}),
166− function (_v14) {
167− return function () {
168− return extractRequests(io._0._0(_v10._0._0));
169− }();
170− });}
171− break;
172− case "Nothing":
173− return pure({ctor: "_Tuple2"
174− ,_0: _L.fromArray([getS])
175− ,_1: io});}
176− _E.Case($moduleName,
177− "between lines 51 and 55");
178− }();
179− });
180− case "PutC":
181− return A2(_op[">>="],
182− extractRequests(io._0._1),
183− function (_v16) {
184− return function () {
185− switch (_v16.ctor)
186− {case "_Tuple2":
187− return pure({ctor: "_Tuple2"
188− ,_0: {ctor: "::"
189− ,_0: putS(A2(String.cons,
190− io._0._0,
191− ""))
192− ,_1: _v16._0}
193− ,_1: _v16._1});}
194− _E.Case($moduleName,
195− "on line 47, column 22 to 61");
196− }();
197− });}
198− _E.Case($moduleName,
199− "between lines 45 and 55");
200− }();
201− case "Pure":
202− return pure({ctor: "_Tuple2"
203− ,_0: _L.fromArray([exit(0)])
204− ,_1: IO.IO.Pure(io._0)});}
205− _E.Case($moduleName,
206− "between lines 43 and 55");
207− }();
208− };
209− var step = F2(function (resp,
210− _v20) {
211− return function () {
212− switch (_v20.ctor)
213− {case "_Tuple2":
214− return function () {
215− var newST = function () {
216− switch (resp.ctor)
217− {case "Just":
218− return _U.replace([["buffer"
219− ,A2(String.append,
220− _v20._1.buffer,
221− resp._0)]],
222− _v20._1);
223− case "Nothing": return _v20._1;}
224− _E.Case($moduleName,
225− "between lines 59 and 62");
226− }();
227− var _ = A2(extractRequests,
228− _v20._0,
229− newST);
230− var k = function () {
231− switch (_.ctor)
232− {case "_Tuple2":
233− switch (_._1.ctor)
234− {case "_Tuple2":
235− return _._1._1;}
236− break;}
237− _E.Case($moduleName,
238− "on line 62, column 27 to 51");
239− }();
240− var newST$ = function () {
241− switch (_.ctor)
242− {case "_Tuple2":
243− switch (_._1.ctor)
244− {case "_Tuple2": return _._0;}
245− break;}
246− _E.Case($moduleName,
247− "on line 62, column 27 to 51");
248− }();
249− var rs = function () {
250− switch (_.ctor)
251− {case "_Tuple2":
252− switch (_._1.ctor)
253− {case "_Tuple2":
254− return _._1._0;}
255− break;}
256− _E.Case($moduleName,
257− "on line 62, column 27 to 51");
258− }();
259− return {ctor: "_Tuple2"
260− ,_0: {ctor: "_Tuple2"
261− ,_0: k
262− ,_1: newST$}
263− ,_1: rs};
264− }();}
265− _E.Case($moduleName,
266− "between lines 59 and 63");
267− }();
268− });
269− var start = {_: {},buffer: ""};
270− var run = F2(function (resps,
271− io) {
272− return A3(Automaton.run,
273− A2(Automaton.hiddenState,
274− {ctor: "_Tuple2"
275− ,_0: io
276− ,_1: start},
277− step),
278− _L.fromArray([]),
279− resps);
280− });
281− var orSig = F2(function (s1,
282− s2) {
283− return A2(Signal.merge,
284− A2(Signal._op["<~"],
285− Either.Left,
286− s1),
287− A2(Signal._op["<~"],
288− Either.Right,
289− s2));
290− });
291− var IOState = function (a) {
292− return {_: {},buffer: a};
293− };
294− var Request = F3(function (a,
295− b,
296− c) {
297− return {_: {}
298− ,mExit: b
299− ,mGet: c
300− ,mPut: a};
301− });
302− _elm.IO.Runner.values = {_op: _op
303− ,orSig: orSig
304− ,start: start
305− ,run: run
306− ,empty: empty
307− ,putS: putS
308− ,exit: exit
309− ,getS: getS
310− ,extractRequests: extractRequests
311− ,step: step
312− ,pure: pure
313− ,ask: ask
314− ,put: put
315− ,Request: Request
316− ,IOState: IOState};
317− return _elm.IO.Runner.values;
318−};Elm.Automaton = Elm.Automaton || {};
319−Elm.Automaton.make = function (_elm) {
320− "use strict";
321− _elm.Automaton = _elm.Automaton || {};
322− if (_elm.Automaton.values)
323− return _elm.Automaton.values;
324− var _N = Elm.Native,
325− _U = _N.Utils.make(_elm),
326− _L = _N.List.make(_elm),
327− _E = _N.Error.make(_elm),
328− $moduleName = "Automaton";
329− var Basics = Elm.Basics.make(_elm);
330− var Color = Elm.Color.make(_elm);
331− var Graphics = Graphics || {};
332− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
333− var Graphics = Graphics || {};
334− Graphics.Element = Elm.Graphics.Element.make(_elm);
335− var List = Elm.List.make(_elm);
336− var Maybe = Elm.Maybe.make(_elm);
337− var Native = Native || {};
338− Native.Json = Elm.Native.Json.make(_elm);
339− var Native = Native || {};
340− Native.Ports = Elm.Native.Ports.make(_elm);
341− var Signal = Elm.Signal.make(_elm);
342− var String = Elm.String.make(_elm);
343− var Text = Elm.Text.make(_elm);
344− var Time = Elm.Time.make(_elm);
345− var _op = {};
346− var dequeue = function (q) {
347− return function () {
348− switch (q.ctor)
349− {case "_Tuple2":
350− switch (q._0.ctor)
351− {case "[]": switch (q._1.ctor)
352− {case "[]":
353− return Maybe.Nothing;}
354− break;}
355− switch (q._1.ctor)
356− {case "::":
357− return Maybe.Just({ctor: "_Tuple2"
358− ,_0: q._1._0
359− ,_1: {ctor: "_Tuple2"
360− ,_0: q._0
361− ,_1: q._1._1}});
362− case "[]":
363− return dequeue({ctor: "_Tuple2"
364− ,_0: _L.fromArray([])
365− ,_1: List.reverse(q._0)});}
366− break;}
367− _E.Case($moduleName,
368− "between lines 116 and 121");
369− }();
370− };
371− var enqueue = F2(function (x,
372− _v5) {
373− return function () {
374− switch (_v5.ctor)
375− {case "_Tuple2":
376− return {ctor: "_Tuple2"
377− ,_0: {ctor: "::"
378− ,_0: x
379− ,_1: _v5._0}
380− ,_1: _v5._1};}
381− _E.Case($moduleName,
382− "on line 115, column 22 to 31");
383− }();
384− });
385− var empty = {ctor: "_Tuple2"
386− ,_0: _L.fromArray([])
387− ,_1: _L.fromArray([])};
388− var Step = function (a) {
389− return {ctor: "Step",_0: a};
390− };
391− var run = F3(function (auto,
392− base,
393− inputs) {
394− return function () {
395− var step = F2(function (a,
396− _v9) {
397− return function () {
398− switch (_v9.ctor)
399− {case "_Tuple2":
400− switch (_v9._0.ctor)
401− {case "Step":
402− return _v9._0._0(a);}
403− break;}
404− _E.Case($moduleName,
405− "on line 43, column 28 to 31");
406− }();
407− });
408− return A2(Signal.lift,
409− function (_v14) {
410− return function () {
411− switch (_v14.ctor)
412− {case "_Tuple2":
413− return _v14._1;}
414− _E.Case($moduleName,
415− "on line 44, column 23 to 24");
416− }();
417− },
418− A3(Signal.foldp,
419− step,
420− {ctor: "_Tuple2"
421− ,_0: auto
422− ,_1: base},
423− inputs));
424− }();
425− });
426− var step = F2(function (a,
427− _v18) {
428− return function () {
429− switch (_v18.ctor)
430− {case "Step":
431− return _v18._0(a);}
432− _E.Case($moduleName,
433− "on line 48, column 19 to 22");
434− }();
435− });
436− var andThen = F2(function (f,
437− g) {
438− return Step(function (a) {
439− return function () {
440− var $ = A2(step,a,f),
441− f$ = $._0,
442− b = $._1;
443− var $ = A2(step,b,g),
444− g$ = $._0,
445− c = $._1;
446− return {ctor: "_Tuple2"
447− ,_0: A2(andThen,f$,g$)
448− ,_1: c};
449− }();
450− });
451− });
452− var loop = F2(function (state,
453− auto) {
454− return Step(function (input) {
455− return function () {
456− var _ = A2(step,
457− {ctor: "_Tuple2"
458− ,_0: input
459− ,_1: state},
460− auto);
461− var auto$ = function () {
462− switch (_.ctor)
463− {case "_Tuple2":
464− switch (_._1.ctor)
465− {case "_Tuple2": return _._0;}
466− break;}
467− _E.Case($moduleName,
468− "on line 68, column 54 to 77");
469− }();
470− var output = function () {
471− switch (_.ctor)
472− {case "_Tuple2":
473− switch (_._1.ctor)
474− {case "_Tuple2":
475− return _._1._0;}
476− break;}
477− _E.Case($moduleName,
478− "on line 68, column 54 to 77");
479− }();
480− var state$ = function () {
481− switch (_.ctor)
482− {case "_Tuple2":
483− switch (_._1.ctor)
484− {case "_Tuple2":
485− return _._1._1;}
486− break;}
487− _E.Case($moduleName,
488− "on line 68, column 54 to 77");
489− }();
490− return {ctor: "_Tuple2"
491− ,_0: A2(loop,state$,auto$)
492− ,_1: output};
493− }();
494− });
495− });
496− var combine = function (autos) {
497− return Step(function (a) {
498− return function () {
499− var $ = List.unzip(A2(List.map,
500− step(a),
501− autos)),
502− autos$ = $._0,
503− bs = $._1;
504− return {ctor: "_Tuple2"
505− ,_0: combine(autos$)
506− ,_1: bs};
507− }();
508− });
509− };
510− var pure = function (f) {
511− return Step(function (x) {
512− return {ctor: "_Tuple2"
513− ,_0: pure(f)
514− ,_1: f(x)};
515− });
516− };
517− var state = F2(function (s,f) {
518− return Step(function (x) {
519− return function () {
520− var s$ = A2(f,x,s);
521− return {ctor: "_Tuple2"
522− ,_0: A2(state,s$,f)
523− ,_1: s$};
524− }();
525− });
526− });
527− var count = A2(state,
528− 0,
529− F2(function (_v36,c) {
530− return function () {
531− return c + 1;
532− }();
533− }));
534− var hiddenState = F2(function (s,
535− f) {
536− return Step(function (x) {
537− return function () {
538− var $ = A2(f,x,s),
539− s$ = $._0,
540− out = $._1;
541− return {ctor: "_Tuple2"
542− ,_0: A2(hiddenState,s$,f)
543− ,_1: out};
544− }();
545− });
546− });
547− var average = function (k) {
548− return function () {
549− var stepFull = F2(function (n,
550− _v38) {
551− return function () {
552− switch (_v38.ctor)
553− {case "_Tuple3":
554− return function () {
555− var _v43 = dequeue(_v38._0);
556− switch (_v43.ctor)
557− {case "Just":
558− switch (_v43._0.ctor)
559− {case "_Tuple2":
560− return function () {
561− var sum$ = _v38._2 + n - _v43._0._0;
562− return {ctor: "_Tuple2"
563− ,_0: {ctor: "_Tuple3"
564− ,_0: A2(enqueue,n,_v43._0._1)
565− ,_1: _v38._1
566− ,_2: sum$}
567− ,_1: sum$ / Basics.toFloat(_v38._1)};
568− }();}
569− break;
570− case "Nothing":
571− return {ctor: "_Tuple2"
572− ,_0: {ctor: "_Tuple3"
573− ,_0: _v38._0
574− ,_1: _v38._1
575− ,_2: _v38._2}
576− ,_1: 0};}
577− _E.Case($moduleName,
578− "between lines 128 and 132");
579− }();}
580− _E.Case($moduleName,
581− "between lines 128 and 132");
582− }();
583− });
584− var step = F2(function (n,
585− _v47) {
586− return function () {
587− switch (_v47.ctor)
588− {case "_Tuple3":
589− return _U.eq(_v47._1,
590− k) ? A2(stepFull,
591− n,
592− {ctor: "_Tuple3"
593− ,_0: _v47._0
594− ,_1: _v47._1
595− ,_2: _v47._2}) : {ctor: "_Tuple2"
596− ,_0: {ctor: "_Tuple3"
597− ,_0: A2(enqueue,n,_v47._0)
598− ,_1: _v47._1 + 1
599− ,_2: _v47._2 + n}
600− ,_1: (_v47._2 + n) / (Basics.toFloat(_v47._1) + 1)};}
601− _E.Case($moduleName,
602− "between lines 125 and 126");
603− }();
604− });
605− return A2(hiddenState,
606− {ctor: "_Tuple3"
607− ,_0: empty
608− ,_1: 0
609− ,_2: 0},
610− step);
611− }();
612− };
613− _elm.Automaton.values = {_op: _op
614− ,pure: pure
615− ,state: state
616− ,hiddenState: hiddenState
617− ,run: run
618− ,step: step
619− ,andThen: andThen
620− ,combine: combine
621− ,loop: loop
622− ,count: count
623− ,average: average};
624− return _elm.Automaton.values;
625−};Elm.ElmTest = Elm.ElmTest || {};
626−Elm.ElmTest.Runner = Elm.ElmTest.Runner || {};
627−Elm.ElmTest.Runner.Console = Elm.ElmTest.Runner.Console || {};
628−Elm.ElmTest.Runner.Console.make = function (_elm) {
629− "use strict";
630− _elm.ElmTest = _elm.ElmTest || {};
631− _elm.ElmTest.Runner = _elm.ElmTest.Runner || {};
632− _elm.ElmTest.Runner.Console = _elm.ElmTest.Runner.Console || {};
633− if (_elm.ElmTest.Runner.Console.values)
634− return _elm.ElmTest.Runner.Console.values;
635− var _N = Elm.Native,
636− _U = _N.Utils.make(_elm),
637− _L = _N.List.make(_elm),
638− _E = _N.Error.make(_elm),
639− $moduleName = "ElmTest.Runner.Console";
640− var Basics = Elm.Basics.make(_elm);
641− var Color = Elm.Color.make(_elm);
642− var ElmTest = ElmTest || {};
643− ElmTest.Runner = ElmTest.Runner || {};
644− ElmTest.Runner.String = Elm.ElmTest.Runner.String.make(_elm);
645− var ElmTest = ElmTest || {};
646− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
647− var Graphics = Graphics || {};
648− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
649− var Graphics = Graphics || {};
650− Graphics.Element = Elm.Graphics.Element.make(_elm);
651− var IO = IO || {};
652− IO.IO = Elm.IO.IO.make(_elm);
653− var List = Elm.List.make(_elm);
654− var Maybe = Elm.Maybe.make(_elm);
655− var Native = Native || {};
656− Native.Json = Elm.Native.Json.make(_elm);
657− var Native = Native || {};
658− Native.Ports = Elm.Native.Ports.make(_elm);
659− var Signal = Elm.Signal.make(_elm);
660− var String = Elm.String.make(_elm);
661− var Text = Elm.Text.make(_elm);
662− var Time = Elm.Time.make(_elm);
663− var _op = {};
664− var runDisplay = function (tests) {
665− return function () {
666− var $ = ElmTest.Runner.String.runDisplay(tests),
667− allPassed = $._0,
668− results = $._1;
669− return A2(IO.IO._op[">>"],
670− IO.IO.putStrLn(results),
671− function () {
672− switch (allPassed)
673− {case false:
674− return IO.IO.exit(1);
675− case true:
676− return IO.IO.exit(0);}
677− _E.Case($moduleName,
678− "between lines 23 and 25");
679− }());
680− }();
681− };
682− _elm.ElmTest.Runner.Console.values = {_op: _op
683− ,runDisplay: runDisplay};
684− return _elm.ElmTest.Runner.Console.values;
685−};Elm.ElmTest = Elm.ElmTest || {};
686−Elm.ElmTest.Runner = Elm.ElmTest.Runner || {};
687−Elm.ElmTest.Runner.String = Elm.ElmTest.Runner.String || {};
688−Elm.ElmTest.Runner.String.make = function (_elm) {
689− "use strict";
690− _elm.ElmTest = _elm.ElmTest || {};
691− _elm.ElmTest.Runner = _elm.ElmTest.Runner || {};
692− _elm.ElmTest.Runner.String = _elm.ElmTest.Runner.String || {};
693− if (_elm.ElmTest.Runner.String.values)
694− return _elm.ElmTest.Runner.String.values;
695− var _N = Elm.Native,
696− _U = _N.Utils.make(_elm),
697− _L = _N.List.make(_elm),
698− _E = _N.Error.make(_elm),
699− $moduleName = "ElmTest.Runner.String";
700− var Basics = Elm.Basics.make(_elm);
701− var Color = Elm.Color.make(_elm);
702− var ElmTest = ElmTest || {};
703− ElmTest.Run = Elm.ElmTest.Run.make(_elm);
704− var ElmTest = ElmTest || {};
705− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
706− var Graphics = Graphics || {};
707− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
708− var Graphics = Graphics || {};
709− Graphics.Element = Elm.Graphics.Element.make(_elm);
710− var List = Elm.List.make(_elm);
711− var Maybe = Elm.Maybe.make(_elm);
712− var Native = Native || {};
713− Native.Json = Elm.Native.Json.make(_elm);
714− var Native = Native || {};
715− Native.Ports = Elm.Native.Ports.make(_elm);
716− var Signal = Elm.Signal.make(_elm);
717− var String = Elm.String.make(_elm);
718− var Text = Elm.Text.make(_elm);
719− var Time = Elm.Time.make(_elm);
720− var _op = {};
721− var pretty = F2(function (_v0,
722− r) {
723− return function () {
724− switch (_v0.ctor)
725− {case "TestCase":
726− return function () {
727− switch (r.ctor)
728− {case "Just":
729− return _L.append(_v0._0,
730− _L.append(": FAILED. ",r._0));
731− case "Nothing":
732− return _L.append(_v0._0,
733− ": passed.");}
734− _E.Case($moduleName,
735− "between lines 29 and 33");
736− }();}
737− _E.Case($moduleName,
738− "between lines 29 and 33");
739− }();
740− });
741− var replicate = F2(function (n,
742− c) {
743− return function () {
744− var go = function (n) {
745− return _U.cmp(n,
746− 0) < 1 ? _L.fromArray([]) : {ctor: "::"
747− ,_0: c
748− ,_1: go(n - 1)};
749− };
750− return String.fromList(go(n));
751− }();
752− });
753− var vcat = function ($) {
754− return List.concat(List.intersperse("\n")($));
755− };
756− var indent = function (n) {
757− return function () {
758− var indents = A2(replicate,
759− n,
760− _U.chr(" "));
761− return function ($) {
762− return vcat(List.map(String.append(indents))(String.lines($)));
763− };
764− }();
765− };
766− var runDisplay = function (ts) {
767− return function () {
768− var r = ElmTest.Run.report(ts);
769− var passed = List.length(r.passes);
770− var failed = List.length(r.failures);
771− var summary = vcat(List.map(indent(2))(_L.fromArray([_L.append(String.show(List.length(ts)),
772− " tests executed")
773− ,_L.append(String.show(passed),
774− " tests passed")
775− ,_L.append(String.show(failed),
776− " tests failed")])));
777− var pass = _U.eq(failed,0);
778− var results = pass ? _L.fromArray([]) : A3(List.zipWith,
779− pretty,
780− ts,
781− r.results);
782− return {ctor: "_Tuple2"
783− ,_0: pass
784− ,_1: vcat({ctor: "::"
785− ,_0: summary
786− ,_1: results})};
787− }();
788− };
789− _elm.ElmTest.Runner.String.values = {_op: _op
790− ,runDisplay: runDisplay};
791− return _elm.ElmTest.Runner.String.values;
792−};Elm.ElmTest = Elm.ElmTest || {};
793−Elm.ElmTest.Run = Elm.ElmTest.Run || {};
794−Elm.ElmTest.Run.make = function (_elm) {
795− "use strict";
796− _elm.ElmTest = _elm.ElmTest || {};
797− _elm.ElmTest.Run = _elm.ElmTest.Run || {};
798− if (_elm.ElmTest.Run.values)
799− return _elm.ElmTest.Run.values;
800− var _N = Elm.Native,
801− _U = _N.Utils.make(_elm),
802− _L = _N.List.make(_elm),
803− _E = _N.Error.make(_elm),
804− $moduleName = "ElmTest.Run";
805− var Basics = Elm.Basics.make(_elm);
806− var Color = Elm.Color.make(_elm);
807− var ElmTest = ElmTest || {};
808− ElmTest.Assertion = Elm.ElmTest.Assertion.make(_elm);
809− var ElmTest = ElmTest || {};
810− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
811− var Graphics = Graphics || {};
812− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
813− var Graphics = Graphics || {};
814− Graphics.Element = Elm.Graphics.Element.make(_elm);
815− var List = Elm.List.make(_elm);
816− var Maybe = Elm.Maybe.make(_elm);
817− var Native = Native || {};
818− Native.Json = Elm.Native.Json.make(_elm);
819− var Native = Native || {};
820− Native.Ports = Elm.Native.Ports.make(_elm);
821− var Signal = Elm.Signal.make(_elm);
822− var String = Elm.String.make(_elm);
823− var Text = Elm.Text.make(_elm);
824− var Time = Elm.Time.make(_elm);
825− var _op = {};
826− var pass = function (m) {
827− return function () {
828− switch (m.ctor)
829− {case "Just": return false;
830− case "Nothing": return true;}
831− _E.Case($moduleName,
832− "between lines 33 and 37");
833− }();
834− };
835− var fail = function ($) {
836− return Basics.not(pass($));
837− };
838− var run = function (_v2) {
839− return function () {
840− switch (_v2.ctor)
841− {case "TestCase":
842− return function () {
843− var runAssertion = F2(function (t,
844− m) {
845− return t({ctor: "_Tuple0"}) ? Maybe.Nothing : Maybe.Just(m);
846− });
847− return function () {
848− switch (_v2._1.ctor)
849− {case "AssertEqual":
850− return runAssertion(_v2._1._0)(_L.append("Expected: ",
851− _L.append(_v2._1._1,
852− _L.append("; got: ",
853− _v2._1._2))));
854− case "AssertFalse":
855− return runAssertion(_v2._1._0)("not False");
856− case "AssertNotEqual":
857− return runAssertion(_v2._1._0)(_L.append(_v2._1._1,
858− _L.append(" equals ",
859− _v2._1._2)));
860− case "AssertTrue":
861− return runAssertion(_v2._1._0)("not True");}
862− _E.Case($moduleName,
863− "between lines 25 and 31");
864− }();
865− }();}
866− _E.Case($moduleName,
867− "between lines 22 and 31");
868− }();
869− };
870− var report = function (ts) {
871− return function () {
872− var results = A2(List.map,
873− run,
874− ts);
875− var $ = A2(List.partition,
876− pass,
877− results),
878− passes = $._0,
879− fails = $._1;
880− return {_: {}
881− ,failures: fails
882− ,passes: passes
883− ,results: results};
884− }();
885− };
886− var Report = F3(function (a,
887− b,
888− c) {
889− return {_: {}
890− ,failures: c
891− ,passes: b
892− ,results: a};
893− });
894− _elm.ElmTest.Run.values = {_op: _op
895− ,run: run
896− ,pass: pass
897− ,fail: fail
898− ,report: report
899− ,Report: Report};
900− return _elm.ElmTest.Run.values;
901−};Elm.ElmTest = Elm.ElmTest || {};
902−Elm.ElmTest.Test = Elm.ElmTest.Test || {};
903−Elm.ElmTest.Test.make = function (_elm) {
904− "use strict";
905− _elm.ElmTest = _elm.ElmTest || {};
906− _elm.ElmTest.Test = _elm.ElmTest.Test || {};
907− if (_elm.ElmTest.Test.values)
908− return _elm.ElmTest.Test.values;
909− var _N = Elm.Native,
910− _U = _N.Utils.make(_elm),
911− _L = _N.List.make(_elm),
912− _E = _N.Error.make(_elm),
913− $moduleName = "ElmTest.Test";
914− var Basics = Elm.Basics.make(_elm);
915− var Color = Elm.Color.make(_elm);
916− var ElmTest = ElmTest || {};
917− ElmTest.Assertion = Elm.ElmTest.Assertion.make(_elm);
918− var Graphics = Graphics || {};
919− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
920− var Graphics = Graphics || {};
921− Graphics.Element = Elm.Graphics.Element.make(_elm);
922− var List = Elm.List.make(_elm);
923− var Maybe = Elm.Maybe.make(_elm);
924− var Native = Native || {};
925− Native.Json = Elm.Native.Json.make(_elm);
926− var Native = Native || {};
927− Native.Ports = Elm.Native.Ports.make(_elm);
928− var Signal = Elm.Signal.make(_elm);
929− var String = Elm.String.make(_elm);
930− var Text = Elm.Text.make(_elm);
931− var Time = Elm.Time.make(_elm);
932− var _op = {};
933− var TestCase = F2(function (a,
934− b) {
935− return {ctor: "TestCase"
936− ,_0: a
937− ,_1: b};
938− });
939− var test = F2(function (name,
940− a) {
941− return A2(TestCase,name,a);
942− });
943− var defaultTest = function (a) {
944− return function () {
945− var name = function () {
946− switch (a.ctor)
947− {case "AssertEqual":
948− return _L.append(a._1,
949− _L.append(" == ",a._2));
950− case "AssertNotEqual":
951− return _L.append(a._1,
952− _L.append(" /= ",a._2));
953− case "AssertTrue":
954− return "True";}
955− _E.Case($moduleName,
956− "between lines 25 and 30");
957− }();
958− return A2(test,name,a);
959− }();
960− };
961− var equals = F2(function (a,b) {
962− return defaultTest(A2(ElmTest.Assertion.assertEqual,
963− a,
964− b));
965− });
966− _elm.ElmTest.Test.values = {_op: _op
967− ,equals: equals
968− ,test: test
969− ,defaultTest: defaultTest
970− ,TestCase: TestCase};
971− return _elm.ElmTest.Test.values;
972−};Elm.ElmTest = Elm.ElmTest || {};
973−Elm.ElmTest.Assertion = Elm.ElmTest.Assertion || {};
974−Elm.ElmTest.Assertion.make = function (_elm) {
975− "use strict";
976− _elm.ElmTest = _elm.ElmTest || {};
977− _elm.ElmTest.Assertion = _elm.ElmTest.Assertion || {};
978− if (_elm.ElmTest.Assertion.values)
979− return _elm.ElmTest.Assertion.values;
980− var _N = Elm.Native,
981− _U = _N.Utils.make(_elm),
982− _L = _N.List.make(_elm),
983− _E = _N.Error.make(_elm),
984− $moduleName = "ElmTest.Assertion";
985− var Basics = Elm.Basics.make(_elm);
986− var Color = Elm.Color.make(_elm);
987− var Graphics = Graphics || {};
988− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
989− var Graphics = Graphics || {};
990− Graphics.Element = Elm.Graphics.Element.make(_elm);
991− var List = Elm.List.make(_elm);
992− var Maybe = Elm.Maybe.make(_elm);
993− var Native = Native || {};
994− Native.Json = Elm.Native.Json.make(_elm);
995− var Native = Native || {};
996− Native.Ports = Elm.Native.Ports.make(_elm);
997− var Signal = Elm.Signal.make(_elm);
998− var String = Elm.String.make(_elm);
999− var Text = Elm.Text.make(_elm);
1000− var Time = Elm.Time.make(_elm);
1001− var _op = {};
1002− var AssertNotEqual = F3(function (a,
1003− b,
1004− c) {
1005− return {ctor: "AssertNotEqual"
1006− ,_0: a
1007− ,_1: b
1008− ,_2: c};
1009− });
1010− var assertNotEqual = F2(function (a,
1011− b) {
1012− return A3(AssertNotEqual,
1013− function (_v0) {
1014− return function () {
1015− return !_U.eq(a,b);
1016− }();
1017− },
1018− String.show(a),
1019− String.show(b));
1020− });
1021− var AssertEqual = F3(function (a,
1022− b,
1023− c) {
1024− return {ctor: "AssertEqual"
1025− ,_0: a
1026− ,_1: b
1027− ,_2: c};
1028− });
1029− var assertEqual = F2(function (a,
1030− b) {
1031− return A3(AssertEqual,
1032− function (_v2) {
1033− return function () {
1034− return _U.eq(a,b);
1035− }();
1036− },
1037− String.show(a),
1038− String.show(b));
1039− });
1040− var assertionList = F2(function (xs,
1041− ys) {
1042− return A3(List.zipWith,
1043− assertEqual,
1044− xs,
1045− ys);
1046− });
1047− var AssertFalse = function (a) {
1048− return {ctor: "AssertFalse"
1049− ,_0: a};
1050− };
1051− var AssertTrue = function (a) {
1052− return {ctor: "AssertTrue"
1053− ,_0: a};
1054− };
1055− var assertT = AssertTrue;
1056− var assert = function (b) {
1057− return AssertTrue(function (_v4) {
1058− return function () {
1059− return b;
1060− }();
1061− });
1062− };
1063− _elm.ElmTest.Assertion.values = {_op: _op
1064− ,assertT: assertT
1065− ,assert: assert
1066− ,assertEqual: assertEqual
1067− ,assertionList: assertionList
1068− ,assertNotEqual: assertNotEqual
1069− ,AssertTrue: AssertTrue
1070− ,AssertFalse: AssertFalse
1071− ,AssertEqual: AssertEqual
1072− ,AssertNotEqual: AssertNotEqual};
1073− return _elm.ElmTest.Assertion.values;
1074−};Elm.IO = Elm.IO || {};
1075−Elm.IO.IO = Elm.IO.IO || {};
1076−Elm.IO.IO.make = function (_elm) {
1077− "use strict";
1078− _elm.IO = _elm.IO || {};
1079− _elm.IO.IO = _elm.IO.IO || {};
1080− if (_elm.IO.IO.values)
1081− return _elm.IO.IO.values;
1082− var _N = Elm.Native,
1083− _U = _N.Utils.make(_elm),
1084− _L = _N.List.make(_elm),
1085− _E = _N.Error.make(_elm),
1086− $moduleName = "IO.IO";
1087− var Basics = Elm.Basics.make(_elm);
1088− var Color = Elm.Color.make(_elm);
1089− var Graphics = Graphics || {};
1090− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
1091− var Graphics = Graphics || {};
1092− Graphics.Element = Elm.Graphics.Element.make(_elm);
1093− var List = Elm.List.make(_elm);
1094− var Maybe = Elm.Maybe.make(_elm);
1095− var Native = Native || {};
1096− Native.Json = Elm.Native.Json.make(_elm);
1097− var Native = Native || {};
1098− Native.Ports = Elm.Native.Ports.make(_elm);
1099− var Signal = Elm.Signal.make(_elm);
1100− var String = Elm.String.make(_elm);
1101− var Text = Elm.Text.make(_elm);
1102− var Time = Elm.Time.make(_elm);
1103− var _op = {};
1104− var Impure = function (a) {
1105− return {ctor: "Impure"
1106− ,_0: a};
1107− };
1108− var Pure = function (a) {
1109− return {ctor: "Pure",_0: a};
1110− };
1111− var Exit = function (a) {
1112− return {ctor: "Exit",_0: a};
1113− };
1114− var GetC = function (a) {
1115− return {ctor: "GetC",_0: a};
1116− };
1117− var PutC = F2(function (a,b) {
1118− return {ctor: "PutC"
1119− ,_0: a
1120− ,_1: b};
1121− });
1122− var mapF = F2(function (f,iof) {
1123− return function () {
1124− switch (iof.ctor)
1125− {case "Exit":
1126− return Exit(iof._0);
1127− case "GetC":
1128− return GetC(function ($) {
1129− return f(iof._0($));
1130− });
1131− case "PutC": return A2(PutC,
1132− iof._0,
1133− f(iof._1));}
1134− _E.Case($moduleName,
1135− "between lines 77 and 80");
1136− }();
1137− });
1138− var foldIO = F3(function (pur,
1139− impur,
1140− io) {
1141− return function () {
1142− switch (io.ctor)
1143− {case "Impure":
1144− return impur(A2(mapF,
1145− A2(foldIO,pur,impur),
1146− io._0));
1147− case "Pure": return pur(io._0);}
1148− _E.Case($moduleName,
1149− "between lines 84 and 86");
1150− }();
1151− });
1152− var bind = F2(function (io,f) {
1153− return function () {
1154− switch (io.ctor)
1155− {case "Impure":
1156− return Impure(A2(mapF,
1157− A2(Basics.flip,bind,f),
1158− io._0));
1159− case "Pure": return f(io._0);}
1160− _E.Case($moduleName,
1161− "between lines 52 and 54");
1162− }();
1163− });
1164− _op[">>="] = bind;
1165− var seq = F2(function (x,y) {
1166− return A2(_op[">>="],
1167− x,
1168− function (_v11) {
1169− return function () {
1170− return y;
1171− }();
1172− });
1173− });
1174− _op[">>"] = seq;
1175− var forever = function (m) {
1176− return A2(_op[">>="],
1177− m,
1178− function (_v13) {
1179− return function () {
1180− return forever(m);
1181− }();
1182− });
1183− };
1184− var pure = Pure;
1185− var apply = F2(function (iof,
1186− iom) {
1187− return A2(_op[">>="],
1188− iof,
1189− function (f) {
1190− return A2(_op[">>="],
1191− iom,
1192− function (m) {
1193− return pure(f(m));
1194− });
1195− });
1196− });
1197− _op["<*>"] = apply;
1198− var mapIO = F2(function (f,xs) {
1199− return A3(List.foldr,
1200− function ($) {
1201− return F2(function (x,y) {
1202− return A2(_op[">>"],x,y);
1203− })(f($));
1204− },
1205− pure({ctor: "_Tuple0"}),
1206− xs);
1207− });
1208− var map = F2(function (f,io) {
1209− return function () {
1210− switch (io.ctor)
1211− {case "Impure":
1212− return Impure(A2(mapF,
1213− map(f),
1214− io._0));
1215− case "Pure":
1216− return Pure(f(io._0));}
1217− _E.Case($moduleName,
1218− "between lines 33 and 35");
1219− }();
1220− });
1221− var exit = function ($) {
1222− return Impure(Exit($));
1223− };
1224− var getChar = Impure(GetC(Pure));
1225− var readUntil = function (end) {
1226− return function () {
1227− var go = function (s) {
1228− return A2(_op[">>="],
1229− getChar,
1230− function (c) {
1231− return _U.eq(c,
1232− end) ? pure(s) : go(A2(String.append,
1233− s,
1234− A2(String.cons,c,"")));
1235− });
1236− };
1237− return go("");
1238− }();
1239− };
1240− var getLine = readUntil(_U.chr("\n"));
1241− var putChar = function (c) {
1242− return Impure(A2(PutC,
1243− c,
1244− Pure({ctor: "_Tuple0"})));
1245− };
1246− var putStr = function ($) {
1247− return mapIO(putChar)(String.toList($));
1248− };
1249− var putStrLn = function (s) {
1250− return A2(_op[">>"],
1251− putStr(s),
1252− putChar(_U.chr("\n")));
1253− };
1254− _elm.IO.IO.values = {_op: _op
1255− ,putChar: putChar
1256− ,getChar: getChar
1257− ,exit: exit
1258− ,putStr: putStr
1259− ,putStrLn: putStrLn
1260− ,readUntil: readUntil
1261− ,getLine: getLine
1262− ,map: map
1263− ,mapIO: mapIO
1264− ,pure: pure
1265− ,apply: apply
1266− ,bind: bind
1267− ,seq: seq
1268− ,forever: forever
1269− ,mapF: mapF
1270− ,foldIO: foldIO
1271− ,PutC: PutC
1272− ,GetC: GetC
1273− ,Exit: Exit
1274− ,Pure: Pure
1275− ,Impure: Impure};
1276− return _elm.IO.IO.values;
1277−};</script></head><body><script type="text/javascript">Elm.fullscreen(Elm.Main)</script><noscript></noscript></body></html>
tests/elm/build/Test.jsdeleted−1276
@@ -1,1276 +0,0 @@
1−Elm.Main = Elm.Main || {};
2−Elm.Main.make = function (_elm) {
3− "use strict";
4− _elm.Main = _elm.Main || {};
5− if (_elm.Main.values)
6− return _elm.Main.values;
7− var _N = Elm.Native,
8− _U = _N.Utils.make(_elm),
9− _L = _N.List.make(_elm),
10− _E = _N.Error.make(_elm),
11− $moduleName = "Main";
12− var Basics = Elm.Basics.make(_elm);
13− var Color = Elm.Color.make(_elm);
14− var ElmTest = ElmTest || {};
15− ElmTest.Assertion = Elm.ElmTest.Assertion.make(_elm);
16− var ElmTest = ElmTest || {};
17− ElmTest.Run = Elm.ElmTest.Run.make(_elm);
18− var ElmTest = ElmTest || {};
19− ElmTest.Runner = ElmTest.Runner || {};
20− ElmTest.Runner.Console = Elm.ElmTest.Runner.Console.make(_elm);
21− var ElmTest = ElmTest || {};
22− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
23− var Graphics = Graphics || {};
24− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
25− var Graphics = Graphics || {};
26− Graphics.Element = Elm.Graphics.Element.make(_elm);
27− var IO = IO || {};
28− IO.IO = Elm.IO.IO.make(_elm);
29− var IO = IO || {};
30− IO.Runner = Elm.IO.Runner.make(_elm);
31− var List = Elm.List.make(_elm);
32− var Maybe = Elm.Maybe.make(_elm);
33− var Native = Native || {};
34− Native.Json = Elm.Native.Json.make(_elm);
35− var Native = Native || {};
36− Native.Ports = Elm.Native.Ports.make(_elm);
37− var Signal = Elm.Signal.make(_elm);
38− var String = Elm.String.make(_elm);
39− var Text = Elm.Text.make(_elm);
40− var Time = Elm.Time.make(_elm);
41− var _op = {};
42− var responses = Native.Ports.portIn("responses",
43− Native.Ports.incomingSignal(function (v) {
44− return v === null ? Maybe.Nothing : Maybe.Just(typeof v === "string" || typeof v === "object" && v instanceof String ? v : _E.raise("invalid input, expecting JSString but got " + v));
45− }));
46− var tests = _L.fromArray([A2(ElmTest.Test.equals,
47− 0,
48− 1)]);
49− var console = ElmTest.Runner.Console.runDisplay(tests);
50− var requests = Native.Ports.portOut("requests",
51− Native.Ports.outgoingSignal(function (v) {
52− return _L.toArray(v).map(function (v) {
53− return {mPut: v.mPut.ctor === "Nothing" ? null : v.mPut._0
54− ,mExit: v.mExit.ctor === "Nothing" ? null : v.mExit._0
55− ,mGet: v.mGet};
56− });
57− }),
58− A2(IO.Runner.run,
59− responses,
60− console));
61− _elm.Main.values = {_op: _op
62− ,tests: tests
63− ,console: console};
64− return _elm.Main.values;
65−};Elm.IO = Elm.IO || {};
66−Elm.IO.Runner = Elm.IO.Runner || {};
67−Elm.IO.Runner.make = function (_elm) {
68− "use strict";
69− _elm.IO = _elm.IO || {};
70− _elm.IO.Runner = _elm.IO.Runner || {};
71− if (_elm.IO.Runner.values)
72− return _elm.IO.Runner.values;
73− var _N = Elm.Native,
74− _U = _N.Utils.make(_elm),
75− _L = _N.List.make(_elm),
76− _E = _N.Error.make(_elm),
77− $moduleName = "IO.Runner";
78− var Automaton = Elm.Automaton.make(_elm);
79− var Basics = Elm.Basics.make(_elm);
80− var Color = Elm.Color.make(_elm);
81− var Either = Elm.Either.make(_elm);
82− var Graphics = Graphics || {};
83− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
84− var Graphics = Graphics || {};
85− Graphics.Element = Elm.Graphics.Element.make(_elm);
86− var IO = IO || {};
87− IO.IO = Elm.IO.IO.make(_elm);
88− var List = Elm.List.make(_elm);
89− var Maybe = Elm.Maybe.make(_elm);
90− var Native = Native || {};
91− Native.Json = Elm.Native.Json.make(_elm);
92− var Native = Native || {};
93− Native.Ports = Elm.Native.Ports.make(_elm);
94− var Signal = Elm.Signal.make(_elm);
95− var String = Elm.String.make(_elm);
96− var Text = Elm.Text.make(_elm);
97− var Time = Elm.Time.make(_elm);
98− var _op = {};
99− var put = F2(function (s,_v0) {
100− return function () {
101− return {ctor: "_Tuple2"
102− ,_0: s
103− ,_1: {ctor: "_Tuple0"}};
104− }();
105− });
106− var ask = function (s) {
107− return {ctor: "_Tuple2"
108− ,_0: s
109− ,_1: s};
110− };
111− _op[">>="] = F3(function (f,
112− k,
113− s) {
114− return function () {
115− var $ = f(s),
116− s$ = $._0,
117− y = $._1;
118− return A2(k,y,s$);
119− }();
120− });
121− var pure = F2(function (x,s) {
122− return {ctor: "_Tuple2"
123− ,_0: s
124− ,_1: x};
125− });
126− var empty = {_: {}
127− ,mExit: Maybe.Nothing
128− ,mGet: false
129− ,mPut: Maybe.Nothing};
130− var putS = function (s) {
131− return _U.replace([["mPut"
132− ,Maybe.Just(s)]],
133− empty);
134− };
135− var exit = function (n) {
136− return _U.replace([["mExit"
137− ,Maybe.Just(n)]],
138− empty);
139− };
140− var getS = _U.replace([["mGet"
141− ,true]],
142− empty);
143− var extractRequests = function (io) {
144− return function () {
145− switch (io.ctor)
146− {case "Impure":
147− return function () {
148− switch (io._0.ctor)
149− {case "Exit":
150− return pure({ctor: "_Tuple2"
151− ,_0: _L.fromArray([exit(io._0._0)])
152− ,_1: io});
153− case "GetC":
154− return A2(_op[">>="],
155− ask,
156− function (st) {
157− return function () {
158− var _v10 = String.uncons(st.buffer);
159− switch (_v10.ctor)
160− {case "Just":
161− switch (_v10._0.ctor)
162− {case "_Tuple2":
163− return A2(_op[">>="],
164− put({_: {},buffer: _v10._0._1}),
165− function (_v14) {
166− return function () {
167− return extractRequests(io._0._0(_v10._0._0));
168− }();
169− });}
170− break;
171− case "Nothing":
172− return pure({ctor: "_Tuple2"
173− ,_0: _L.fromArray([getS])
174− ,_1: io});}
175− _E.Case($moduleName,
176− "between lines 51 and 55");
177− }();
178− });
179− case "PutC":
180− return A2(_op[">>="],
181− extractRequests(io._0._1),
182− function (_v16) {
183− return function () {
184− switch (_v16.ctor)
185− {case "_Tuple2":
186− return pure({ctor: "_Tuple2"
187− ,_0: {ctor: "::"
188− ,_0: putS(A2(String.cons,
189− io._0._0,
190− ""))
191− ,_1: _v16._0}
192− ,_1: _v16._1});}
193− _E.Case($moduleName,
194− "on line 47, column 22 to 61");
195− }();
196− });}
197− _E.Case($moduleName,
198− "between lines 45 and 55");
199− }();
200− case "Pure":
201− return pure({ctor: "_Tuple2"
202− ,_0: _L.fromArray([exit(0)])
203− ,_1: IO.IO.Pure(io._0)});}
204− _E.Case($moduleName,
205− "between lines 43 and 55");
206− }();
207− };
208− var step = F2(function (resp,
209− _v20) {
210− return function () {
211− switch (_v20.ctor)
212− {case "_Tuple2":
213− return function () {
214− var newST = function () {
215− switch (resp.ctor)
216− {case "Just":
217− return _U.replace([["buffer"
218− ,A2(String.append,
219− _v20._1.buffer,
220− resp._0)]],
221− _v20._1);
222− case "Nothing": return _v20._1;}
223− _E.Case($moduleName,
224− "between lines 59 and 62");
225− }();
226− var _ = A2(extractRequests,
227− _v20._0,
228− newST);
229− var k = function () {
230− switch (_.ctor)
231− {case "_Tuple2":
232− switch (_._1.ctor)
233− {case "_Tuple2":
234− return _._1._1;}
235− break;}
236− _E.Case($moduleName,
237− "on line 62, column 27 to 51");
238− }();
239− var newST$ = function () {
240− switch (_.ctor)
241− {case "_Tuple2":
242− switch (_._1.ctor)
243− {case "_Tuple2": return _._0;}
244− break;}
245− _E.Case($moduleName,
246− "on line 62, column 27 to 51");
247− }();
248− var rs = function () {
249− switch (_.ctor)
250− {case "_Tuple2":
251− switch (_._1.ctor)
252− {case "_Tuple2":
253− return _._1._0;}
254− break;}
255− _E.Case($moduleName,
256− "on line 62, column 27 to 51");
257− }();
258− return {ctor: "_Tuple2"
259− ,_0: {ctor: "_Tuple2"
260− ,_0: k
261− ,_1: newST$}
262− ,_1: rs};
263− }();}
264− _E.Case($moduleName,
265− "between lines 59 and 63");
266− }();
267− });
268− var start = {_: {},buffer: ""};
269− var run = F2(function (resps,
270− io) {
271− return A3(Automaton.run,
272− A2(Automaton.hiddenState,
273− {ctor: "_Tuple2"
274− ,_0: io
275− ,_1: start},
276− step),
277− _L.fromArray([]),
278− resps);
279− });
280− var orSig = F2(function (s1,
281− s2) {
282− return A2(Signal.merge,
283− A2(Signal._op["<~"],
284− Either.Left,
285− s1),
286− A2(Signal._op["<~"],
287− Either.Right,
288− s2));
289− });
290− var IOState = function (a) {
291− return {_: {},buffer: a};
292− };
293− var Request = F3(function (a,
294− b,
295− c) {
296− return {_: {}
297− ,mExit: b
298− ,mGet: c
299− ,mPut: a};
300− });
301− _elm.IO.Runner.values = {_op: _op
302− ,orSig: orSig
303− ,start: start
304− ,run: run
305− ,empty: empty
306− ,putS: putS
307− ,exit: exit
308− ,getS: getS
309− ,extractRequests: extractRequests
310− ,step: step
311− ,pure: pure
312− ,ask: ask
313− ,put: put
314− ,Request: Request
315− ,IOState: IOState};
316− return _elm.IO.Runner.values;
317−};Elm.Automaton = Elm.Automaton || {};
318−Elm.Automaton.make = function (_elm) {
319− "use strict";
320− _elm.Automaton = _elm.Automaton || {};
321− if (_elm.Automaton.values)
322− return _elm.Automaton.values;
323− var _N = Elm.Native,
324− _U = _N.Utils.make(_elm),
325− _L = _N.List.make(_elm),
326− _E = _N.Error.make(_elm),
327− $moduleName = "Automaton";
328− var Basics = Elm.Basics.make(_elm);
329− var Color = Elm.Color.make(_elm);
330− var Graphics = Graphics || {};
331− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
332− var Graphics = Graphics || {};
333− Graphics.Element = Elm.Graphics.Element.make(_elm);
334− var List = Elm.List.make(_elm);
335− var Maybe = Elm.Maybe.make(_elm);
336− var Native = Native || {};
337− Native.Json = Elm.Native.Json.make(_elm);
338− var Native = Native || {};
339− Native.Ports = Elm.Native.Ports.make(_elm);
340− var Signal = Elm.Signal.make(_elm);
341− var String = Elm.String.make(_elm);
342− var Text = Elm.Text.make(_elm);
343− var Time = Elm.Time.make(_elm);
344− var _op = {};
345− var dequeue = function (q) {
346− return function () {
347− switch (q.ctor)
348− {case "_Tuple2":
349− switch (q._0.ctor)
350− {case "[]": switch (q._1.ctor)
351− {case "[]":
352− return Maybe.Nothing;}
353− break;}
354− switch (q._1.ctor)
355− {case "::":
356− return Maybe.Just({ctor: "_Tuple2"
357− ,_0: q._1._0
358− ,_1: {ctor: "_Tuple2"
359− ,_0: q._0
360− ,_1: q._1._1}});
361− case "[]":
362− return dequeue({ctor: "_Tuple2"
363− ,_0: _L.fromArray([])
364− ,_1: List.reverse(q._0)});}
365− break;}
366− _E.Case($moduleName,
367− "between lines 116 and 121");
368− }();
369− };
370− var enqueue = F2(function (x,
371− _v5) {
372− return function () {
373− switch (_v5.ctor)
374− {case "_Tuple2":
375− return {ctor: "_Tuple2"
376− ,_0: {ctor: "::"
377− ,_0: x
378− ,_1: _v5._0}
379− ,_1: _v5._1};}
380− _E.Case($moduleName,
381− "on line 115, column 22 to 31");
382− }();
383− });
384− var empty = {ctor: "_Tuple2"
385− ,_0: _L.fromArray([])
386− ,_1: _L.fromArray([])};
387− var Step = function (a) {
388− return {ctor: "Step",_0: a};
389− };
390− var run = F3(function (auto,
391− base,
392− inputs) {
393− return function () {
394− var step = F2(function (a,
395− _v9) {
396− return function () {
397− switch (_v9.ctor)
398− {case "_Tuple2":
399− switch (_v9._0.ctor)
400− {case "Step":
401− return _v9._0._0(a);}
402− break;}
403− _E.Case($moduleName,
404− "on line 43, column 28 to 31");
405− }();
406− });
407− return A2(Signal.lift,
408− function (_v14) {
409− return function () {
410− switch (_v14.ctor)
411− {case "_Tuple2":
412− return _v14._1;}
413− _E.Case($moduleName,
414− "on line 44, column 23 to 24");
415− }();
416− },
417− A3(Signal.foldp,
418− step,
419− {ctor: "_Tuple2"
420− ,_0: auto
421− ,_1: base},
422− inputs));
423− }();
424− });
425− var step = F2(function (a,
426− _v18) {
427− return function () {
428− switch (_v18.ctor)
429− {case "Step":
430− return _v18._0(a);}
431− _E.Case($moduleName,
432− "on line 48, column 19 to 22");
433− }();
434− });
435− var andThen = F2(function (f,
436− g) {
437− return Step(function (a) {
438− return function () {
439− var $ = A2(step,a,f),
440− f$ = $._0,
441− b = $._1;
442− var $ = A2(step,b,g),
443− g$ = $._0,
444− c = $._1;
445− return {ctor: "_Tuple2"
446− ,_0: A2(andThen,f$,g$)
447− ,_1: c};
448− }();
449− });
450− });
451− var loop = F2(function (state,
452− auto) {
453− return Step(function (input) {
454− return function () {
455− var _ = A2(step,
456− {ctor: "_Tuple2"
457− ,_0: input
458− ,_1: state},
459− auto);
460− var auto$ = function () {
461− switch (_.ctor)
462− {case "_Tuple2":
463− switch (_._1.ctor)
464− {case "_Tuple2": return _._0;}
465− break;}
466− _E.Case($moduleName,
467− "on line 68, column 54 to 77");
468− }();
469− var output = function () {
470− switch (_.ctor)
471− {case "_Tuple2":
472− switch (_._1.ctor)
473− {case "_Tuple2":
474− return _._1._0;}
475− break;}
476− _E.Case($moduleName,
477− "on line 68, column 54 to 77");
478− }();
479− var state$ = function () {
480− switch (_.ctor)
481− {case "_Tuple2":
482− switch (_._1.ctor)
483− {case "_Tuple2":
484− return _._1._1;}
485− break;}
486− _E.Case($moduleName,
487− "on line 68, column 54 to 77");
488− }();
489− return {ctor: "_Tuple2"
490− ,_0: A2(loop,state$,auto$)
491− ,_1: output};
492− }();
493− });
494− });
495− var combine = function (autos) {
496− return Step(function (a) {
497− return function () {
498− var $ = List.unzip(A2(List.map,
499− step(a),
500− autos)),
501− autos$ = $._0,
502− bs = $._1;
503− return {ctor: "_Tuple2"
504− ,_0: combine(autos$)
505− ,_1: bs};
506− }();
507− });
508− };
509− var pure = function (f) {
510− return Step(function (x) {
511− return {ctor: "_Tuple2"
512− ,_0: pure(f)
513− ,_1: f(x)};
514− });
515− };
516− var state = F2(function (s,f) {
517− return Step(function (x) {
518− return function () {
519− var s$ = A2(f,x,s);
520− return {ctor: "_Tuple2"
521− ,_0: A2(state,s$,f)
522− ,_1: s$};
523− }();
524− });
525− });
526− var count = A2(state,
527− 0,
528− F2(function (_v36,c) {
529− return function () {
530− return c + 1;
531− }();
532− }));
533− var hiddenState = F2(function (s,
534− f) {
535− return Step(function (x) {
536− return function () {
537− var $ = A2(f,x,s),
538− s$ = $._0,
539− out = $._1;
540− return {ctor: "_Tuple2"
541− ,_0: A2(hiddenState,s$,f)
542− ,_1: out};
543− }();
544− });
545− });
546− var average = function (k) {
547− return function () {
548− var stepFull = F2(function (n,
549− _v38) {
550− return function () {
551− switch (_v38.ctor)
552− {case "_Tuple3":
553− return function () {
554− var _v43 = dequeue(_v38._0);
555− switch (_v43.ctor)
556− {case "Just":
557− switch (_v43._0.ctor)
558− {case "_Tuple2":
559− return function () {
560− var sum$ = _v38._2 + n - _v43._0._0;
561− return {ctor: "_Tuple2"
562− ,_0: {ctor: "_Tuple3"
563− ,_0: A2(enqueue,n,_v43._0._1)
564− ,_1: _v38._1
565− ,_2: sum$}
566− ,_1: sum$ / Basics.toFloat(_v38._1)};
567− }();}
568− break;
569− case "Nothing":
570− return {ctor: "_Tuple2"
571− ,_0: {ctor: "_Tuple3"
572− ,_0: _v38._0
573− ,_1: _v38._1
574− ,_2: _v38._2}
575− ,_1: 0};}
576− _E.Case($moduleName,
577− "between lines 128 and 132");
578− }();}
579− _E.Case($moduleName,
580− "between lines 128 and 132");
581− }();
582− });
583− var step = F2(function (n,
584− _v47) {
585− return function () {
586− switch (_v47.ctor)
587− {case "_Tuple3":
588− return _U.eq(_v47._1,
589− k) ? A2(stepFull,
590− n,
591− {ctor: "_Tuple3"
592− ,_0: _v47._0
593− ,_1: _v47._1
594− ,_2: _v47._2}) : {ctor: "_Tuple2"
595− ,_0: {ctor: "_Tuple3"
596− ,_0: A2(enqueue,n,_v47._0)
597− ,_1: _v47._1 + 1
598− ,_2: _v47._2 + n}
599− ,_1: (_v47._2 + n) / (Basics.toFloat(_v47._1) + 1)};}
600− _E.Case($moduleName,
601− "between lines 125 and 126");
602− }();
603− });
604− return A2(hiddenState,
605− {ctor: "_Tuple3"
606− ,_0: empty
607− ,_1: 0
608− ,_2: 0},
609− step);
610− }();
611− };
612− _elm.Automaton.values = {_op: _op
613− ,pure: pure
614− ,state: state
615− ,hiddenState: hiddenState
616− ,run: run
617− ,step: step
618− ,andThen: andThen
619− ,combine: combine
620− ,loop: loop
621− ,count: count
622− ,average: average};
623− return _elm.Automaton.values;
624−};Elm.ElmTest = Elm.ElmTest || {};
625−Elm.ElmTest.Runner = Elm.ElmTest.Runner || {};
626−Elm.ElmTest.Runner.Console = Elm.ElmTest.Runner.Console || {};
627−Elm.ElmTest.Runner.Console.make = function (_elm) {
628− "use strict";
629− _elm.ElmTest = _elm.ElmTest || {};
630− _elm.ElmTest.Runner = _elm.ElmTest.Runner || {};
631− _elm.ElmTest.Runner.Console = _elm.ElmTest.Runner.Console || {};
632− if (_elm.ElmTest.Runner.Console.values)
633− return _elm.ElmTest.Runner.Console.values;
634− var _N = Elm.Native,
635− _U = _N.Utils.make(_elm),
636− _L = _N.List.make(_elm),
637− _E = _N.Error.make(_elm),
638− $moduleName = "ElmTest.Runner.Console";
639− var Basics = Elm.Basics.make(_elm);
640− var Color = Elm.Color.make(_elm);
641− var ElmTest = ElmTest || {};
642− ElmTest.Runner = ElmTest.Runner || {};
643− ElmTest.Runner.String = Elm.ElmTest.Runner.String.make(_elm);
644− var ElmTest = ElmTest || {};
645− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
646− var Graphics = Graphics || {};
647− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
648− var Graphics = Graphics || {};
649− Graphics.Element = Elm.Graphics.Element.make(_elm);
650− var IO = IO || {};
651− IO.IO = Elm.IO.IO.make(_elm);
652− var List = Elm.List.make(_elm);
653− var Maybe = Elm.Maybe.make(_elm);
654− var Native = Native || {};
655− Native.Json = Elm.Native.Json.make(_elm);
656− var Native = Native || {};
657− Native.Ports = Elm.Native.Ports.make(_elm);
658− var Signal = Elm.Signal.make(_elm);
659− var String = Elm.String.make(_elm);
660− var Text = Elm.Text.make(_elm);
661− var Time = Elm.Time.make(_elm);
662− var _op = {};
663− var runDisplay = function (tests) {
664− return function () {
665− var $ = ElmTest.Runner.String.runDisplay(tests),
666− allPassed = $._0,
667− results = $._1;
668− return A2(IO.IO._op[">>"],
669− IO.IO.putStrLn(results),
670− function () {
671− switch (allPassed)
672− {case false:
673− return IO.IO.exit(1);
674− case true:
675− return IO.IO.exit(0);}
676− _E.Case($moduleName,
677− "between lines 23 and 25");
678− }());
679− }();
680− };
681− _elm.ElmTest.Runner.Console.values = {_op: _op
682− ,runDisplay: runDisplay};
683− return _elm.ElmTest.Runner.Console.values;
684−};Elm.ElmTest = Elm.ElmTest || {};
685−Elm.ElmTest.Runner = Elm.ElmTest.Runner || {};
686−Elm.ElmTest.Runner.String = Elm.ElmTest.Runner.String || {};
687−Elm.ElmTest.Runner.String.make = function (_elm) {
688− "use strict";
689− _elm.ElmTest = _elm.ElmTest || {};
690− _elm.ElmTest.Runner = _elm.ElmTest.Runner || {};
691− _elm.ElmTest.Runner.String = _elm.ElmTest.Runner.String || {};
692− if (_elm.ElmTest.Runner.String.values)
693− return _elm.ElmTest.Runner.String.values;
694− var _N = Elm.Native,
695− _U = _N.Utils.make(_elm),
696− _L = _N.List.make(_elm),
697− _E = _N.Error.make(_elm),
698− $moduleName = "ElmTest.Runner.String";
699− var Basics = Elm.Basics.make(_elm);
700− var Color = Elm.Color.make(_elm);
701− var ElmTest = ElmTest || {};
702− ElmTest.Run = Elm.ElmTest.Run.make(_elm);
703− var ElmTest = ElmTest || {};
704− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
705− var Graphics = Graphics || {};
706− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
707− var Graphics = Graphics || {};
708− Graphics.Element = Elm.Graphics.Element.make(_elm);
709− var List = Elm.List.make(_elm);
710− var Maybe = Elm.Maybe.make(_elm);
711− var Native = Native || {};
712− Native.Json = Elm.Native.Json.make(_elm);
713− var Native = Native || {};
714− Native.Ports = Elm.Native.Ports.make(_elm);
715− var Signal = Elm.Signal.make(_elm);
716− var String = Elm.String.make(_elm);
717− var Text = Elm.Text.make(_elm);
718− var Time = Elm.Time.make(_elm);
719− var _op = {};
720− var pretty = F2(function (_v0,
721− r) {
722− return function () {
723− switch (_v0.ctor)
724− {case "TestCase":
725− return function () {
726− switch (r.ctor)
727− {case "Just":
728− return _L.append(_v0._0,
729− _L.append(": FAILED. ",r._0));
730− case "Nothing":
731− return _L.append(_v0._0,
732− ": passed.");}
733− _E.Case($moduleName,
734− "between lines 29 and 33");
735− }();}
736− _E.Case($moduleName,
737− "between lines 29 and 33");
738− }();
739− });
740− var replicate = F2(function (n,
741− c) {
742− return function () {
743− var go = function (n) {
744− return _U.cmp(n,
745− 0) < 1 ? _L.fromArray([]) : {ctor: "::"
746− ,_0: c
747− ,_1: go(n - 1)};
748− };
749− return String.fromList(go(n));
750− }();
751− });
752− var vcat = function ($) {
753− return List.concat(List.intersperse("\n")($));
754− };
755− var indent = function (n) {
756− return function () {
757− var indents = A2(replicate,
758− n,
759− _U.chr(" "));
760− return function ($) {
761− return vcat(List.map(String.append(indents))(String.lines($)));
762− };
763− }();
764− };
765− var runDisplay = function (ts) {
766− return function () {
767− var r = ElmTest.Run.report(ts);
768− var passed = List.length(r.passes);
769− var failed = List.length(r.failures);
770− var summary = vcat(List.map(indent(2))(_L.fromArray([_L.append(String.show(List.length(ts)),
771− " tests executed")
772− ,_L.append(String.show(passed),
773− " tests passed")
774− ,_L.append(String.show(failed),
775− " tests failed")])));
776− var pass = _U.eq(failed,0);
777− var results = pass ? _L.fromArray([]) : A3(List.zipWith,
778− pretty,
779− ts,
780− r.results);
781− return {ctor: "_Tuple2"
782− ,_0: pass
783− ,_1: vcat({ctor: "::"
784− ,_0: summary
785− ,_1: results})};
786− }();
787− };
788− _elm.ElmTest.Runner.String.values = {_op: _op
789− ,runDisplay: runDisplay};
790− return _elm.ElmTest.Runner.String.values;
791−};Elm.ElmTest = Elm.ElmTest || {};
792−Elm.ElmTest.Run = Elm.ElmTest.Run || {};
793−Elm.ElmTest.Run.make = function (_elm) {
794− "use strict";
795− _elm.ElmTest = _elm.ElmTest || {};
796− _elm.ElmTest.Run = _elm.ElmTest.Run || {};
797− if (_elm.ElmTest.Run.values)
798− return _elm.ElmTest.Run.values;
799− var _N = Elm.Native,
800− _U = _N.Utils.make(_elm),
801− _L = _N.List.make(_elm),
802− _E = _N.Error.make(_elm),
803− $moduleName = "ElmTest.Run";
804− var Basics = Elm.Basics.make(_elm);
805− var Color = Elm.Color.make(_elm);
806− var ElmTest = ElmTest || {};
807− ElmTest.Assertion = Elm.ElmTest.Assertion.make(_elm);
808− var ElmTest = ElmTest || {};
809− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
810− var Graphics = Graphics || {};
811− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
812− var Graphics = Graphics || {};
813− Graphics.Element = Elm.Graphics.Element.make(_elm);
814− var List = Elm.List.make(_elm);
815− var Maybe = Elm.Maybe.make(_elm);
816− var Native = Native || {};
817− Native.Json = Elm.Native.Json.make(_elm);
818− var Native = Native || {};
819− Native.Ports = Elm.Native.Ports.make(_elm);
820− var Signal = Elm.Signal.make(_elm);
821− var String = Elm.String.make(_elm);
822− var Text = Elm.Text.make(_elm);
823− var Time = Elm.Time.make(_elm);
824− var _op = {};
825− var pass = function (m) {
826− return function () {
827− switch (m.ctor)
828− {case "Just": return false;
829− case "Nothing": return true;}
830− _E.Case($moduleName,
831− "between lines 33 and 37");
832− }();
833− };
834− var fail = function ($) {
835− return Basics.not(pass($));
836− };
837− var run = function (_v2) {
838− return function () {
839− switch (_v2.ctor)
840− {case "TestCase":
841− return function () {
842− var runAssertion = F2(function (t,
843− m) {
844− return t({ctor: "_Tuple0"}) ? Maybe.Nothing : Maybe.Just(m);
845− });
846− return function () {
847− switch (_v2._1.ctor)
848− {case "AssertEqual":
849− return runAssertion(_v2._1._0)(_L.append("Expected: ",
850− _L.append(_v2._1._1,
851− _L.append("; got: ",
852− _v2._1._2))));
853− case "AssertFalse":
854− return runAssertion(_v2._1._0)("not False");
855− case "AssertNotEqual":
856− return runAssertion(_v2._1._0)(_L.append(_v2._1._1,
857− _L.append(" equals ",
858− _v2._1._2)));
859− case "AssertTrue":
860− return runAssertion(_v2._1._0)("not True");}
861− _E.Case($moduleName,
862− "between lines 25 and 31");
863− }();
864− }();}
865− _E.Case($moduleName,
866− "between lines 22 and 31");
867− }();
868− };
869− var report = function (ts) {
870− return function () {
871− var results = A2(List.map,
872− run,
873− ts);
874− var $ = A2(List.partition,
875− pass,
876− results),
877− passes = $._0,
878− fails = $._1;
879− return {_: {}
880− ,failures: fails
881− ,passes: passes
882− ,results: results};
883− }();
884− };
885− var Report = F3(function (a,
886− b,
887− c) {
888− return {_: {}
889− ,failures: c
890− ,passes: b
891− ,results: a};
892− });
893− _elm.ElmTest.Run.values = {_op: _op
894− ,run: run
895− ,pass: pass
896− ,fail: fail
897− ,report: report
898− ,Report: Report};
899− return _elm.ElmTest.Run.values;
900−};Elm.ElmTest = Elm.ElmTest || {};
901−Elm.ElmTest.Test = Elm.ElmTest.Test || {};
902−Elm.ElmTest.Test.make = function (_elm) {
903− "use strict";
904− _elm.ElmTest = _elm.ElmTest || {};
905− _elm.ElmTest.Test = _elm.ElmTest.Test || {};
906− if (_elm.ElmTest.Test.values)
907− return _elm.ElmTest.Test.values;
908− var _N = Elm.Native,
909− _U = _N.Utils.make(_elm),
910− _L = _N.List.make(_elm),
911− _E = _N.Error.make(_elm),
912− $moduleName = "ElmTest.Test";
913− var Basics = Elm.Basics.make(_elm);
914− var Color = Elm.Color.make(_elm);
915− var ElmTest = ElmTest || {};
916− ElmTest.Assertion = Elm.ElmTest.Assertion.make(_elm);
917− var Graphics = Graphics || {};
918− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
919− var Graphics = Graphics || {};
920− Graphics.Element = Elm.Graphics.Element.make(_elm);
921− var List = Elm.List.make(_elm);
922− var Maybe = Elm.Maybe.make(_elm);
923− var Native = Native || {};
924− Native.Json = Elm.Native.Json.make(_elm);
925− var Native = Native || {};
926− Native.Ports = Elm.Native.Ports.make(_elm);
927− var Signal = Elm.Signal.make(_elm);
928− var String = Elm.String.make(_elm);
929− var Text = Elm.Text.make(_elm);
930− var Time = Elm.Time.make(_elm);
931− var _op = {};
932− var TestCase = F2(function (a,
933− b) {
934− return {ctor: "TestCase"
935− ,_0: a
936− ,_1: b};
937− });
938− var test = F2(function (name,
939− a) {
940− return A2(TestCase,name,a);
941− });
942− var defaultTest = function (a) {
943− return function () {
944− var name = function () {
945− switch (a.ctor)
946− {case "AssertEqual":
947− return _L.append(a._1,
948− _L.append(" == ",a._2));
949− case "AssertNotEqual":
950− return _L.append(a._1,
951− _L.append(" /= ",a._2));
952− case "AssertTrue":
953− return "True";}
954− _E.Case($moduleName,
955− "between lines 25 and 30");
956− }();
957− return A2(test,name,a);
958− }();
959− };
960− var equals = F2(function (a,b) {
961− return defaultTest(A2(ElmTest.Assertion.assertEqual,
962− a,
963− b));
964− });
965− _elm.ElmTest.Test.values = {_op: _op
966− ,equals: equals
967− ,test: test
968− ,defaultTest: defaultTest
969− ,TestCase: TestCase};
970− return _elm.ElmTest.Test.values;
971−};Elm.ElmTest = Elm.ElmTest || {};
972−Elm.ElmTest.Assertion = Elm.ElmTest.Assertion || {};
973−Elm.ElmTest.Assertion.make = function (_elm) {
974− "use strict";
975− _elm.ElmTest = _elm.ElmTest || {};
976− _elm.ElmTest.Assertion = _elm.ElmTest.Assertion || {};
977− if (_elm.ElmTest.Assertion.values)
978− return _elm.ElmTest.Assertion.values;
979− var _N = Elm.Native,
980− _U = _N.Utils.make(_elm),
981− _L = _N.List.make(_elm),
982− _E = _N.Error.make(_elm),
983− $moduleName = "ElmTest.Assertion";
984− var Basics = Elm.Basics.make(_elm);
985− var Color = Elm.Color.make(_elm);
986− var Graphics = Graphics || {};
987− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
988− var Graphics = Graphics || {};
989− Graphics.Element = Elm.Graphics.Element.make(_elm);
990− var List = Elm.List.make(_elm);
991− var Maybe = Elm.Maybe.make(_elm);
992− var Native = Native || {};
993− Native.Json = Elm.Native.Json.make(_elm);
994− var Native = Native || {};
995− Native.Ports = Elm.Native.Ports.make(_elm);
996− var Signal = Elm.Signal.make(_elm);
997− var String = Elm.String.make(_elm);
998− var Text = Elm.Text.make(_elm);
999− var Time = Elm.Time.make(_elm);
1000− var _op = {};
1001− var AssertNotEqual = F3(function (a,
1002− b,
1003− c) {
1004− return {ctor: "AssertNotEqual"
1005− ,_0: a
1006− ,_1: b
1007− ,_2: c};
1008− });
1009− var assertNotEqual = F2(function (a,
1010− b) {
1011− return A3(AssertNotEqual,
1012− function (_v0) {
1013− return function () {
1014− return !_U.eq(a,b);
1015− }();
1016− },
1017− String.show(a),
1018− String.show(b));
1019− });
1020− var AssertEqual = F3(function (a,
1021− b,
1022− c) {
1023− return {ctor: "AssertEqual"
1024− ,_0: a
1025− ,_1: b
1026− ,_2: c};
1027− });
1028− var assertEqual = F2(function (a,
1029− b) {
1030− return A3(AssertEqual,
1031− function (_v2) {
1032− return function () {
1033− return _U.eq(a,b);
1034− }();
1035− },
1036− String.show(a),
1037− String.show(b));
1038− });
1039− var assertionList = F2(function (xs,
1040− ys) {
1041− return A3(List.zipWith,
1042− assertEqual,
1043− xs,
1044− ys);
1045− });
1046− var AssertFalse = function (a) {
1047− return {ctor: "AssertFalse"
1048− ,_0: a};
1049− };
1050− var AssertTrue = function (a) {
1051− return {ctor: "AssertTrue"
1052− ,_0: a};
1053− };
1054− var assertT = AssertTrue;
1055− var assert = function (b) {
1056− return AssertTrue(function (_v4) {
1057− return function () {
1058− return b;
1059− }();
1060− });
1061− };
1062− _elm.ElmTest.Assertion.values = {_op: _op
1063− ,assertT: assertT
1064− ,assert: assert
1065− ,assertEqual: assertEqual
1066− ,assertionList: assertionList
1067− ,assertNotEqual: assertNotEqual
1068− ,AssertTrue: AssertTrue
1069− ,AssertFalse: AssertFalse
1070− ,AssertEqual: AssertEqual
1071− ,AssertNotEqual: AssertNotEqual};
1072− return _elm.ElmTest.Assertion.values;
1073−};Elm.IO = Elm.IO || {};
1074−Elm.IO.IO = Elm.IO.IO || {};
1075−Elm.IO.IO.make = function (_elm) {
1076− "use strict";
1077− _elm.IO = _elm.IO || {};
1078− _elm.IO.IO = _elm.IO.IO || {};
1079− if (_elm.IO.IO.values)
1080− return _elm.IO.IO.values;
1081− var _N = Elm.Native,
1082− _U = _N.Utils.make(_elm),
1083− _L = _N.List.make(_elm),
1084− _E = _N.Error.make(_elm),
1085− $moduleName = "IO.IO";
1086− var Basics = Elm.Basics.make(_elm);
1087− var Color = Elm.Color.make(_elm);
1088− var Graphics = Graphics || {};
1089− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
1090− var Graphics = Graphics || {};
1091− Graphics.Element = Elm.Graphics.Element.make(_elm);
1092− var List = Elm.List.make(_elm);
1093− var Maybe = Elm.Maybe.make(_elm);
1094− var Native = Native || {};
1095− Native.Json = Elm.Native.Json.make(_elm);
1096− var Native = Native || {};
1097− Native.Ports = Elm.Native.Ports.make(_elm);
1098− var Signal = Elm.Signal.make(_elm);
1099− var String = Elm.String.make(_elm);
1100− var Text = Elm.Text.make(_elm);
1101− var Time = Elm.Time.make(_elm);
1102− var _op = {};
1103− var Impure = function (a) {
1104− return {ctor: "Impure"
1105− ,_0: a};
1106− };
1107− var Pure = function (a) {
1108− return {ctor: "Pure",_0: a};
1109− };
1110− var Exit = function (a) {
1111− return {ctor: "Exit",_0: a};
1112− };
1113− var GetC = function (a) {
1114− return {ctor: "GetC",_0: a};
1115− };
1116− var PutC = F2(function (a,b) {
1117− return {ctor: "PutC"
1118− ,_0: a
1119− ,_1: b};
1120− });
1121− var mapF = F2(function (f,iof) {
1122− return function () {
1123− switch (iof.ctor)
1124− {case "Exit":
1125− return Exit(iof._0);
1126− case "GetC":
1127− return GetC(function ($) {
1128− return f(iof._0($));
1129− });
1130− case "PutC": return A2(PutC,
1131− iof._0,
1132− f(iof._1));}
1133− _E.Case($moduleName,
1134− "between lines 77 and 80");
1135− }();
1136− });
1137− var foldIO = F3(function (pur,
1138− impur,
1139− io) {
1140− return function () {
1141− switch (io.ctor)
1142− {case "Impure":
1143− return impur(A2(mapF,
1144− A2(foldIO,pur,impur),
1145− io._0));
1146− case "Pure": return pur(io._0);}
1147− _E.Case($moduleName,
1148− "between lines 84 and 86");
1149− }();
1150− });
1151− var bind = F2(function (io,f) {
1152− return function () {
1153− switch (io.ctor)
1154− {case "Impure":
1155− return Impure(A2(mapF,
1156− A2(Basics.flip,bind,f),
1157− io._0));
1158− case "Pure": return f(io._0);}
1159− _E.Case($moduleName,
1160− "between lines 52 and 54");
1161− }();
1162− });
1163− _op[">>="] = bind;
1164− var seq = F2(function (x,y) {
1165− return A2(_op[">>="],
1166− x,
1167− function (_v11) {
1168− return function () {
1169− return y;
1170− }();
1171− });
1172− });
1173− _op[">>"] = seq;
1174− var forever = function (m) {
1175− return A2(_op[">>="],
1176− m,
1177− function (_v13) {
1178− return function () {
1179− return forever(m);
1180− }();
1181− });
1182− };
1183− var pure = Pure;
1184− var apply = F2(function (iof,
1185− iom) {
1186− return A2(_op[">>="],
1187− iof,
1188− function (f) {
1189− return A2(_op[">>="],
1190− iom,
1191− function (m) {
1192− return pure(f(m));
1193− });
1194− });
1195− });
1196− _op["<*>"] = apply;
1197− var mapIO = F2(function (f,xs) {
1198− return A3(List.foldr,
1199− function ($) {
1200− return F2(function (x,y) {
1201− return A2(_op[">>"],x,y);
1202− })(f($));
1203− },
1204− pure({ctor: "_Tuple0"}),
1205− xs);
1206− });
1207− var map = F2(function (f,io) {
1208− return function () {
1209− switch (io.ctor)
1210− {case "Impure":
1211− return Impure(A2(mapF,
1212− map(f),
1213− io._0));
1214− case "Pure":
1215− return Pure(f(io._0));}
1216− _E.Case($moduleName,
1217− "between lines 33 and 35");
1218− }();
1219− });
1220− var exit = function ($) {
1221− return Impure(Exit($));
1222− };
1223− var getChar = Impure(GetC(Pure));
1224− var readUntil = function (end) {
1225− return function () {
1226− var go = function (s) {
1227− return A2(_op[">>="],
1228− getChar,
1229− function (c) {
1230− return _U.eq(c,
1231− end) ? pure(s) : go(A2(String.append,
1232− s,
1233− A2(String.cons,c,"")));
1234− });
1235− };
1236− return go("");
1237− }();
1238− };
1239− var getLine = readUntil(_U.chr("\n"));
1240− var putChar = function (c) {
1241− return Impure(A2(PutC,
1242− c,
1243− Pure({ctor: "_Tuple0"})));
1244− };
1245− var putStr = function ($) {
1246− return mapIO(putChar)(String.toList($));
1247− };
1248− var putStrLn = function (s) {
1249− return A2(_op[">>"],
1250− putStr(s),
1251− putChar(_U.chr("\n")));
1252− };
1253− _elm.IO.IO.values = {_op: _op
1254− ,putChar: putChar
1255− ,getChar: getChar
1256− ,exit: exit
1257− ,putStr: putStr
1258− ,putStrLn: putStrLn
1259− ,readUntil: readUntil
1260− ,getLine: getLine
1261− ,map: map
1262− ,mapIO: mapIO
1263− ,pure: pure
1264− ,apply: apply
1265− ,bind: bind
1266− ,seq: seq
1267− ,forever: forever
1268− ,mapF: mapF
1269− ,foldIO: foldIO
1270− ,PutC: PutC
1271− ,GetC: GetC
1272− ,Exit: Exit
1273− ,Pure: Pure
1274− ,Impure: Impure};
1275− return _elm.IO.IO.values;
1276−};
tests/elm/exe.jsdeleted−10164
@@ -1,10164 +0,0 @@
1−var jsdom = require("jsdom");
2−var callback = function(errors, window) {
3− var document = window.document;
4−// Elm goes here:
5−'use strict';
6−var Elm = {}; Elm.Native = {}; Elm.Native.Graphics = {};
7−var ElmRuntime = {}; ElmRuntime.Render = {};
8−Elm.Native.JavaScript = {};
9−Elm.Native.JavaScript.make = function(elm) {
10− elm.Native = elm.Native || {};
11− elm.Native.JavaScript = elm.Native.JavaScript || {};
12− if (elm.Native.JavaScript.values) return elm.Native.JavaScript.values;
13−
14− var List = Elm.Native.List.make(elm);
15− var Render = ElmRuntime.use(ElmRuntime.Render.Element);
16−
17− function fromJS(v) {
18− var type = typeof v;
19− if (type === 'number' ) return v;
20− if (type === 'boolean') return v;
21− if (type === 'string' ) return v;
22− if (v instanceof Array) {
23− var arr = [];
24− var len = v.length;
25− for (var i = 0; i < len; ++i) {
26− var x = fromJS(v[i]);
27− if (x !== null) arr.push(x);
28− }
29− return List.fromArray(arr);
30− }
31− if (type === 'object') {
32− var rec = { _:{} };
33− for (var f in v) {
34− var x = fromJS(v[f]);
35− if (x !== null) rec[f] = x;
36− }
37− return rec;
38− }
39− return null;
40− }
41−
42− function toJS(v) {
43− var type = typeof v;
44− if (type === 'number' || type === 'boolean' || type === 'string') return v;
45− if (type === 'object' && '_' in v) {
46− var obj = {};
47− for (var k in v) {
48− var x = toJS(v[k]);
49− if (x !== null) obj[k] = x;
50− }
51− return obj;
52− }
53− if (type === 'object' && (v.ctor === '::' || v.ctor === '[]')) {
54− var array = List.toArray(v);
55− for (var i = array.length; i--; ) {
56− array[i] = toJS(array[i]);
57− }
58− return array;
59− }
60− return null;
61− }
62−
63− function fromRecord(r) {
64− if (typeof r === 'object' && '_' in r) {
65− return toJS(r);
66− }
67− throw new Error("'fromRecord' must be called on a record.");
68− }
69−
70− return elm.Native.JavaScript.values = {
71− toRecord : fromJS,
72− fromRecord : fromRecord
73− };
74−
75−};
76−Elm.Native.Regex = {};
77−Elm.Native.Regex.make = function(elm) {
78− elm.Native = elm.Native || {};
79− elm.Native.Regex = elm.Native.Regex || {};
80− if (elm.Native.Regex.values) return elm.Native.Regex.values;
81− if ('values' in Elm.Native.Regex)
82− return elm.Native.Regex.values = Elm.Native.Regex.values;
83−
84− var List = Elm.Native.List.make(elm);
85− var Maybe = Elm.Maybe.make(elm);
86−
87− function escape(str) {
88− return str.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
89− }
90− function caseInsensitive(re) {
91− return new RegExp(re.source, 'gi');
92− }
93− function regex(raw) {
94− return new RegExp(raw, 'g');
95− }
96−
97− function contains(re, string) {
98− return string.match(re) !== null;
99− }
100−
101− function find(n, re, str) {
102− n = n.ctor === "All" ? Infinity : n._0;
103− var out = [];
104− var number = 0;
105− var string = str;
106− var result;
107− while (number++ < n && (result = re.exec(string))) {
108− var i = result.length - 1;
109− var subs = new Array(i);
110− while (i > 0) {
111− var submatch = result[i];
112− subs[--i] = submatch === undefined
113− ? Maybe.Nothing
114− : Maybe.Just(submatch);
115− }
116− out.push({
117− _:{},
118− match: result[0],
119− submatches: List.fromArray(subs),
120− index: result.index,
121− number: number,
122− });
123− }
124− return List.fromArray(out);
125− }
126−
127− function replace(n, re, replacer, string) {
128− n = n.ctor === "All" ? Infinity : n._0;
129− var count = 0;
130− function jsReplacer(match) {
131− if (count++ > n) return match;
132− var i = arguments.length-3;
133− var submatches = new Array(i);
134− while (i > 0) {
135− var submatch = arguments[i];
136− submatches[--i] = submatch === undefined
137− ? Maybe.Nothing
138− : Maybe.Just(submatch);
139− }
140− return replacer({
141− _:{},
142− match:match,
143− submatches:List.fromArray(submatches),
144− index:arguments[i-1],
145− number:count
146− });
147− }
148− return string.replace(re, jsReplacer);
149− }
150−
151− function split(n, re, str) {
152− if (n === Infinity) {
153− return List.fromArray(string.split(re));
154− }
155− var string = str;
156− var result;
157− var out = [];
158− var start = re.lastIndex;
159− while (n--) {
160− if (!(result = re.exec(string))) break;
161− out.push(string.slice(start, result.index));
162− start = re.lastIndex;
163− }
164− out.push(string.slice(start));
165− return List.fromArray(out);
166− }
167−
168− return Elm.Native.Regex.values = {
169− regex: regex,
170− caseInsensitive: caseInsensitive,
171− escape: escape,
172−
173− contains: F2(contains),
174− find: F3(find),
175− replace: F4(replace),
176− split: F3(split),
177− };
178−};
179−Elm.Native.Array = {};
180−Elm.Native.Array.make = function(elm) {
181− elm.Native = elm.Native || {};
182− elm.Native.Array = elm.Native.Array || {};
183− if (elm.Native.Array.values) return elm.Native.Array.values;
184− if ('values' in Elm.Native.Array)
185− return elm.Native.Array.values = Elm.Native.Array.values;
186−
187− var List = Elm.Native.List.make(elm);
188−
189− // A RRB-Tree has two distinct data types.
190− // Leaf -> "height" is always 0
191− // "table" is an array of elements
192− // Node -> "height" is always greater than 0
193− // "table" is an array of child nodes
194− // "lengths" is an array of accumulated lengths of the child nodes
195−
196− // M is the maximal table size. 32 seems fast. E is the allowed increase
197− // of search steps when concatting to find an index. Lower values will
198− // decrease balancing, but will increase search steps.
199− var M = 32;
200− var E = 2;
201−
202− // An empty array.
203− var empty = { ctor:"_Array", height:0, table:new Array() };
204−
205− // Gets the value at index i recursively.
206− function get(i, a) {
207− if (a.height == 0) {
208− if (i < a.table.length) {
209− return a.table[i];
210− } else {
211− throw new Error("Index "+ i +" is out of range. Check the length of your array first or use getSafe or getMaybe.");
212− }
213− }
214−
215− var slot = getSlot(i, a);
216− var sub = slot > 0 ? a.lengths[slot-1] : 0;
217− return get(i - sub, a.table[slot]);
218− }
219−
220− // Sets the value at the index i. Only the nodes leading to i will get
221− // copied and updated.
222− function set(i, item, a) {
223− if (length(a) <= i) {
224− return a;
225− }
226− var newA = nodeCopy(a);
227− newA.table = a.table.slice();
228−
229− if (a.height == 0) {
230− newA.table[i] = item;
231− } else {
232− var slot = getSlot(i, a);
233− var sub = slot > 0 ? a.lengths[slot-1] : 0;
234− newA.table[slot] = set(i - sub, item, a.table[slot]);
235− }
236− return newA;
237− }
238−
239− // Pushes an item via push_ to the bottom right of a tree.
240− function push(item, a) {
241− var pushed = push_(item, a);
242− if (pushed !== null) {
243− return pushed;
244− }
245−
246− newTree = create(item, a.height);
247− return siblise(a, newTree);
248− }
249−
250− // Recursively tries to push an item to the bottom-right most
251− // tree possible. If there is no space left for the item,
252− // null will be returned.
253− function push_(item, a) {
254− // Handle resursion stop at leaf level.
255− if (a.height == 0) {
256− if (a.table.length < M) {
257− var newA = { ctor:"_Array", height:0, table:a.table.slice() };
258− newA.table.push(item);
259− return newA;
260− } else {
261− return null;
262− }
263− }
264−
265− // Recursively push
266− var pushed = push_(item, botRight(a));
267−
268− // There was space in the bottom right tree, so the slot will
269− // be updated.
270− if (pushed != null) {
271− var newA = nodeCopy(a);
272− newA.table[newA.table.length - 1] = pushed;
273− newA.lengths[newA.lengths.length - 1]++;
274− return newA
275− }
276−
277− // When there was no space left, check if there is space left
278− // for a new slot with a tree which contains only the item
279− // at the bottom.
280− if (a.table.length < M) {
281− var newSlot = create(item, a.height - 1);
282− var newA = nodeCopy(a);
283− newA.table.push(newSlot);
284− newA.lengths.push(newA.lengths[newA.lengths.length - 1] + length(newSlot));
285− return newA
286− } else {
287− return null;
288− }
289− }
290−
291− // Converts an array into a list of elements.
292− function toList(a) {
293− return toList_(List.Nil, a);
294− }
295−
296− function toList_(list, a) {
297− for (var i = a.table.length - 1; i >= 0; i--) {
298− list = a.height == 0 ? List.Cons(a.table[i], list) : toList_(list, a.table[i]);
299− }
300− return list;
301− }
302−
303− // Maps a function over the elements of an array.
304− function map(f, a) {
305− var newA = { ctor:"_Array", height:a.height, table:new Array(a.table) };
306− if (a.height > 0) { newA.lengths = a.lengths; }
307− for (var i = 0; i < a.table.length; i++) {
308− newA.table[i] = a.height == 0 ? f(a.table[i]) : map(f, a.table[i]);
309− }
310− return newA;
311− }
312−
313− // Maps a function over the elements with their index as first argument.
314− function indexedMap(f, a) {
315− var newA = { ctor:"_Array", height:a.height, table:new Array(a.table) };
316− if (a.height > 0) { newA.lengths = a.lengths; }
317− for (var i = 0; i < a.table.length; i++) {
318− newA.table[i] = a.height == 0 ? A2(f, i, a.table[i]) : indexedMap(f, a.table[i]);
319− }
320− return newA;
321− }
322−
323− function foldl(f, b, a) {
324− for (var i = a.table.length - 1; i >= 0; i--) {
325− b = A2(f, a.height == 0 ? a.table[i] : foldl(f, b, a.table[i]), b);
326− }
327− return b;
328− }
329−
330− function foldr(f, b, a) {
331− for (var i = 0; i < a.table.length; i++) {
332− b = A2(f, a.height == 0 ? a.table[i] : foldr(f, b, a.table[i]), b);
333− }
334− return b;
335− }
336−
337− // Returns a sliced tree. "to" is inclusive, but this may change,
338− // when I understand, why e.g. JS does not handle it this way. :-)
339− // If "from" or "to" is negative, they will select from the end on.
340− // TODO: currently, it slices the right, then the left. This can be
341− // optimized.
342− function slice(from, to, a) {
343− if (from < 0) { from += length(a); }
344− if (to < 0) { to += length(a); }
345− return sliceLeft(from, sliceRight(to, a));
346− }
347−
348− function sliceRight(to, a) {
349− if (to == length(a)) {
350− return a;
351− }
352−
353− // Handle leaf level.
354− if (a.height == 0) {
355− var newA = { ctor:"_Array", height:0 };
356− newA.table = a.table.slice(0, to + 1);
357− return newA;
358− }
359−
360− // Slice the right recursively.
361− var right = getSlot(to, a);
362− var sliced = sliceRight(to - (right > 0 ? a.lengths[right - 1] : 0), a.table[right]);
363−
364− // Maybe the a node is not even needed, as sliced contains the whole slice.
365− if (right == 0) {
366− return sliced;
367− }
368−
369− // Create new node.
370− var newA = { ctor:"_Array", height:a.height
371− , table:a.table.slice(0, right + 1)
372− , lengths:a.lengths.slice(0, right + 1) };
373− newA.table[right] = sliced;
374− newA.lengths[right] = length(sliced) + (right > 0 ? newA.lengths[right - 1] : 0);
375− return newA;
376− }
377−
378− function sliceLeft(from, a) {
379− if (from == 0) {
380− return a;
381− }
382−
383− // Handle leaf level.
384− if (a.height == 0) {
385− var newA = { ctor:"_Array", height:0 };
386− newA.table = a.table.slice(from, a.table.length + 1);
387− return newA;
388− }
389−
390− // Slice the left recursively.
391− var left = getSlot(from, a);
392− var sliced = sliceLeft(from - (left > 0 ? a.lengths[left - 1] : 0), a.table[left]);
393−
394− // Maybe the a node is not even needed, as sliced contains the whole slice.
395− if (left == a.table.length - 1) {
396− return sliced;
397− }
398−
399− // Create new node.
400− var newA = { ctor:"_Array", height:a.height
401− , table:a.table.slice(left, a.table.length + 1)
402− , lengths:new Array(a.table.length - left) };
403− newA.table[left] = sliced;
404− var len = 0;
405− for (var i = 0; i < newA.table.length; i++) {
406− len += length(newA.table[i]);
407− newA.lengths[i] = len;
408− }
409−
410− return newA;
411− }
412−
413− // Concats two trees.
414− // TODO: Add support for concatting trees of different sizes. Current
415− // behavior will just rise the lower tree and then concat them.
416− function concat(a, b) {
417− if (b.height > a.height) { return concat(parentise(a, b.height), b); }
418− if (a.height > b.height) { return concat(a, parentise(b, a.height)); }
419− if (a.height == 0) { return concat(parentise(a, 1), parentise(b, 1)); }
420−
421− var c = concat_(a, b);
422− if (c[1].table.length > 0) {
423− return siblise(c[0], c[1]);
424− } else {
425− return c[0];
426− }
427− }
428−
429− // Returns an array of two nodes. The second node _may_ be empty. This case
430− // needs to be handled by the function, that called concat_. May be only
431− // called for trees with an minimal height of 1.
432− function concat_(a, b) {
433− if (a.height == 1) {
434− // Check if balancing is needed and return based on that.
435− var toRemove = calcToRemove(a, b);
436− if (toRemove <= E) {
437− return [a,b];
438− }
439−
440− return shuffle(a, b, toRemove);
441− }
442−
443− var concated = concat_(botRight(a), botLeft(b));
444− a = nodeCopy(a), b = nodeCopy(b);
445−
446− // Adjust the bottom right side of the new tree.
447− a.table[a.table.length - 1] = concated[0];
448− a.lengths[a.lengths.length - 1] = length(concated[0])
449− a.lengths[a.lengths.length - 1] += a.lengths.length > 1 ? a.lengths[a.lengths.length - 2] : 0;
450−
451− // Adjust the bottom left side of the new tree.
452− if (concated[1].table.length > 0) {
453− b.table[0] = concated[1];
454− b.lengths[0] = length(concated[1]);
455− for (var i = 1, len = length(b.table[0]); i < b.lengths.length; i++) {
456− len += length(b.table[i]);
457− b.lengths[i] = len;
458− }
459− } else {
460− b.table.shift();
461− for (var i = 1; i < b.lengths.length; i++) {
462− b.lengths[i] = b.lengths[i] - b.lengths[0];
463− }
464− b.lengths.shift();
465− }
466−
467− // Check if balancing is needed and return based on that.
468− var toRemove = calcToRemove(a, b);
469− if (toRemove <= E || b.table.length == 0) {
470− return [a,b];
471− }
472−
473− return shuffle(a, b, toRemove);
474− }
475−
476− // Returns the extra search steps for E. Refer to the paper.
477− function calcToRemove(a, b) {
478− var subLengths = 0;
479− for (var i = 0; i < a.table.length; i++) {
480− subLengths += a.table[i].table.length;
481− }
482− for (var i = 0; i < b.table.length; i++) {
483− subLengths += b.table[i].table.length;
484− }
485−
486− var toRemove = a.table.length + b.table.length
487− return toRemove - (Math.floor((subLengths - 1) / M) + 1);
488− }
489−
490− // get2, set2 and saveSlot are helpers for accessing elements over two arrays.
491− function get2(a, b, index) {
492− return index < a.length ? a[index] : b[index - a.length];
493− }
494−
495− function set2(a, b, index, value) {
496− if (index < a.length) {
497− a[index] = value;
498− } else {
499− b[index - a.length] = value;
500− }
501− }
502−
503− function saveSlot(a, b, index, slot) {
504− set2(a.table, b.table, index, slot);
505−
506− var l = (index == 0 || index == a.lengths.length) ?
507− 0 : get2(a.lengths, a.lengths, index - 1);
508− set2(a.lengths, b.lengths, index, l + length(slot));
509− }
510−
511− // Creates a node or leaf with a given length at their arrays for perfomance.
512− // Is only used by shuffle.
513− function createNode(h, length) {
514− if (length < 0) { length = 0; }
515− var a = { ctor:"_Array", height:h, table:new Array(length) };
516− if (h > 0) {
517− a.lengths = new Array(length);
518− }
519− return a;
520− }
521−
522− // Returns an array of two balanced nodes.
523− function shuffle(a, b, toRemove) {
524− var newA = createNode(a.height, Math.min(M, a.table.length + b.table.length - toRemove));
525− var newB = createNode(a.height, newA.table.length - (a.table.length + b.table.length - toRemove));
526−
527− // Skip the slots with size M. More precise: copy the slot references
528− // to the new node
529− var read = 0;
530− while (get2(a.table, b.table, read).table.length % M == 0) {
531− set2(newA.table, newB.table, read, get2(a.table, b.table, read));
532− set2(newA.lengths, newB.lengths, read, get2(a.lengths, b.lengths, read));
533− read++;
534− }
535−
536− // Pulling items from left to right, caching in a slot before writing
537− // it into the new nodes.
538− var write = read;
539− var slot = new createNode(a.height - 1, 0);
540− var from = 0;
541−
542− // If the current slot is still containing data, then there will be at
543− // least one more write, so we do not break this loop yet.
544− while (read - write - (slot.table.length > 0 ? 1 : 0) < toRemove) {
545− // Find out the max possible items for copying.
546− var source = get2(a.table, b.table, read);
547− var to = Math.min(M - slot.table.length, source.table.length)
548−
549− // Copy and adjust size table.
550− slot.table = slot.table.concat(source.table.slice(from, to));
551− if (slot.height > 0) {
552− var len = slot.lengths.length;
553− for (var i = len; i < len + to - from; i++) {
554− slot.lengths[i] = length(slot.table[i]);
555− slot.lengths[i] += (i > 0 ? slot.lengths[i - 1] : 0);
556− }
557− }
558−
559− from += to;
560−
561− // Only proceed to next slots[i] if the current one was
562− // fully copied.
563− if (source.table.length <= to) {
564− read++; from = 0;
565− }
566−
567− // Only create a new slot if the current one is filled up.
568− if (slot.table.length == M) {
569− saveSlot(newA, newB, write, slot);
570− slot = createNode(a.height - 1,0);
571− write++;
572− }
573− }
574−
575− // Cleanup after the loop. Copy the last slot into the new nodes.
576− if (slot.table.length > 0) {
577− saveSlot(newA, newB, write, slot);
578− write++;
579− }
580−
581− // Shift the untouched slots to the left
582− while (read < a.table.length + b.table.length ) {
583− saveSlot(newA, newB, write, get2(a.table, b.table, read));
584− read++; write++;
585− }
586−
587− return [newA, newB];
588− }
589−
590− // Navigation functions
591− function botRight(a) { return a.table[a.table.length - 1]; }
592− function botLeft(a) { return a.table[0]; }
593−
594− // Copies a node for updating. Note that you should not use this if
595− // only updating only one of "table" or "lengths" for performance reasons.
596− function nodeCopy(a) {
597− var newA = { ctor:"_Array", height:a.height
598− , table:a.table.slice() };
599− if (a.height > 0) { newA.lengths = a.lengths.slice(); }
600− return newA;
601− }
602−
603− // Returns how many items are in the tree.
604− function length(a) {
605− if (a.height == 0) {
606− return a.table.length;
607− } else {
608− return a.lengths[a.lengths.length - 1];
609− }
610− }
611−
612− // Calculates in which slot of "table" the item probably is, then
613− // find the exact slot via forward searching in "lengths". Returns the index.
614− function getSlot(i, a) {
615− var slot = Math.floor(i / (Math.pow(M, a.height)));
616− while (a.lengths[slot] <= i) {
617− slot++
618− }
619− return slot;
620− }
621−
622− // Recursively creates a tree with a given height containing
623− // only the given item.
624− function create(item, h) {
625− if (h == 0) {
626− return { ctor:"_Array", height:0
627− , table:[item] };
628− } else {
629− return { ctor:"_Array", height:h
630− , table:[create(item, h - 1)]
631− , lengths:[1] };
632− }
633− }
634−
635− // Recursively creates a tree that contains the given tree.
636− function parentise(tree, h) {
637− if (h == tree.height) {
638− return tree;
639− } else {
640− return { ctor:"_Array", height:h
641− , table:[parentise(tree, h - 1)]
642− , lengths:[length(tree)] };
643− }
644− }
645−
646− // Emphasizes blood brotherhood beneath two trees.
647− function siblise(a, b) {
648− return { ctor:"_Array", height:a.height + 1
649− , table:[a, b]
650− , lengths:[length(a), length(a) + length(b)] };
651− }
652−
653− Elm.Native.Array.values = {
654− empty:empty,
655− toList:toList,
656− concat:F2(concat),
657− push:F2(push),
658− slice:F3(slice),
659− get:F2(get),
660− set:F3(set),
661− map:F2(map),
662− indexedMap:F2(indexedMap),
663− foldl:F3(foldl),
664− foldr:F3(foldr),
665− length:length
666− };
667−
668− return elm.Native.Array.values = Elm.Native.Array.values;
669−}
670−Elm.Native.Show = {};
671−Elm.Native.Show.make = function(elm) {
672− elm.Native = elm.Native || {};
673− elm.Native.Show = elm.Native.Show || {};
674− if (elm.Native.Show.values) return elm.Native.Show.values;
675−
676− var NList = Elm.Native.List.make(elm);
677− var Array = Elm.Array.make(elm);
678− var List = Elm.List.make(elm);
679− var Dict = Elm.Dict.make(elm);
680− var Tuple2 = Elm.Native.Utils.make(elm).Tuple2;
681−
682− var toString = function(v) {
683− var type = typeof v;
684− if (type === "function") {
685− var name = v.func ? v.func.name : v.name;
686− return '<function' + (name === '' ? '' : ': ') + name + '>';
687− } else if (type === "boolean") {
688− return v ? "True" : "False";
689− } else if (type === "number") {
690− return v+"";
691− } else if ((v instanceof String) && v.isChar) {
692− return "'" + addSlashes(v) + "'";
693− } else if (type === "string") {
694− return '"' + addSlashes(v) + '"';
695− } else if (type === "object" && '_' in v && probablyPublic(v)) {
696− var output = [];
697− for (var k in v._) {
698− for (var i = v._[k].length; i--; ) {
699− output.push(k + " = " + toString(v._[k][i]));
700− }
701− }
702− for (var k in v) {
703− if (k === '_') continue;
704− output.push(k + " = " + toString(v[k]));
705− }
706− if (output.length === 0) return "{}";
707− return "{ " + output.join(", ") + " }";
708− } else if (type === "object" && 'ctor' in v) {
709− if (v.ctor.substring(0,6) === "_Tuple") {
710− var output = [];
711− for (var k in v) {
712− if (k === 'ctor') continue;
713− output.push(toString(v[k]));
714− }
715− return "(" + output.join(",") + ")";
716− } else if (v.ctor === "_Array") {
717− var list = Array.toList(v);
718− return "Array.fromList " + toString(list);
719− } else if (v.ctor === "::") {
720− var output = '[' + toString(v._0);
721− v = v._1;
722− while (v.ctor === "::") {
723− output += "," + toString(v._0);
724− v = v._1;
725− }
726− return output + ']';
727− } else if (v.ctor === "[]") {
728− return "[]";
729− } else if (v.ctor === "RBNode" || v.ctor === "RBEmpty") {
730− var cons = F3(function(k,v,acc){return NList.Cons(Tuple2(k,v),acc)});
731− var list = A3(Dict.foldr, cons, NList.Nil, v);
732− var name = "Dict";
733− if (list.ctor === "::" && list._0._1.ctor === "_Tuple0") {
734− name = "Set";
735− list = A2(List.map, function(x){return x._0}, list);
736− }
737− return name + ".fromList " + toString(list);
738− } else {
739− var output = "";
740− for (var i in v) {
741− if (i === 'ctor') continue;
742− var str = toString(v[i]);
743− var parenless = str[0] === '{' || str[0] === '<' || str.indexOf(' ') < 0;
744− output += ' ' + (parenless ? str : '(' + str + ')');
745− }
746− return v.ctor + output;
747− }
748− }
749− if (type === 'object' && 'recv' in v) return '<signal>';
750− return "<internal structure>";
751− };
752−
753− function addSlashes(str) {
754− return str.replace(/\\/g, '\\\\')
755− .replace(/\n/g, '\\n')
756− .replace(/\t/g, '\\t')
757− .replace(/\r/g, '\\r')
758− .replace(/\v/g, '\\v')
759− .replace(/\0/g, '\\0')
760− .replace(/\'/g, "\\'")
761− .replace(/\"/g, '\\"');
762− }
763−
764− function probablyPublic(v) {
765− var keys = Object.keys(v);
766− var len = keys.length;
767− if (len === 3
768− && 'props' in v
769− && 'element' in v) return false;
770− if (len === 5
771− && 'horizontal' in v
772− && 'vertical' in v
773− && 'x' in v
774− && 'y' in v) return false;
775− if (len === 7
776− && 'theta' in v
777− && 'scale' in v
778− && 'x' in v
779− && 'y' in v
780− && 'alpha' in v
781− && 'form' in v) return false;
782− return true;
783− }
784−
785− return elm.Native.Show.values = { show:toString };
786−};
787−Elm.Native.Debug = {};
788−Elm.Native.Debug.make = function(elm) {
789− elm.Native = elm.Native || {};
790− elm.Native.Debug = elm.Native.Debug || {};
791− if (elm.Native.Debug.values) return elm.Native.Debug.values;
792−
793− var show = Elm.Native.Show.make(elm).show;
794−
795− function log(tag,value) {
796− var msg = tag + ': ' + show(value);
797− var process = process || {};
798− if (process.stdout) {
799− process.stdout.write(msg);
800− } else {
801− console.log(msg);
802− }
803− return value;
804− }
805−
806− return elm.Native.Debug.values = {
807− log: F2(log)
808− };
809−
810−};
811−Elm.Native.Transform2D = {};
812−Elm.Native.Transform2D.make = function(elm) {
813−
814− elm.Native = elm.Native || {};
815− elm.Native.Transform2D = elm.Native.Transform2D || {};
816− if (elm.Native.Transform2D.values) return elm.Native.Transform2D.values;
817−
818− var A;
819− if (typeof Float32Array === 'undefined') {
820− A = function(arr) {
821− this.length = arr.length;
822− this[0] = arr[0];
823− this[1] = arr[1];
824− this[2] = arr[2];
825− this[3] = arr[3];
826− this[4] = arr[4];
827− this[5] = arr[5];
828− };
829− } else {
830− A = Float32Array;
831− }
832−
833− // layout of matrix in an array is
834− //
835− // | m11 m12 dx |
836− // | m21 m22 dy |
837− // | 0 0 1 |
838− //
839− // new A([ m11, m12, dx, m21, m22, dy ])
840−
841− var identity = new A([1,0,0,0,1,0]);
842− function matrix(m11, m12, m21, m22, dx, dy) {
843− return new A([m11, m12, dx, m21, m22, dy]);
844− }
845− function rotation(t) {
846− var c = Math.cos(t);
847− var s = Math.sin(t);
848− return new A([c, -s, 0, s, c, 0]);
849− }
850− function rotate(t,m) {
851− var c = Math.cos(t);
852− var s = Math.sin(t);
853− var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];
854− return new A([m11*c + m12*s, -m11*s + m12*c, m[2],
855− m21*c + m22*s, -m21*s + m22*c, m[5]]);
856− }
857− /*
858− function move(xy,m) {
859− var x = xy._0;
860− var y = xy._1;
861− var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];
862− return new A([m11, m12, m11*x + m12*y + m[2],
863− m21, m22, m21*x + m22*y + m[5]]);
864− }
865− function scale(s,m) { return new A([m[0]*s, m[1]*s, m[2], m[3]*s, m[4]*s, m[5]]); }
866− function scaleX(x,m) { return new A([m[0]*x, m[1], m[2], m[3]*x, m[4], m[5]]); }
867− function scaleY(y,m) { return new A([m[0], m[1]*y, m[2], m[3], m[4]*y, m[5]]); }
868− function reflectX(m) { return new A([-m[0], m[1], m[2], -m[3], m[4], m[5]]); }
869− function reflectY(m) { return new A([m[0], -m[1], m[2], m[3], -m[4], m[5]]); }
870−
871− function transform(m11, m21, m12, m22, mdx, mdy, n) {
872− var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5];
873− return new A([m11*n11 + m12*n21,
874− m11*n12 + m12*n22,
875− m11*ndx + m12*ndy + mdx,
876− m21*n11 + m22*n21,
877− m21*n12 + m22*n22,
878− m21*ndx + m22*ndy + mdy]);
879− }
880− */
881− function multiply(m, n) {
882− var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4], mdx = m[2], mdy = m[5];
883− var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5];
884− return new A([m11*n11 + m12*n21,
885− m11*n12 + m12*n22,
886− m11*ndx + m12*ndy + mdx,
887− m21*n11 + m22*n21,
888− m21*n12 + m22*n22,
889− m21*ndx + m22*ndy + mdy]);
890− }
891−
892− return elm.Native.Transform2D.values = {
893− identity:identity,
894− matrix:F6(matrix),
895− rotation:rotation,
896− multiply:F2(multiply)
897− /*
898− transform:F7(transform),
899− rotate:F2(rotate),
900− move:F2(move),
901− scale:F2(scale),
902− scaleX:F2(scaleX),
903− scaleY:F2(scaleY),
904− reflectX:reflectX,
905− reflectY:reflectY
906− */
907− };
908−
909−};
910−
911−Elm.Native.Basics = {};
912−Elm.Native.Basics.make = function(elm) {
913− elm.Native = elm.Native || {};
914− elm.Native.Basics = elm.Native.Basics || {};
915− if (elm.Native.Basics.values) return elm.Native.Basics.values;
916−
917− var JS = Elm.Native.JavaScript.make(elm);
918− var Utils = Elm.Native.Utils.make(elm);
919−
920− function div(a,b) { return (a/b)|0; }
921− function rem(a,b) { return a % b; }
922− var mod = Utils.mod;
923− function abs(x) { return x < 0 ? -x : x; }
924− function logBase(base,n) { return Math.log(n) / Math.log(base); }
925− function min(a,b) { return Utils.cmp(a,b) < 0 ? a : b; }
926− function max(a,b) { return Utils.cmp(a,b) > 0 ? a : b; }
927− function clamp(lo,hi,n) {
928− return Utils.cmp(n,lo) < 0 ? lo : Utils.cmp(n,hi) > 0 ? hi : n; }
929− function xor(a,b) { return a !== b; }
930− function not(b) { return !b; }
931− function isInfinite(n) { return n === Infinity || n === -Infinity }
932−
933− function truncate(n) { return n|0; }
934−
935− var basics = {
936− div:F2(div),
937− rem:F2(rem),
938− mod:mod,
939−
940− pi:Math.PI,
941− e:Math.E,
942− cos:Math.cos,
943− sin:Math.sin,
944− tan:Math.tan,
945− acos:Math.acos,
946− asin:Math.asin,
947− atan:Math.atan,
948− atan2:F2(Math.atan2),
949−
950− sqrt:Math.sqrt,
951− abs:abs,
952− logBase:F2(logBase),
953− min:F2(min),
954− max:F2(max),
955− clamp:F3(clamp),
956− compare:Utils.compare,
957−
958− xor:F2(xor),
959− not:not,
960−
961− truncate:truncate,
962− ceiling:Math.ceil,
963− floor:Math.floor,
964− round:Math.round,
965− toFloat:function(x) { return x; },
966− isNaN:isNaN,
967− isInfinite:isInfinite
968− };
969−
970− return elm.Native.Basics.values = basics;
971−};
972−Elm.Native.Text = {};
973−Elm.Native.Text.make = function(elm) {
974− elm.Native = elm.Native || {};
975− elm.Native.Text = elm.Native.Text || {};
976− if (elm.Native.Text.values) return elm.Native.Text.values;
977−
978− var toCss = Elm.Native.Color.make(elm).toCss;
979− var Element = Elm.Graphics.Element.make(elm);
980− var List = Elm.Native.List.make(elm);
981− var Utils = Elm.Native.Utils.make(elm);
982−
983− function makeSpaces(s) {
984− if (s.length == 0) { return s; }
985− var arr = s.split('');
986− if (arr[0] == ' ') { arr[0] = "&nbsp;" }
987− for (var i = arr.length; --i; ) {
988− if (arr[i][0] == ' ' && arr[i-1] == ' ') {
989− arr[i-1] = arr[i-1] + arr[i];
990− arr[i] = '';
991− }
992− }
993− for (var i = arr.length; i--; ) {
994− if (arr[i].length > 1 && arr[i][0] == ' ') {
995− var spaces = arr[i].split('');
996− for (var j = spaces.length - 2; j >= 0; j -= 2) {
997− spaces[j] = '&nbsp;';
998− }
999− arr[i] = spaces.join('');
1000− }
1001− }
1002− arr = arr.join('');
1003− if (arr[arr.length-1] === " ") {
1004− return arr.slice(0,-1) + '&nbsp;';
1005− }
1006− return arr;
1007− }
1008−
1009− function properEscape(str) {
1010− if (str.length == 0) return str;
1011− str = str //.replace(/&/g, "&#38;")
1012− .replace(/"/g, '&#34;')
1013− .replace(/'/g, "&#39;")
1014− .replace(/</g, "&#60;")
1015− .replace(/>/g, "&#62;")
1016− .replace(/\n/g, "<br/>");
1017− var arr = str.split('<br/>');
1018− for (var i = arr.length; i--; ) {
1019− arr[i] = makeSpaces(arr[i]);
1020− }
1021− return arr.join('<br/>');
1022− }
1023−
1024− function toText(str) { return Utils.txt(properEscape(str)); }
1025−
1026− // conversions from Elm values to CSS
1027− function toTypefaces(list) {
1028− var typefaces = List.toArray(list);
1029− for (var i = typefaces.length; i--; ) {
1030− var typeface = typefaces[i];
1031− if (typeface.indexOf(' ') > -1) {
1032− typefaces[i] = "'" + typeface + "'";
1033− }
1034− }
1035− return typefaces.join(',');
1036− }
1037− function toLine(line) {
1038− var ctor = line.ctor;
1039− return ctor === 'Under' ? 'underline' :
1040− ctor === 'Over' ? 'overline' : 'line-through';
1041− }
1042−
1043− // setting styles of Text
1044− function style(style, text) {
1045− var newText = '<span style="color:' + toCss(style.color) + ';'
1046− if (style.typeface.ctor !== '[]') {
1047− newText += 'font-family:' + toTypefaces(style.typeface) + ';'
1048− }
1049− if (style.height.ctor !== "Nothing") {
1050− newText += 'font-size:' + style.height._0 + 'px;';
1051− }
1052− if (style.bold) {
1053− newText += 'font-weight:bold;';
1054− }
1055− if (style.italic) {
1056− newText += 'font-style:italic;';
1057− }
1058− if (style.line.ctor !== 'Nothing') {
1059− newText += 'text-decoration:' + toLine(style.line._0) + ';';
1060− }
1061− newText += '">' + Utils.makeText(text) + '</span>'
1062− return Utils.txt(newText);
1063− }
1064− function height(px, text) {
1065− return { style: 'font-size:' + px + 'px;', text:text }
1066− }
1067− function typeface(names, text) {
1068− return { style: 'font-family:' + toTypefaces(names) + ';', text:text }
1069− }
1070− function monospace(text) {
1071− return { style: 'font-family:monospace;', text:text }
1072− }
1073− function italic(text) {
1074− return { style: 'font-style:italic;', text:text }
1075− }
1076− function bold(text) {
1077− return { style: 'font-weight:bold;', text:text }
1078− }
1079− function link(href, text) {
1080− return { href: toText(href), text:text };
1081− }
1082− function line(line, text) {
1083− return { style: 'text-decoration:' + toLine(line) + ';', text:text };
1084− }
1085−
1086− function color(color, text) {
1087− return { style: 'color:' + toCss(color) + ';', text:text };
1088− }
1089−
1090− function block(align) {
1091− return function(text) {
1092− var raw = {
1093− ctor :'RawHtml',
1094− html : Utils.makeText(text),
1095− align: align,
1096− guid : null,
1097− args : [],
1098− };
1099− var pos = A2(Utils.htmlHeight, 0, raw);
1100− return A3(Element.newElement, pos._0, pos._1, raw);
1101− }
1102− }
1103−
1104− function markdown(text, guid) {
1105− var raw = {
1106− ctor:'RawHtml',
1107− html: text,
1108− align: null,
1109− guid: guid,
1110− args: [],
1111− };
1112− var pos = A2(Utils.htmlHeight, 0, raw);
1113− return A3(Element.newElement, pos._0, pos._1, raw);
1114− }
1115−
1116− return elm.Native.Text.values = {
1117− toText: toText,
1118−
1119− height : F2(height),
1120− italic : italic,
1121− bold : bold,
1122− line : F2(line),
1123− monospace : monospace,
1124− typeface : F2(typeface),
1125− color : F2(color),
1126− link : F2(link),
1127−
1128− leftAligned : block('left'),
1129− rightAligned : block('right'),
1130− centered : block('center'),
1131− justified : block('justify'),
1132− markdown : markdown,
1133−
1134− toTypefaces:toTypefaces,
1135− toLine:toLine,
1136− };
1137−};
1138−Elm.Native.Trampoline = {};
1139−Elm.Native.Trampoline.make = function(elm) {
1140− elm.Native = elm.Native || {};
1141− elm.Native.Trampoline = elm.Native.Trampoline || {};
1142− if (elm.Native.Trampoline.values) return elm.Native.Trampoline.values;
1143−
1144− // trampoline : Trampoline a -> a
1145− function trampoline(t) {
1146− var tramp = t;
1147− while(true) {
1148− switch(tramp.ctor) {
1149− case "Done":
1150− return tramp._0;
1151− case "Continue":
1152− tramp = tramp._0({ctor: "_Tuple0"});
1153− continue;
1154− }
1155− }
1156− }
1157−
1158− return elm.Native.Trampoline.values = {
1159− trampoline:trampoline
1160− };
1161−};
1162−Elm.Native.Ports = {};
1163−Elm.Native.Ports.make = function(elm) {
1164− elm.Native = elm.Native || {};
1165− elm.Native.Ports = elm.Native.Ports || {};
1166− if (elm.Native.Ports.values) return elm.Native.Ports.values;
1167−
1168− var Signal = Elm.Signal.make(elm);
1169−
1170− function incomingSignal(converter) {
1171− converter.isSignal = true;
1172− return converter;
1173− }
1174−
1175− function outgoingSignal(converter) {
1176− return function(signal) {
1177− var subscribers = []
1178− function subscribe(handler) {
1179− subscribers.push(handler);
1180− }
1181− function unsubscribe(handler) {
1182− subscribers.pop(subscribers.indexOf(handler));
1183− }
1184− A2( Signal.lift, function(value) {
1185− var val = converter(value);
1186− var len = subscribers.length;
1187− for (var i = 0; i < len; ++i) {
1188− subscribers[i](val);
1189− }
1190− }, signal);
1191− return { subscribe:subscribe, unsubscribe:unsubscribe };
1192− }
1193− }
1194−
1195− function portIn(name, converter) {
1196− var jsValue = elm.ports.incoming[name];
1197− if (jsValue === undefined) {
1198− throw new Error("Initialization Error: port '" + name +
1199− "' was not given an input!");
1200− }
1201− elm.ports.uses[name] += 1;
1202− try {
1203− var elmValue = converter(jsValue);
1204− } catch(e) {
1205− throw new Error("Initialization Error on port '" + name + "': \n" + e.message);
1206− }
1207−
1208− // just return a static value if it is not a signal
1209− if (!converter.isSignal) {
1210− return elmValue;
1211− }
1212−
1213− // create a signal if necessary
1214− var signal = Signal.constant(elmValue);
1215− function send(jsValue) {
1216− try {
1217− var elmValue = converter(jsValue);
1218− } catch(e) {
1219− throw new Error("Error sending to port '" + name + "': \n" + e.message);
1220− }
1221− setTimeout(function() {
1222− elm.notify(signal.id, elmValue);
1223− }, 0);
1224− }
1225− elm.ports.outgoing[name] = { send:send };
1226− return signal;
1227− }
1228−
1229− function portOut(name, converter, value) {
1230− try {
1231− elm.ports.outgoing[name] = converter(value);
1232− } catch(e) {
1233− throw new Error("Initialization Error on port '" + name + "': \n" + e.message);
1234− }
1235− return value;
1236− }
1237−
1238− return elm.Native.Ports.values = {
1239− incomingSignal: incomingSignal,
1240− outgoingSignal: outgoingSignal,
1241− portOut: portOut,
1242− portIn: portIn
1243− };
1244−};
1245−Elm.Native.Color = {};
1246−Elm.Native.Color.make = function(elm) {
1247− elm.Native = elm.Native || {};
1248− elm.Native.Color = elm.Native.Color || {};
1249− if (elm.Native.Color.values) return elm.Native.Color.values;
1250−
1251− var Utils = Elm.Native.Utils.make(elm);
1252−
1253− function toCss(c) {
1254− return (c._3 === 1)
1255− ? ('rgb(' + c._0 + ', ' + c._1 + ', ' + c._2 + ')')
1256− : ('rgba(' + c._0 + ', ' + c._1 + ', ' + c._2 + ', ' + c._3 + ')');
1257− }
1258−
1259− function complement(rgb) {
1260− var hsv = toHSV(rgb);
1261− hsv.hue = (hsv.hue + 180) % 360;
1262− return toRGB(hsv);
1263− }
1264−
1265− function hsva(h,s,v,a) {
1266− var degree = A2(Utils.mod, h * 180 / Math.PI, 360);
1267− var clr = toRGB({hue:degree, saturation:s, value:v});
1268− clr._3 = a;
1269− return clr;
1270− }
1271−
1272− function hsv(h,s,v) {
1273− var degree = A2(Utils.mod, h * 180 / Math.PI, 360);
1274− return toRGB({hue:degree, saturation:s, value:v});
1275− }
1276−
1277− function toHSV(rgb) {
1278− var hsv = {};
1279− var r = rgb._0 / 255.0, g = rgb._1 / 255.0, b = rgb._2 / 255.0;
1280− var M = Math.max(r,g,b);
1281− var m = Math.min(r,g,b);
1282− var c = M - m;
1283−
1284− var h = 0;
1285− if (c === 0) { h = 0; }
1286− else if (M === r) { h = ((g - b) / c) % 6; }
1287− else if (M === g) { h = ((b - r) / c) + 2; }
1288− else if (M === b) { h = ((r - g) / c) + 4; }
1289− h *= 60;
1290−
1291− return { value : M, hue : h, saturation : (M === 0 ? 0 : c / M) };
1292− }
1293−
1294− function between(lo,hi,x) { return lo <= x && x < hi; }
1295− function norm(n) { return Math.round(n*255); }
1296−
1297− function toRGB(hsv) {
1298− var c = hsv.value * hsv.saturation;
1299− var hue = hsv.hue / 60;
1300− var x = c * (1 - Math.abs((hue % 2) - 1));
1301− var r = 0, g = 0, b = 0;
1302− if (between(0,1,hue)) { r = c; g = x; b = 0; }
1303− else if (between(1,2,hue)) { r = x; g = c; b = 0; }
1304− else if (between(2,3,hue)) { r = 0; g = c; b = x; }
1305− else if (between(3,4,hue)) { r = 0; g = x; b = c; }
1306− else if (between(4,5,hue)) { r = x; g = 0; b = c; }
1307− else if (between(5,6,hue)) { r = c; g = 0; b = x; }
1308−
1309− var m = hsv.value - c;
1310− return { ctor:"Color", _0:norm(r+m), _1:norm(g+m), _2:norm(b+m), _3:1 };
1311− }
1312−
1313− return elm.Native.Color.values = {
1314− hsva:F4(hsva),
1315− hsv:F3(hsv),
1316− complement:complement,
1317− toCss:toCss
1318− };
1319−
1320−};
1321−Elm.Native.Date = {};
1322−Elm.Native.Date.make = function(elm) {
1323− elm.Native = elm.Native || {};
1324− elm.Native.Date = elm.Native.Date || {};
1325− if (elm.Native.Date.values) return elm.Native.Date.values;
1326−
1327− var Maybe = Elm.Maybe.make(elm);
1328−
1329− function dateNow() { return new window.Date; }
1330− function readDate(str) {
1331− var d = new window.Date(str);
1332− if (isNaN(d.getTime())) return Maybe.Nothing;
1333− return Maybe.Just(d);
1334− }
1335−
1336− var dayTable = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
1337− var monthTable = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
1338− "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
1339−
1340− return elm.Native.Date.values = {
1341− read : readDate,
1342− year : function(d) { return d.getFullYear(); },
1343− month : function(d) { return { ctor:monthTable[d.getMonth()] }; },
1344− day : function(d) { return d.getDate(); },
1345− hour : function(d) { return d.getHours(); },
1346− minute : function(d) { return d.getMinutes(); },
1347− second : function(d) { return d.getSeconds(); },
1348− toTime : function(d) { return d.getTime(); },
1349− fromTime: function(t) { return new window.Date(t); },
1350− dayOfWeek : function(d) { return { ctor:dayTable[d.getDay()] }; }
1351− };
1352−
1353−};
1354−Elm.Native.Error = {};
1355−Elm.Native.Error.make = function(elm) {
1356− elm.Native = elm.Native || {};
1357− elm.Native.Error = elm.Native.Error || {};
1358− if (elm.Native.Error.values) return elm.Native.Error.values;
1359−
1360− var fromString = Elm.Native.JavaScript.make(elm).fromString;
1361−
1362− function indent(lines) {
1363− var msg = '';
1364− for (var i = 0; i < lines.length; ++i) {
1365− msg += '<br/>&nbsp; &nbsp; ' + lines[i];
1366− }
1367− return msg;
1368− }
1369−
1370− function Case(moduleName, span) {
1371− var msg = indent(['Non-exhaustive pattern match in case-expression.',
1372− 'Make sure your patterns cover every case!']);
1373− throw new Error('Runtime error in module ' + moduleName + ' (' + span + '):' + msg);
1374− }
1375−
1376− function If(moduleName, span) {
1377− var msg = indent(['Non-exhaustive pattern match in multi-way-if expression.',
1378− 'It is best to use \'otherwise\' as the last branch of multi-way-if.']);
1379− throw new Error('Runtime error in module ' + moduleName + ' (' + span + '):' + msg);
1380− }
1381−
1382− function raise(str) { throw new Error(fromString(str)); }
1383−
1384− return elm.Native.Error.values = { Case: Case, If: If, raise: raise };
1385−};Elm.Native.List = {};
1386−Elm.Native.List.make = function(elm) {
1387− elm.Native = elm.Native || {};
1388− elm.Native.List = elm.Native.List || {};
1389− if (elm.Native.List.values) return elm.Native.List.values;
1390− if ('values' in Elm.Native.List)
1391− return elm.Native.List.values = Elm.Native.List.values;
1392−
1393− var Utils = Elm.Native.Utils.make(elm);
1394−
1395− // TODO: Improve Nil handling
1396− // We can change places like: if (xs.ctor === '[]') ... to if (xs === Nil) ...
1397− // but only if we're confident Nil can only be defined once.
1398− // Currently (27Mar2013) each module can have different instantiations, so multiple Nil objects can exist
1399− // (and if they're used interchangeably then direct object comparison fails where ctor doesn't).
1400− // So, this can only be fixed when modules initialisation is also fixed.
1401− // The performance overhead of the .ctor calls is 5-10% according to jsperf (depending on fn + list size)
1402− // (on firefox 19)
1403−
1404− var Nil = { ctor:'[]' };
1405−
1406− // using freeze for every cons would be nice but is a huge (9x on firefox 19)
1407− // performance penalty
1408− function Cons(hd,tl) { return { ctor:"::", _0:hd, _1:tl }; }
1409−
1410− function throwError(f) {
1411− throw new Error("Function '" + f + "' expects a non-empty list!");
1412− }
1413−
1414− function toArray(xs) {
1415− var out = [];
1416− while (xs.ctor !== '[]') {
1417− out.push(xs._0);
1418− xs = xs._1;
1419− }
1420− return out;
1421− }
1422−
1423− function fromArray(arr) {
1424− var out = Nil;
1425− for (var i = arr.length; i--; ) {
1426− out = Cons(arr[i], out);
1427− }
1428− return out;
1429− }
1430−
1431− function range(lo,hi) {
1432− var lst = Nil;
1433− if (lo <= hi) {
1434− do { lst = Cons(hi,lst) } while (hi-->lo);
1435− }
1436− return lst
1437− }
1438−
1439− function append(xs,ys) {
1440− // append Text
1441− if (xs.text || ys.text) {
1442− return Utils.txt(Utils.makeText(xs) + Utils.makeText(ys));
1443− }
1444−
1445− // append Strings
1446− if (typeof xs === "string") return xs + ys;
1447−
1448− // append Lists
1449− if (xs.ctor === '[]') { return ys; }
1450− var root = Cons(xs._0, Nil);
1451− var curr = root;
1452− xs = xs._1;
1453− while (xs.ctor !== '[]') {
1454− curr._1 = Cons(xs._0, Nil);
1455− xs = xs._1;
1456− curr = curr._1;
1457− }
1458− curr._1 = ys;
1459− return root;
1460− }
1461−
1462− function head(v) { return v.ctor === '[]' ? throwError('head') : v._0; }
1463− function tail(v) { return v.ctor === '[]' ? throwError('tail') : v._1; }
1464−
1465− function last(xs) {
1466− if (xs.ctor === '[]') { throwError('last'); }
1467− var out = xs._0;
1468− while (xs.ctor !== '[]') {
1469− out = xs._0;
1470− xs = xs._1;
1471− }
1472− return out;
1473− }
1474−
1475− function map(f, xs) {
1476− var arr = [];
1477− while (xs.ctor !== '[]') {
1478− arr.push(f(xs._0));
1479− xs = xs._1;
1480− }
1481− return fromArray(arr);
1482− }
1483−
1484− // f defined similarly for both foldl and foldr (NB: different from Haskell)
1485− // ie, foldl : (a -> b -> b) -> b -> [a] -> b
1486− function foldl(f, b, xs) {
1487− var acc = b;
1488− while (xs.ctor !== '[]') {
1489− acc = A2(f, xs._0, acc);
1490− xs = xs._1;
1491− }
1492− return acc;
1493− }
1494−
1495− function foldr(f, b, xs) {
1496− var arr = toArray(xs);
1497− var acc = b;
1498− for (var i = arr.length; i--; ) {
1499− acc = A2(f, arr[i], acc);
1500− }
1501− return acc;
1502− }
1503−
1504− function foldl1(f, xs) {
1505− return xs.ctor === '[]' ? throwError('foldl1') : foldl(f, xs._0, xs._1);
1506− }
1507−
1508− function foldr1(f, xs) {
1509− if (xs.ctor === '[]') { throwError('foldr1'); }
1510− var arr = toArray(xs);
1511− var acc = arr.pop();
1512− for (var i = arr.length; i--; ) {
1513− acc = A2(f, arr[i], acc);
1514− }
1515− return acc;
1516− }
1517−
1518− function scanl(f, b, xs) {
1519− var arr = toArray(xs);
1520− arr.unshift(b);
1521− var len = arr.length;
1522− for (var i = 1; i < len; ++i) {
1523− arr[i] = A2(f, arr[i], arr[i-1]);
1524− }
1525− return fromArray(arr);
1526− }
1527−
1528− function scanl1(f, xs) {
1529− return xs.ctor === '[]' ? throwError('scanl1') : scanl(f, xs._0, xs._1);
1530− }
1531−
1532− function filter(pred, xs) {
1533− var arr = [];
1534− while (xs.ctor !== '[]') {
1535− if (pred(xs._0)) { arr.push(xs._0); }
1536− xs = xs._1;
1537− }
1538− return fromArray(arr);
1539− }
1540−
1541− function length(xs) {
1542− var out = 0;
1543− while (xs.ctor !== '[]') {
1544− out += 1;
1545− xs = xs._1;
1546− }
1547− return out;
1548− }
1549−
1550− function member(x, xs) {
1551− while (xs.ctor !== '[]') {
1552− if (Utils.eq(x,xs._0)) return true;
1553− xs = xs._1;
1554− }
1555− return false;
1556− }
1557−
1558− function reverse(xs) { return fromArray(toArray(xs).reverse()); }
1559−
1560− function concat(xss) {
1561− if (xss.ctor === '[]') return xss;
1562− var arr = toArray(xss);
1563− var xs = arr[arr.length-1];
1564− for (var i = arr.length-1; i--; ) {
1565− xs = append(arr[i], xs);
1566− }
1567− return xs;
1568− }
1569−
1570− function all(pred, xs) {
1571− while (xs.ctor !== '[]') {
1572− if (!pred(xs._0)) return false;
1573− xs = xs._1;
1574− }
1575− return true;
1576− }
1577−
1578− function any(pred, xs) {
1579− while (xs.ctor !== '[]') {
1580− if (pred(xs._0)) return true;
1581− xs = xs._1;
1582− }
1583− return false;
1584− }
1585−
1586− function zipWith(f, xs, ys) {
1587− var arr = [];
1588− while (xs.ctor !== '[]' && ys.ctor !== '[]') {
1589− arr.push(A2(f, xs._0, ys._0));
1590− xs = xs._1;
1591− ys = ys._1;
1592− }
1593− return fromArray(arr);
1594− }
1595−
1596− function zip(xs, ys) {
1597− var arr = [];
1598− while (xs.ctor !== '[]' && ys.ctor !== '[]') {
1599− arr.push(Utils.Tuple2(xs._0, ys._0));
1600− xs = xs._1;
1601− ys = ys._1;
1602− }
1603− return fromArray(arr);
1604− }
1605−
1606− function sort(xs) {
1607− return fromArray(toArray(xs).sort(Utils.cmp));
1608− }
1609−
1610− function sortBy(f, xs) {
1611− return fromArray(toArray(xs).sort(function(a,b){
1612− return Utils.cmp(f(a), f(b));
1613− }));
1614− }
1615−
1616− function sortWith(f, xs) {
1617− return fromArray(toArray(xs).sort(function(a,b){
1618− var ord = f(a)(b).ctor;
1619− return ord === 'EQ' ? 0 : ord === 'LT' ? -1 : 1;
1620− }));
1621− }
1622−
1623− function nth(xs, n) {
1624− return toArray(xs)[n];
1625− }
1626−
1627− function take(n, xs) {
1628− var arr = [];
1629− while (xs.ctor !== '[]' && n > 0) {
1630− arr.push(xs._0);
1631− xs = xs._1;
1632− --n;
1633− }
1634− return fromArray(arr);
1635− }
1636−
1637− function drop(n, xs) {
1638− while (xs.ctor !== '[]' && n > 0) {
1639− xs = xs._1;
1640− --n;
1641− }
1642− return xs;
1643− }
1644−
1645− function repeat(n, x) {
1646− var arr = [];
1647− var pattern = [x];
1648− while (n > 0) {
1649− if (n & 1) arr = arr.concat(pattern);
1650− n >>= 1, pattern = pattern.concat(pattern);
1651− }
1652− return fromArray(arr);
1653− }
1654−
1655− function join(sep, xss) {
1656− if (sep.text) {
1657− sep = Utils.makeText(sep);
1658− xss = toArray(xss);
1659− for (var i = xss.length; i--; ) {
1660− xss[i] = Utils.makeText(xss[i]);
1661− }
1662− return Utils.txt(xss.join(sep));
1663− }
1664− if (typeof sep === 'string') return toArray(xss).join(sep);
1665− if (xss.ctor === '[]') return Nil;
1666− var s = toArray(sep);
1667− var out = toArray(xss._0);
1668− xss = xss._1;
1669− while (xss.ctor !== '[]') {
1670− out = out.concat(s, toArray(xss._0));
1671− xss = xss._1;
1672− }
1673− return fromArray(out);
1674− }
1675−
1676− Elm.Native.List.values = {
1677− Nil:Nil,
1678− Cons:Cons,
1679− cons:F2(Cons),
1680− toArray:toArray,
1681− fromArray:fromArray,
1682− range:range,
1683− append:append,
1684−
1685− head:head,
1686− tail:tail,
1687− last:last,
1688−
1689− map:F2(map),
1690− foldl:F3(foldl),
1691− foldr:F3(foldr),
1692−
1693− foldl1:F2(foldl1),
1694− foldr1:F2(foldr1),
1695− scanl:F3(scanl),
1696− scanl1:F2(scanl1),
1697− filter:F2(filter),
1698− length:length,
1699− member:F2(member),
1700− reverse:reverse,
1701− concat:concat,
1702−
1703− all:F2(all),
1704− any:F2(any),
1705− zipWith:F3(zipWith),
1706− zip:F2(zip),
1707− sort:sort,
1708− sortBy:F2(sortBy),
1709− sortWith:F2(sortWith),
1710− nth:F2(nth),
1711− take:F2(take),
1712− drop:F2(drop),
1713− repeat:F2(repeat),
1714−
1715− join:F2(join)
1716− };
1717− return elm.Native.List.values = Elm.Native.List.values;
1718−
1719−};
1720−Elm.Native.Json = {};
1721−Elm.Native.Json.make = function(elm) {
1722−
1723− elm.Native = elm.Native || {};
1724− elm.Native.Json = elm.Native.Json || {};
1725− if (elm.Native.Json.values) return elm.Native.Json.values;
1726−
1727− var Maybe = Elm.Maybe.make(elm);
1728− var Dict = Elm.Dict.make(elm);
1729− var List = Elm.Native.List.make(elm);
1730− var Utils = Elm.Native.Utils.make(elm);
1731−
1732− function toJS(v) {
1733− switch (v.ctor) {
1734− case 'Null' : return null;
1735− case 'String' : return v._0;
1736− case 'Number' : return v._0;
1737− case 'Boolean': return v._0;
1738− case 'Object' :
1739− var obj = {};
1740− var array = List.toArray(Dict.toList(v._0));
1741− for (var i = array.length; i--; ) {
1742− var entry = array[i];
1743− obj[entry._0] = toJS(entry._1);
1744− }
1745− return obj;
1746− case 'Array' :
1747− var array = List.toArray(v._0);
1748− for (var i = array.length; i--; ) {
1749− array[i] = toJS(array[i]);
1750− }
1751− return array;
1752− }
1753− }
1754−
1755− function toString(sep, value) {
1756− return JSON.stringify(toJS(value), null, sep);
1757− }
1758−
1759− function fromJS(v) {
1760− switch (typeof v) {
1761− case 'string' : return { ctor:"String" , _0: v };
1762− case 'number' : return { ctor:"Number" , _0: v };
1763− case 'boolean': return { ctor:"Boolean", _0: v };
1764− case 'object' :
1765− if (v === null) return { ctor:"Null" };
1766− if (v instanceof Array) {
1767− var array = new Array(v.length);
1768− for (var i = v.length; i--; ) {
1769− array[i] = fromJS(v[i]);
1770− }
1771− return {
1772− ctor:"Array",
1773− _0: List.fromArray(array)
1774− };
1775− }
1776− var array = [];
1777− for (var key in v) {
1778− var value = fromJS(v[key]);
1779− array.push(Utils.Tuple2(key, value));
1780− }
1781− var list = List.fromArray(array);
1782− return {
1783− ctor:"Object",
1784− _0: Dict.fromList(list)
1785− };
1786− }
1787− }
1788−
1789− function fromString(str) {
1790− try {
1791− return Maybe.Just(fromJS(JSON.parse(str)));
1792− } catch (e) {
1793− return Maybe.Nothing;
1794− }
1795− }
1796−
1797− return elm.Native.Json.values = {
1798− toString : F2(toString),
1799− fromString : fromString,
1800− fromJS : fromJS,
1801− toJS : toJS,
1802− };
1803−
1804−};
1805−Elm.Native.String = {};
1806−Elm.Native.String.make = function(elm) {
1807− elm.Native = elm.Native || {};
1808− elm.Native.String = elm.Native.String || {};
1809− if (elm.Native.String.values) return elm.Native.String.values;
1810− if ('values' in Elm.Native.String)
1811− return elm.Native.String.values = Elm.Native.String.values;
1812−
1813− var Char = Elm.Char.make(elm);
1814− var Maybe = Elm.Maybe.make(elm);
1815− var List = Elm.Native.List.make(elm);
1816− var Utils = Elm.Native.Utils.make(elm);
1817−
1818− function isEmpty(str) {
1819− return str.length === 0;
1820− }
1821− function cons(chr,str) {
1822− return chr + str;
1823− }
1824− function uncons(str) {
1825− var hd;
1826− return (hd = str[0]) ? Maybe.Just(Utils.Tuple2(Utils.chr(hd), str.slice(1)))
1827− : Maybe.Nothing;
1828− }
1829− function append(a,b) {
1830− return a + b;
1831− }
1832− function concat(strs) {
1833− return List.toArray(strs).join('');
1834− }
1835− function length(str) {
1836− return str.length;
1837− }
1838− function map(f,str) {
1839− var out = str.split('');
1840− for (var i = out.length; i--; ) {
1841− out[i] = f(Utils.chr(out[i]));
1842− }
1843− return out.join('');
1844− }
1845− function filter(pred,str) {
1846− return str.split('').map(Utils.chr).filter(pred).join('');
1847− }
1848− function reverse(str) {
1849− return str.split('').reverse().join('');
1850− }
1851− function foldl(f,b,str) {
1852− var len = str.length;
1853− for (var i = 0; i < len; ++i) {
1854− b = A2(f, Utils.chr(str[i]), b);
1855− }
1856− return b;
1857− }
1858− function foldr(f,b,str) {
1859− for (var i = str.length; i--; ) {
1860− b = A2(f, Utils.chr(str[i]), b);
1861− }
1862− return b;
1863− }
1864−
1865− function split(sep, str) {
1866− return List.fromArray(str.split(sep));
1867− }
1868− function join(sep, strs) {
1869− return List.toArray(strs).join(sep);
1870− }
1871− function repeat(n, str) {
1872− var result = '';
1873− while (n > 0) {
1874− if (n & 1) result += str;
1875− n >>= 1, str += str;
1876− }
1877− return result;
1878− }
1879−
1880− function sub(start, end, str) {
1881− return str.slice(start,end);
1882− }
1883− function left(n, str) {
1884− return n < 1 ? "" : str.slice(0,n);
1885− }
1886− function right(n, str) {
1887− return n < 1 ? "" : str.slice(-n);
1888− }
1889− function dropLeft(n, str) {
1890− return n < 1 ? str : str.slice(n);
1891− }
1892− function dropRight(n, str) {
1893− return n < 1 ? str : str.slice(0,-n);
1894− }
1895−
1896− function pad(n,chr,str) {
1897− var half = (n - str.length) / 2;
1898− return repeat(Math.ceil(half),chr) + str + repeat(half|0,chr);
1899− }
1900− function padRight(n,chr,str) {
1901− return str + repeat(n - str.length, chr);
1902− }
1903− function padLeft(n,chr,str) {
1904− return repeat(n - str.length, chr) + str;
1905− }
1906−
1907− function trim(str) {
1908− return str.trim();
1909− }
1910− function trimLeft(str) {
1911− return str.trimLeft();
1912− }
1913− function trimRight(str) {
1914− return str.trimRight();
1915− }
1916−
1917− function words(str) {
1918− return List.fromArray(str.split(/\s+/g));
1919− }
1920− function lines(str) {
1921− return List.fromArray(str.split(/\r\n|\r|\n/g));
1922− }
1923−
1924− function toUpper(str) {
1925− return str.toUpperCase();
1926− }
1927− function toLower(str) {
1928− return str.toLowerCase();
1929− }
1930−
1931− function any(pred, str) {
1932− for (var i = str.length; i--; ) {
1933− if (pred(Utils.chr(str[i]))) return true;
1934− }
1935− return false;
1936− }
1937− function all(pred, str) {
1938− for (var i = str.length; i--; ) {
1939− if (!pred(Utils.chr(str[i]))) return false;
1940− }
1941− return true;
1942− }
1943−
1944− function contains(sub, str) {
1945− return str.indexOf(sub) > -1;
1946− }
1947− function startsWith(sub, str) {
1948− return str.indexOf(sub) === 0;
1949− }
1950− function endsWith(sub, str) {
1951− return str.length >= sub.length &&
1952− str.lastIndexOf(sub) === str.length - sub.length;
1953− }
1954− function indexes(sub, str) {
1955− var subLen = sub.length;
1956− var i = 0;
1957− var is = [];
1958− while ((i = str.indexOf(sub, i)) > -1) {
1959− is.push(i);
1960− i = i + subLen;
1961− }
1962− return List.fromArray(is);
1963− }
1964−
1965− function toInt(s) {
1966− var len = s.length;
1967− if (len === 0) { return Maybe.Nothing; }
1968− var start = 0;
1969− if (s[0] == '-') {
1970− if (len === 1) { return Maybe.Nothing; }
1971− start = 1;
1972− }
1973− for (var i = start; i < len; ++i) {
1974− if (!Char.isDigit(s[i])) { return Maybe.Nothing; }
1975− }
1976− return Maybe.Just(parseInt(s, 10));
1977− }
1978−
1979− function toFloat(s) {
1980− var len = s.length;
1981− if (len === 0) { return Maybe.Nothing; }
1982− var start = 0;
1983− if (s[0] == '-') {
1984− if (len === 1) { return Maybe.Nothing; }
1985− start = 1;
1986− }
1987− var dotCount = 0;
1988− for (var i = start; i < len; ++i) {
1989− if (Char.isDigit(s[i])) { continue; }
1990− if (s[i] === '.') {
1991− dotCount += 1;
1992− if (dotCount <= 1) { continue; }
1993− }
1994− return Maybe.Nothing;
1995− }
1996− return Maybe.Just(parseFloat(s));
1997− }
1998−
1999− function toList(str) {
2000− return List.fromArray(str.split('').map(Utils.chr));
2001− }
2002− function fromList(chars) {
2003− return List.toArray(chars).join('');
2004− }
2005−
2006− return Elm.Native.String.values = {
2007− isEmpty: isEmpty,
2008− cons: F2(cons),
2009− uncons: uncons,
2010− append: F2(append),
2011− concat: concat,
2012− length: length,
2013− map: F2(map),
2014− filter: F2(filter),
2015− reverse: reverse,
2016− foldl: F3(foldl),
2017− foldr: F3(foldr),
2018−
2019− split: F2(split),
2020− join: F2(join),
2021− repeat: F2(repeat),
2022−
2023− sub: F3(sub),
2024− left: F2(left),
2025− right: F2(right),
2026− dropLeft: F2(dropLeft),
2027− dropRight: F2(dropRight),
2028−
2029− pad: F3(pad),
2030− padLeft: F3(padLeft),
2031− padRight: F3(padRight),
2032−
2033− trim: trim,
2034− trimLeft: trimLeft,
2035− trimRight: trimRight,
2036−
2037− words: words,
2038− lines: lines,
2039−
2040− toUpper: toUpper,
2041− toLower: toLower,
2042−
2043− any: F2(any),
2044− all: F2(all),
2045−
2046− contains: F2(contains),
2047− startsWith: F2(startsWith),
2048− endsWith: F2(endsWith),
2049− indexes: F2(indexes),
2050−
2051− toInt: toInt,
2052− toFloat: toFloat,
2053− toList: toList,
2054− fromList: fromList,
2055− };
2056−};
2057−Elm.Native.Char = {};
2058−Elm.Native.Char.make = function(elm) {
2059− elm.Native = elm.Native || {};
2060− elm.Native.Char = elm.Native.Char || {};
2061− if (elm.Native.Char.values) return elm.Native.Char.values;
2062−
2063− function isBetween(lo,hi) { return function(chr) {
2064− var c = chr.charCodeAt(0);
2065− return lo <= c && c <= hi;
2066− };
2067− }
2068− var isDigit = isBetween('0'.charCodeAt(0),'9'.charCodeAt(0));
2069− var chk1 = isBetween('a'.charCodeAt(0),'f'.charCodeAt(0));
2070− var chk2 = isBetween('A'.charCodeAt(0),'F'.charCodeAt(0));
2071−
2072− return elm.Native.Char.values = {
2073− fromCode : function(c) { return String.fromCharCode(c); },
2074− toCode : function(c) { return c.toUpperCase().charCodeAt(0); },
2075− toUpper : function(c) { return c.toUpperCase(); },
2076− toLower : function(c) { return c.toLowerCase(); },
2077− toLocaleUpper : function(c) { return c.toLocaleUpperCase(); },
2078− toLocaleLower : function(c) { return c.toLocaleLowerCase(); },
2079− isLower : isBetween('a'.charCodeAt(0),'z'.charCodeAt(0)),
2080− isUpper : isBetween('A'.charCodeAt(0),'Z'.charCodeAt(0)),
2081− isDigit : isDigit,
2082− isOctDigit : isBetween('0'.charCodeAt(0),'7'.charCodeAt(0)),
2083− isHexDigit : function(c) { return isDigit(c) || chk1(c) || chk2(c); }
2084− };
2085−};
2086−Elm.Native.Utils = {};
2087−Elm.Native.Utils.make = function(elm) {
2088−
2089− elm.Native = elm.Native || {};
2090− elm.Native.Utils = elm.Native.Utils || {};
2091− if (elm.Native.Utils.values) return elm.Native.Utils.values;
2092−
2093− function eq(x,y) {
2094− if (x === y) return true;
2095− if (typeof x === "object") {
2096− var c = 0;
2097− for (var i in x) {
2098− ++c;
2099− if (!eq(x[i],y[i])) {
2100− return false;
2101− }
2102− }
2103− return c === Object.keys(y).length;
2104− }
2105− if (typeof x === 'function') {
2106− throw new Error('Equality error: general function equality is ' +
2107− 'undecidable, and therefore, unsupported');
2108− }
2109− return x === y;
2110− }
2111−
2112− // code in Generate/JavaScript.hs depends on the particular
2113− // integer values assigned to LT, EQ, and GT
2114− var LT = -1, EQ = 0, GT = 1, ord = ['LT','EQ','GT'];
2115− function compare(x,y) { return { ctor: ord[cmp(x,y)+1] } }
2116− function cmp(x,y) {
2117− var ord;
2118− if (typeof x !== 'object' || x instanceof String){
2119− return x === y ? EQ : x < y ? LT : GT;
2120− }
2121−
2122− if (x.ctor === "::" || x.ctor === "[]") {
2123− while (true) {
2124− if (x.ctor === "[]" && y.ctor === "[]") return EQ;
2125− if (x.ctor !== y.ctor) return x.ctor === '[]' ? LT : GT;
2126− ord = cmp(x._0, y._0);
2127− if (ord !== EQ) return ord;
2128− x = x._1;
2129− y = y._1;
2130− }
2131− }
2132−
2133− if (x.ctor.slice(0,6) === '_Tuple') {
2134− var n = x.ctor.slice(6) - 0;
2135− var err = 'cannot compare tuples with more than 6 elements.';
2136− if (n === 0) return EQ;
2137− if (n >= 1) { ord = cmp(x._0, y._0); if (ord !== EQ) return ord;
2138− if (n >= 2) { ord = cmp(x._1, y._1); if (ord !== EQ) return ord;
2139− if (n >= 3) { ord = cmp(x._2, y._2); if (ord !== EQ) return ord;
2140− if (n >= 4) { ord = cmp(x._3, y._3); if (ord !== EQ) return ord;
2141− if (n >= 5) { ord = cmp(x._4, y._4); if (ord !== EQ) return ord;
2142− if (n >= 6) { ord = cmp(x._5, y._5); if (ord !== EQ) return ord;
2143− if (n >= 7) throw new Error('Comparison error: ' + err); } } } } } }
2144− return EQ;
2145− }
2146− throw new Error('Comparison error: comparison is only defined on ints, ' +
2147− 'floats, times, chars, strings, lists of comparable values, ' +
2148− 'and tuples of comparable values.')
2149− }
2150−
2151−
2152− var Tuple0 = { ctor: "_Tuple0" };
2153− function Tuple2(x,y) { return { ctor:"_Tuple2", _0:x, _1:y } }
2154−
2155− function chr(c) {
2156− var x = new String(c);
2157− x.isChar = true;
2158− return x;
2159− }
2160−
2161− function txt(str) {
2162− var t = new String(str);
2163− t.text = true;
2164− return t;
2165− }
2166−
2167− function makeText(text) {
2168− var style = '';
2169− var href = '';
2170− while (true) {
2171− if (text.style) {
2172− style += text.style;
2173− text = text.text;
2174− continue;
2175− }
2176− if (text.href) {
2177− href = text.href;
2178− text = text.text;
2179− continue;
2180− }
2181− if (href) text = '<a href="' + href + '">' + text + '</a>';
2182− if (style) text = '<span style="' + style + '">' + text + '</span>';
2183− return text;
2184− }
2185− }
2186−
2187− var count = 0;
2188− function guid(_) { return count++ }
2189−
2190− function copy(r) {
2191− var o = {};
2192− for (var i in r) { o[i] = r[i]; }
2193− return o;
2194− }
2195−
2196− function remove(x,r) {
2197− var o = copy(r);
2198− if (x in o._) {
2199− o[x] = o._[x][0];
2200− o._[x] = o._[x].slice(1);
2201− if (o._[x].length === 0) { delete o._[x]; }
2202− } else {
2203− delete o[x];
2204− }
2205− return o;
2206− }
2207−
2208− function replace(kvs,r) {
2209− var o = copy(r);
2210− for (var i = kvs.length; i--; ) {
2211− var kvsi = kvs[i];
2212− o[kvsi[0]] = kvsi[1];
2213− }
2214− return o;
2215− }
2216−
2217− function insert(x,v,r) {
2218− var o = copy(r);
2219− if (x in o) o._[x] = [o[x]].concat(x in o._ ? o._[x].slice(0) : []);
2220− o[x] = v;
2221− return o;
2222− }
2223−
2224− function max(a,b) { return a > b ? a : b }
2225− function min(a,b) { return a < b ? a : b }
2226−
2227− function mod(a,b) {
2228− if (b === 0) {
2229− throw new Error("Cannot perform mod 0. Division by zero error.");
2230− }
2231− var r = a % b;
2232− var m = a === 0 ? 0 : (b > 0 ? (a >= 0 ? r : r+b) : -mod(-a,-b));
2233−
2234− return m === b ? 0 : m;
2235− }
2236−
2237− function htmlHeight(width, rawHtml) {
2238− // create dummy node
2239− var html = rawHtml.html;
2240− var t = document.createElement('div');
2241− t.innerHTML = html;
2242− if (width > 0) { t.style.width = width + "px"; }
2243− t.style.visibility = "hidden";
2244− t.style.styleFloat = "left";
2245− t.style.cssFloat = "left";
2246−
2247− document.body.appendChild(t);
2248−
2249− // insert interpolated values
2250− var args = rawHtml.args;
2251− var guid = rawHtml.guid;
2252− for (var i = args.length; i--; ) {
2253− var arg = args[i];
2254− var span = document.getElementById('md-' + guid + '-' + i);
2255− if (arg.isElement) {
2256− span.style.width = arg.props.width + 'px';
2257− span.style.height = arg.props.height + 'px';
2258− } else {
2259− span.innerHTML = arg;
2260− }
2261− }
2262−
2263− // get dimensions
2264− var style = window.getComputedStyle(t, null);
2265− var w = Math.ceil(style.getPropertyValue("width").slice(0,-2) - 0);
2266− var h = Math.ceil(style.getPropertyValue("height").slice(0,-2) - 0);
2267− document.body.removeChild(t);
2268− return Tuple2(w,h);
2269− }
2270−
2271− function getXY(e) {
2272− var posx = 0;
2273− var posy = 0;
2274− if (e.pageX || e.pageY) {
2275− posx = e.pageX;
2276− posy = e.pageY;
2277− } else if (e.clientX || e.clientY) {
2278− posx = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
2279− posy = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;
2280− }
2281−
2282− if (elm.display === ElmRuntime.Display.COMPONENT) {
2283− var rect = elm.node.getBoundingClientRect();
2284− var relx = rect.left + document.body.scrollLeft + document.documentElement.scrollLeft;
2285− var rely = rect.top + document.body.scrollTop + document.documentElement.scrollTop;
2286− // TODO: figure out if there is a way to avoid rounding here
2287− posx = posx - Math.round(relx) - elm.node.clientLeft;
2288− posy = posy - Math.round(rely) - elm.node.clientTop;
2289− }
2290− return Tuple2(posx, posy);
2291− }
2292−
2293− return elm.Native.Utils.values = {
2294− eq:eq,
2295− cmp:cmp,
2296− compare:F2(compare),
2297− Tuple0:Tuple0,
2298− Tuple2:Tuple2,
2299− chr:chr,
2300− txt:txt,
2301− makeText:makeText,
2302− copy: copy,
2303− remove: remove,
2304− replace: replace,
2305− insert: insert,
2306− guid: guid,
2307− max : F2(max),
2308− min : F2(min),
2309− mod : F2(mod),
2310− htmlHeight: F2(htmlHeight),
2311− getXY: getXY,
2312− toFloat: function(x) { return +x; }
2313− };
2314−};
2315−Elm.Native.Bitwise = {};
2316−Elm.Native.Bitwise.make = function(elm) {
2317− elm.Native = elm.Native || {};
2318− elm.Native.Bitwise = elm.Native.Bitwise || {};
2319− if (elm.Native.Bitwise.values) return elm.Native.Bitwise.values;
2320−
2321− function and(a,b) { return a & b; }
2322− function or (a,b) { return a | b; }
2323− function xor(a,b) { return a ^ b; }
2324− function not(a) { return ~a; }
2325− function sll(a,offset) { return a << offset; }
2326− function sra(a,offset) { return a >> offset; }
2327− function srl(a,offset) { return a >>> offset; }
2328−
2329− return elm.Native.Bitwise.values = {
2330− and: F2(and),
2331− or : F2(or ),
2332− xor: F2(xor),
2333− complement: not,
2334− shiftLeft : F2(sll),
2335− shiftRightArithmatic: F2(sra),
2336− shiftRightLogical : F2(srl),
2337− };
2338−
2339−};
2340−
2341−function F2(fun) {
2342− function wrapper(a) { return function(b) { return fun(a,b) } }
2343− wrapper.arity = 2;
2344− wrapper.func = fun;
2345− return wrapper;
2346−}
2347−
2348−function F3(fun) {
2349− function wrapper(a) {
2350− return function(b) { return function(c) { return fun(a,b,c) }}
2351− }
2352− wrapper.arity = 3;
2353− wrapper.func = fun;
2354− return wrapper;
2355−}
2356−
2357−function F4(fun) {
2358− function wrapper(a) { return function(b) { return function(c) {
2359− return function(d) { return fun(a,b,c,d) }}}
2360− }
2361− wrapper.arity = 4;
2362− wrapper.func = fun;
2363− return wrapper;
2364−}
2365−
2366−function F5(fun) {
2367− function wrapper(a) { return function(b) { return function(c) {
2368− return function(d) { return function(e) { return fun(a,b,c,d,e) }}}}
2369− }
2370− wrapper.arity = 5;
2371− wrapper.func = fun;
2372− return wrapper;
2373−}
2374−
2375−function F6(fun) {
2376− function wrapper(a) { return function(b) { return function(c) {
2377− return function(d) { return function(e) { return function(f) {
2378− return fun(a,b,c,d,e,f) }}}}}
2379− }
2380− wrapper.arity = 6;
2381− wrapper.func = fun;
2382− return wrapper;
2383−}
2384−
2385−function F7(fun) {
2386− function wrapper(a) { return function(b) { return function(c) {
2387− return function(d) { return function(e) { return function(f) {
2388− return function(g) { return fun(a,b,c,d,e,f,g) }}}}}}
2389− }
2390− wrapper.arity = 7;
2391− wrapper.func = fun;
2392− return wrapper;
2393−}
2394−
2395−function F8(fun) {
2396− function wrapper(a) { return function(b) { return function(c) {
2397− return function(d) { return function(e) { return function(f) {
2398− return function(g) { return function(h) {return fun(a,b,c,d,e,f,g,h)}}}}}}}
2399− }
2400− wrapper.arity = 8;
2401− wrapper.func = fun;
2402− return wrapper;
2403−}
2404−
2405−function F9(fun) {
2406− function wrapper(a) { return function(b) { return function(c) {
2407− return function(d) { return function(e) { return function(f) {
2408− return function(g) { return function(h) { return function(i) {
2409− return fun(a,b,c,d,e,f,g,h,i) }}}}}}}}
2410− }
2411− wrapper.arity = 9;
2412− wrapper.func = fun;
2413− return wrapper;
2414−}
2415−
2416−function A2(fun,a,b) {
2417− return fun.arity === 2 ? fun.func(a,b) : fun(a)(b);
2418−}
2419−function A3(fun,a,b,c) {
2420− return fun.arity === 3 ? fun.func(a,b,c) : fun(a)(b)(c);
2421−}
2422−function A4(fun,a,b,c,d) {
2423− return fun.arity === 4 ? fun.func(a,b,c,d) : fun(a)(b)(c)(d);
2424−}
2425−function A5(fun,a,b,c,d,e) {
2426− return fun.arity === 5 ? fun.func(a,b,c,d,e) : fun(a)(b)(c)(d)(e);
2427−}
2428−function A6(fun,a,b,c,d,e,f) {
2429− return fun.arity === 6 ? fun.func(a,b,c,d,e,f) : fun(a)(b)(c)(d)(e)(f);
2430−}
2431−function A7(fun,a,b,c,d,e,f,g) {
2432− return fun.arity === 7 ? fun.func(a,b,c,d,e,f,g) : fun(a)(b)(c)(d)(e)(f)(g);
2433−}
2434−function A8(fun,a,b,c,d,e,f,g,h) {
2435− return fun.arity === 8 ? fun.func(a,b,c,d,e,f,g,h) : fun(a)(b)(c)(d)(e)(f)(g)(h);
2436−}
2437−function A9(fun,a,b,c,d,e,f,g,h,i) {
2438− return fun.arity === 9 ? fun.func(a,b,c,d,e,f,g,h,i)
2439− : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
2440−}
2441−Elm.Native.Graphics.Input = {};
2442−Elm.Native.Graphics.Input.make = function(elm) {
2443− elm.Native = elm.Native || {};
2444− elm.Native.Graphics = elm.Native.Graphics || {};
2445− elm.Native.Graphics.Input = elm.Native.Graphics.Input || {};
2446− if (elm.Native.Graphics.Input.values) return elm.Native.Graphics.Input.values;
2447−
2448− var Render = ElmRuntime.use(ElmRuntime.Render.Element);
2449− var newNode = ElmRuntime.use(ElmRuntime.Render.Utils).newElement;
2450−
2451− var toCss = Elm.Native.Color.make(elm).toCss;
2452− var Text = Elm.Native.Text.make(elm);
2453− var Signal = Elm.Signal.make(elm);
2454− var newElement = Elm.Graphics.Element.make(elm).newElement;
2455− var List = Elm.Native.List.make(elm);
2456− var Utils = Elm.Native.Utils.make(elm);
2457− var Tuple2 = Utils.Tuple2;
2458−
2459− function input(initialValue) {
2460− var signal = Signal.constant(initialValue);
2461− return { _:{}, signal:signal, handle:signal };
2462− }
2463−
2464− function renderDropDown(signal, values) {
2465− return function(_) {
2466− var entries = List.toArray(values);
2467−
2468− var drop = newNode('select');
2469− drop.style.border = '0 solid';
2470− drop.style.pointerEvents = 'auto';
2471− for (var i = 0; i < entries.length; ++i) {
2472− var option = newNode('option');
2473− var name = entries[i]._0;
2474− option.value = name;
2475− option.innerHTML = name;
2476− drop.appendChild(option);
2477− }
2478− drop.addEventListener('change', function() {
2479− elm.notify(signal.id, entries[drop.selectedIndex]._1);
2480− });
2481−
2482− var t = drop.cloneNode(true);
2483− t.style.visibility = "hidden";
2484−
2485− elm.node.appendChild(t);
2486− var style = window.getComputedStyle(t, null);
2487− var w = Math.ceil(style.getPropertyValue("width").slice(0,-2) - 0);
2488− var h = Math.ceil(style.getPropertyValue("height").slice(0,-2) - 0);
2489− elm.node.removeChild(t);
2490− return drop;
2491− };
2492− }
2493−
2494− function updateDropDown(node, oldModel, newModel) {
2495− }
2496−
2497− function dropDown(signal, values) {
2498− return A3(newElement, 100, 24, {
2499− ctor: 'Custom',
2500− type: 'DropDown',
2501− render: renderDropDown(signal,values),
2502− update: updateDropDown,
2503− model: {}
2504− });
2505− }
2506−
2507− function renderButton(model) {
2508− var node = newNode('button');
2509− node.style.display = 'block';
2510− node.style.pointerEvents = 'auto';
2511− node.elm_signal = model.signal;
2512− node.elm_value = model.value;
2513− function click() {
2514− elm.notify(node.elm_signal.id, node.elm_value);
2515− }
2516− node.addEventListener('click', click);
2517− node.innerHTML = model.text;
2518− return node;
2519− }
2520−
2521− function updateButton(node, oldModel, newModel) {
2522− node.elm_signal = newModel.signal;
2523− node.elm_value = newModel.value;
2524− var txt = newModel.text;
2525− if (oldModel.text !== txt) node.innerHTML = txt;
2526− }
2527−
2528− function button(signal, value, text) {
2529− return A3(newElement, 100, 40, {
2530− ctor: 'Custom',
2531− type: 'Button',
2532− render: renderButton,
2533− update: updateButton,
2534− model: { signal:signal, value:value, text:text }
2535− });
2536− }
2537−
2538− function renderCustomButton(model) {
2539− var btn = newNode('div');
2540− btn.style.pointerEvents = 'auto';
2541− btn.elm_signal = model.signal;
2542− btn.elm_value = model.value;
2543−
2544− btn.elm_up = Render.render(model.up);
2545− btn.elm_hover = Render.render(model.hover);
2546− btn.elm_down = Render.render(model.down);
2547−
2548− function replace(node) {
2549− if (node !== btn.firstChild) {
2550− btn.replaceChild(node, btn.firstChild);
2551− }
2552− }
2553− var overCount = 0;
2554− function over(e) {
2555− if (overCount++ > 0) return;
2556− replace(btn.elm_hover);
2557− }
2558− function out(e) {
2559− if (btn.contains(e.toElement || e.relatedTarget)) return;
2560− overCount = 0;
2561− replace(btn.elm_up);
2562− }
2563− function up() {
2564− replace(btn.elm_hover);
2565− elm.notify(btn.elm_signal.id, btn.elm_value);
2566− }
2567− function down() {
2568− replace(btn.elm_down);
2569− }
2570− btn.addEventListener('mouseover', over);
2571− btn.addEventListener('mouseout' , out);
2572− btn.addEventListener('mousedown', down);
2573− btn.addEventListener('mouseup' , up);
2574−
2575− btn.appendChild(btn.elm_up);
2576−
2577− var clicker = newNode('div');
2578− clicker.style.width = btn.elm_up.style.width;
2579− clicker.style.height = btn.elm_up.style.height;
2580− clicker.style.position = 'absolute';
2581− clicker.style.top = 0;
2582− btn.appendChild(clicker);
2583−
2584− return btn;
2585− }
2586−
2587− function updateCustomButton(node, oldModel, newModel) {
2588− var signal = newModel.signal;
2589− node.elm_up.elm_signal = signal;
2590− node.elm_hover.elm_signal = signal;
2591− node.elm_down.elm_signal = signal;
2592−
2593− var value = newModel.value;
2594− node.elm_up.elm_value = value;
2595− node.elm_hover.elm_value = value;
2596− node.elm_down.elm_value = value;
2597−
2598− Render.update(node.elm_up, oldModel.up, newModel.up)
2599− Render.update(node.elm_hover, oldModel.hover, newModel.hover)
2600− Render.update(node.elm_down, oldModel.down, newModel.down)
2601− }
2602−
2603− function max3(a,b,c) {
2604− var ab = a > b ? a : b;
2605− return ab > c ? ab : c;
2606− }
2607−
2608− function customButton(signal, value, up, hover, down) {
2609− return A3(newElement,
2610− max3(up.props.width, hover.props.width, down.props.width),
2611− max3(up.props.height, hover.props.height, down.props.height),
2612− { ctor: 'Custom',
2613− type: 'CustomButton',
2614− render: renderCustomButton,
2615− update: updateCustomButton,
2616− model: { signal:signal, value:value, up:up, hover:hover, down:down }
2617− });
2618− }
2619−
2620− function renderCheckbox(model) {
2621− var node = newNode('input');
2622− node.type = 'checkbox';
2623− node.checked = model.checked;
2624− node.style.display = 'block';
2625− node.style.pointerEvents = 'auto';
2626− node.elm_signal = model.signal;
2627− node.elm_handler = model.handler;
2628− function change() {
2629− elm.notify(node.elm_signal.id, node.elm_handler(node.checked));
2630− }
2631− node.addEventListener('change', change);
2632− return node;
2633− }
2634−
2635− function updateCheckbox(node, oldModel, newModel) {
2636− node.elm_signal = newModel.signal;
2637− node.elm_handler = newModel.handler;
2638− node.checked = newModel.checked;
2639− return true;
2640− }
2641−
2642− function checkbox(signal, handler, checked) {
2643− return A3(newElement, 13, 13, {
2644− ctor: 'Custom',
2645− type: 'CheckBox',
2646− render: renderCheckbox,
2647− update: updateCheckbox,
2648− model: { signal:signal, handler:handler, checked:checked }
2649− });
2650− }
2651−
2652− function setRange(node, start, end, dir) {
2653− if (node.parentNode) {
2654− node.setSelectionRange(start, end, dir);
2655− } else {
2656− setTimeout(function(){node.setSelectionRange(start, end, dir);}, 0);
2657− }
2658− }
2659−
2660− function updateIfNeeded(css, attribute, latestAttribute) {
2661− if (css[attribute] !== latestAttribute) {
2662− css[attribute] = latestAttribute;
2663− }
2664− }
2665− function cssDimensions(dimensions) {
2666− return dimensions.top + 'px ' +
2667− dimensions.right + 'px ' +
2668− dimensions.bottom + 'px ' +
2669− dimensions.left + 'px';
2670− }
2671− function updateFieldStyle(css, style) {
2672− updateIfNeeded(css, 'padding', cssDimensions(style.padding));
2673−
2674− var outline = style.outline;
2675− updateIfNeeded(css, 'border-width', cssDimensions(outline.width));
2676− updateIfNeeded(css, 'border-color', toCss(outline.color));
2677− updateIfNeeded(css, 'border-radius', outline.radius + 'px');
2678−
2679− var highlight = style.highlight;
2680− if (highlight.width === 0) {
2681− css.outline = 'none';
2682− } else {
2683− updateIfNeeded(css, 'outline-width', highlight.width + 'px');
2684− updateIfNeeded(css, 'outline-color', toCss(highlight.color));
2685− }
2686−
2687− var textStyle = style.style;
2688− updateIfNeeded(css, 'color', toCss(textStyle.color));
2689− if (textStyle.typeface.ctor !== '[]') {
2690− updateIfNeeded(css, 'font-family', Text.toTypefaces(textStyle.typeface));
2691− }
2692− if (textStyle.height.ctor !== "Nothing") {
2693− updateIfNeeded(css, 'font-size', textStyle.height._0 + 'px');
2694− }
2695− updateIfNeeded(css, 'font-weight', textStyle.bold ? 'bold' : 'normal');
2696− updateIfNeeded(css, 'font-style', textStyle.italic ? 'italic' : 'normal');
2697− if (textStyle.line.ctor !== 'Nothing') {
2698− updateIfNeeded(css, 'text-decoration', Text.toLine(textStyle.line._0));
2699− }
2700− }
2701−
2702− function renderField(model) {
2703− var field = newNode('input');
2704− updateFieldStyle(field.style, model.style);
2705− field.style.borderStyle = 'solid';
2706− field.style.pointerEvents = 'auto';
2707−
2708− field.type = model.type;
2709− field.placeholder = model.placeHolder;
2710− field.value = model.content.string;
2711−
2712− field.elm_signal = model.signal;
2713− field.elm_handler = model.handler;
2714− field.elm_old_value = field.value;
2715−
2716− function inputUpdate(event) {
2717− var curr = field.elm_old_value;
2718− var next = field.value;
2719− if (curr === next) {
2720− return;
2721− }
2722−
2723− var direction = field.selectionDirection === 'forward' ? 'Forward' : 'Backward';
2724− var start = field.selectionStart;
2725− var end = field.selectionEnd;
2726− field.value = field.elm_old_value;
2727−
2728− elm.notify(field.elm_signal.id, field.elm_handler({
2729− _:{},
2730− string: next,
2731− selection: {
2732− _:{},
2733− start: start,
2734− end: end,
2735− direction: { ctor: direction }
2736− },
2737− }));
2738− }
2739−
2740− function mouseUpdate(event) {
2741− var direction = field.selectionDirection === 'forward' ? 'Forward' : 'Backward';
2742− elm.notify(field.elm_signal.id, field.elm_handler({
2743− _:{},
2744− string: field.value,
2745− selection: {
2746− _:{},
2747− start: field.selectionStart,
2748− end: field.selectionEnd,
2749− direction: { ctor: direction }
2750− },
2751− }));
2752− }
2753− function mousedown(event) {
2754− mouseUpdate(event);
2755− elm.node.addEventListener('mouseup', mouseup);
2756− }
2757− function mouseup(event) {
2758− mouseUpdate(event);
2759− elm.node.removeEventListener('mouseup', mouseup)
2760− }
2761− field.addEventListener('input', inputUpdate);
2762− field.addEventListener('mousedown', mousedown);
2763− field.addEventListener('focus', function() {
2764− field.elm_hasFocus = true;
2765− });
2766− field.addEventListener('blur', function() {
2767− field.elm_hasFocus = false;
2768− });
2769−
2770− return field;
2771− }
2772−
2773− function updateField(field, oldModel, newModel) {
2774− if (oldModel.style !== newModel.style) {
2775− updateFieldStyle(field.style, newModel.style);
2776− }
2777− field.elm_signal = newModel.signal;
2778− field.elm_handler = newModel.handler;
2779−
2780− field.type = newModel.type;
2781− field.placeholder = newModel.placeHolder;
2782− var value = newModel.content.string;
2783− field.value = value;
2784− field.elm_old_value = value;
2785− if (field.elm_hasFocus) {
2786− var selection = newModel.content.selection;
2787− var direction = selection.direction.ctor === 'Forward' ? 'forward' : 'backward';
2788− setRange(field, selection.start, selection.end, direction);
2789− }
2790− }
2791−
2792− function mkField(type) {
2793− function field(style, signal, handler, placeHolder, content) {
2794− var padding = style.padding;
2795− var outline = style.outline.width;
2796− var adjustWidth = padding.left + padding.right + outline.left + outline.right;
2797− var adjustHeight = padding.top + padding.bottom + outline.top + outline.bottom;
2798− return A3(newElement, 200, 30, {
2799− ctor: 'Custom',
2800− type: type + 'Field',
2801− adjustWidth: adjustWidth,
2802− adjustHeight: adjustHeight,
2803− render: renderField,
2804− update: updateField,
2805− model: {
2806− signal:signal,
2807− handler:handler,
2808− placeHolder:placeHolder,
2809− content:content,
2810− style:style,
2811− type:type
2812− }
2813− });
2814− }
2815− return F5(field);
2816− }
2817−
2818− function hoverable(signal, handler, elem) {
2819− function onHover(bool) {
2820− elm.notify(signal.id, handler(bool));
2821− }
2822− var props = Utils.replace([['hover',onHover]], elem.props);
2823− return { props:props, element:elem.element };
2824− }
2825−
2826− function clickable(signal, value, elem) {
2827− function onClick(bool) {
2828− elm.notify(signal.id, value);
2829− }
2830− var props = Utils.replace([['click',onClick]], elem.props);
2831− return { props:props, element:elem.element };
2832− }
2833−
2834− return elm.Native.Graphics.Input.values = {
2835− input:input,
2836− button:F3(button),
2837− customButton:F5(customButton),
2838− checkbox:F3(checkbox),
2839− dropDown:F2(dropDown),
2840− field:mkField('text'),
2841− email:mkField('email'),
2842− password:mkField('password'),
2843− hoverable:F3(hoverable),
2844− clickable:F3(clickable)
2845− };
2846−
2847−};
2848−Elm.Native.Graphics.Collage = {};
2849−Elm.Native.Graphics.Collage.make = function(elm) {
2850−
2851− elm.Native = elm.Native || {};
2852− elm.Native.Graphics = elm.Native.Graphics || {};
2853− elm.Native.Graphics.Collage = elm.Native.Graphics.Collage || {};
2854− if (elm.Native.Graphics.Collage.values) return elm.Native.Graphics.Collage.values;
2855−
2856− var newElement = Elm.Graphics.Element.make(elm).newElement;
2857− var C = ElmRuntime.use(ElmRuntime.Render.Collage);
2858−
2859− function collage(w,h,forms) {
2860− return A3(newElement, w, h, {
2861− ctor: 'Custom',
2862− type: 'Collage',
2863− render: C.render,
2864− update: C.update,
2865− model: {w:w, h:h, forms:forms}
2866− });
2867− }
2868− return elm.Native.Graphics.Collage.values = { collage:F3(collage) };
2869−
2870−};Elm.Native.Mouse = {};
2871−Elm.Native.Mouse.make = function(elm) {
2872−
2873− elm.Native = elm.Native || {};
2874− elm.Native.Mouse = elm.Native.Mouse || {};
2875− if (elm.Native.Mouse.values) return elm.Native.Mouse.values;
2876−
2877− var Signal = Elm.Signal.make(elm);
2878− var Utils = Elm.Native.Utils.make(elm);
2879−
2880− var position = Signal.constant(Utils.Tuple2(0,0));
2881− position.defaultNumberOfKids = 2;
2882−
2883− // do not move x and y into Elm. By setting their default number
2884− // of kids, it is possible to detatch the mouse listeners if
2885− // they are not needed.
2886− var x = A2( Signal.lift, function(p){return p._0}, position);
2887− x.defaultNumberOfKids = 0;
2888− var y = A2( Signal.lift, function(p){return p._1}, position);
2889− y.defaultNumberOfKids = 0;
2890−
2891− var isDown = Signal.constant(false);
2892− var clicks = Signal.constant(Utils.Tuple0);
2893−
2894− var node = elm.display === ElmRuntime.Display.FULLSCREEN ? document : elm.node;
2895−
2896− elm.addListener([clicks.id], node, 'click', function click() {
2897− elm.notify(clicks.id, Utils.Tuple0);
2898− });
2899− elm.addListener([isDown.id], node, 'mousedown', function down() {
2900− elm.notify(isDown.id, true);
2901− });
2902− elm.addListener([isDown.id], node, 'mouseup', function up() {
2903− elm.notify(isDown.id, false);
2904− });
2905− elm.addListener([position.id], node, 'mousemove', function move(e) {
2906− elm.notify(position.id, Utils.getXY(e));
2907− });
2908−
2909− return elm.Native.Mouse.values = {
2910− position: position,
2911− x:x,
2912− y:y,
2913− isDown: isDown,
2914− clicks: clicks
2915− };
2916−};
2917−Elm.Native.Time = {};
2918−Elm.Native.Time.make = function(elm) {
2919−
2920− elm.Native = elm.Native || {};
2921− elm.Native.Time = elm.Native.Time || {};
2922− if (elm.Native.Time.values) return elm.Native.Time.values;
2923−
2924− var Signal = Elm.Signal.make(elm);
2925− var NS = Elm.Native.Signal.make(elm);
2926− var Maybe = Elm.Maybe.make(elm);
2927− var Utils = Elm.Native.Utils.make(elm);
2928−
2929− function fpsWhen(desiredFPS, isOn) {
2930− var msPerFrame = 1000 / desiredFPS;
2931− var prev = Date.now(), curr = prev, diff = 0, wasOn = true;
2932− var ticker = Signal.constant(diff);
2933− function tick(zero) { return function() {
2934− curr = Date.now();
2935− diff = zero ? 0 : curr - prev;
2936− prev = curr;
2937− elm.notify(ticker.id, diff);
2938− };
2939− }
2940− var timeoutID = 0;
2941− function f(isOn, t) {
2942− if (isOn) {
2943− timeoutID = setTimeout(tick(!wasOn && isOn), msPerFrame);
2944− } else if (wasOn) {
2945− clearTimeout(timeoutID);
2946− }
2947− wasOn = isOn;
2948− return t;
2949− }
2950− return A3( Signal.lift2, F2(f), isOn, ticker );
2951− }
2952−
2953− function every(t) {
2954− var clock = Signal.constant(Date.now());
2955− setInterval(function() {
2956− elm.notify(clock.id, Date.now());
2957− }, t);
2958− return clock;
2959− }
2960−
2961− function since(t, s) {
2962− function cmp(a,b) { return !Utils.eq(a,b); }
2963− var dcount = Signal.count(A2(NS.delay, t, s));
2964− return A3( Signal.lift2, F2(cmp), Signal.count(s), dcount );
2965− }
2966− function read(s) {
2967− var t = Date.parse(s);
2968− return isNaN(t) ? Maybe.Nothing : Maybe.Just(t);
2969− }
2970− return elm.Native.Time.values = {
2971− fpsWhen : F2(fpsWhen),
2972− fps : function(t) { return fpsWhen(t, Signal.constant(true)); },
2973− every : every,
2974− delay : NS.delay,
2975− timestamp : NS.timestamp,
2976− since : F2(since),
2977− toDate : function(t) { return new window.Date(t); },
2978− read : read
2979− };
2980−
2981−};
2982−Elm.Native.WebSocket = {};
2983−Elm.Native.WebSocket.make = function(elm) {
2984−
2985− elm.Native = elm.Native || {};
2986− elm.Native.WebSocket = elm.Native.WebSocket || {};
2987− if (elm.Native.WebSocket.values) return elm.Native.WebSocket.values;
2988−
2989− var Signal = Elm.Signal.make(elm);
2990− var List = Elm.Native.List.make(elm);
2991−
2992− function open(url, outgoing) {
2993− var incoming = Signal.constant(List.Nil);
2994− var ws = new WebSocket(url);
2995−
2996− var pending = [];
2997− var ready = false;
2998−
2999− ws.onopen = function(e) {
3000− var len = pending.length;
3001− for (var i = 0; i < len; ++i) { ws.send(pending[i]); }
3002− ready = true;
3003− };
3004− ws.onmessage = function(event) {
3005− elm.notify(incoming.id, event.data);
3006− };
3007−
3008− function send(msg) {
3009− ready ? ws.send(msg) : pending.push(msg);
3010− }
3011−
3012− function take1(x,y) { return x }
3013− return A3(Signal.lift2, F2(take1), incoming, A2(Signal.lift, send, outgoing));
3014− }
3015−
3016− return elm.Native.WebSocket.values = { connect: F2(open) };
3017−};
3018−Elm.Native.Http = {};
3019−Elm.Native.Http.make = function(elm) {
3020−
3021− elm.Native = elm.Native || {};
3022− elm.Native.Http = elm.Native.Http || {};
3023− if (elm.Native.Http.values) return elm.Native.Http.values;
3024−
3025− var List = Elm.List.make(elm);
3026− var Signal = Elm.Signal.make(elm);
3027−
3028− function registerReq(queue,responses) {
3029− return function(req) {
3030− if (req.url.length > 0) {
3031− sendReq(queue,responses,req);
3032− }
3033− };
3034− }
3035−
3036− function updateQueue(queue,responses) {
3037− if (queue.length > 0) {
3038− elm.notify(responses.id, queue[0].value);
3039− if (queue[0].value.ctor !== 'Waiting') {
3040− queue.shift();
3041− setTimeout(function() { updateQueue(queue,responses); }, 0);
3042− }
3043− }
3044− }
3045−
3046− function sendReq(queue,responses,req) {
3047− var response = { value: { ctor:'Waiting' } };
3048− queue.push(response);
3049−
3050− var request = (window.ActiveXObject
3051− ? new ActiveXObject("Microsoft.XMLHTTP")
3052− : new XMLHttpRequest());
3053−
3054− request.onreadystatechange = function(e) {
3055− if (request.readyState === 4) {
3056− response.value = (request.status >= 200 && request.status < 300 ?
3057− { ctor:'Success', _0:request.responseText } :
3058− { ctor:'Failure', _0:request.status, _1:request.statusText });
3059− setTimeout(function() { updateQueue(queue,responses); }, 0);
3060− }
3061− };
3062− request.open(req.verb, req.url, true);
3063− function setHeader(pair) {
3064− request.setRequestHeader( pair._0, pair._1 );
3065− }
3066− A2( List.map, setHeader, req.headers );
3067− request.send(req.body);
3068− }
3069−
3070− function send(requests) {
3071− var responses = Signal.constant(elm.Http.values.Waiting);
3072− var sender = A2( Signal.lift, registerReq([],responses), requests );
3073− function f(x) { return function(y) { return x; } }
3074− return A3( Signal.lift2, f, responses, sender );
3075− }
3076−
3077− return elm.Native.Http.values = {
3078− send:send
3079− };
3080−};
3081−
3082−Elm.Native.Signal = {};
3083−Elm.Native.Signal.make = function(elm) {
3084−
3085− elm.Native = elm.Native || {};
3086− elm.Native.Signal = elm.Native.Signal || {};
3087− if (elm.Native.Signal.values) return elm.Native.Signal.values;
3088−
3089− var Utils = Elm.Native.Utils.make(elm);
3090− var foldr1 = Elm.List.make(elm).foldr1;
3091−
3092− function send(node, timestep, changed) {
3093− var kids = node.kids;
3094− for (var i = kids.length; i--; ) {
3095− kids[i].recv(timestep, changed, node.id);
3096− }
3097− }
3098−
3099− function Input(base) {
3100− this.id = Utils.guid();
3101− this.value = base;
3102− this.kids = [];
3103− this.defaultNumberOfKids = 0;
3104− this.recv = function(timestep, eid, v) {
3105− var changed = eid === this.id;
3106− if (changed) { this.value = v; }
3107− send(this, timestep, changed);
3108− return changed;
3109− };
3110− elm.inputs.push(this);
3111− }
3112−
3113− function LiftN(update, args) {
3114− this.id = Utils.guid();
3115− this.value = update();
3116− this.kids = [];
3117−
3118− var n = args.length;
3119− var count = 0;
3120− var isChanged = false;
3121−
3122− this.recv = function(timestep, changed, parentID) {
3123− ++count;
3124− if (changed) { isChanged = true; }
3125− if (count == n) {
3126− if (isChanged) { this.value = update(); }
3127− send(this, timestep, isChanged);
3128− isChanged = false;
3129− count = 0;
3130− }
3131− };
3132− for (var i = n; i--; ) { args[i].kids.push(this); }
3133− }
3134−
3135− function lift(func, a) {
3136− function update() { return func(a.value); }
3137− return new LiftN(update, [a]);
3138− }
3139− function lift2(func, a, b) {
3140− function update() { return A2( func, a.value, b.value ); }
3141− return new LiftN(update, [a,b]);
3142− }
3143− function lift3(func, a, b, c) {
3144− function update() { return A3( func, a.value, b.value, c.value ); }
3145− return new LiftN(update, [a,b,c]);
3146− }
3147− function lift4(func, a, b, c, d) {
3148− function update() { return A4( func, a.value, b.value, c.value, d.value ); }
3149− return new LiftN(update, [a,b,c,d]);
3150− }
3151− function lift5(func, a, b, c, d, e) {
3152− function update() { return A5( func, a.value, b.value, c.value, d.value, e.value ); }
3153− return new LiftN(update, [a,b,c,d,e]);
3154− }
3155− function lift6(func, a, b, c, d, e, f) {
3156− function update() { return A6( func, a.value, b.value, c.value, d.value, e.value, f.value ); }
3157− return new LiftN(update, [a,b,c,d,e,f]);
3158− }
3159− function lift7(func, a, b, c, d, e, f, g) {
3160− function update() { return A7( func, a.value, b.value, c.value, d.value, e.value, f.value, g.value ); }
3161− return new LiftN(update, [a,b,c,d,e,f,g]);
3162− }
3163− function lift8(func, a, b, c, d, e, f, g, h) {
3164− function update() { return A8( func, a.value, b.value, c.value, d.value, e.value, f.value, g.value, h.value ); }
3165− return new LiftN(update, [a,b,c,d,e,f,g,h]);
3166− }
3167−
3168− function Foldp(step, state, input) {
3169− this.id = Utils.guid();
3170− this.value = state;
3171− this.kids = [];
3172−
3173− this.recv = function(timestep, changed, parentID) {
3174− if (changed) {
3175− this.value = A2( step, input.value, this.value );
3176− }
3177− send(this, timestep, changed);
3178− };
3179− input.kids.push(this);
3180− }
3181−
3182− function foldp(step, state, input) {
3183− return new Foldp(step, state, input);
3184− }
3185−
3186− function DropIf(pred,base,input) {
3187− this.id = Utils.guid();
3188− this.value = pred(input.value) ? base : input.value;
3189− this.kids = [];
3190− this.recv = function(timestep, changed, parentID) {
3191− var chng = changed && !pred(input.value);
3192− if (chng) { this.value = input.value; }
3193− send(this, timestep, chng);
3194− };
3195− input.kids.push(this);
3196− }
3197−
3198− function DropRepeats(input) {
3199− this.id = Utils.guid();
3200− this.value = input.value;
3201− this.kids = [];
3202− this.recv = function(timestep, changed, parentID) {
3203− var chng = changed && !Utils.eq(this.value,input.value);
3204− if (chng) { this.value = input.value; }
3205− send(this, timestep, chng);
3206− };
3207− input.kids.push(this);
3208− }
3209−
3210− function timestamp(a) {
3211− function update() { return Utils.Tuple2(Date.now(), a.value); }
3212− return new LiftN(update, [a]);
3213− }
3214−
3215− function SampleOn(s1,s2) {
3216− this.id = Utils.guid();
3217− this.value = s2.value;
3218− this.kids = [];
3219−
3220− var count = 0;
3221− var isChanged = false;
3222−
3223− this.recv = function(timestep, changed, parentID) {
3224− if (parentID === s1.id) isChanged = changed;
3225− ++count;
3226− if (count == 2) {
3227− if (isChanged) { this.value = s2.value; }
3228− send(this, timestep, isChanged);
3229− count = 0;
3230− isChanged = false;
3231− }
3232− };
3233− s1.kids.push(this);
3234− s2.kids.push(this);
3235− }
3236−
3237− function sampleOn(s1,s2) { return new SampleOn(s1,s2); }
3238−
3239− function delay(t,s) {
3240− var delayed = new Input(s.value);
3241− var firstEvent = true;
3242− function update(v) {
3243− if (firstEvent) { firstEvent = false; return; }
3244− setTimeout(function() { elm.notify(delayed.id, v); }, t);
3245− }
3246− function first(a,b) { return a; }
3247− return new SampleOn(delayed, lift2(F2(first), delayed, lift(update,s)));
3248− }
3249−
3250− function Merge(s1,s2) {
3251− this.id = Utils.guid();
3252− this.value = s1.value;
3253− this.kids = [];
3254−
3255− var next = null;
3256− var count = 0;
3257− var isChanged = false;
3258−
3259− this.recv = function(timestep, changed, parentID) {
3260− ++count;
3261− if (changed) {
3262− isChanged = true;
3263− if (parentID == s2.id && next === null) { next = s2.value; }
3264− if (parentID == s1.id) { next = s1.value; }
3265− }
3266−
3267− if (count == 2) {
3268− if (isChanged) { this.value = next; next = null; }
3269− send(this, timestep, isChanged);
3270− isChanged = false;
3271− count = 0;
3272− }
3273− };
3274− s1.kids.push(this);
3275− s2.kids.push(this);
3276− }
3277−
3278− function merge(s1,s2) { return new Merge(s1,s2); }
3279− function merges(ss) { return A2(foldr1, F2(merge), ss); }
3280−
3281− return elm.Native.Signal.values = {
3282− constant : function(v) { return new Input(v); },
3283− lift : F2(lift ),
3284− lift2 : F3(lift2),
3285− lift3 : F4(lift3),
3286− lift4 : F5(lift4),
3287− lift5 : F6(lift5),
3288− lift6 : F7(lift6),
3289− lift7 : F8(lift7),
3290− lift8 : F9(lift8),
3291− foldp : F3(foldp),
3292− delay : F2(delay),
3293− merge : F2(merge),
3294− merges : merges,
3295− count : function(s) { return foldp(F2(function(_,c) { return c+1; }), 0, s); },
3296− countIf : F2(function(pred,s) {
3297− return foldp(F2(function(x,c){
3298− return pred(x) ? c+1 : c; }), 0, s)}),
3299− keepIf : F3(function(pred,base,sig) {
3300− return new DropIf(function(x) {return !pred(x);},base,sig); }),
3301− dropIf : F3(function(pred,base,sig) { return new DropIf(pred,base,sig); }),
3302− dropRepeats : function(s) { return new DropRepeats(s);},
3303− sampleOn : F2(sampleOn),
3304− timestamp : timestamp
3305− };
3306−};
3307−Elm.Native.Random = {};
3308−Elm.Native.Random.make = function(elm) {
3309−
3310− elm.Native = elm.Native || {};
3311− elm.Native.Random = elm.Native.Random || {};
3312− if (elm.Native.Random.values) return elm.Native.Random.values;
3313−
3314− var Signal = Elm.Signal.make(elm);
3315− var List = Elm.Native.List.make(elm);
3316−
3317− function range(min, max, signal) {
3318− function f(x) { return Math.floor(Math.random() * (max-min+1)) + min; }
3319− return A2( Signal.lift, f, signal );
3320− }
3321−
3322− function float_(signal) {
3323− function f(x) { return Math.random(); }
3324− return A2( Signal.lift, f, signal );
3325− }
3326−
3327− function floatList(signal) {
3328− function f(n) {
3329− if (n < 0) return List.Nil;
3330− var arr = new Array(n);
3331− for (var i = n; i--; ) {
3332− arr[i] = Math.random();
3333− }
3334− return List.fromArray(arr);
3335− }
3336− return A2( Signal.lift, f, signal );
3337− }
3338−
3339− return elm.Native.Random.values = {
3340− range: F3(range),
3341− float_: float_,
3342− floatList: floatList
3343− };
3344−
3345−};
3346−Elm.Native.Window = {};
3347−Elm.Native.Window.make = function(elm) {
3348−
3349− elm.Native = elm.Native || {};
3350− elm.Native.Window = elm.Native.Window || {};
3351− if (elm.Native.Window.values) return elm.Native.Window.values;
3352−
3353− var Signal = Elm.Signal.make(elm);
3354− var Tuple2 = Elm.Native.Utils.make(elm).Tuple2;
3355−
3356− function getWidth() { return elm.node.clientWidth; }
3357− function getHeight() {
3358− if (elm.display === ElmRuntime.Display.FULLSCREEN) {
3359− return window.innerHeight;
3360− }
3361− return elm.node.clientHeight;
3362− }
3363−
3364− var dimensions = Signal.constant(Tuple2(getWidth(), getHeight()));
3365− dimensions.defaultNumberOfKids = 2;
3366−
3367− // Do not move width and height into Elm. By setting the default number of kids,
3368− // the resize listener can be detached.
3369− var width = A2(Signal.lift, function(p){return p._0;}, dimensions);
3370− width.defaultNumberOfKids = 0;
3371−
3372− var height = A2(Signal.lift, function(p){return p._1;}, dimensions);
3373− height.defaultNumberOfKids = 0;
3374−
3375− function resizeIfNeeded() {
3376− // Do not trigger event if the dimensions have not changed.
3377− // This should be most of the time.
3378− var w = getWidth();
3379− var h = getHeight();
3380− if (dimensions.value._0 === w && dimensions.value._1 === h) return;
3381−
3382− setTimeout(function () {
3383− // Check again to see if the dimensions have changed.
3384− // It is conceivable that the dimensions have changed
3385− // again while some other event was being processed.
3386− var w = getWidth();
3387− var h = getHeight();
3388− if (dimensions.value._0 === w && dimensions.value._1 === h) return;
3389− elm.notify(dimensions.id, Tuple2(w,h));
3390− }, 0);
3391− }
3392− elm.addListener([dimensions.id], window, 'resize', resizeIfNeeded);
3393−
3394− return elm.Native.Window.values = {
3395− dimensions:dimensions,
3396− width:width,
3397− height:height,
3398− resizeIfNeeded:resizeIfNeeded
3399− };
3400−
3401−};
3402−Elm.Native.Touch = {};
3403−Elm.Native.Touch.make = function(elm) {
3404−
3405− elm.Native = elm.Native || {};
3406− elm.Native.Touch = elm.Native.Touch || {};
3407− if (elm.Native.Touch.values) return elm.Native.Touch.values;
3408−
3409− var Signal = Elm.Signal.make(elm);
3410− var List = Elm.Native.List.make(elm);
3411− var Utils = Elm.Native.Utils.make(elm);
3412−
3413− function Dict() {
3414− this.keys = [];
3415− this.values = [];
3416−
3417− this.insert = function(key,value) {
3418− this.keys.push(key);
3419− this.values.push(value);
3420− };
3421− this.lookup = function(key) {
3422− var i = this.keys.indexOf(key)
3423− return i >= 0 ? this.values[i] : {x:0,y:0,t:0};
3424− };
3425− this.remove = function(key) {
3426− var i = this.keys.indexOf(key);
3427− if (i < 0) return;
3428− var t = this.values[i];
3429− this.keys.splice(i,1);
3430− this.values.splice(i,1);
3431− return t;
3432− };
3433− this.clear = function() {
3434− this.keys = [];
3435− this.values = [];
3436− };
3437− }
3438−
3439− var root = Signal.constant([]),
3440− tapTime = 500,
3441− hasTap = false,
3442− tap = {_:{},x:0,y:0},
3443− dict = new Dict();
3444−
3445− function touch(t) {
3446− var r = dict.lookup(t.identifier);
3447− var point = Utils.getXY(t);
3448− return {_ : {},
3449− id: t.identifier,
3450− x : point._0,
3451− y : point._1,
3452− x0: r.x,
3453− y0: r.y,
3454− t0: r.t
3455− };
3456− }
3457−
3458− var node = elm.display === ElmRuntime.Display.FULLSCREEN ? document : elm.node;
3459−
3460− function start(e) {
3461− var point = Utils.getXY(e);
3462− dict.insert(e.identifier,
3463− {x: point._0,
3464− y: point._1,
3465− t: Date.now()});
3466− }
3467− function end(e) {
3468− var t = dict.remove(e.identifier);
3469− if (Date.now() - t.t < tapTime) {
3470− hasTap = true;
3471− tap = {_:{}, x:t.x, y:t.y};
3472− }
3473− }
3474−
3475− function listen(name, f) {
3476− function update(e) {
3477− for (var i = e.changedTouches.length; i--; ) { f(e.changedTouches[i]); }
3478− var ts = new Array(e.touches.length);
3479− for (var i = e.touches.length; i--; ) { ts[i] = touch(e.touches[i]); }
3480− elm.notify(root.id, ts);
3481− e.preventDefault();
3482− }
3483− elm.addListener([root.id], node, name, update);
3484− }
3485−
3486− listen("touchstart", start);
3487− listen("touchmove", function(_){});
3488− listen("touchend", end);
3489− listen("touchcancel", end);
3490− listen("touchleave", end);
3491−
3492− var mouseID = -1;
3493− function move(e) {
3494− var point = Utils.getXY(e);
3495− for (var i = root.value.length; i--; ) {
3496− if (root.value[i].id === mouseID) {
3497− root.value[i].x = point._0;
3498− root.value[i].y = point._1;
3499− elm.notify(root.id, root.value);
3500− break;
3501− }
3502− }
3503− }
3504− elm.addListener([root.id], node, "mousedown", function down(e) {
3505− node.addEventListener("mousemove", move);
3506− e.identifier = mouseID;
3507− start(e);
3508− root.value.push(touch(e));
3509− elm.notify(root.id, root.value);
3510− });
3511− elm.addListener([root.id], node, "mouseup", function up(e) {
3512− node.removeEventListener("mousemove", move);
3513− e.identifier = mouseID;
3514− end(e);
3515− for (var i = root.value.length; i--; ) {
3516− if (root.value[i].id === mouseID) {
3517− root.value.splice(i, 1);
3518− --mouseID;
3519− break;
3520− }
3521− }
3522− elm.notify(root.id, root.value);
3523− });
3524− elm.addListener([root.id], node, "blur", function blur(e) {
3525− node.removeEventListener("mousemove", move);
3526− if (root.value.length > 0) {
3527− elm.notify(root.id, []);
3528− --mouseID;
3529− }
3530− dict.clear();
3531− });
3532−
3533− function dependency(f) {
3534− var sig = A2( Signal.lift, f, root );
3535− root.defaultNumberOfKids += 1;
3536− sig.defaultNumberOfKids = 0;
3537− return sig;
3538− }
3539−
3540− var touches = dependency(List.fromArray);
3541−
3542− var taps = function() {
3543− var sig = dependency(function(_) { return tap; });
3544− sig.defaultNumberOfKids = 1;
3545− function pred(_) { var b = hasTap; hasTap = false; return b; }
3546− var sig2 = A3( Signal.keepIf, pred, {_:{},x:0,y:0}, sig);
3547− sig2.defaultNumberOfKids = 0;
3548− return sig2;
3549− }();
3550−
3551− return elm.Native.Touch.values = { touches: touches, taps: taps };
3552−
3553−};
3554−Elm.Native.Keyboard = {};
3555−Elm.Native.Keyboard.make = function(elm) {
3556−
3557− elm.Native = elm.Native || {};
3558− elm.Native.Keyboard = elm.Native.Keyboard || {};
3559− if (elm.Native.Keyboard.values) return elm.Native.Keyboard.values;
3560−
3561− // Duplicated from Native.Signal
3562− function send(node, timestep, changed) {
3563− var kids = node.kids;
3564− for (var i = kids.length; i--; ) {
3565− kids[i].recv(timestep, changed, node.id);
3566− }
3567− }
3568−
3569− var Signal = Elm.Signal.make(elm);
3570− var NList = Elm.Native.List.make(elm);
3571− var Utils = Elm.Native.Utils.make(elm);
3572−
3573− var downEvents = Signal.constant(0);
3574− var upEvents = Signal.constant(0);
3575− var blurEvents = Signal.constant(0);
3576−
3577− elm.addListener([downEvents.id], document, 'keydown', function down(e) {
3578− elm.notify(downEvents.id, e.keyCode);
3579− });
3580−
3581− elm.addListener([upEvents.id], document, 'keyup', function up(e) {
3582− elm.notify(upEvents.id, e.keyCode);
3583− });
3584−
3585− elm.addListener([blurEvents.id], document, 'blur', function blur(e) {
3586− elm.notify(blurEvents.id, NList.Nil);
3587− });
3588−
3589− function KeyMerge(down, up, blur) {
3590− var args = [down,up,blur];
3591− this.id = Utils.guid();
3592− // Ignore starting values here
3593− this.value = NList.Nil
3594− this.kids = [];
3595−
3596− var n = args.length;
3597− var count = 0;
3598− var isChanged = false;
3599−
3600− this.recv = function(timestep, changed, parentID) {
3601− ++count;
3602− if (changed) {
3603− // We know this a change must only be one of the following cases
3604− if (parentID === down.id && !(NList.member(down.value)(this.value))) {
3605− isChanged = true;
3606− this.value = NList.Cons(down.value, this.value);
3607− }
3608− if (parentID === up.id) {
3609− isChanged = true;
3610− var notEq = function(kc) { return kc !== up.value };
3611− this.value = NList.filter(notEq)(this.value);
3612− }
3613− if (parentID === blur.id) {
3614− isChanged = true;
3615− this.value = NList.Nil;
3616− }
3617− }
3618− if (count == n) {
3619− send(this, timestep, isChanged);
3620− isChanged = false;
3621− count = 0;
3622− }
3623− };
3624−
3625− for (var i = n; i--; ) { args[i].kids.push(this); }
3626−
3627− }
3628−
3629− var keysDown = Signal.dropRepeats(new KeyMerge(downEvents,upEvents,blurEvents));
3630−
3631− function keySignal(f) {
3632− var signal = A2(Signal.lift, f, keysDown);
3633− // must set the default number of kids to make it possible to filter
3634− // these signals if they are not actually used.
3635− keysDown.defaultNumberOfKids += 1;
3636− signal.defaultNumberOfKids = 1;
3637− var filtered = Signal.dropRepeats(signal)
3638− filtered.defaultNumberOfKids = 0;
3639− return filtered;
3640− }
3641−
3642− function dir(up, down, left, right) {
3643− function f(ks) {
3644− var x = 0, y = 0;
3645− while (ks.ctor === "::") {
3646− switch (ks._0) {
3647− case left : --x; break;
3648− case right: ++x; break;
3649− case up : ++y; break;
3650− case down : --y; break;
3651− }
3652− ks = ks._1;
3653− }
3654− return { _:{}, x:x, y:y };
3655− }
3656− return keySignal(f);
3657− }
3658−
3659− function is(key) { return keySignal(NList.member(key)); }
3660−
3661− var lastPressed = downEvents;
3662−
3663− return elm.Native.Keyboard.values = {
3664− isDown:is,
3665− directions:F4(dir),
3666− keysDown:keysDown,
3667− lastPressed:lastPressed
3668− };
3669−
3670−};
3671−Elm.Bitwise = Elm.Bitwise || {};
3672−Elm.Bitwise.make = function (_elm) {
3673− "use strict";
3674− _elm.Bitwise = _elm.Bitwise || {};
3675− if (_elm.Bitwise.values)
3676− return _elm.Bitwise.values;
3677− var _N = Elm.Native,
3678− _U = _N.Utils.make(_elm),
3679− _L = _N.List.make(_elm),
3680− _E = _N.Error.make(_elm),
3681− $moduleName = "Bitwise";
3682− var Native = Native || {};
3683− Native.Bitwise = Elm.Native.Bitwise.make(_elm);
3684− var _op = {};
3685− var shiftRightLogical = Native.Bitwise.shiftRightLogical;
3686− var shiftRight = Native.Bitwise.shiftRightArithmatic;
3687− var shiftLeft = Native.Bitwise.shiftLeft;
3688− var complement = Native.Bitwise.complement;
3689− var xor = Native.Bitwise.xor;
3690− var or = Native.Bitwise.or;
3691− var and = Native.Bitwise.and;
3692− _elm.Bitwise.values = {_op: _op
3693− ,and: and
3694− ,or: or
3695− ,xor: xor
3696− ,complement: complement
3697− ,shiftLeft: shiftLeft
3698− ,shiftRight: shiftRight
3699− ,shiftRightLogical: shiftRightLogical};
3700− return _elm.Bitwise.values;
3701−};Elm.Random = Elm.Random || {};
3702−Elm.Random.make = function (_elm) {
3703− "use strict";
3704− _elm.Random = _elm.Random || {};
3705− if (_elm.Random.values)
3706− return _elm.Random.values;
3707− var _N = Elm.Native,
3708− _U = _N.Utils.make(_elm),
3709− _L = _N.List.make(_elm),
3710− _E = _N.Error.make(_elm),
3711− $moduleName = "Random";
3712− var Native = Native || {};
3713− Native.Random = Elm.Native.Random.make(_elm);
3714− var Signal = Elm.Signal.make(_elm);
3715− var _op = {};
3716− var floatList = Native.Random.floatList;
3717− var $float = Native.Random.float_;
3718− var range = Native.Random.range;
3719− _elm.Random.values = {_op: _op
3720− ,range: range
3721− ,$float: $float
3722− ,floatList: floatList};
3723− return _elm.Random.values;
3724−};Elm.WebSocket = Elm.WebSocket || {};
3725−Elm.WebSocket.make = function (_elm) {
3726− "use strict";
3727− _elm.WebSocket = _elm.WebSocket || {};
3728− if (_elm.WebSocket.values)
3729− return _elm.WebSocket.values;
3730− var _N = Elm.Native,
3731− _U = _N.Utils.make(_elm),
3732− _L = _N.List.make(_elm),
3733− _E = _N.Error.make(_elm),
3734− $moduleName = "WebSocket";
3735− var Basics = Elm.Basics.make(_elm);
3736− var Native = Native || {};
3737− Native.WebSocket = Elm.Native.WebSocket.make(_elm);
3738− var Signal = Elm.Signal.make(_elm);
3739− var _op = {};
3740− var connect = Native.WebSocket.connect;
3741− _elm.WebSocket.values = {_op: _op
3742− ,connect: connect};
3743− return _elm.WebSocket.values;
3744−};Elm.Signal = Elm.Signal || {};
3745−Elm.Signal.make = function (_elm) {
3746− "use strict";
3747− _elm.Signal = _elm.Signal || {};
3748− if (_elm.Signal.values)
3749− return _elm.Signal.values;
3750− var _N = Elm.Native,
3751− _U = _N.Utils.make(_elm),
3752− _L = _N.List.make(_elm),
3753− _E = _N.Error.make(_elm),
3754− $moduleName = "Signal";
3755− var Basics = Elm.Basics.make(_elm);
3756− var List = Elm.List.make(_elm);
3757− var Maybe = Elm.Maybe.make(_elm);
3758− var Native = Native || {};
3759− Native.Error = Elm.Native.Error.make(_elm);
3760− var Native = Native || {};
3761− Native.Signal = Elm.Native.Signal.make(_elm);
3762− var _op = {};
3763− _op["~"] = F2(function (sf,s) {
3764− return A3(Native.Signal.lift2,
3765− F2(function (f,x) {
3766− return f(x);
3767− }),
3768− sf,
3769− s);
3770− });
3771− _op["<~"] = F2(function (f,s) {
3772− return A2(Native.Signal.lift,
3773− f,
3774− s);
3775− });
3776− var sampleOn = Native.Signal.sampleOn;
3777− var dropRepeats = Native.Signal.dropRepeats;
3778− var dropIf = Native.Signal.dropIf;
3779− var keepIf = Native.Signal.keepIf;
3780− var keepWhen = F3(function (bs,
3781− def,
3782− sig) {
3783− return A2(_op["<~"],
3784− Basics.snd,
3785− A3(keepIf,
3786− Basics.fst,
3787− {ctor: "_Tuple2"
3788− ,_0: false
3789− ,_1: def},
3790− A2(_op["~"],
3791− A2(_op["<~"],
3792− F2(function (v0,v1) {
3793− return {ctor: "_Tuple2"
3794− ,_0: v0
3795− ,_1: v1};
3796− }),
3797− A2(sampleOn,sig,bs)),
3798− sig)));
3799− });
3800− var dropWhen = function (bs) {
3801− return keepWhen(A2(_op["<~"],
3802− Basics.not,
3803− bs));
3804− };
3805− var countIf = Native.Signal.countIf;
3806− var count = Native.Signal.count;
3807− var combine = A2(List.foldr,
3808− Native.Signal.lift2(F2(function (x,
3809− y) {
3810− return {ctor: "::"
3811− ,_0: x
3812− ,_1: y};
3813− })),
3814− Native.Signal.constant(_L.fromArray([])));
3815− var merges = Native.Signal.merges;
3816− var merge = Native.Signal.merge;
3817− var foldp = Native.Signal.foldp;
3818− var lift8 = Native.Signal.lift8;
3819− var lift7 = Native.Signal.lift7;
3820− var lift6 = Native.Signal.lift6;
3821− var lift5 = Native.Signal.lift5;
3822− var lift4 = Native.Signal.lift4;
3823− var lift3 = Native.Signal.lift3;
3824− var lift2 = Native.Signal.lift2;
3825− var lift = Native.Signal.lift;
3826− var constant = Native.Signal.constant;
3827− var Signal = {ctor: "Signal"};
3828− _elm.Signal.values = {_op: _op
3829− ,constant: constant
3830− ,lift: lift
3831− ,lift2: lift2
3832− ,lift3: lift3
3833− ,lift4: lift4
3834− ,lift5: lift5
3835− ,lift6: lift6
3836− ,lift7: lift7
3837− ,lift8: lift8
3838− ,foldp: foldp
3839− ,merge: merge
3840− ,merges: merges
3841− ,combine: combine
3842− ,count: count
3843− ,countIf: countIf
3844− ,keepIf: keepIf
3845− ,dropIf: dropIf
3846− ,keepWhen: keepWhen
3847− ,dropWhen: dropWhen
3848− ,dropRepeats: dropRepeats
3849− ,sampleOn: sampleOn
3850− ,Signal: Signal};
3851− return _elm.Signal.values;
3852−};Elm.Time = Elm.Time || {};
3853−Elm.Time.make = function (_elm) {
3854− "use strict";
3855− _elm.Time = _elm.Time || {};
3856− if (_elm.Time.values)
3857− return _elm.Time.values;
3858− var _N = Elm.Native,
3859− _U = _N.Utils.make(_elm),
3860− _L = _N.List.make(_elm),
3861− _E = _N.Error.make(_elm),
3862− $moduleName = "Time";
3863− var Basics = Elm.Basics.make(_elm);
3864− var Native = Native || {};
3865− Native.Time = Elm.Native.Time.make(_elm);
3866− var Signal = Elm.Signal.make(_elm);
3867− var _op = {};
3868− var delay = Native.Time.delay;
3869− var timestamp = Native.Time.timestamp;
3870− var since = Native.Time.since;
3871− var every = Native.Time.every;
3872− var fpsWhen = Native.Time.fpsWhen;
3873− var fps = Native.Time.fps;
3874− var inMilliseconds = function (t) {
3875− return t;
3876− };
3877− var millisecond = 1;
3878− var second = 1000 * millisecond;
3879− var minute = 60 * second;
3880− var hour = 60 * minute;
3881− var inHours = function (t) {
3882− return t / hour;
3883− };
3884− var inMinutes = function (t) {
3885− return t / minute;
3886− };
3887− var inSeconds = function (t) {
3888− return t / second;
3889− };
3890− _elm.Time.values = {_op: _op
3891− ,millisecond: millisecond
3892− ,second: second
3893− ,minute: minute
3894− ,hour: hour
3895− ,inMilliseconds: inMilliseconds
3896− ,inSeconds: inSeconds
3897− ,inMinutes: inMinutes
3898− ,inHours: inHours
3899− ,fps: fps
3900− ,fpsWhen: fpsWhen
3901− ,every: every
3902− ,since: since
3903− ,timestamp: timestamp
3904− ,delay: delay};
3905− return _elm.Time.values;
3906−};Elm.Dict = Elm.Dict || {};
3907−Elm.Dict.make = function (_elm) {
3908− "use strict";
3909− _elm.Dict = _elm.Dict || {};
3910− if (_elm.Dict.values)
3911− return _elm.Dict.values;
3912− var _N = Elm.Native,
3913− _U = _N.Utils.make(_elm),
3914− _L = _N.List.make(_elm),
3915− _E = _N.Error.make(_elm),
3916− $moduleName = "Dict";
3917− var Basics = Elm.Basics.make(_elm);
3918− var List = Elm.List.make(_elm);
3919− var Maybe = Elm.Maybe.make(_elm);
3920− var Native = Native || {};
3921− Native.Error = Elm.Native.Error.make(_elm);
3922− var Native = Native || {};
3923− Native.Utils = Elm.Native.Utils.make(_elm);
3924− var _op = {};
3925− var Same = {ctor: "Same"};
3926− var Remove = {ctor: "Remove"};
3927− var Insert = {ctor: "Insert"};
3928− var showFlag = function (f) {
3929− return function () {
3930− switch (f.ctor)
3931− {case "Insert": return "Insert";
3932− case "Remove": return "Remove";
3933− case "Same": return "Same";}
3934− _E.Case($moduleName,
3935− "between lines 136 and 141");
3936− }();
3937− };
3938− var RBEmpty = function (a) {
3939− return {ctor: "RBEmpty"
3940− ,_0: a};
3941− };
3942− var RBNode = F5(function (a,
3943− b,
3944− c,
3945− d,
3946− e) {
3947− return {ctor: "RBNode"
3948− ,_0: a
3949− ,_1: b
3950− ,_2: c
3951− ,_3: d
3952− ,_4: e};
3953− });
3954− var max = function (t) {
3955− return function () {
3956− switch (t.ctor)
3957− {case "RBEmpty":
3958− return Native.Error.raise("(max Empty) is not defined");
3959− case "RBNode":
3960− switch (t._4.ctor)
3961− {case "RBEmpty":
3962− return {ctor: "_Tuple2"
3963− ,_0: t._1
3964− ,_1: t._2};}
3965− return max(t._4);}
3966− _E.Case($moduleName,
3967− "between lines 82 and 87");
3968− }();
3969− };
3970− var LBBlack = {ctor: "LBBlack"};
3971− var LBlack = {ctor: "LBlack"};
3972− var showLColor = function (c) {
3973− return function () {
3974− switch (c.ctor)
3975− {case "LBBlack":
3976− return "LBBlack";
3977− case "LBlack": return "LBlack";}
3978− _E.Case($moduleName,
3979− "between lines 62 and 64");
3980− }();
3981− };
3982− var empty = RBEmpty(LBlack);
3983− var min = function (t) {
3984− return function () {
3985− switch (t.ctor)
3986− {case "RBEmpty":
3987− switch (t._0.ctor)
3988− {case "LBlack":
3989− return Native.Error.raise("(min Empty) is not defined");}
3990− break;
3991− case "RBNode":
3992− switch (t._3.ctor)
3993− {case "RBEmpty":
3994− switch (t._3._0.ctor)
3995− {case "LBlack":
3996− return {ctor: "_Tuple2"
3997− ,_0: t._1
3998− ,_1: t._2};}
3999− break;}
4000− return min(t._3);}
4001− _E.Case($moduleName,
4002− "between lines 75 and 78");
4003− }();
4004− };
4005− var lookup = F2(function (k,t) {
4006− return function () {
4007− switch (t.ctor)
4008− {case "RBEmpty":
4009− switch (t._0.ctor)
4010− {case "LBlack":
4011− return Maybe.Nothing;}
4012− break;
4013− case "RBNode":
4014− return function () {
4015− var _v25 = A2(Native.Utils.compare,
4016− k,
4017− t._1);
4018− switch (_v25.ctor)
4019− {case "EQ":
4020− return Maybe.Just(t._2);
4021− case "GT": return A2(lookup,
4022− k,
4023− t._4);
4024− case "LT": return A2(lookup,
4025− k,
4026− t._3);}
4027− _E.Case($moduleName,
4028− "between lines 93 and 99");
4029− }();}
4030− _E.Case($moduleName,
4031− "between lines 90 and 99");
4032− }();
4033− });
4034− var member = F2(function (k,t) {
4035− return Maybe.isJust(A2(lookup,
4036− k,
4037− t));
4038− });
4039− var findWithDefault = F3(function (base,
4040− k,
4041− t) {
4042− return function () {
4043− switch (t.ctor)
4044− {case "RBEmpty":
4045− switch (t._0.ctor)
4046− {case "LBlack": return base;}
4047− break;
4048− case "RBNode":
4049− return function () {
4050− var _v33 = A2(Native.Utils.compare,
4051− k,
4052− t._1);
4053− switch (_v33.ctor)
4054− {case "EQ": return t._2;
4055− case "GT":
4056− return A3(findWithDefault,
4057− base,
4058− k,
4059− t._4);
4060− case "LT":
4061− return A3(findWithDefault,
4062− base,
4063− k,
4064− t._3);}
4065− _E.Case($moduleName,
4066− "between lines 105 and 110");
4067− }();}
4068− _E.Case($moduleName,
4069− "between lines 102 and 110");
4070− }();
4071− });
4072− var map = F2(function (f,t) {
4073− return function () {
4074− switch (t.ctor)
4075− {case "RBEmpty":
4076− switch (t._0.ctor)
4077− {case "LBlack":
4078− return RBEmpty(LBlack);}
4079− break;
4080− case "RBNode": return A5(RBNode,
4081− t._0,
4082− t._1,
4083− f(t._2),
4084− A2(map,f,t._3),
4085− A2(map,f,t._4));}
4086− _E.Case($moduleName,
4087− "between lines 302 and 307");
4088− }();
4089− });
4090− var foldl = F3(function (f,
4091− acc,
4092− t) {
4093− return function () {
4094− switch (t.ctor)
4095− {case "RBEmpty":
4096− switch (t._0.ctor)
4097− {case "LBlack": return acc;}
4098− break;
4099− case "RBNode": return A3(foldl,
4100− f,
4101− A3(f,
4102− t._1,
4103− t._2,
4104− A3(foldl,f,acc,t._3)),
4105− t._4);}
4106− _E.Case($moduleName,
4107− "between lines 310 and 315");
4108− }();
4109− });
4110− var foldr = F3(function (f,
4111− acc,
4112− t) {
4113− return function () {
4114− switch (t.ctor)
4115− {case "RBEmpty":
4116− switch (t._0.ctor)
4117− {case "LBlack": return acc;}
4118− break;
4119− case "RBNode": return A3(foldr,
4120− f,
4121− A3(f,
4122− t._1,
4123− t._2,
4124− A3(foldr,f,acc,t._4)),
4125− t._3);}
4126− _E.Case($moduleName,
4127− "between lines 318 and 323");
4128− }();
4129− });
4130− var keys = function (t) {
4131− return A3(foldr,
4132− F3(function (k,v,acc) {
4133− return {ctor: "::"
4134− ,_0: k
4135− ,_1: acc};
4136− }),
4137− _L.fromArray([]),
4138− t);
4139− };
4140− var values = function (t) {
4141− return A3(foldr,
4142− F3(function (k,v,acc) {
4143− return {ctor: "::"
4144− ,_0: v
4145− ,_1: acc};
4146− }),
4147− _L.fromArray([]),
4148− t);
4149− };
4150− var toList = function (t) {
4151− return A3(foldr,
4152− F3(function (k,v,acc) {
4153− return {ctor: "::"
4154− ,_0: {ctor: "_Tuple2"
4155− ,_0: k
4156− ,_1: v}
4157− ,_1: acc};
4158− }),
4159− _L.fromArray([]),
4160− t);
4161− };
4162− var NBlack = {ctor: "NBlack"};
4163− var BBlack = {ctor: "BBlack"};
4164− var isBBlack = function (t) {
4165− return function () {
4166− switch (t.ctor)
4167− {case "RBEmpty":
4168− switch (t._0.ctor)
4169− {case "LBBlack": return true;}
4170− break;
4171− case "RBNode":
4172− switch (t._0.ctor)
4173− {case "BBlack": return true;}
4174− break;}
4175− return false;
4176− }();
4177− };
4178− var Black = {ctor: "Black"};
4179− var blackish = function (t) {
4180− return function () {
4181− switch (t.ctor)
4182− {case "RBEmpty": return true;
4183− case "RBNode":
4184− return _U.eq(t._0,
4185− Black) || _U.eq(t._0,BBlack);}
4186− _E.Case($moduleName,
4187− "between lines 253 and 255");
4188− }();
4189− };
4190− var blacken = function (t) {
4191− return function () {
4192− switch (t.ctor)
4193− {case "RBEmpty":
4194− return RBEmpty(LBlack);
4195− case "RBNode": return A5(RBNode,
4196− Black,
4197− t._1,
4198− t._2,
4199− t._3,
4200− t._4);}
4201− _E.Case($moduleName,
4202− "between lines 289 and 291");
4203− }();
4204− };
4205− var Red = {ctor: "Red"};
4206− var showNColor = function (c) {
4207− return function () {
4208− switch (c.ctor)
4209− {case "BBlack": return "BBlack";
4210− case "Black": return "Black";
4211− case "NBlack": return "NBlack";
4212− case "Red": return "Red";}
4213− _E.Case($moduleName,
4214− "between lines 51 and 55");
4215− }();
4216− };
4217− var reportRemBug = F4(function (msg,
4218− c,
4219− lgot,
4220− rgot) {
4221− return Native.Error.raise(List.concat(_L.fromArray(["Internal red-black tree invariant violated, expected "
4222− ,msg
4223− ,"and got"
4224− ,showNColor(c)
4225− ," "
4226− ,lgot
4227− ," "
4228− ,rgot
4229− ,"\nPlease report this bug to https://github.com/evancz/Elm/issues"])));
4230− });
4231− var ensureBlackRoot = function (t) {
4232− return function () {
4233− switch (t.ctor)
4234− {case "RBEmpty":
4235− switch (t._0.ctor)
4236− {case "LBlack": return t;}
4237− break;
4238− case "RBNode":
4239− switch (t._0.ctor)
4240− {case "Black": return t;
4241− case "Red": return A5(RBNode,
4242− Black,
4243− t._1,
4244− t._2,
4245− t._3,
4246− t._4);}
4247− break;}
4248− _E.Case($moduleName,
4249− "between lines 117 and 123");
4250− }();
4251− };
4252− var moreBlack = function (c) {
4253− return function () {
4254− switch (c.ctor)
4255− {case "BBlack":
4256− return Native.Error.raise("Can\'t make a double black node more black!");
4257− case "Black": return BBlack;
4258− case "NBlack": return Red;
4259− case "Red": return Black;}
4260− _E.Case($moduleName,
4261− "between lines 179 and 183");
4262− }();
4263− };
4264− var lessBlack = function (c) {
4265− return function () {
4266− switch (c.ctor)
4267− {case "BBlack": return Black;
4268− case "Black": return Red;
4269− case "NBlack":
4270− return Native.Error.raise("Can\'t make a negative black node less black!");
4271− case "Red": return NBlack;}
4272− _E.Case($moduleName,
4273− "between lines 186 and 190");
4274− }();
4275− };
4276− var lessBlackTree = function (t) {
4277− return function () {
4278− switch (t.ctor)
4279− {case "RBEmpty":
4280− switch (t._0.ctor)
4281− {case "LBBlack":
4282− return RBEmpty(LBlack);}
4283− break;
4284− case "RBNode": return A5(RBNode,
4285− lessBlack(t._0),
4286− t._1,
4287− t._2,
4288− t._3,
4289− t._4);}
4290− _E.Case($moduleName,
4291− "between lines 193 and 195");
4292− }();
4293− };
4294− var redden = function (t) {
4295− return function () {
4296− switch (t.ctor)
4297− {case "RBEmpty":
4298− return Native.Error.raise("can\'t make a Leaf red");
4299− case "RBNode": return A5(RBNode,
4300− Red,
4301− t._1,
4302− t._2,
4303− t._3,
4304− t._4);}
4305− _E.Case($moduleName,
4306− "between lines 295 and 299");
4307− }();
4308− };
4309− var balance_node = function (t) {
4310− return function () {
4311− var assemble = function (col) {
4312− return function (xk) {
4313− return function (xv) {
4314− return function (yk) {
4315− return function (yv) {
4316− return function (zk) {
4317− return function (zv) {
4318− return function (a) {
4319− return function (b) {
4320− return function (c) {
4321− return function (d) {
4322− return A5(RBNode,
4323− lessBlack(col),
4324− yk,
4325− yv,
4326− A5(RBNode,Black,xk,xv,a,b),
4327− A5(RBNode,Black,zk,zv,c,d));
4328− };
4329− };
4330− };
4331− };
4332− };
4333− };
4334− };
4335− };
4336− };
4337− };
4338− };
4339− return blackish(t) ? function () {
4340− switch (t.ctor)
4341− {case "RBNode":
4342− switch (t._3.ctor)
4343− {case "RBNode":
4344− switch (t._3._0.ctor)
4345− {case "Red":
4346− switch (t._3._3.ctor)
4347− {case "RBNode":
4348− switch (t._3._3._0.ctor)
4349− {case "Red":
4350− return assemble(t._0)(t._3._3._1)(t._3._3._2)(t._3._1)(t._3._2)(t._1)(t._2)(t._3._3._3)(t._3._3._4)(t._3._4)(t._4);}
4351− break;}
4352− switch (t._3._4.ctor)
4353− {case "RBNode":
4354− switch (t._3._4._0.ctor)
4355− {case "Red":
4356− return assemble(t._0)(t._3._1)(t._3._2)(t._3._4._1)(t._3._4._2)(t._1)(t._2)(t._3._3)(t._3._4._3)(t._3._4._4)(t._4);}
4357− break;}
4358− break;}
4359− break;}
4360− switch (t._4.ctor)
4361− {case "RBNode":
4362− switch (t._4._0.ctor)
4363− {case "Red":
4364− switch (t._4._3.ctor)
4365− {case "RBNode":
4366− switch (t._4._3._0.ctor)
4367− {case "Red":
4368− return assemble(t._0)(t._1)(t._2)(t._4._3._1)(t._4._3._2)(t._4._1)(t._4._2)(t._3)(t._4._3._3)(t._4._3._4)(t._4._4);}
4369− break;}
4370− switch (t._4._4.ctor)
4371− {case "RBNode":
4372− switch (t._4._4._0.ctor)
4373− {case "Red":
4374− return assemble(t._0)(t._1)(t._2)(t._4._1)(t._4._2)(t._4._4._1)(t._4._4._2)(t._3)(t._4._3)(t._4._4._3)(t._4._4._4);}
4375− break;}
4376− break;}
4377− break;}
4378− switch (t._0.ctor)
4379− {case "BBlack":
4380− switch (t._4.ctor)
4381− {case "RBNode":
4382− switch (t._4._0.ctor)
4383− {case "NBlack":
4384− switch (t._4._3.ctor)
4385− {case "RBNode":
4386− switch (t._4._3._0.ctor)
4387− {case "Black":
4388− return function () {
4389− switch (t._4._4.ctor)
4390− {case "RBNode":
4391− switch (t._4._4._0.ctor)
4392− {case "Black":
4393− return A5(RBNode,
4394− Black,
4395− t._4._3._1,
4396− t._4._3._2,
4397− A5(RBNode,
4398− Black,
4399− t._1,
4400− t._2,
4401− t._3,
4402− t._4._3._3),
4403− A5(balance,
4404− Black,
4405− t._4._1,
4406− t._4._2,
4407− t._4._3._4,
4408− redden(t._4._4)));}
4409− break;}
4410− return t;
4411− }();}
4412− break;}
4413− break;}
4414− break;}
4415− switch (t._3.ctor)
4416− {case "RBNode":
4417− switch (t._3._0.ctor)
4418− {case "NBlack":
4419− switch (t._3._4.ctor)
4420− {case "RBNode":
4421− switch (t._3._4._0.ctor)
4422− {case "Black":
4423− return function () {
4424− switch (t._3._3.ctor)
4425− {case "RBNode":
4426− switch (t._3._3._0.ctor)
4427− {case "Black":
4428− return A5(RBNode,
4429− Black,
4430− t._3._4._1,
4431− t._3._4._2,
4432− A5(balance,
4433− Black,
4434− t._3._1,
4435− t._3._2,
4436− redden(t._3._3),
4437− t._3._4._3),
4438− A5(RBNode,
4439− Black,
4440− t._1,
4441− t._2,
4442− t._3._4._4,
4443− t._4));}
4444− break;}
4445− return t;
4446− }();}
4447− break;}
4448− break;}
4449− break;}
4450− break;}
4451− break;}
4452− return t;
4453− }() : t;
4454− }();
4455− };
4456− var balance = F5(function (c,
4457− k,
4458− v,
4459− l,
4460− r) {
4461− return balance_node(A5(RBNode,
4462− c,
4463− k,
4464− v,
4465− l,
4466− r));
4467− });
4468− var bubble = F5(function (c,
4469− k,
4470− v,
4471− l,
4472− r) {
4473− return isBBlack(l) || isBBlack(r) ? A5(balance,
4474− moreBlack(c),
4475− k,
4476− v,
4477− lessBlackTree(l),
4478− lessBlackTree(r)) : A5(RBNode,
4479− c,
4480− k,
4481− v,
4482− l,
4483− r);
4484− });
4485− var remove_max = F5(function (c,
4486− k,
4487− v,
4488− l,
4489− r) {
4490− return function () {
4491− switch (r.ctor)
4492− {case "RBEmpty": return A3(rem,
4493− c,
4494− l,
4495− r);
4496− case "RBNode": return A5(bubble,
4497− c,
4498− k,
4499− v,
4500− l,
4501− A5(remove_max,
4502− r._0,
4503− r._1,
4504− r._2,
4505− r._3,
4506− r._4));}
4507− _E.Case($moduleName,
4508− "between lines 241 and 244");
4509− }();
4510− });
4511− var rem = F3(function (c,l,r) {
4512− return function () {
4513− var _v175 = {ctor: "_Tuple2"
4514− ,_0: l
4515− ,_1: r};
4516− switch (_v175.ctor)
4517− {case "_Tuple2":
4518− switch (_v175._0.ctor)
4519− {case "RBEmpty":
4520− switch (_v175._1.ctor)
4521− {case "RBEmpty":
4522− return function () {
4523− switch (c.ctor)
4524− {case "Black":
4525− return RBEmpty(LBBlack);
4526− case "Red":
4527− return RBEmpty(LBlack);}
4528− _E.Case($moduleName,
4529− "between lines 214 and 217");
4530− }();
4531− case "RBNode":
4532− return function () {
4533− var _v197 = {ctor: "_Tuple3"
4534− ,_0: c
4535− ,_1: _v175._0._0
4536− ,_2: _v175._1._0};
4537− switch (_v197.ctor)
4538− {case "_Tuple3":
4539− switch (_v197._0.ctor)
4540− {case "Black":
4541− switch (_v197._1.ctor)
4542− {case "LBlack":
4543− switch (_v197._2.ctor)
4544− {case "Red": return A5(RBNode,
4545− Black,
4546− _v175._1._1,
4547− _v175._1._2,
4548− _v175._1._3,
4549− _v175._1._4);}
4550− break;}
4551− break;}
4552− break;}
4553− return A4(reportRemBug,
4554− "Black, LBlack, Red",
4555− c,
4556− showLColor(_v175._0._0),
4557− showNColor(_v175._1._0));
4558− }();}
4559− break;
4560− case "RBNode":
4561− switch (_v175._1.ctor)
4562− {case "RBEmpty":
4563− return function () {
4564− var _v201 = {ctor: "_Tuple3"
4565− ,_0: c
4566− ,_1: _v175._0._0
4567− ,_2: _v175._1._0};
4568− switch (_v201.ctor)
4569− {case "_Tuple3":
4570− switch (_v201._0.ctor)
4571− {case "Black":
4572− switch (_v201._1.ctor)
4573− {case "Red":
4574− switch (_v201._2.ctor)
4575− {case "LBlack":
4576− return A5(RBNode,
4577− Black,
4578− _v175._0._1,
4579− _v175._0._2,
4580− _v175._0._3,
4581− _v175._0._4);}
4582− break;}
4583− break;}
4584− break;}
4585− return A4(reportRemBug,
4586− "Black, Red, LBlack",
4587− c,
4588− showNColor(_v175._0._0),
4589− showLColor(_v175._1._0));
4590− }();
4591− case "RBNode":
4592− return function () {
4593− var l$ = A5(remove_max,
4594− _v175._0._0,
4595− _v175._0._1,
4596− _v175._0._2,
4597− _v175._0._3,
4598− _v175._0._4);
4599− var r = A5(RBNode,
4600− _v175._1._0,
4601− _v175._1._1,
4602− _v175._1._2,
4603− _v175._1._3,
4604− _v175._1._4);
4605− var l = A5(RBNode,
4606− _v175._0._0,
4607− _v175._0._1,
4608− _v175._0._2,
4609− _v175._0._3,
4610− _v175._0._4);
4611− var $ = max(l),
4612− k = $._0,
4613− v = $._1;
4614− return A5(bubble,c,k,v,l$,r);
4615− }();}
4616− break;}
4617− break;}
4618− _E.Case($moduleName,
4619− "between lines 213 and 231");
4620− }();
4621− });
4622− var update = F3(function (k,
4623− u,
4624− t) {
4625− return function () {
4626− var up = function (t) {
4627− return function () {
4628− switch (t.ctor)
4629− {case "RBEmpty":
4630− switch (t._0.ctor)
4631− {case "LBlack":
4632− return function () {
4633− var _v212 = u(Maybe.Nothing);
4634− switch (_v212.ctor)
4635− {case "Just":
4636− return {ctor: "_Tuple2"
4637− ,_0: Insert
4638− ,_1: A5(RBNode,
4639− Red,
4640− k,
4641− _v212._0,
4642− empty,
4643− empty)};
4644− case "Nothing":
4645− return {ctor: "_Tuple2"
4646− ,_0: Same
4647− ,_1: empty};}
4648− _E.Case($moduleName,
4649− "between lines 145 and 148");
4650− }();}
4651− break;
4652− case "RBNode":
4653− return function () {
4654− var _v214 = A2(Native.Utils.compare,
4655− k,
4656− t._1);
4657− switch (_v214.ctor)
4658− {case "EQ": return function () {
4659− var _v215 = u(Maybe.Just(t._2));
4660− switch (_v215.ctor)
4661− {case "Just":
4662− return {ctor: "_Tuple2"
4663− ,_0: Same
4664− ,_1: A5(RBNode,
4665− t._0,
4666− t._1,
4667− _v215._0,
4668− t._3,
4669− t._4)};
4670− case "Nothing":
4671− return {ctor: "_Tuple2"
4672− ,_0: Remove
4673− ,_1: A3(rem,t._0,t._3,t._4)};}
4674− _E.Case($moduleName,
4675− "between lines 149 and 152");
4676− }();
4677− case "GT": return function () {
4678− var $ = up(t._4),
4679− fl = $._0,
4680− r$ = $._1;
4681− return function () {
4682− switch (fl.ctor)
4683− {case "Insert":
4684− return {ctor: "_Tuple2"
4685− ,_0: Insert
4686− ,_1: A5(balance,
4687− t._0,
4688− t._1,
4689− t._2,
4690− t._3,
4691− r$)};
4692− case "Remove":
4693− return {ctor: "_Tuple2"
4694− ,_0: Remove
4695− ,_1: A5(bubble,
4696− t._0,
4697− t._1,
4698− t._2,
4699− t._3,
4700− r$)};
4701− case "Same":
4702− return {ctor: "_Tuple2"
4703− ,_0: Same
4704− ,_1: A5(RBNode,
4705− t._0,
4706− t._1,
4707− t._2,
4708− t._3,
4709− r$)};}
4710− _E.Case($moduleName,
4711− "between lines 158 and 162");
4712− }();
4713− }();
4714− case "LT": return function () {
4715− var $ = up(t._3),
4716− fl = $._0,
4717− l$ = $._1;
4718− return function () {
4719− switch (fl.ctor)
4720− {case "Insert":
4721− return {ctor: "_Tuple2"
4722− ,_0: Insert
4723− ,_1: A5(balance,
4724− t._0,
4725− t._1,
4726− t._2,
4727− l$,
4728− t._4)};
4729− case "Remove":
4730− return {ctor: "_Tuple2"
4731− ,_0: Remove
4732− ,_1: A5(bubble,
4733− t._0,
4734− t._1,
4735− t._2,
4736− l$,
4737− t._4)};
4738− case "Same":
4739− return {ctor: "_Tuple2"
4740− ,_0: Same
4741− ,_1: A5(RBNode,
4742− t._0,
4743− t._1,
4744− t._2,
4745− l$,
4746− t._4)};}
4747− _E.Case($moduleName,
4748− "between lines 153 and 157");
4749− }();
4750− }();}
4751− _E.Case($moduleName,
4752− "between lines 148 and 162");
4753− }();}
4754− _E.Case($moduleName,
4755− "between lines 144 and 162");
4756− }();
4757− };
4758− var $ = up(t),
4759− fl = $._0,
4760− t$ = $._1;
4761− return function () {
4762− switch (fl.ctor)
4763− {case "Insert":
4764− return ensureBlackRoot(t$);
4765− case "Remove":
4766− return blacken(t$);
4767− case "Same": return t$;}
4768− _E.Case($moduleName,
4769− "between lines 163 and 168");
4770− }();
4771− }();
4772− });
4773− var insert = F3(function (k,
4774− v,
4775− t) {
4776− return function () {
4777− var u = function (_v220) {
4778− return function () {
4779− return Maybe.Just(v);
4780− }();
4781− };
4782− return A3(update,k,u,t);
4783− }();
4784− });
4785− var singleton = F2(function (k,
4786− v) {
4787− return A3(insert,
4788− k,
4789− v,
4790− RBEmpty(LBlack));
4791− });
4792− var union = F2(function (t1,
4793− t2) {
4794− return A3(foldl,
4795− insert,
4796− t2,
4797− t1);
4798− });
4799− var intersect = F2(function (t1,
4800− t2) {
4801− return function () {
4802− var combine = F3(function (k,
4803− v,
4804− t) {
4805− return A2(member,
4806− k,
4807− t2) ? A3(insert,k,v,t) : t;
4808− });
4809− return A3(foldl,
4810− combine,
4811− empty,
4812− t1);
4813− }();
4814− });
4815− var fromList = function (assocs) {
4816− return A3(List.foldl,
4817− F2(function (_v222,d) {
4818− return function () {
4819− switch (_v222.ctor)
4820− {case "_Tuple2":
4821− return A3(insert,
4822− _v222._0,
4823− _v222._1,
4824− d);}
4825− _E.Case($moduleName,
4826− "on line 353, column 43 to 55");
4827− }();
4828− }),
4829− empty,
4830− assocs);
4831− };
4832− var remove = F2(function (k,t) {
4833− return function () {
4834− var u = function (_v226) {
4835− return function () {
4836− return Maybe.Nothing;
4837− }();
4838− };
4839− return A3(update,k,u,t);
4840− }();
4841− });
4842− var diff = F2(function (t1,t2) {
4843− return A3(foldl,
4844− F3(function (k,v,t) {
4845− return A2(remove,k,t);
4846− }),
4847− t1,
4848− t2);
4849− });
4850− _elm.Dict.values = {_op: _op
4851− ,empty: empty
4852− ,singleton: singleton
4853− ,insert: insert
4854− ,update: update
4855− ,lookup: lookup
4856− ,findWithDefault: findWithDefault
4857− ,remove: remove
4858− ,member: member
4859− ,foldl: foldl
4860− ,foldr: foldr
4861− ,map: map
4862− ,union: union
4863− ,intersect: intersect
4864− ,diff: diff
4865− ,keys: keys
4866− ,values: values
4867− ,toList: toList
4868− ,fromList: fromList};
4869− return _elm.Dict.values;
4870−};Elm.Char = Elm.Char || {};
4871−Elm.Char.make = function (_elm) {
4872− "use strict";
4873− _elm.Char = _elm.Char || {};
4874− if (_elm.Char.values)
4875− return _elm.Char.values;
4876− var _N = Elm.Native,
4877− _U = _N.Utils.make(_elm),
4878− _L = _N.List.make(_elm),
4879− _E = _N.Error.make(_elm),
4880− $moduleName = "Char";
4881− var Native = Native || {};
4882− Native.Char = Elm.Native.Char.make(_elm);
4883− var _op = {};
4884− var fromCode = Native.Char.fromCode;
4885− var toCode = Native.Char.toCode;
4886− var toLocaleLower = Native.Char.toLocaleLower;
4887− var toLocaleUpper = Native.Char.toLocaleUpper;
4888− var toLower = Native.Char.toLower;
4889− var toUpper = Native.Char.toUpper;
4890− var isHexDigit = Native.Char.isHexDigit;
4891− var isOctDigit = Native.Char.isOctDigit;
4892− var isDigit = Native.Char.isDigit;
4893− var isLower = Native.Char.isLower;
4894− var isUpper = Native.Char.isUpper;
4895− _elm.Char.values = {_op: _op
4896− ,isUpper: isUpper
4897− ,isLower: isLower
4898− ,isDigit: isDigit
4899− ,isOctDigit: isOctDigit
4900− ,isHexDigit: isHexDigit
4901− ,toUpper: toUpper
4902− ,toLower: toLower
4903− ,toLocaleUpper: toLocaleUpper
4904− ,toLocaleLower: toLocaleLower
4905− ,toCode: toCode
4906− ,fromCode: fromCode};
4907− return _elm.Char.values;
4908−};Elm.Either = Elm.Either || {};
4909−Elm.Either.make = function (_elm) {
4910− "use strict";
4911− _elm.Either = _elm.Either || {};
4912− if (_elm.Either.values)
4913− return _elm.Either.values;
4914− var _N = Elm.Native,
4915− _U = _N.Utils.make(_elm),
4916− _L = _N.List.make(_elm),
4917− _E = _N.Error.make(_elm),
4918− $moduleName = "Either";
4919− var List = Elm.List.make(_elm);
4920− var _op = {};
4921− var Right = function (a) {
4922− return {ctor: "Right",_0: a};
4923− };
4924− var isRight = function (e) {
4925− return function () {
4926− switch (e.ctor)
4927− {case "Right": return true;}
4928− return false;
4929− }();
4930− };
4931− var Left = function (a) {
4932− return {ctor: "Left",_0: a};
4933− };
4934− var either = F3(function (f,
4935− g,
4936− e) {
4937− return function () {
4938− switch (e.ctor)
4939− {case "Left": return f(e._0);
4940− case "Right": return g(e._0);}
4941− _E.Case($moduleName,
4942− "on line 37, column 16 to 60");
4943− }();
4944− });
4945− var isLeft = function (e) {
4946− return function () {
4947− switch (e.ctor)
4948− {case "Left": return true;}
4949− return false;
4950− }();
4951− };
4952− var consLeft = F2(function (e,
4953− vs) {
4954− return function () {
4955− switch (e.ctor)
4956− {case "Left": return {ctor: "::"
4957− ,_0: e._0
4958− ,_1: vs};
4959− case "Right": return vs;}
4960− _E.Case($moduleName,
4961− "between lines 78 and 80");
4962− }();
4963− });
4964− var lefts = function (es) {
4965− return A3(List.foldr,
4966− consLeft,
4967− _L.fromArray([]),
4968− es);
4969− };
4970− var consRight = F2(function (e,
4971− vs) {
4972− return function () {
4973− switch (e.ctor)
4974− {case "Left": return vs;
4975− case "Right": return {ctor: "::"
4976− ,_0: e._0
4977− ,_1: vs};}
4978− _E.Case($moduleName,
4979− "between lines 83 and 85");
4980− }();
4981− });
4982− var rights = function (es) {
4983− return A3(List.foldr,
4984− consRight,
4985− _L.fromArray([]),
4986− es);
4987− };
4988− var consEither = F2(function (e,
4989− _v13) {
4990− return function () {
4991− switch (_v13.ctor)
4992− {case "_Tuple2":
4993− return function () {
4994− switch (e.ctor)
4995− {case "Left":
4996− return {ctor: "_Tuple2"
4997− ,_0: {ctor: "::"
4998− ,_0: e._0
4999− ,_1: _v13._0}
5000− ,_1: _v13._1};
5001− case "Right":
5002− return {ctor: "_Tuple2"
5003− ,_0: _v13._0
5004− ,_1: {ctor: "::"
5005− ,_0: e._0
5006− ,_1: _v13._1}};}
5007− _E.Case($moduleName,
5008− "between lines 88 and 90");
5009− }();}
5010− _E.Case($moduleName,
5011− "between lines 88 and 90");
5012− }();
5013− });
5014− var partition = function (es) {
5015− return A3(List.foldr,
5016− consEither,
5017− {ctor: "_Tuple2"
5018− ,_0: _L.fromArray([])
5019− ,_1: _L.fromArray([])},
5020− es);
5021− };
5022− _elm.Either.values = {_op: _op
5023− ,either: either
5024− ,isLeft: isLeft
5025− ,isRight: isRight
5026− ,lefts: lefts
5027− ,rights: rights
5028− ,partition: partition
5029− ,consLeft: consLeft
5030− ,consRight: consRight
5031− ,consEither: consEither
5032− ,Left: Left
5033− ,Right: Right};
5034− return _elm.Either.values;
5035−};Elm.Transform2D = Elm.Transform2D || {};
5036−Elm.Transform2D.make = function (_elm) {
5037− "use strict";
5038− _elm.Transform2D = _elm.Transform2D || {};
5039− if (_elm.Transform2D.values)
5040− return _elm.Transform2D.values;
5041− var _N = Elm.Native,
5042− _U = _N.Utils.make(_elm),
5043− _L = _N.List.make(_elm),
5044− _E = _N.Error.make(_elm),
5045− $moduleName = "Transform2D";
5046− var Native = Native || {};
5047− Native.Transform2D = Elm.Native.Transform2D.make(_elm);
5048− var _op = {};
5049− var multiply = Native.Transform2D.multiply;
5050− var rotation = Native.Transform2D.rotation;
5051− var matrix = Native.Transform2D.matrix;
5052− var translation = F2(function (x,
5053− y) {
5054− return A6(matrix,
5055− 1,
5056− 0,
5057− 0,
5058− 1,
5059− x,
5060− y);
5061− });
5062− var scale = function (s) {
5063− return A6(matrix,
5064− s,
5065− 0,
5066− 0,
5067− s,
5068− 0,
5069− 0);
5070− };
5071− var scaleX = function (x) {
5072− return A6(matrix,
5073− x,
5074− 0,
5075− 0,
5076− 1,
5077− 0,
5078− 0);
5079− };
5080− var scaleY = function (y) {
5081− return A6(matrix,
5082− 1,
5083− 0,
5084− 0,
5085− y,
5086− 0,
5087− 0);
5088− };
5089− var identity = Native.Transform2D.identity;
5090− var Transform2D = {ctor: "Transform2D"};
5091− _elm.Transform2D.values = {_op: _op
5092− ,identity: identity
5093− ,matrix: matrix
5094− ,rotation: rotation
5095− ,translation: translation
5096− ,scale: scale
5097− ,scaleX: scaleX
5098− ,scaleY: scaleY
5099− ,multiply: multiply
5100− ,Transform2D: Transform2D};
5101− return _elm.Transform2D.values;
5102−};Elm.Basics = Elm.Basics || {};
5103−Elm.Basics.make = function (_elm) {
5104− "use strict";
5105− _elm.Basics = _elm.Basics || {};
5106− if (_elm.Basics.values)
5107− return _elm.Basics.values;
5108− var _N = Elm.Native,
5109− _U = _N.Utils.make(_elm),
5110− _L = _N.List.make(_elm),
5111− _E = _N.Error.make(_elm),
5112− $moduleName = "Basics";
5113− var Native = Native || {};
5114− Native.Basics = Elm.Native.Basics.make(_elm);
5115− var _op = {};
5116− var uncurry = F2(function (f,
5117− _v0) {
5118− return function () {
5119− switch (_v0.ctor)
5120− {case "_Tuple2": return A2(f,
5121− _v0._0,
5122− _v0._1);}
5123− _E.Case($moduleName,
5124− "on line 381, column 19 to 24");
5125− }();
5126− });
5127− var curry = F3(function (f,
5128− a,
5129− b) {
5130− return f({ctor: "_Tuple2"
5131− ,_0: a
5132− ,_1: b});
5133− });
5134− var flip = F3(function (f,b,a) {
5135− return A2(f,a,b);
5136− });
5137− var snd = function (_v4) {
5138− return function () {
5139− switch (_v4.ctor)
5140− {case "_Tuple2": return _v4._1;}
5141− _E.Case($moduleName,
5142− "on line 365, column 13 to 14");
5143− }();
5144− };
5145− var fst = function (_v8) {
5146− return function () {
5147− switch (_v8.ctor)
5148− {case "_Tuple2": return _v8._0;}
5149− _E.Case($moduleName,
5150− "on line 361, column 13 to 14");
5151− }();
5152− };
5153− var always = F2(function (a,
5154− _v12) {
5155− return function () {
5156− return a;
5157− }();
5158− });
5159− var id = function (x) {
5160− return x;
5161− };
5162− _op["<|"] = F2(function (f,x) {
5163− return f(x);
5164− });
5165− _op["|>"] = F2(function (x,f) {
5166− return f(x);
5167− });
5168− _op["."] = F3(function (f,g,x) {
5169− return f(g(x));
5170− });
5171− var isInfinite = Native.Basics.isInfinite;
5172− var isNaN = Native.Basics.isNaN;
5173− var toFloat = Native.Basics.toFloat;
5174− var ceiling = Native.Basics.ceiling;
5175− var floor = Native.Basics.floor;
5176− var truncate = Native.Basics.truncate;
5177− var round = Native.Basics.round;
5178− var otherwise = true;
5179− var not = Native.Basics.not;
5180− var xor = Native.Basics.xor;
5181− _op["||"] = Native.Basics.or;
5182− _op["&&"] = Native.Basics.and;
5183− var max = Native.Basics.max;
5184− var min = Native.Basics.min;
5185− var GT = {ctor: "GT"};
5186− var EQ = {ctor: "EQ"};
5187− var LT = {ctor: "LT"};
5188− var compare = Native.Basics.compare;
5189− _op[">="] = Native.Basics.ge;
5190− _op["<="] = Native.Basics.le;
5191− _op[">"] = Native.Basics.gt;
5192− _op["<"] = Native.Basics.lt;
5193− _op["/="] = Native.Basics.neq;
5194− _op["=="] = Native.Basics.eq;
5195− var e = Native.Basics.e;
5196− var pi = Native.Basics.pi;
5197− var clamp = Native.Basics.clamp;
5198− var logBase = Native.Basics.logBase;
5199− var abs = Native.Basics.abs;
5200− var sqrt = Native.Basics.sqrt;
5201− var atan2 = Native.Basics.atan2;
5202− var atan = Native.Basics.atan;
5203− var asin = Native.Basics.asin;
5204− var acos = Native.Basics.acos;
5205− var tan = Native.Basics.tan;
5206− var sin = Native.Basics.sin;
5207− var cos = Native.Basics.cos;
5208− _op["^"] = Native.Basics.exp;
5209− var mod = Native.Basics.mod;
5210− var rem = Native.Basics.rem;
5211− var div = Native.Basics.div;
5212− _op["/"] = Native.Basics.floatDiv;
5213− _op["*"] = Native.Basics.mul;
5214− _op["-"] = Native.Basics.sub;
5215− _op["+"] = Native.Basics.add;
5216− var toPolar = function (_v14) {
5217− return function () {
5218− switch (_v14.ctor)
5219− {case "_Tuple2":
5220− return {ctor: "_Tuple2"
5221− ,_0: Native.Basics.sqrt(Math.pow(_v14._0,
5222− 2) + Math.pow(_v14._1,2))
5223− ,_1: A2(Native.Basics.atan2,
5224− _v14._1,
5225− _v14._0)};}
5226− _E.Case($moduleName,
5227− "on line 79, column 18 to 73");
5228− }();
5229− };
5230− var fromPolar = function (_v18) {
5231− return function () {
5232− switch (_v18.ctor)
5233− {case "_Tuple2":
5234− return {ctor: "_Tuple2"
5235− ,_0: _v18._0 * Native.Basics.cos(_v18._1)
5236− ,_1: _v18._0 * Native.Basics.sin(_v18._1)};}
5237− _E.Case($moduleName,
5238− "on line 73, column 20 to 68");
5239− }();
5240− };
5241− var turns = function (r) {
5242− return 2 * Native.Basics.pi * r;
5243− };
5244− var degrees = function (d) {
5245− return d * Native.Basics.pi / 180;
5246− };
5247− var radians = function (t) {
5248− return t;
5249− };
5250− _elm.Basics.values = {_op: _op
5251− ,radians: radians
5252− ,degrees: degrees
5253− ,turns: turns
5254− ,fromPolar: fromPolar
5255− ,toPolar: toPolar
5256− ,div: div
5257− ,rem: rem
5258− ,mod: mod
5259− ,cos: cos
5260− ,sin: sin
5261− ,tan: tan
5262− ,acos: acos
5263− ,asin: asin
5264− ,atan: atan
5265− ,atan2: atan2
5266− ,sqrt: sqrt
5267− ,abs: abs
5268− ,logBase: logBase
5269− ,clamp: clamp
5270− ,pi: pi
5271− ,e: e
5272− ,compare: compare
5273− ,min: min
5274− ,max: max
5275− ,xor: xor
5276− ,not: not
5277− ,otherwise: otherwise
5278− ,round: round
5279− ,truncate: truncate
5280− ,floor: floor
5281− ,ceiling: ceiling
5282− ,toFloat: toFloat
5283− ,isNaN: isNaN
5284− ,isInfinite: isInfinite
5285− ,id: id
5286− ,always: always
5287− ,fst: fst
5288− ,snd: snd
5289− ,flip: flip
5290− ,curry: curry
5291− ,uncurry: uncurry
5292− ,LT: LT
5293− ,EQ: EQ
5294− ,GT: GT};
5295− return _elm.Basics.values;
5296−};Elm.Date = Elm.Date || {};
5297−Elm.Date.make = function (_elm) {
5298− "use strict";
5299− _elm.Date = _elm.Date || {};
5300− if (_elm.Date.values)
5301− return _elm.Date.values;
5302− var _N = Elm.Native,
5303− _U = _N.Utils.make(_elm),
5304− _L = _N.List.make(_elm),
5305− _E = _N.Error.make(_elm),
5306− $moduleName = "Date";
5307− var Maybe = Elm.Maybe.make(_elm);
5308− var Native = Native || {};
5309− Native.Date = Elm.Native.Date.make(_elm);
5310− var Time = Elm.Time.make(_elm);
5311− var _op = {};
5312− var second = Native.Date.second;
5313− var minute = Native.Date.minute;
5314− var hour = Native.Date.hour;
5315− var dayOfWeek = Native.Date.dayOfWeek;
5316− var day = Native.Date.day;
5317− var month = Native.Date.month;
5318− var year = Native.Date.year;
5319− var fromTime = Native.Date.fromTime;
5320− var toTime = Native.Date.toTime;
5321− var read = Native.Date.read;
5322− var Dec = {ctor: "Dec"};
5323− var Nov = {ctor: "Nov"};
5324− var Oct = {ctor: "Oct"};
5325− var Sep = {ctor: "Sep"};
5326− var Aug = {ctor: "Aug"};
5327− var Jul = {ctor: "Jul"};
5328− var Jun = {ctor: "Jun"};
5329− var May = {ctor: "May"};
5330− var Apr = {ctor: "Apr"};
5331− var Mar = {ctor: "Mar"};
5332− var Feb = {ctor: "Feb"};
5333− var Jan = {ctor: "Jan"};
5334− var Sun = {ctor: "Sun"};
5335− var Sat = {ctor: "Sat"};
5336− var Fri = {ctor: "Fri"};
5337− var Thu = {ctor: "Thu"};
5338− var Wed = {ctor: "Wed"};
5339− var Tue = {ctor: "Tue"};
5340− var Mon = {ctor: "Mon"};
5341− var Date = {ctor: "Date"};
5342− _elm.Date.values = {_op: _op
5343− ,read: read
5344− ,toTime: toTime
5345− ,fromTime: fromTime
5346− ,year: year
5347− ,month: month
5348− ,day: day
5349− ,dayOfWeek: dayOfWeek
5350− ,hour: hour
5351− ,minute: minute
5352− ,second: second
5353− ,Date: Date
5354− ,Mon: Mon
5355− ,Tue: Tue
5356− ,Wed: Wed
5357− ,Thu: Thu
5358− ,Fri: Fri
5359− ,Sat: Sat
5360− ,Sun: Sun
5361− ,Jan: Jan
5362− ,Feb: Feb
5363− ,Mar: Mar
5364− ,Apr: Apr
5365− ,May: May
5366− ,Jun: Jun
5367− ,Jul: Jul
5368− ,Aug: Aug
5369− ,Sep: Sep
5370− ,Oct: Oct
5371− ,Nov: Nov
5372− ,Dec: Dec};
5373− return _elm.Date.values;
5374−};Elm.Debug = Elm.Debug || {};
5375−Elm.Debug.make = function (_elm) {
5376− "use strict";
5377− _elm.Debug = _elm.Debug || {};
5378− if (_elm.Debug.values)
5379− return _elm.Debug.values;
5380− var _N = Elm.Native,
5381− _U = _N.Utils.make(_elm),
5382− _L = _N.List.make(_elm),
5383− _E = _N.Error.make(_elm),
5384− $moduleName = "Debug";
5385− var Native = Native || {};
5386− Native.Debug = Elm.Native.Debug.make(_elm);
5387− var _op = {};
5388− var log = Native.Debug.log;
5389− _elm.Debug.values = {_op: _op
5390− ,log: log};
5391− return _elm.Debug.values;
5392−};Elm.Http = Elm.Http || {};
5393−Elm.Http.make = function (_elm) {
5394− "use strict";
5395− _elm.Http = _elm.Http || {};
5396− if (_elm.Http.values)
5397− return _elm.Http.values;
5398− var _N = Elm.Native,
5399− _U = _N.Utils.make(_elm),
5400− _L = _N.List.make(_elm),
5401− _E = _N.Error.make(_elm),
5402− $moduleName = "Http";
5403− var Native = Native || {};
5404− Native.Http = Elm.Native.Http.make(_elm);
5405− var Signal = Elm.Signal.make(_elm);
5406− var _op = {};
5407− var send = Native.Http.send;
5408− var Request = F4(function (a,
5409− b,
5410− c,
5411− d) {
5412− return {_: {}
5413− ,body: c
5414− ,headers: d
5415− ,url: b
5416− ,verb: a};
5417− });
5418− var request = Request;
5419− var get = function (url) {
5420− return A4(Request,
5421− "GET",
5422− url,
5423− "",
5424− _L.fromArray([]));
5425− };
5426− var sendGet = function (reqs) {
5427− return send(A2(Signal.lift,
5428− get,
5429− reqs));
5430− };
5431− var post = F2(function (url,
5432− body) {
5433− return A4(Request,
5434− "POST",
5435− url,
5436− body,
5437− _L.fromArray([]));
5438− });
5439− var Failure = F2(function (a,
5440− b) {
5441− return {ctor: "Failure"
5442− ,_0: a
5443− ,_1: b};
5444− });
5445− var Waiting = {ctor: "Waiting"};
5446− var Success = function (a) {
5447− return {ctor: "Success"
5448− ,_0: a};
5449− };
5450− _elm.Http.values = {_op: _op
5451− ,request: request
5452− ,get: get
5453− ,post: post
5454− ,send: send
5455− ,sendGet: sendGet
5456− ,Success: Success
5457− ,Waiting: Waiting
5458− ,Failure: Failure
5459− ,Request: Request};
5460− return _elm.Http.values;
5461−};Elm.Text = Elm.Text || {};
5462−Elm.Text.make = function (_elm) {
5463− "use strict";
5464− _elm.Text = _elm.Text || {};
5465− if (_elm.Text.values)
5466− return _elm.Text.values;
5467− var _N = Elm.Native,
5468− _U = _N.Utils.make(_elm),
5469− _L = _N.List.make(_elm),
5470− _E = _N.Error.make(_elm),
5471− $moduleName = "Text";
5472− var Basics = Elm.Basics.make(_elm);
5473− var Color = Elm.Color.make(_elm);
5474− var Graphics = Graphics || {};
5475− Graphics.Element = Elm.Graphics.Element.make(_elm);
5476− var Maybe = Elm.Maybe.make(_elm);
5477− var Native = Native || {};
5478− Native.Show = Elm.Native.Show.make(_elm);
5479− var Native = Native || {};
5480− Native.Text = Elm.Native.Text.make(_elm);
5481− var String = Elm.String.make(_elm);
5482− var _op = {};
5483− var markdown = Native.Text.markdown;
5484− var justified = Native.Text.justified;
5485− var centered = Native.Text.centered;
5486− var rightAligned = Native.Text.rightAligned;
5487− var leftAligned = Native.Text.leftAligned;
5488− var line = Native.Text.line;
5489− var italic = Native.Text.italic;
5490− var bold = Native.Text.bold;
5491− var color = Native.Text.color;
5492− var height = Native.Text.height;
5493− var link = Native.Text.link;
5494− var monospace = Native.Text.monospace;
5495− var typeface = Native.Text.typeface;
5496− var style = Native.Text.style;
5497− var toText = Native.Text.toText;
5498− var plainText = function (str) {
5499− return leftAligned(toText(str));
5500− };
5501− var asText = function (value) {
5502− return leftAligned(monospace(toText(Native.Show.show(value))));
5503− };
5504− var defaultStyle = {_: {}
5505− ,bold: false
5506− ,color: Color.black
5507− ,height: Maybe.Nothing
5508− ,italic: false
5509− ,line: Maybe.Nothing
5510− ,typeface: _L.fromArray([])};
5511− var Style = F6(function (a,
5512− b,
5513− c,
5514− d,
5515− e,
5516− f) {
5517− return {_: {}
5518− ,bold: d
5519− ,color: c
5520− ,height: b
5521− ,italic: e
5522− ,line: f
5523− ,typeface: a};
5524− });
5525− var Through = {ctor: "Through"};
5526− var Over = {ctor: "Over"};
5527− var Under = {ctor: "Under"};
5528− var Text = {ctor: "Text"};
5529− _elm.Text.values = {_op: _op
5530− ,defaultStyle: defaultStyle
5531− ,toText: toText
5532− ,style: style
5533− ,typeface: typeface
5534− ,monospace: monospace
5535− ,link: link
5536− ,height: height
5537− ,color: color
5538− ,bold: bold
5539− ,italic: italic
5540− ,line: line
5541− ,leftAligned: leftAligned
5542− ,rightAligned: rightAligned
5543− ,centered: centered
5544− ,justified: justified
5545− ,plainText: plainText
5546− ,markdown: markdown
5547− ,asText: asText
5548− ,Text: Text
5549− ,Under: Under
5550− ,Over: Over
5551− ,Through: Through
5552− ,Style: Style};
5553− return _elm.Text.values;
5554−};Elm.Json = Elm.Json || {};
5555−Elm.Json.make = function (_elm) {
5556− "use strict";
5557− _elm.Json = _elm.Json || {};
5558− if (_elm.Json.values)
5559− return _elm.Json.values;
5560− var _N = Elm.Native,
5561− _U = _N.Utils.make(_elm),
5562− _L = _N.List.make(_elm),
5563− _E = _N.Error.make(_elm),
5564− $moduleName = "Json";
5565− var Dict = Elm.Dict.make(_elm);
5566− var Maybe = Elm.Maybe.make(_elm);
5567− var Native = Native || {};
5568− Native.Json = Elm.Native.Json.make(_elm);
5569− var _op = {};
5570− var fromString = function (str) {
5571− return Native.Json.fromString(str);
5572− };
5573− var toString = F2(function (sep,
5574− value) {
5575− return A2(Native.Json.toString,
5576− sep,
5577− value);
5578− });
5579− var Object = function (a) {
5580− return {ctor: "Object"
5581− ,_0: a};
5582− };
5583− var Array = function (a) {
5584− return {ctor: "Array",_0: a};
5585− };
5586− var Null = {ctor: "Null"};
5587− var Boolean = function (a) {
5588− return {ctor: "Boolean"
5589− ,_0: a};
5590− };
5591− var Number = function (a) {
5592− return {ctor: "Number"
5593− ,_0: a};
5594− };
5595− var String = function (a) {
5596− return {ctor: "String"
5597− ,_0: a};
5598− };
5599− _elm.Json.values = {_op: _op
5600− ,toString: toString
5601− ,fromString: fromString
5602− ,String: String
5603− ,Number: Number
5604− ,Boolean: Boolean
5605− ,Null: Null
5606− ,Array: Array
5607− ,Object: Object};
5608− return _elm.Json.values;
5609−};Elm.String = Elm.String || {};
5610−Elm.String.make = function (_elm) {
5611− "use strict";
5612− _elm.String = _elm.String || {};
5613− if (_elm.String.values)
5614− return _elm.String.values;
5615− var _N = Elm.Native,
5616− _U = _N.Utils.make(_elm),
5617− _L = _N.List.make(_elm),
5618− _E = _N.Error.make(_elm),
5619− $moduleName = "String";
5620− var Maybe = Elm.Maybe.make(_elm);
5621− var Native = Native || {};
5622− Native.Show = Elm.Native.Show.make(_elm);
5623− var Native = Native || {};
5624− Native.String = Elm.Native.String.make(_elm);
5625− var _op = {};
5626− var fromList = Native.String.fromList;
5627− var toList = Native.String.toList;
5628− var toFloat = Native.String.toFloat;
5629− var toInt = Native.String.toInt;
5630− var show = Native.Show.show;
5631− var indices = Native.String.indexes;
5632− var indexes = Native.String.indexes;
5633− var endsWith = Native.String.endsWith;
5634− var startsWith = Native.String.startsWith;
5635− var contains = Native.String.contains;
5636− var all = Native.String.all;
5637− var any = Native.String.any;
5638− var toLower = Native.String.toLower;
5639− var toUpper = Native.String.toUpper;
5640− var lines = Native.String.lines;
5641− var words = Native.String.words;
5642− var trimRight = Native.String.trimRight;
5643− var trimLeft = Native.String.trimLeft;
5644− var trim = Native.String.trim;
5645− var padRight = Native.String.padRight;
5646− var padLeft = Native.String.padLeft;
5647− var pad = Native.String.pad;
5648− var dropRight = Native.String.dropRight;
5649− var dropLeft = Native.String.dropLeft;
5650− var right = Native.String.right;
5651− var left = Native.String.left;
5652− var sub = Native.String.sub;
5653− var repeat = Native.String.repeat;
5654− var join = Native.String.join;
5655− var split = Native.String.split;
5656− var foldr = Native.String.foldr;
5657− var foldl = Native.String.foldl;
5658− var reverse = Native.String.reverse;
5659− var filter = Native.String.filter;
5660− var map = Native.String.map;
5661− var length = Native.String.length;
5662− var concat = Native.String.concat;
5663− var append = Native.String.append;
5664− var uncons = Native.String.uncons;
5665− var cons = Native.String.cons;
5666− var isEmpty = Native.String.isEmpty;
5667− _elm.String.values = {_op: _op
5668− ,isEmpty: isEmpty
5669− ,cons: cons
5670− ,uncons: uncons
5671− ,append: append
5672− ,concat: concat
5673− ,length: length
5674− ,map: map
5675− ,filter: filter
5676− ,reverse: reverse
5677− ,foldl: foldl
5678− ,foldr: foldr
5679− ,split: split
5680− ,join: join
5681− ,repeat: repeat
5682− ,sub: sub
5683− ,left: left
5684− ,right: right
5685− ,dropLeft: dropLeft
5686− ,dropRight: dropRight
5687− ,pad: pad
5688− ,padLeft: padLeft
5689− ,padRight: padRight
5690− ,trim: trim
5691− ,trimLeft: trimLeft
5692− ,trimRight: trimRight
5693− ,words: words
5694− ,lines: lines
5695− ,toUpper: toUpper
5696− ,toLower: toLower
5697− ,any: any
5698− ,all: all
5699− ,contains: contains
5700− ,startsWith: startsWith
5701− ,endsWith: endsWith
5702− ,indexes: indexes
5703− ,indices: indices
5704− ,show: show
5705− ,toInt: toInt
5706− ,toFloat: toFloat
5707− ,toList: toList
5708− ,fromList: fromList};
5709− return _elm.String.values;
5710−};Elm.Window = Elm.Window || {};
5711−Elm.Window.make = function (_elm) {
5712− "use strict";
5713− _elm.Window = _elm.Window || {};
5714− if (_elm.Window.values)
5715− return _elm.Window.values;
5716− var _N = Elm.Native,
5717− _U = _N.Utils.make(_elm),
5718− _L = _N.List.make(_elm),
5719− _E = _N.Error.make(_elm),
5720− $moduleName = "Window";
5721− var Native = Native || {};
5722− Native.Window = Elm.Native.Window.make(_elm);
5723− var Signal = Elm.Signal.make(_elm);
5724− var _op = {};
5725− var height = Native.Window.height;
5726− var width = Native.Window.width;
5727− var dimensions = Native.Window.dimensions;
5728− _elm.Window.values = {_op: _op
5729− ,dimensions: dimensions
5730− ,width: width
5731− ,height: height};
5732− return _elm.Window.values;
5733−};Elm.Regex = Elm.Regex || {};
5734−Elm.Regex.make = function (_elm) {
5735− "use strict";
5736− _elm.Regex = _elm.Regex || {};
5737− if (_elm.Regex.values)
5738− return _elm.Regex.values;
5739− var _N = Elm.Native,
5740− _U = _N.Utils.make(_elm),
5741− _L = _N.List.make(_elm),
5742− _E = _N.Error.make(_elm),
5743− $moduleName = "Regex";
5744− var Maybe = Elm.Maybe.make(_elm);
5745− var Native = Native || {};
5746− Native.Regex = Elm.Native.Regex.make(_elm);
5747− var _op = {};
5748− var split = Native.Regex.split;
5749− var replace = Native.Regex.replace;
5750− var find = Native.Regex.find;
5751− var AtMost = function (a) {
5752− return {ctor: "AtMost"
5753− ,_0: a};
5754− };
5755− var All = {ctor: "All"};
5756− var Match = F4(function (a,
5757− b,
5758− c,
5759− d) {
5760− return {_: {}
5761− ,index: c
5762− ,match: a
5763− ,number: d
5764− ,submatches: b};
5765− });
5766− var contains = Native.Regex.contains;
5767− var caseInsensitive = Native.Regex.caseInsensitive;
5768− var regex = Native.Regex.regex;
5769− var escape = Native.Regex.escape;
5770− var Regex = {ctor: "Regex"};
5771− _elm.Regex.values = {_op: _op
5772− ,escape: escape
5773− ,regex: regex
5774− ,caseInsensitive: caseInsensitive
5775− ,contains: contains
5776− ,find: find
5777− ,replace: replace
5778− ,split: split
5779− ,Regex: Regex
5780− ,All: All
5781− ,AtMost: AtMost
5782− ,Match: Match};
5783− return _elm.Regex.values;
5784−};Elm.Color = Elm.Color || {};
5785−Elm.Color.make = function (_elm) {
5786− "use strict";
5787− _elm.Color = _elm.Color || {};
5788− if (_elm.Color.values)
5789− return _elm.Color.values;
5790− var _N = Elm.Native,
5791− _U = _N.Utils.make(_elm),
5792− _L = _N.List.make(_elm),
5793− _E = _N.Error.make(_elm),
5794− $moduleName = "Color";
5795− var Basics = Elm.Basics.make(_elm);
5796− var Native = Native || {};
5797− Native.Color = Elm.Native.Color.make(_elm);
5798− var _op = {};
5799− var Radial = F5(function (a,
5800− b,
5801− c,
5802− d,
5803− e) {
5804− return {ctor: "Radial"
5805− ,_0: a
5806− ,_1: b
5807− ,_2: c
5808− ,_3: d
5809− ,_4: e};
5810− });
5811− var radial = Radial;
5812− var Linear = F3(function (a,
5813− b,
5814− c) {
5815− return {ctor: "Linear"
5816− ,_0: a
5817− ,_1: b
5818− ,_2: c};
5819− });
5820− var linear = Linear;
5821− var hsv = Native.Color.hsv;
5822− var hsva = Native.Color.hsva;
5823− var complement = Native.Color.complement;
5824− var greyscale = function (p) {
5825− return A3(hsv,0,0,1 - p);
5826− };
5827− var grayscale = function (p) {
5828− return A3(hsv,0,0,1 - p);
5829− };
5830− var Color = F4(function (a,
5831− b,
5832− c,
5833− d) {
5834− return {ctor: "Color"
5835− ,_0: a
5836− ,_1: b
5837− ,_2: c
5838− ,_3: d};
5839− });
5840− var rgba = Color;
5841− var rgb = F3(function (r,g,b) {
5842− return A4(Color,r,g,b,1);
5843− });
5844− var lightRed = A4(Color,
5845− 239,
5846− 41,
5847− 41,
5848− 1);
5849− var red = A4(Color,204,0,0,1);
5850− var darkRed = A4(Color,
5851− 164,
5852− 0,
5853− 0,
5854− 1);
5855− var lightOrange = A4(Color,
5856− 252,
5857− 175,
5858− 62,
5859− 1);
5860− var orange = A4(Color,
5861− 245,
5862− 121,
5863− 0,
5864− 1);
5865− var darkOrange = A4(Color,
5866− 206,
5867− 92,
5868− 0,
5869− 1);
5870− var lightYellow = A4(Color,
5871− 255,
5872− 233,
5873− 79,
5874− 1);
5875− var yellow = A4(Color,
5876− 237,
5877− 212,
5878− 0,
5879− 1);
5880− var darkYellow = A4(Color,
5881− 196,
5882− 160,
5883− 0,
5884− 1);
5885− var lightGreen = A4(Color,
5886− 138,
5887− 226,
5888− 52,
5889− 1);
5890− var green = A4(Color,
5891− 115,
5892− 210,
5893− 22,
5894− 1);
5895− var darkGreen = A4(Color,
5896− 78,
5897− 154,
5898− 6,
5899− 1);
5900− var lightBlue = A4(Color,
5901− 114,
5902− 159,
5903− 207,
5904− 1);
5905− var blue = A4(Color,
5906− 52,
5907− 101,
5908− 164,
5909− 1);
5910− var darkBlue = A4(Color,
5911− 32,
5912− 74,
5913− 135,
5914− 1);
5915− var lightPurple = A4(Color,
5916− 173,
5917− 127,
5918− 168,
5919− 1);
5920− var purple = A4(Color,
5921− 117,
5922− 80,
5923− 123,
5924− 1);
5925− var darkPurple = A4(Color,
5926− 92,
5927− 53,
5928− 102,
5929− 1);
5930− var lightBrown = A4(Color,
5931− 233,
5932− 185,
5933− 110,
5934− 1);
5935− var brown = A4(Color,
5936− 193,
5937− 125,
5938− 17,
5939− 1);
5940− var darkBrown = A4(Color,
5941− 143,
5942− 89,
5943− 2,
5944− 1);
5945− var black = A4(Color,0,0,0,1);
5946− var white = A4(Color,
5947− 255,
5948− 255,
5949− 255,
5950− 1);
5951− var lightGrey = A4(Color,
5952− 238,
5953− 238,
5954− 236,
5955− 1);
5956− var grey = A4(Color,
5957− 211,
5958− 215,
5959− 207,
5960− 1);
5961− var darkGrey = A4(Color,
5962− 186,
5963− 189,
5964− 182,
5965− 1);
5966− var lightGray = A4(Color,
5967− 238,
5968− 238,
5969− 236,
5970− 1);
5971− var gray = A4(Color,
5972− 211,
5973− 215,
5974− 207,
5975− 1);
5976− var darkGray = A4(Color,
5977− 186,
5978− 189,
5979− 182,
5980− 1);
5981− var lightCharcoal = A4(Color,
5982− 136,
5983− 138,
5984− 133,
5985− 1);
5986− var charcoal = A4(Color,
5987− 85,
5988− 87,
5989− 83,
5990− 1);
5991− var darkCharcoal = A4(Color,
5992− 46,
5993− 52,
5994− 54,
5995− 1);
5996− _elm.Color.values = {_op: _op
5997− ,rgba: rgba
5998− ,rgb: rgb
5999− ,lightRed: lightRed
6000− ,red: red
6001− ,darkRed: darkRed
6002− ,lightOrange: lightOrange
6003− ,orange: orange
6004− ,darkOrange: darkOrange
6005− ,lightYellow: lightYellow
6006− ,yellow: yellow
6007− ,darkYellow: darkYellow
6008− ,lightGreen: lightGreen
6009− ,green: green
6010− ,darkGreen: darkGreen
6011− ,lightBlue: lightBlue
6012− ,blue: blue
6013− ,darkBlue: darkBlue
6014− ,lightPurple: lightPurple
6015− ,purple: purple
6016− ,darkPurple: darkPurple
6017− ,lightBrown: lightBrown
6018− ,brown: brown
6019− ,darkBrown: darkBrown
6020− ,black: black
6021− ,white: white
6022− ,lightGrey: lightGrey
6023− ,grey: grey
6024− ,darkGrey: darkGrey
6025− ,lightGray: lightGray
6026− ,gray: gray
6027− ,darkGray: darkGray
6028− ,lightCharcoal: lightCharcoal
6029− ,charcoal: charcoal
6030− ,darkCharcoal: darkCharcoal
6031− ,grayscale: grayscale
6032− ,greyscale: greyscale
6033− ,complement: complement
6034− ,hsva: hsva
6035− ,hsv: hsv
6036− ,linear: linear
6037− ,radial: radial
6038− ,Color: Color
6039− ,Linear: Linear
6040− ,Radial: Radial};
6041− return _elm.Color.values;
6042−};Elm.Maybe = Elm.Maybe || {};
6043−Elm.Maybe.make = function (_elm) {
6044− "use strict";
6045− _elm.Maybe = _elm.Maybe || {};
6046− if (_elm.Maybe.values)
6047− return _elm.Maybe.values;
6048− var _N = Elm.Native,
6049− _U = _N.Utils.make(_elm),
6050− _L = _N.List.make(_elm),
6051− _E = _N.Error.make(_elm),
6052− $moduleName = "Maybe";
6053− var Basics = Elm.Basics.make(_elm);
6054− var List = Elm.List.make(_elm);
6055− var _op = {};
6056− var Nothing = {ctor: "Nothing"};
6057− var Just = function (a) {
6058− return {ctor: "Just",_0: a};
6059− };
6060− var maybe = F3(function (b,
6061− f,
6062− m) {
6063− return function () {
6064− switch (m.ctor)
6065− {case "Just": return f(m._0);
6066− case "Nothing": return b;}
6067− _E.Case($moduleName,
6068− "between lines 35 and 44");
6069− }();
6070− });
6071− var isJust = A2(maybe,
6072− false,
6073− function (_v2) {
6074− return function () {
6075− return true;
6076− }();
6077− });
6078− var isNothing = function ($) {
6079− return Basics.not(isJust($));
6080− };
6081− var cons = F2(function (mx,xs) {
6082− return A3(maybe,
6083− xs,
6084− function (x) {
6085− return {ctor: "::"
6086− ,_0: x
6087− ,_1: xs};
6088− },
6089− mx);
6090− });
6091− var justs = A2(List.foldr,
6092− cons,
6093− _L.fromArray([]));
6094− _elm.Maybe.values = {_op: _op
6095− ,maybe: maybe
6096− ,isJust: isJust
6097− ,isNothing: isNothing
6098− ,cons: cons
6099− ,justs: justs
6100− ,Just: Just
6101− ,Nothing: Nothing};
6102− return _elm.Maybe.values;
6103−};Elm.Touch = Elm.Touch || {};
6104−Elm.Touch.make = function (_elm) {
6105− "use strict";
6106− _elm.Touch = _elm.Touch || {};
6107− if (_elm.Touch.values)
6108− return _elm.Touch.values;
6109− var _N = Elm.Native,
6110− _U = _N.Utils.make(_elm),
6111− _L = _N.List.make(_elm),
6112− _E = _N.Error.make(_elm),
6113− $moduleName = "Touch";
6114− var Native = Native || {};
6115− Native.Touch = Elm.Native.Touch.make(_elm);
6116− var Signal = Elm.Signal.make(_elm);
6117− var Time = Elm.Time.make(_elm);
6118− var _op = {};
6119− var taps = Native.Touch.taps;
6120− var touches = Native.Touch.touches;
6121− var Touch = F6(function (a,
6122− b,
6123− c,
6124− d,
6125− e,
6126− f) {
6127− return {_: {}
6128− ,id: c
6129− ,t0: f
6130− ,x: a
6131− ,x0: d
6132− ,y: b
6133− ,y0: e};
6134− });
6135− _elm.Touch.values = {_op: _op
6136− ,touches: touches
6137− ,taps: taps
6138− ,Touch: Touch};
6139− return _elm.Touch.values;
6140−};Elm.Mouse = Elm.Mouse || {};
6141−Elm.Mouse.make = function (_elm) {
6142− "use strict";
6143− _elm.Mouse = _elm.Mouse || {};
6144− if (_elm.Mouse.values)
6145− return _elm.Mouse.values;
6146− var _N = Elm.Native,
6147− _U = _N.Utils.make(_elm),
6148− _L = _N.List.make(_elm),
6149− _E = _N.Error.make(_elm),
6150− $moduleName = "Mouse";
6151− var Native = Native || {};
6152− Native.Mouse = Elm.Native.Mouse.make(_elm);
6153− var Signal = Elm.Signal.make(_elm);
6154− var _op = {};
6155− var clicks = Native.Mouse.clicks;
6156− var isDown = Native.Mouse.isDown;
6157− var y = Native.Mouse.y;
6158− var x = Native.Mouse.x;
6159− var position = Native.Mouse.position;
6160− _elm.Mouse.values = {_op: _op
6161− ,position: position
6162− ,x: x
6163− ,y: y
6164− ,isDown: isDown
6165− ,clicks: clicks};
6166− return _elm.Mouse.values;
6167−};Elm.Array = Elm.Array || {};
6168−Elm.Array.make = function (_elm) {
6169− "use strict";
6170− _elm.Array = _elm.Array || {};
6171− if (_elm.Array.values)
6172− return _elm.Array.values;
6173− var _N = Elm.Native,
6174− _U = _N.Utils.make(_elm),
6175− _L = _N.List.make(_elm),
6176− _E = _N.Error.make(_elm),
6177− $moduleName = "Array";
6178− var Basics = Elm.Basics.make(_elm);
6179− var List = Elm.List.make(_elm);
6180− var Maybe = Elm.Maybe.make(_elm);
6181− var Native = Native || {};
6182− Native.Array = Elm.Native.Array.make(_elm);
6183− var _op = {};
6184− var concat = Native.Array.concat;
6185− var length = Native.Array.length;
6186− var slice = Native.Array.slice;
6187− var updates = F2(function (us,
6188− array) {
6189− return A3(List.foldl,
6190− Basics.uncurry(Native.Array.set),
6191− array,
6192− us);
6193− });
6194− var set = Native.Array.set;
6195− var getSafe = F3(function ($default,
6196− i,
6197− array) {
6198− return _U.cmp(Native.Array.length(array),
6199− i) > 0 ? A2(Native.Array.get,
6200− i,
6201− array) : $default;
6202− });
6203− var getMaybe = F2(function (i,
6204− array) {
6205− return _U.cmp(Native.Array.length(array),
6206− i) > 0 ? Maybe.Just(A2(Native.Array.get,
6207− i,
6208− array)) : Maybe.Nothing;
6209− });
6210− var get = Native.Array.get;
6211− var push = Native.Array.push;
6212− var empty = Native.Array.empty;
6213− var foldr = Native.Array.foldr;
6214− var foldl = Native.Array.foldl;
6215− var indexedMap = Native.Array.indexedMap;
6216− var map = Native.Array.map;
6217− var indices = function (a) {
6218− return _L.range(0,
6219− Native.Array.length(a) - 1);
6220− };
6221− var toIndexedList = function (a) {
6222− return A2(List.zip,
6223− indices(a),
6224− Native.Array.toList(a));
6225− };
6226− var toList = Native.Array.toList;
6227− var fromList = A2(List.foldl,
6228− Native.Array.push,
6229− Native.Array.empty);
6230− var zipWith = F3(function (f,
6231− a,
6232− b) {
6233− return fromList(A3(List.zipWith,
6234− f,
6235− Native.Array.toList(a),
6236− Native.Array.toList(b)));
6237− });
6238− var zip = zipWith(F2(function (v0,
6239− v1) {
6240− return {ctor: "_Tuple2"
6241− ,_0: v0
6242− ,_1: v1};
6243− }));
6244− var fill = F2(function (len,e) {
6245− return fromList(A2(List.map,
6246− Basics.always(e),
6247− _L.range(1,len)));
6248− });
6249− var Array = {ctor: "Array"};
6250− _elm.Array.values = {_op: _op
6251− ,fill: fill
6252− ,fromList: fromList
6253− ,toList: toList
6254− ,indices: indices
6255− ,toIndexedList: toIndexedList
6256− ,map: map
6257− ,indexedMap: indexedMap
6258− ,foldl: foldl
6259− ,foldr: foldr
6260− ,zip: zip
6261− ,zipWith: zipWith
6262− ,empty: empty
6263− ,push: push
6264− ,get: get
6265− ,getMaybe: getMaybe
6266− ,getSafe: getSafe
6267− ,set: set
6268− ,updates: updates
6269− ,slice: slice
6270− ,length: length
6271− ,concat: concat
6272− ,Array: Array};
6273− return _elm.Array.values;
6274−};Elm.Trampoline = Elm.Trampoline || {};
6275−Elm.Trampoline.make = function (_elm) {
6276− "use strict";
6277− _elm.Trampoline = _elm.Trampoline || {};
6278− if (_elm.Trampoline.values)
6279− return _elm.Trampoline.values;
6280− var _N = Elm.Native,
6281− _U = _N.Utils.make(_elm),
6282− _L = _N.List.make(_elm),
6283− _E = _N.Error.make(_elm),
6284− $moduleName = "Trampoline";
6285− var Native = Native || {};
6286− Native.Trampoline = Elm.Native.Trampoline.make(_elm);
6287− var _op = {};
6288− var trampoline = Native.Trampoline.trampoline;
6289− var Continue = function (a) {
6290− return {ctor: "Continue"
6291− ,_0: a};
6292− };
6293− var Done = function (a) {
6294− return {ctor: "Done",_0: a};
6295− };
6296− _elm.Trampoline.values = {_op: _op
6297− ,trampoline: trampoline
6298− ,Done: Done
6299− ,Continue: Continue};
6300− return _elm.Trampoline.values;
6301−};Elm.Keyboard = Elm.Keyboard || {};
6302−Elm.Keyboard.make = function (_elm) {
6303− "use strict";
6304− _elm.Keyboard = _elm.Keyboard || {};
6305− if (_elm.Keyboard.values)
6306− return _elm.Keyboard.values;
6307− var _N = Elm.Native,
6308− _U = _N.Utils.make(_elm),
6309− _L = _N.List.make(_elm),
6310− _E = _N.Error.make(_elm),
6311− $moduleName = "Keyboard";
6312− var Native = Native || {};
6313− Native.Keyboard = Elm.Native.Keyboard.make(_elm);
6314− var Signal = Elm.Signal.make(_elm);
6315− var _op = {};
6316− var lastPressed = Native.Keyboard.lastPressed;
6317− var keysDown = Native.Keyboard.keysDown;
6318− var isDown = Native.Keyboard.isDown;
6319− var shift = isDown(16);
6320− var ctrl = isDown(17);
6321− var space = isDown(32);
6322− var enter = isDown(13);
6323− var directions = Native.Keyboard.directions;
6324− var arrows = A4(directions,
6325− 38,
6326− 40,
6327− 37,
6328− 39);
6329− var wasd = A4(directions,
6330− 87,
6331− 83,
6332− 65,
6333− 68);
6334− _elm.Keyboard.values = {_op: _op
6335− ,directions: directions
6336− ,arrows: arrows
6337− ,wasd: wasd
6338− ,isDown: isDown
6339− ,shift: shift
6340− ,ctrl: ctrl
6341− ,space: space
6342− ,enter: enter
6343− ,keysDown: keysDown
6344− ,lastPressed: lastPressed};
6345− return _elm.Keyboard.values;
6346−};Elm.Set = Elm.Set || {};
6347−Elm.Set.make = function (_elm) {
6348− "use strict";
6349− _elm.Set = _elm.Set || {};
6350− if (_elm.Set.values)
6351− return _elm.Set.values;
6352− var _N = Elm.Native,
6353− _U = _N.Utils.make(_elm),
6354− _L = _N.List.make(_elm),
6355− _E = _N.Error.make(_elm),
6356− $moduleName = "Set";
6357− var Dict = Elm.Dict.make(_elm);
6358− var List = Elm.List.make(_elm);
6359− var Maybe = Elm.Maybe.make(_elm);
6360− var _op = {};
6361− var foldr = F3(function (f,
6362− b,
6363− s) {
6364− return A3(Dict.foldr,
6365− F3(function (k,_v0,b) {
6366− return function () {
6367− return A2(f,k,b);
6368− }();
6369− }),
6370− b,
6371− s);
6372− });
6373− var foldl = F3(function (f,
6374− b,
6375− s) {
6376− return A3(Dict.foldl,
6377− F3(function (k,_v2,b) {
6378− return function () {
6379− return A2(f,k,b);
6380− }();
6381− }),
6382− b,
6383− s);
6384− });
6385− var toList = Dict.keys;
6386− var diff = Dict.diff;
6387− var intersect = Dict.intersect;
6388− var union = Dict.union;
6389− var member = Dict.member;
6390− var remove = Dict.remove;
6391− var insert = function (k) {
6392− return A2(Dict.insert,
6393− k,
6394− {ctor: "_Tuple0"});
6395− };
6396− var singleton = function (k) {
6397− return A2(Dict.singleton,
6398− k,
6399− {ctor: "_Tuple0"});
6400− };
6401− var empty = Dict.empty;
6402− var fromList = function (xs) {
6403− return A3(List.foldl,
6404− insert,
6405− empty,
6406− xs);
6407− };
6408− var map = F2(function (f,s) {
6409− return fromList(A2(List.map,
6410− f,
6411− toList(s)));
6412− });
6413− _elm.Set.values = {_op: _op
6414− ,empty: empty
6415− ,singleton: singleton
6416− ,insert: insert
6417− ,remove: remove
6418− ,member: member
6419− ,foldl: foldl
6420− ,foldr: foldr
6421− ,map: map
6422− ,union: union
6423− ,intersect: intersect
6424− ,diff: diff
6425− ,toList: toList
6426− ,fromList: fromList};
6427− return _elm.Set.values;
6428−};Elm.List = Elm.List || {};
6429−Elm.List.make = function (_elm) {
6430− "use strict";
6431− _elm.List = _elm.List || {};
6432− if (_elm.List.values)
6433− return _elm.List.values;
6434− var _N = Elm.Native,
6435− _U = _N.Utils.make(_elm),
6436− _L = _N.List.make(_elm),
6437− _E = _N.Error.make(_elm),
6438− $moduleName = "List";
6439− var Basics = Elm.Basics.make(_elm);
6440− var Native = Native || {};
6441− Native.List = Elm.Native.List.make(_elm);
6442− var _op = {};
6443− var sortWith = Native.List.sortWith;
6444− var sortBy = Native.List.sortBy;
6445− var sort = Native.List.sort;
6446− var repeat = Native.List.repeat;
6447− var drop = Native.List.drop;
6448− var take = Native.List.take;
6449− var join = Native.List.join;
6450− var zipWith = Native.List.zipWith;
6451− var zip = Native.List.zip;
6452− var concat = Native.List.concat;
6453− var any = Native.List.any;
6454− var all = Native.List.all;
6455− var reverse = Native.List.reverse;
6456− var length = Native.List.length;
6457− var filter = Native.List.filter;
6458− var scanl1 = Native.List.scanl1;
6459− var scanl = Native.List.scanl;
6460− var foldr1 = Native.List.foldr1;
6461− var foldl1 = Native.List.foldl1;
6462− var maximum = foldl1(Basics.max);
6463− var minimum = foldl1(Basics.min);
6464− var foldr = Native.List.foldr;
6465− var foldl = Native.List.foldl;
6466− var and = A2(foldl,
6467− F2(function (x,y) {
6468− return x && y;
6469− }),
6470− true);
6471− var or = A2(foldl,
6472− F2(function (x,y) {
6473− return x || y;
6474− }),
6475− false);
6476− var sum = A2(foldl,
6477− F2(function (x,y) {
6478− return x + y;
6479− }),
6480− 0);
6481− var product = A2(foldl,
6482− F2(function (x,y) {
6483− return x * y;
6484− }),
6485− 1);
6486− var map = Native.List.map;
6487− var concatMap = F2(function (f,
6488− list) {
6489− return concat(A2(map,
6490− f,
6491− list));
6492− });
6493− var isEmpty = function (xs) {
6494− return function () {
6495− switch (xs.ctor)
6496− {case "[]": return true;}
6497− return false;
6498− }();
6499− };
6500− var last = Native.List.last;
6501− var tail = Native.List.tail;
6502− var head = Native.List.head;
6503− _op["++"] = Native.List.append;
6504− _op["::"] = Native.List.cons;
6505− var partition = F2(function (pred,
6506− lst) {
6507− return function () {
6508− switch (lst.ctor)
6509− {case "::": return function () {
6510− var $ = A2(partition,
6511− pred,
6512− lst._1),
6513− bs = $._0,
6514− cs = $._1;
6515− return pred(lst._0) ? {ctor: "_Tuple2"
6516− ,_0: {ctor: "::"
6517− ,_0: lst._0
6518− ,_1: bs}
6519− ,_1: cs} : {ctor: "_Tuple2"
6520− ,_0: bs
6521− ,_1: {ctor: "::"
6522− ,_0: lst._0
6523− ,_1: cs}};
6524− }();
6525− case "[]":
6526− return {ctor: "_Tuple2"
6527− ,_0: _L.fromArray([])
6528− ,_1: _L.fromArray([])};}
6529− _E.Case($moduleName,
6530− "between lines 169 and 179");
6531− }();
6532− });
6533− var unzip = function (pairs) {
6534− return function () {
6535− switch (pairs.ctor)
6536− {case "::":
6537− switch (pairs._0.ctor)
6538− {case "_Tuple2":
6539− return function () {
6540− var $ = unzip(pairs._1),
6541− xs = $._0,
6542− ys = $._1;
6543− return {ctor: "_Tuple2"
6544− ,_0: {ctor: "::"
6545− ,_0: pairs._0._0
6546− ,_1: xs}
6547− ,_1: {ctor: "::"
6548− ,_0: pairs._0._1
6549− ,_1: ys}};
6550− }();}
6551− break;
6552− case "[]":
6553− return {ctor: "_Tuple2"
6554− ,_0: _L.fromArray([])
6555− ,_1: _L.fromArray([])};}
6556− _E.Case($moduleName,
6557− "between lines 194 and 202");
6558− }();
6559− };
6560− var intersperse = F2(function (sep,
6561− xs) {
6562− return function () {
6563− switch (xs.ctor)
6564− {case "::": switch (xs._1.ctor)
6565− {case "::": return {ctor: "::"
6566− ,_0: xs._0
6567− ,_1: {ctor: "::"
6568− ,_0: sep
6569− ,_1: A2(intersperse,
6570− sep,
6571− {ctor: "::"
6572− ,_0: xs._1._0
6573− ,_1: xs._1._1})}};
6574− case "[]":
6575− return _L.fromArray([xs._0]);}
6576− break;
6577− case "[]":
6578− return _L.fromArray([]);}
6579− _E.Case($moduleName,
6580− "between lines 212 and 217");
6581− }();
6582− });
6583− _elm.List.values = {_op: _op
6584− ,head: head
6585− ,tail: tail
6586− ,last: last
6587− ,isEmpty: isEmpty
6588− ,map: map
6589− ,foldl: foldl
6590− ,foldr: foldr
6591− ,foldl1: foldl1
6592− ,foldr1: foldr1
6593− ,scanl: scanl
6594− ,scanl1: scanl1
6595− ,filter: filter
6596− ,length: length
6597− ,reverse: reverse
6598− ,all: all
6599− ,any: any
6600− ,and: and
6601− ,or: or
6602− ,concat: concat
6603− ,concatMap: concatMap
6604− ,sum: sum
6605− ,product: product
6606− ,maximum: maximum
6607− ,minimum: minimum
6608− ,partition: partition
6609− ,zip: zip
6610− ,zipWith: zipWith
6611− ,unzip: unzip
6612− ,join: join
6613− ,intersperse: intersperse
6614− ,take: take
6615− ,drop: drop
6616− ,repeat: repeat
6617− ,sort: sort
6618− ,sortBy: sortBy
6619− ,sortWith: sortWith};
6620− return _elm.List.values;
6621−};Elm.JavaScript = Elm.JavaScript || {};
6622−Elm.JavaScript.Experimental = Elm.JavaScript.Experimental || {};
6623−Elm.JavaScript.Experimental.make = function (_elm) {
6624− "use strict";
6625− _elm.JavaScript = _elm.JavaScript || {};
6626− _elm.JavaScript.Experimental = _elm.JavaScript.Experimental || {};
6627− if (_elm.JavaScript.Experimental.values)
6628− return _elm.JavaScript.Experimental.values;
6629− var _N = Elm.Native,
6630− _U = _N.Utils.make(_elm),
6631− _L = _N.List.make(_elm),
6632− _E = _N.Error.make(_elm),
6633− $moduleName = "JavaScript.Experimental";
6634− var Json = Elm.Json.make(_elm);
6635− var Native = Native || {};
6636− Native.JavaScript = Elm.Native.JavaScript.make(_elm);
6637− var _op = {};
6638− var fromJson = Native.Json.toJS;
6639− var toJson = Native.Json.fromJS;
6640− var fromRecord = Native.JavaScript.fromRecord;
6641− var toRecord = Native.JavaScript.toRecord;
6642− var RawObject = {ctor: "RawObject"};
6643− _elm.JavaScript.Experimental.values = {_op: _op
6644− ,toRecord: toRecord
6645− ,fromRecord: fromRecord
6646− ,toJson: toJson
6647− ,fromJson: fromJson
6648− ,RawObject: RawObject};
6649− return _elm.JavaScript.Experimental.values;
6650−};Elm.Graphics = Elm.Graphics || {};
6651−Elm.Graphics.Collage = Elm.Graphics.Collage || {};
6652−Elm.Graphics.Collage.make = function (_elm) {
6653− "use strict";
6654− _elm.Graphics = _elm.Graphics || {};
6655− _elm.Graphics.Collage = _elm.Graphics.Collage || {};
6656− if (_elm.Graphics.Collage.values)
6657− return _elm.Graphics.Collage.values;
6658− var _N = Elm.Native,
6659− _U = _N.Utils.make(_elm),
6660− _L = _N.List.make(_elm),
6661− _E = _N.Error.make(_elm),
6662− $moduleName = "Graphics.Collage";
6663− var Basics = Elm.Basics.make(_elm);
6664− var Color = Elm.Color.make(_elm);
6665− var Either = Elm.Either.make(_elm);
6666− var Graphics = Graphics || {};
6667− Graphics.Element = Elm.Graphics.Element.make(_elm);
6668− var List = Elm.List.make(_elm);
6669− var Maybe = Elm.Maybe.make(_elm);
6670− var Native = Native || {};
6671− Native.Graphics = Native.Graphics || {};
6672− Native.Graphics.Collage = Elm.Native.Graphics.Collage.make(_elm);
6673− var Transform2D = Elm.Transform2D.make(_elm);
6674− var _op = {};
6675− var ngon = F2(function (n,r) {
6676− return function () {
6677− var m = Basics.toFloat(n);
6678− var t = 2 * Basics.pi / m;
6679− var f = function (i) {
6680− return {ctor: "_Tuple2"
6681− ,_0: r * Basics.cos(t * i)
6682− ,_1: r * Basics.sin(t * i)};
6683− };
6684− return A2(List.map,
6685− f,
6686− _L.range(0,m - 1));
6687− }();
6688− });
6689− var oval = F2(function (w,h) {
6690− return function () {
6691− var hh = h / 2;
6692− var hw = w / 2;
6693− var n = 50;
6694− var t = 2 * Basics.pi / n;
6695− var f = function (i) {
6696− return {ctor: "_Tuple2"
6697− ,_0: hw * Basics.cos(t * i)
6698− ,_1: hh * Basics.sin(t * i)};
6699− };
6700− return A2(List.map,
6701− f,
6702− _L.range(0,n - 1));
6703− }();
6704− });
6705− var circle = function (r) {
6706− return A2(oval,2 * r,2 * r);
6707− };
6708− var rect = F2(function (w,h) {
6709− return function () {
6710− var hh = h / 2;
6711− var hw = w / 2;
6712− return _L.fromArray([{ctor: "_Tuple2"
6713− ,_0: 0 - hw
6714− ,_1: 0 - hh}
6715− ,{ctor: "_Tuple2"
6716− ,_0: 0 - hw
6717− ,_1: hh}
6718− ,{ctor: "_Tuple2",_0: hw,_1: hh}
6719− ,{ctor: "_Tuple2"
6720− ,_0: hw
6721− ,_1: 0 - hh}]);
6722− }();
6723− });
6724− var square = function (n) {
6725− return A2(rect,n,n);
6726− };
6727− var polygon = function (points) {
6728− return points;
6729− };
6730− var segment = F2(function (p1,
6731− p2) {
6732− return _L.fromArray([p1,p2]);
6733− });
6734− var path = function (ps) {
6735− return ps;
6736− };
6737− var collage = Native.Graphics.Collage.collage;
6738− var alpha = F2(function (a,f) {
6739− return _U.replace([["alpha"
6740− ,a]],
6741− f);
6742− });
6743− var rotate = F2(function (t,f) {
6744− return _U.replace([["theta"
6745− ,f.theta + t]],
6746− f);
6747− });
6748− var scale = F2(function (s,f) {
6749− return _U.replace([["scale"
6750− ,f.scale * s]],
6751− f);
6752− });
6753− var moveY = F2(function (y,f) {
6754− return _U.replace([["y"
6755− ,f.y + y]],
6756− f);
6757− });
6758− var moveX = F2(function (x,f) {
6759− return _U.replace([["x"
6760− ,f.x + x]],
6761− f);
6762− });
6763− var move = F2(function (_v0,f) {
6764− return function () {
6765− switch (_v0.ctor)
6766− {case "_Tuple2":
6767− return _U.replace([["x"
6768− ,f.x + _v0._0]
6769− ,["y",f.y + _v0._1]],
6770− f);}
6771− _E.Case($moduleName,
6772− "on line 169, column 20 to 48");
6773− }();
6774− });
6775− var form = function (f) {
6776− return {_: {}
6777− ,alpha: 1
6778− ,form: f
6779− ,scale: 1
6780− ,theta: 0
6781− ,x: 0
6782− ,y: 0};
6783− };
6784− var FGroup = F2(function (a,b) {
6785− return {ctor: "FGroup"
6786− ,_0: a
6787− ,_1: b};
6788− });
6789− var group = function (fs) {
6790− return form(A2(FGroup,
6791− Transform2D.identity,
6792− fs));
6793− };
6794− var groupTransform = F2(function (matrix,
6795− fs) {
6796− return form(A2(FGroup,
6797− matrix,
6798− fs));
6799− });
6800− var FElement = function (a) {
6801− return {ctor: "FElement"
6802− ,_0: a};
6803− };
6804− var toForm = function (e) {
6805− return form(FElement(e));
6806− };
6807− var FImage = F4(function (a,
6808− b,
6809− c,
6810− d) {
6811− return {ctor: "FImage"
6812− ,_0: a
6813− ,_1: b
6814− ,_2: c
6815− ,_3: d};
6816− });
6817− var sprite = F4(function (w,
6818− h,
6819− pos,
6820− src) {
6821− return form(A4(FImage,
6822− w,
6823− h,
6824− pos,
6825− src));
6826− });
6827− var FShape = F2(function (a,b) {
6828− return {ctor: "FShape"
6829− ,_0: a
6830− ,_1: b};
6831− });
6832− var fill = F2(function (style,
6833− shape) {
6834− return form(A2(FShape,
6835− Either.Right(style),
6836− shape));
6837− });
6838− var outlined = F2(function (style,
6839− shape) {
6840− return form(A2(FShape,
6841− Either.Left(style),
6842− shape));
6843− });
6844− var FPath = F2(function (a,b) {
6845− return {ctor: "FPath"
6846− ,_0: a
6847− ,_1: b};
6848− });
6849− var traced = F2(function (style,
6850− path) {
6851− return form(A2(FPath,
6852− style,
6853− path));
6854− });
6855− var LineStyle = F6(function (a,
6856− b,
6857− c,
6858− d,
6859− e,
6860− f) {
6861− return {_: {}
6862− ,cap: c
6863− ,color: a
6864− ,dashOffset: f
6865− ,dashing: e
6866− ,join: d
6867− ,width: b};
6868− });
6869− var Clipped = {ctor: "Clipped"};
6870− var Sharp = function (a) {
6871− return {ctor: "Sharp",_0: a};
6872− };
6873− var Smooth = {ctor: "Smooth"};
6874− var Padded = {ctor: "Padded"};
6875− var Round = {ctor: "Round"};
6876− var Flat = {ctor: "Flat"};
6877− var defaultLine = {_: {}
6878− ,cap: Flat
6879− ,color: Color.black
6880− ,dashOffset: 0
6881− ,dashing: _L.fromArray([])
6882− ,join: Sharp(10)
6883− ,width: 1};
6884− var solid = function (clr) {
6885− return _U.replace([["color"
6886− ,clr]],
6887− defaultLine);
6888− };
6889− var dashed = function (clr) {
6890− return _U.replace([["color"
6891− ,clr]
6892− ,["dashing"
6893− ,_L.fromArray([8,4])]],
6894− defaultLine);
6895− };
6896− var dotted = function (clr) {
6897− return _U.replace([["color"
6898− ,clr]
6899− ,["dashing"
6900− ,_L.fromArray([3,3])]],
6901− defaultLine);
6902− };
6903− var Grad = function (a) {
6904− return {ctor: "Grad",_0: a};
6905− };
6906− var gradient = F2(function (grad,
6907− shape) {
6908− return A2(fill,
6909− Grad(grad),
6910− shape);
6911− });
6912− var Texture = function (a) {
6913− return {ctor: "Texture"
6914− ,_0: a};
6915− };
6916− var textured = F2(function (src,
6917− shape) {
6918− return A2(fill,
6919− Texture(src),
6920− shape);
6921− });
6922− var Solid = function (a) {
6923− return {ctor: "Solid",_0: a};
6924− };
6925− var filled = F2(function (color,
6926− shape) {
6927− return A2(fill,
6928− Solid(color),
6929− shape);
6930− });
6931− var Form = F6(function (a,
6932− b,
6933− c,
6934− d,
6935− e,
6936− f) {
6937− return {_: {}
6938− ,alpha: e
6939− ,form: f
6940− ,scale: b
6941− ,theta: a
6942− ,x: c
6943− ,y: d};
6944− });
6945− _elm.Graphics.Collage.values = {_op: _op
6946− ,defaultLine: defaultLine
6947− ,solid: solid
6948− ,dashed: dashed
6949− ,dotted: dotted
6950− ,form: form
6951− ,fill: fill
6952− ,filled: filled
6953− ,textured: textured
6954− ,gradient: gradient
6955− ,outlined: outlined
6956− ,traced: traced
6957− ,sprite: sprite
6958− ,toForm: toForm
6959− ,group: group
6960− ,groupTransform: groupTransform
6961− ,move: move
6962− ,moveX: moveX
6963− ,moveY: moveY
6964− ,scale: scale
6965− ,rotate: rotate
6966− ,alpha: alpha
6967− ,collage: collage
6968− ,path: path
6969− ,segment: segment
6970− ,polygon: polygon
6971− ,rect: rect
6972− ,square: square
6973− ,oval: oval
6974− ,circle: circle
6975− ,ngon: ngon
6976− ,Solid: Solid
6977− ,Texture: Texture
6978− ,Grad: Grad
6979− ,Flat: Flat
6980− ,Round: Round
6981− ,Padded: Padded
6982− ,Smooth: Smooth
6983− ,Sharp: Sharp
6984− ,Clipped: Clipped
6985− ,FPath: FPath
6986− ,FShape: FShape
6987− ,FImage: FImage
6988− ,FElement: FElement
6989− ,FGroup: FGroup
6990− ,Form: Form
6991− ,LineStyle: LineStyle};
6992− return _elm.Graphics.Collage.values;
6993−};Elm.Graphics = Elm.Graphics || {};
6994−Elm.Graphics.Input = Elm.Graphics.Input || {};
6995−Elm.Graphics.Input.make = function (_elm) {
6996− "use strict";
6997− _elm.Graphics = _elm.Graphics || {};
6998− _elm.Graphics.Input = _elm.Graphics.Input || {};
6999− if (_elm.Graphics.Input.values)
7000− return _elm.Graphics.Input.values;
7001− var _N = Elm.Native,
7002− _U = _N.Utils.make(_elm),
7003− _L = _N.List.make(_elm),
7004− _E = _N.Error.make(_elm),
7005− $moduleName = "Graphics.Input";
7006− var Graphics = Graphics || {};
7007− Graphics.Element = Elm.Graphics.Element.make(_elm);
7008− var Native = Native || {};
7009− Native.Graphics = Native.Graphics || {};
7010− Native.Graphics.Input = Elm.Native.Graphics.Input.make(_elm);
7011− var Signal = Elm.Signal.make(_elm);
7012− var _op = {};
7013− var clickable = Native.Graphics.Input.clickable;
7014− var hoverable = Native.Graphics.Input.hoverable;
7015− var dropDown = Native.Graphics.Input.dropDown;
7016− var checkbox = Native.Graphics.Input.checkbox;
7017− var customButton = Native.Graphics.Input.customButton;
7018− var button = Native.Graphics.Input.button;
7019− var input = Native.Graphics.Input.input;
7020− var Handle = {ctor: "Handle"};
7021− var Input = F2(function (a,b) {
7022− return {_: {}
7023− ,handle: b
7024− ,signal: a};
7025− });
7026− _elm.Graphics.Input.values = {_op: _op
7027− ,input: input
7028− ,button: button
7029− ,customButton: customButton
7030− ,checkbox: checkbox
7031− ,dropDown: dropDown
7032− ,hoverable: hoverable
7033− ,clickable: clickable
7034− ,Handle: Handle
7035− ,Input: Input};
7036− return _elm.Graphics.Input.values;
7037−};Elm.Graphics = Elm.Graphics || {};
7038−Elm.Graphics.Element = Elm.Graphics.Element || {};
7039−Elm.Graphics.Element.make = function (_elm) {
7040− "use strict";
7041− _elm.Graphics = _elm.Graphics || {};
7042− _elm.Graphics.Element = _elm.Graphics.Element || {};
7043− if (_elm.Graphics.Element.values)
7044− return _elm.Graphics.Element.values;
7045− var _N = Elm.Native,
7046− _U = _N.Utils.make(_elm),
7047− _L = _N.List.make(_elm),
7048− _E = _N.Error.make(_elm),
7049− $moduleName = "Graphics.Element";
7050− var Basics = Elm.Basics.make(_elm);
7051− var Color = Elm.Color.make(_elm);
7052− var List = Elm.List.make(_elm);
7053− var Maybe = Elm.Maybe.make(_elm);
7054− var Native = Native || {};
7055− Native.Utils = Elm.Native.Utils.make(_elm);
7056− var _op = {};
7057− var DOut = {ctor: "DOut"};
7058− var outward = DOut;
7059− var DIn = {ctor: "DIn"};
7060− var inward = DIn;
7061− var DRight = {ctor: "DRight"};
7062− var right = DRight;
7063− var DLeft = {ctor: "DLeft"};
7064− var left = DLeft;
7065− var DDown = {ctor: "DDown"};
7066− var down = DDown;
7067− var DUp = {ctor: "DUp"};
7068− var up = DUp;
7069− var Position = F4(function (a,
7070− b,
7071− c,
7072− d) {
7073− return {_: {}
7074− ,horizontal: a
7075− ,vertical: b
7076− ,x: c
7077− ,y: d};
7078− });
7079− var Relative = function (a) {
7080− return {ctor: "Relative"
7081− ,_0: a};
7082− };
7083− var relative = Relative;
7084− var Absolute = function (a) {
7085− return {ctor: "Absolute"
7086− ,_0: a};
7087− };
7088− var absolute = Absolute;
7089− var N = {ctor: "N"};
7090− var bottomLeftAt = F2(function (x,
7091− y) {
7092− return {_: {}
7093− ,horizontal: N
7094− ,vertical: N
7095− ,x: x
7096− ,y: y};
7097− });
7098− var Z = {ctor: "Z"};
7099− var middle = {_: {}
7100− ,horizontal: Z
7101− ,vertical: Z
7102− ,x: Relative(0.5)
7103− ,y: Relative(0.5)};
7104− var midLeft = _U.replace([["horizontal"
7105− ,N]
7106− ,["x",Absolute(0)]],
7107− middle);
7108− var middleAt = F2(function (x,
7109− y) {
7110− return {_: {}
7111− ,horizontal: Z
7112− ,vertical: Z
7113− ,x: x
7114− ,y: y};
7115− });
7116− var midLeftAt = F2(function (x,
7117− y) {
7118− return {_: {}
7119− ,horizontal: N
7120− ,vertical: Z
7121− ,x: x
7122− ,y: y};
7123− });
7124− var midBottomAt = F2(function (x,
7125− y) {
7126− return {_: {}
7127− ,horizontal: Z
7128− ,vertical: N
7129− ,x: x
7130− ,y: y};
7131− });
7132− var P = {ctor: "P"};
7133− var topLeft = {_: {}
7134− ,horizontal: N
7135− ,vertical: P
7136− ,x: Absolute(0)
7137− ,y: Absolute(0)};
7138− var bottomLeft = _U.replace([["vertical"
7139− ,N]],
7140− topLeft);
7141− var topRight = _U.replace([["horizontal"
7142− ,P]],
7143− topLeft);
7144− var bottomRight = _U.replace([["horizontal"
7145− ,P]],
7146− bottomLeft);
7147− var midRight = _U.replace([["horizontal"
7148− ,P]],
7149− midLeft);
7150− var midTop = _U.replace([["vertical"
7151− ,P]
7152− ,["y",Absolute(0)]],
7153− middle);
7154− var midBottom = _U.replace([["vertical"
7155− ,N]],
7156− midTop);
7157− var topLeftAt = F2(function (x,
7158− y) {
7159− return {_: {}
7160− ,horizontal: N
7161− ,vertical: P
7162− ,x: x
7163− ,y: y};
7164− });
7165− var topRightAt = F2(function (x,
7166− y) {
7167− return {_: {}
7168− ,horizontal: P
7169− ,vertical: P
7170− ,x: x
7171− ,y: y};
7172− });
7173− var bottomRightAt = F2(function (x,
7174− y) {
7175− return {_: {}
7176− ,horizontal: P
7177− ,vertical: N
7178− ,x: x
7179− ,y: y};
7180− });
7181− var midRightAt = F2(function (x,
7182− y) {
7183− return {_: {}
7184− ,horizontal: P
7185− ,vertical: Z
7186− ,x: x
7187− ,y: y};
7188− });
7189− var midTopAt = F2(function (x,
7190− y) {
7191− return {_: {}
7192− ,horizontal: Z
7193− ,vertical: P
7194− ,x: x
7195− ,y: y};
7196− });
7197− var Tiled = {ctor: "Tiled"};
7198− var Cropped = function (a) {
7199− return {ctor: "Cropped"
7200− ,_0: a};
7201− };
7202− var Fitted = {ctor: "Fitted"};
7203− var Plain = {ctor: "Plain"};
7204− var Custom = {ctor: "Custom"};
7205− var RawHtml = {ctor: "RawHtml"};
7206− var Spacer = {ctor: "Spacer"};
7207− var Flow = F2(function (a,b) {
7208− return {ctor: "Flow"
7209− ,_0: a
7210− ,_1: b};
7211− });
7212− var Container = F2(function (a,
7213− b) {
7214− return {ctor: "Container"
7215− ,_0: a
7216− ,_1: b};
7217− });
7218− var Image = F4(function (a,
7219− b,
7220− c,
7221− d) {
7222− return {ctor: "Image"
7223− ,_0: a
7224− ,_1: b
7225− ,_2: c
7226− ,_3: d};
7227− });
7228− var link = F2(function (href,
7229− e) {
7230− return function () {
7231− var p = e.props;
7232− return {_: {}
7233− ,element: e.element
7234− ,props: _U.replace([["href"
7235− ,href]],
7236− p)};
7237− }();
7238− });
7239− var tag = F2(function (name,e) {
7240− return function () {
7241− var p = e.props;
7242− return {_: {}
7243− ,element: e.element
7244− ,props: _U.replace([["tag"
7245− ,name]],
7246− p)};
7247− }();
7248− });
7249− var color = F2(function (c,e) {
7250− return function () {
7251− var p = e.props;
7252− return {_: {}
7253− ,element: e.element
7254− ,props: _U.replace([["color"
7255− ,Maybe.Just(c)]],
7256− p)};
7257− }();
7258− });
7259− var opacity = F2(function (o,
7260− e) {
7261− return function () {
7262− var p = e.props;
7263− return {_: {}
7264− ,element: e.element
7265− ,props: _U.replace([["opacity"
7266− ,o]],
7267− p)};
7268− }();
7269− });
7270− var height = F2(function (nh,
7271− e) {
7272− return function () {
7273− var p = e.props;
7274− var props = function () {
7275− var _v0 = e.element;
7276− switch (_v0.ctor)
7277− {case "Image":
7278− return _U.replace([["width"
7279− ,Basics.round(Basics.toFloat(_v0._1) / Basics.toFloat(_v0._2) * Basics.toFloat(nh))]],
7280− p);}
7281− return p;
7282− }();
7283− return {_: {}
7284− ,element: e.element
7285− ,props: _U.replace([["height"
7286− ,nh]],
7287− p)};
7288− }();
7289− });
7290− var width = F2(function (nw,e) {
7291− return function () {
7292− var p = e.props;
7293− var props = function () {
7294− var _v5 = e.element;
7295− switch (_v5.ctor)
7296− {case "Image":
7297− return _U.replace([["height"
7298− ,Basics.round(Basics.toFloat(_v5._2) / Basics.toFloat(_v5._1) * Basics.toFloat(nw))]],
7299− p);
7300− case "RawHtml":
7301− return _U.replace([["height"
7302− ,Basics.snd(A2(Native.Utils.htmlHeight,
7303− nw,
7304− e.element))]],
7305− p);}
7306− return p;
7307− }();
7308− return {_: {}
7309− ,element: e.element
7310− ,props: _U.replace([["width"
7311− ,nw]],
7312− props)};
7313− }();
7314− });
7315− var size = F3(function (w,h,e) {
7316− return A2(height,
7317− h,
7318− A2(width,w,e));
7319− });
7320− var sizeOf = function (e) {
7321− return {ctor: "_Tuple2"
7322− ,_0: e.props.width
7323− ,_1: e.props.height};
7324− };
7325− var heightOf = function (e) {
7326− return e.props.height;
7327− };
7328− var widthOf = function (e) {
7329− return e.props.width;
7330− };
7331− var Element = F2(function (a,
7332− b) {
7333− return {_: {}
7334− ,element: b
7335− ,props: a};
7336− });
7337− var Properties = F9(function (a,
7338− b,
7339− c,
7340− d,
7341− e,
7342− f,
7343− g,
7344− h,
7345− i) {
7346− return {_: {}
7347− ,click: i
7348− ,color: e
7349− ,height: c
7350− ,hover: h
7351− ,href: f
7352− ,id: a
7353− ,opacity: d
7354− ,tag: g
7355− ,width: b};
7356− });
7357− var newElement = F3(function (w,
7358− h,
7359− e) {
7360− return {_: {}
7361− ,element: e
7362− ,props: A9(Properties,
7363− Native.Utils.guid({ctor: "_Tuple0"}),
7364− w,
7365− h,
7366− 1,
7367− Maybe.Nothing,
7368− "",
7369− "",
7370− {ctor: "_Tuple0"},
7371− {ctor: "_Tuple0"})};
7372− });
7373− var image = F3(function (w,
7374− h,
7375− src) {
7376− return A3(newElement,
7377− w,
7378− h,
7379− A4(Image,Plain,w,h,src));
7380− });
7381− var fittedImage = F3(function (w,
7382− h,
7383− src) {
7384− return A3(newElement,
7385− w,
7386− h,
7387− A4(Image,Fitted,w,h,src));
7388− });
7389− var croppedImage = F4(function (pos,
7390− w,
7391− h,
7392− src) {
7393− return A3(newElement,
7394− w,
7395− h,
7396− A4(Image,Cropped(pos),w,h,src));
7397− });
7398− var tiledImage = F3(function (w,
7399− h,
7400− src) {
7401− return A3(newElement,
7402− w,
7403− h,
7404− A4(Image,Tiled,w,h,src));
7405− });
7406− var container = F4(function (w,
7407− h,
7408− pos,
7409− e) {
7410− return A3(newElement,
7411− w,
7412− h,
7413− A2(Container,pos,e));
7414− });
7415− var spacer = F2(function (w,h) {
7416− return A3(newElement,
7417− w,
7418− h,
7419− Spacer);
7420− });
7421− var empty = A2(spacer,0,0);
7422− var flow = F2(function (dir,
7423− es) {
7424− return function () {
7425− var newFlow = F2(function (w,
7426− h) {
7427− return A3(newElement,
7428− w,
7429− h,
7430− A2(Flow,dir,es));
7431− });
7432− var hs = A2(List.map,
7433− heightOf,
7434− es);
7435− var ws = A2(List.map,
7436− widthOf,
7437− es);
7438− return _U.eq(es,
7439− _L.fromArray([])) ? empty : function () {
7440− switch (dir.ctor)
7441− {case "DDown":
7442− return A2(newFlow,
7443− List.maximum(ws),
7444− List.sum(hs));
7445− case "DIn": return A2(newFlow,
7446− List.maximum(ws),
7447− List.maximum(hs));
7448− case "DLeft": return A2(newFlow,
7449− List.sum(ws),
7450− List.maximum(hs));
7451− case "DOut": return A2(newFlow,
7452− List.maximum(ws),
7453− List.maximum(hs));
7454− case "DRight":
7455− return A2(newFlow,
7456− List.sum(ws),
7457− List.maximum(hs));
7458− case "DUp": return A2(newFlow,
7459− List.maximum(ws),
7460− List.sum(hs));}
7461− _E.Case($moduleName,
7462− "between lines 206 and 216");
7463− }();
7464− }();
7465− });
7466− var above = F2(function (hi,
7467− lo) {
7468− return A3(newElement,
7469− A2(Basics.max,
7470− widthOf(hi),
7471− widthOf(lo)),
7472− heightOf(hi) + heightOf(lo),
7473− A2(Flow,
7474− DDown,
7475− _L.fromArray([hi,lo])));
7476− });
7477− var below = F2(function (lo,
7478− hi) {
7479− return A3(newElement,
7480− A2(Basics.max,
7481− widthOf(hi),
7482− widthOf(lo)),
7483− heightOf(hi) + heightOf(lo),
7484− A2(Flow,
7485− DDown,
7486− _L.fromArray([hi,lo])));
7487− });
7488− var beside = F2(function (lft,
7489− rht) {
7490− return A3(newElement,
7491− widthOf(lft) + widthOf(rht),
7492− A2(Basics.max,
7493− heightOf(lft),
7494− heightOf(rht)),
7495− A2(Flow,
7496− right,
7497− _L.fromArray([lft,rht])));
7498− });
7499− var layers = function (es) {
7500− return function () {
7501− var hs = A2(List.map,
7502− heightOf,
7503− es);
7504− var ws = A2(List.map,
7505− widthOf,
7506− es);
7507− return A3(newElement,
7508− List.maximum(ws),
7509− List.maximum(hs),
7510− A2(Flow,DOut,es));
7511− }();
7512− };
7513− _elm.Graphics.Element.values = {_op: _op
7514− ,empty: empty
7515− ,widthOf: widthOf
7516− ,heightOf: heightOf
7517− ,sizeOf: sizeOf
7518− ,width: width
7519− ,height: height
7520− ,size: size
7521− ,opacity: opacity
7522− ,color: color
7523− ,tag: tag
7524− ,link: link
7525− ,newElement: newElement
7526− ,image: image
7527− ,fittedImage: fittedImage
7528− ,croppedImage: croppedImage
7529− ,tiledImage: tiledImage
7530− ,container: container
7531− ,spacer: spacer
7532− ,flow: flow
7533− ,above: above
7534− ,below: below
7535− ,beside: beside
7536− ,layers: layers
7537− ,absolute: absolute
7538− ,relative: relative
7539− ,middle: middle
7540− ,topLeft: topLeft
7541− ,topRight: topRight
7542− ,bottomLeft: bottomLeft
7543− ,bottomRight: bottomRight
7544− ,midLeft: midLeft
7545− ,midRight: midRight
7546− ,midTop: midTop
7547− ,midBottom: midBottom
7548− ,middleAt: middleAt
7549− ,topLeftAt: topLeftAt
7550− ,topRightAt: topRightAt
7551− ,bottomLeftAt: bottomLeftAt
7552− ,bottomRightAt: bottomRightAt
7553− ,midLeftAt: midLeftAt
7554− ,midRightAt: midRightAt
7555− ,midTopAt: midTopAt
7556− ,midBottomAt: midBottomAt
7557− ,up: up
7558− ,down: down
7559− ,left: left
7560− ,right: right
7561− ,inward: inward
7562− ,outward: outward
7563− ,Image: Image
7564− ,Container: Container
7565− ,Flow: Flow
7566− ,Spacer: Spacer
7567− ,RawHtml: RawHtml
7568− ,Custom: Custom
7569− ,Plain: Plain
7570− ,Fitted: Fitted
7571− ,Cropped: Cropped
7572− ,Tiled: Tiled
7573− ,P: P
7574− ,Z: Z
7575− ,N: N
7576− ,Absolute: Absolute
7577− ,Relative: Relative
7578− ,DUp: DUp
7579− ,DDown: DDown
7580− ,DLeft: DLeft
7581− ,DRight: DRight
7582− ,DIn: DIn
7583− ,DOut: DOut
7584− ,Properties: Properties
7585− ,Element: Element
7586− ,Position: Position};
7587− return _elm.Graphics.Element.values;
7588−};Elm.Graphics = Elm.Graphics || {};
7589−Elm.Graphics.Input = Elm.Graphics.Input || {};
7590−Elm.Graphics.Input.Field = Elm.Graphics.Input.Field || {};
7591−Elm.Graphics.Input.Field.make = function (_elm) {
7592− "use strict";
7593− _elm.Graphics = _elm.Graphics || {};
7594− _elm.Graphics.Input = _elm.Graphics.Input || {};
7595− _elm.Graphics.Input.Field = _elm.Graphics.Input.Field || {};
7596− if (_elm.Graphics.Input.Field.values)
7597− return _elm.Graphics.Input.Field.values;
7598− var _N = Elm.Native,
7599− _U = _N.Utils.make(_elm),
7600− _L = _N.List.make(_elm),
7601− _E = _N.Error.make(_elm),
7602− $moduleName = "Graphics.Input.Field";
7603− var Color = Elm.Color.make(_elm);
7604− var Graphics = Graphics || {};
7605− Graphics.Element = Elm.Graphics.Element.make(_elm);
7606− var Graphics = Graphics || {};
7607− Graphics.Input = Elm.Graphics.Input.make(_elm);
7608− var Native = Native || {};
7609− Native.Graphics = Native.Graphics || {};
7610− Native.Graphics.Input = Elm.Native.Graphics.Input.make(_elm);
7611− var Text = Elm.Text.make(_elm);
7612− var _op = {};
7613− var email = Native.Graphics.Input.email;
7614− var password = Native.Graphics.Input.password;
7615− var field = Native.Graphics.Input.field;
7616− var Backward = {ctor: "Backward"};
7617− var Forward = {ctor: "Forward"};
7618− var Selection = F3(function (a,
7619− b,
7620− c) {
7621− return {_: {}
7622− ,direction: c
7623− ,end: b
7624− ,start: a};
7625− });
7626− var Content = F2(function (a,
7627− b) {
7628− return {_: {}
7629− ,selection: b
7630− ,string: a};
7631− });
7632− var noContent = A2(Content,
7633− "",
7634− A3(Selection,0,0,Forward));
7635− var Style = F4(function (a,
7636− b,
7637− c,
7638− d) {
7639− return {_: {}
7640− ,highlight: c
7641− ,outline: b
7642− ,padding: a
7643− ,style: d};
7644− });
7645− var Highlight = F2(function (a,
7646− b) {
7647− return {_: {}
7648− ,color: a
7649− ,width: b};
7650− });
7651− var noHighlight = A2(Highlight,
7652− Color.blue,
7653− 0);
7654− var Outline = F3(function (a,
7655− b,
7656− c) {
7657− return {_: {}
7658− ,color: a
7659− ,radius: c
7660− ,width: b};
7661− });
7662− var Dimensions = F4(function (a,
7663− b,
7664− c,
7665− d) {
7666− return {_: {}
7667− ,bottom: d
7668− ,left: a
7669− ,right: b
7670− ,top: c};
7671− });
7672− var uniformly = function (n) {
7673− return A4(Dimensions,
7674− n,
7675− n,
7676− n,
7677− n);
7678− };
7679− var noOutline = A3(Outline,
7680− Color.grey,
7681− uniformly(0),
7682− 0);
7683− var defaultStyle = {_: {}
7684− ,highlight: A2(Highlight,
7685− Color.blue,
7686− 1)
7687− ,outline: A3(Outline,
7688− Color.grey,
7689− uniformly(1),
7690− 2)
7691− ,padding: uniformly(4)
7692− ,style: Text.defaultStyle};
7693− _elm.Graphics.Input.Field.values = {_op: _op
7694− ,uniformly: uniformly
7695− ,noOutline: noOutline
7696− ,noHighlight: noHighlight
7697− ,defaultStyle: defaultStyle
7698− ,noContent: noContent
7699− ,field: field
7700− ,password: password
7701− ,email: email
7702− ,Forward: Forward
7703− ,Backward: Backward
7704− ,Dimensions: Dimensions
7705− ,Outline: Outline
7706− ,Highlight: Highlight
7707− ,Style: Style
7708− ,Content: Content
7709− ,Selection: Selection};
7710− return _elm.Graphics.Input.Field.values;
7711−};
7712−(function() {
7713−'use strict';
7714−
7715−Elm.fullscreen = function(module, ports) {
7716− var style = document.createElement('style');
7717− style.type = 'text/css';
7718− style.innerHTML = "html,head,body { padding:0; margin:0; }" +
7719− "body { font-family: calibri, helvetica, arial, sans-serif; }";
7720− document.head.appendChild(style);
7721− var container = document.createElement('div');
7722− document.body.appendChild(container);
7723− return init(ElmRuntime.Display.FULLSCREEN, container, module, ports || {});
7724−};
7725−
7726−Elm.embed = function(module, container, ports) {
7727− var tag = container.tagName;
7728− if (tag !== 'DIV') {
7729− throw new Error('Elm.node must be given a DIV, not a ' + tag + '.');
7730− } else if (container.hasChildNodes()) {
7731− throw new Error('Elm.node must be given an empty DIV. No children allowed!');
7732− }
7733− return init(ElmRuntime.Display.COMPONENT, container, module, ports || {});
7734−};
7735−
7736−Elm.worker = function(module, ports) {
7737− return init(ElmRuntime.Display.NONE, {}, module, ports || {});
7738−};
7739−
7740−function init(display, container, module, ports, moduleToReplace) {
7741− // defining state needed for an instance of the Elm RTS
7742− var inputs = [];
7743−
7744− var updateInProgress = false;
7745− function notify(id, v) {
7746− if (updateInProgress) {
7747− throw new Error(
7748− 'The notify function has been called synchronously!\n' +
7749− 'This can lead to frames being dropped.\n' +
7750− 'Definitely report this to <https://github.com/evancz/Elm/issues>\n');
7751− }
7752− updateInProgress = true;
7753− var timestep = Date.now();
7754− for (var i = inputs.length; i--; ) {
7755− inputs[i].recv(timestep, id, v);
7756− }
7757− updateInProgress = false;
7758− }
7759−
7760− var listeners = [];
7761− function addListener(relevantInputs, domNode, eventName, func) {
7762− domNode.addEventListener(eventName, func);
7763− var listener = {
7764− relevantInputs: relevantInputs,
7765− domNode: domNode,
7766− eventName: eventName,
7767− func: func
7768− };
7769− listeners.push(listener);
7770− }
7771−
7772− var portUses = {}
7773− for (var key in ports) {
7774− portUses[key] = 0;
7775− }
7776− // create the actual RTS. Any impure modules will attach themselves to this
7777− // object. This permits many Elm programs to be embedded per document.
7778− var elm = {
7779− notify:notify,
7780− node:container,
7781− display:display,
7782− id:ElmRuntime.guid(),
7783− addListener:addListener,
7784− inputs:inputs,
7785− ports: { incoming:ports, outgoing:{}, uses:portUses }
7786− };
7787−
7788− function swap(newModule) {
7789− removeListeners(listeners);
7790− var div = document.createElement('div');
7791− var newElm = init(display, div, newModule, ports, elm);
7792− inputs = [];
7793− // elm.swap = newElm.swap;
7794− return newElm;
7795− }
7796−
7797− var Module = {};
7798− var reportAnyErrors = function() {};
7799− try {
7800− Module = module.make(elm);
7801− checkPorts(elm);
7802− } catch(e) {
7803− var directions = "<br/>&nbsp; &nbsp; Open the developer console for more details."
7804− Module.main = Elm.Text.make(elm).leftAligned('<code>' + e.message + directions + '</code>');
7805− reportAnyErrors = function() { throw e; }
7806− }
7807− inputs = ElmRuntime.filterDeadInputs(inputs);
7808− filterListeners(inputs, listeners);
7809− addReceivers(elm.ports.outgoing);
7810− if (display !== ElmRuntime.Display.NONE) {
7811− var graphicsNode = initGraphics(elm, Module);
7812− }
7813− if (typeof moduleToReplace !== 'undefined') {
7814− ElmRuntime.swap(moduleToReplace, elm);
7815−
7816− // rerender scene if graphics are enabled.
7817− if (typeof graphicsNode !== 'undefined') {
7818− graphicsNode.recv(0, true, 0);
7819− }
7820− }
7821−
7822− reportAnyErrors();
7823− return { swap:swap, ports:elm.ports.outgoing };
7824−};
7825−
7826−function checkPorts(elm) {
7827− var portUses = elm.ports.uses;
7828− for (var key in portUses) {
7829− var uses = portUses[key]
7830− if (uses === 0) {
7831− throw new Error(
7832− "Initialization Error: provided port '" + key +
7833− "' to a module that does not take it as in input.\n" +
7834− "Remove '" + key + "' from the module initialization code.");
7835− } else if (uses > 1) {
7836− throw new Error(
7837− "Initialization Error: port '" + key +
7838− "' has been declared multiple times in the Elm code.\n" +
7839− "Remove declarations until there is exactly one.");
7840− }
7841− }
7842−}
7843−
7844−function filterListeners(inputs, listeners) {
7845− loop:
7846− for (var i = listeners.length; i--; ) {
7847− var listener = listeners[i];
7848− for (var j = inputs.length; j--; ) {
7849− if (listener.relevantInputs.indexOf(inputs[j].id) >= 0) {
7850− continue loop;
7851− }
7852− }
7853− listener.domNode.removeEventListener(listener.eventName, listener.func);
7854− }
7855−}
7856−
7857−function removeListeners(listeners) {
7858− for (var i = listeners.length; i--; ) {
7859− var listener = listeners[i];
7860− listener.domNode.removeEventListener(listener.eventName, listener.func);
7861− }
7862−}
7863−
7864−// add receivers for built-in ports if they are defined
7865−function addReceivers(ports) {
7866− if ('log' in ports) {
7867− ports.log.subscribe(function(v) { console.log(v) });
7868− }
7869− if ('stdout' in ports) {
7870− var process = process || {};
7871− var handler = process.stdout
7872− ? function(v) { process.stdout.write(v); }
7873− : function(v) { console.log(v); };
7874− ports.stdout.subscribe(handler);
7875− }
7876− if ('stderr' in ports) {
7877− var process = process || {};
7878− var handler = process.stderr
7879− ? function(v) { process.stderr.write(v); }
7880− : function(v) { console.log('Error:' + v); };
7881− ports.stderr.subscribe(handler);
7882− }
7883− if ('title' in ports) {
7884− if (typeof ports.title === 'string') {
7885− document.title = ports.title;
7886− } else {
7887− ports.title.subscribe(function(v) { document.title = v; });
7888− }
7889− }
7890− if ('redirect' in ports) {
7891− ports.redirect.subscribe(function(v) {
7892− if (v.length > 0) window.location = v;
7893− });
7894− }
7895− if ('favicon' in ports) {
7896− if (typeof ports.favicon === 'string') {
7897− changeFavicon(ports.favicon);
7898− } else {
7899− ports.favicon.subscribe(changeFavicon);
7900− }
7901− }
7902− function changeFavicon(src) {
7903− var link = document.createElement('link');
7904− var oldLink = document.getElementById('elm-favicon');
7905− link.id = 'elm-favicon';
7906− link.rel = 'shortcut icon';
7907− link.href = src;
7908− if (oldLink) {
7909− document.head.removeChild(oldLink);
7910− }
7911− document.head.appendChild(link);
7912− }
7913−}
7914−
7915−function initGraphics(elm, Module) {
7916− if (!('main' in Module))
7917− throw new Error("'main' is missing! What do I display?!");
7918−
7919− var signalGraph = Module.main;
7920−
7921− // make sure the signal graph is actually a signal & extract the visual model
7922− var Signal = Elm.Signal.make(elm);
7923− if (!('recv' in signalGraph)) {
7924− signalGraph = Signal.constant(signalGraph);
7925− }
7926− var currentScene = signalGraph.value;
7927−
7928− // Add the currentScene to the DOM
7929− var Render = ElmRuntime.use(ElmRuntime.Render.Element);
7930− elm.node.appendChild(Render.render(currentScene));
7931−
7932− // set up updates so that the DOM is adjusted as necessary.
7933− var savedScene = currentScene;
7934− function domUpdate(newScene) {
7935− ElmRuntime.draw(function(_) {
7936− Render.update(elm.node.firstChild, savedScene, newScene);
7937− if (elm.Native.Window) elm.Native.Window.values.resizeIfNeeded();
7938− savedScene = newScene;
7939− });
7940− }
7941− var renderer = A2(Signal.lift, domUpdate, signalGraph);
7942−
7943− // must check for resize after 'renderer' is created so
7944− // that changes show up.
7945− if (elm.Native.Window) elm.Native.Window.values.resizeIfNeeded();
7946−
7947− return renderer;
7948−}
7949−
7950−}());
7951−
7952−(function() {
7953−'use strict';
7954−
7955−ElmRuntime.Display = { FULLSCREEN: 0, COMPONENT: 1, NONE: 2 };
7956−
7957−ElmRuntime.counter = 0;
7958−ElmRuntime.guid = function() { return ElmRuntime.counter++; }
7959−
7960−ElmRuntime.use = function(M) {
7961− if (typeof M === 'function') M = M();
7962− return M;
7963−};
7964−
7965−function isAlive(input) {
7966− if (!('defaultNumberOfKids' in input)) return true;
7967− var len = input.kids.length;
7968− if (len === 0) return false;
7969− if (len > input.defaultNumberOfKids) return true;
7970− var alive = false;
7971− for (var i = len; i--; ) {
7972− alive = alive || isAlive(input.kids[i]);
7973− }
7974− return alive;
7975−}
7976−
7977−ElmRuntime.filterDeadInputs = function(inputs) {
7978− var temp = [];
7979− for (var i = inputs.length; i--; ) {
7980− if (isAlive(inputs[i])) temp.push(inputs[i]);
7981− }
7982− return temp;
7983−};
7984−
7985−// define the draw function
7986−var vendors = ['ms', 'moz', 'webkit', 'o'];
7987−var win = typeof window !== 'undefined' ? window : {};
7988−for (var i = 0; i < vendors.length && !win.requestAnimationFrame; ++i) {
7989− win.requestAnimationFrame = win[vendors[i]+'RequestAnimationFrame'];
7990− win.cancelAnimationFrame = win[vendors[i]+'CancelAnimationFrame'] ||
7991− win[vendors[i]+'CancelRequestAnimationFrame'];
7992−}
7993−
7994−if (win.requestAnimationFrame && win.cancelAnimationFrame) {
7995− var previous = 0;
7996− ElmRuntime.draw = function(callback) {
7997− win.cancelAnimationFrame(previous);
7998− previous = win.requestAnimationFrame(callback);
7999− };
8000−} else {
8001− ElmRuntime.draw = function(callback) { callback(); };
8002−}
8003−
8004−}());
8005−(function() {
8006−
8007−// Returns boolean indicating if the swap was successful.
8008−// Requires that the two signal graphs have exactly the same
8009−// structure.
8010−ElmRuntime.swap = function(from, to) {
8011− function similar(nodeOld,nodeNew) {
8012− var idOkay = nodeOld.id === nodeNew.id;
8013− var lengthOkay = nodeOld.kids.length === nodeNew.kids.length;
8014− return idOkay && lengthOkay;
8015− }
8016− function swap(nodeOld,nodeNew) {
8017− nodeNew.value = nodeOld.value;
8018− return true;
8019− }
8020− var canSwap = depthFirstTraversals(similar, from.inputs, to.inputs);
8021− if (canSwap) { depthFirstTraversals(swap, from.inputs, to.inputs); }
8022− from.node.parentNode.replaceChild(to.node, from.node);
8023− return canSwap;
8024−}
8025−
8026−// Returns false if the node operation f ever fails.
8027−function depthFirstTraversals(f, queueOld, queueNew) {
8028− if (queueOld.length !== queueNew.length) return false;
8029− queueOld = queueOld.slice(0);
8030− queueNew = queueNew.slice(0);
8031−
8032− var seen = [];
8033− while (queueOld.length > 0 && queueNew.length > 0) {
8034− var nodeOld = queueOld.pop();
8035− var nodeNew = queueNew.pop();
8036− if (seen.indexOf(nodeOld.id) < 0) {
8037− if (!f(nodeOld, nodeNew)) return false;
8038− queueOld = queueOld.concat(nodeOld.kids);
8039− queueNew = queueNew.concat(nodeNew.kids);
8040− seen.push(nodeOld.id);
8041− }
8042− }
8043− return true;
8044−}
8045−
8046−}());
8047−
8048−ElmRuntime.Render.Element = function() {
8049−'use strict';
8050−
8051−var Utils = ElmRuntime.use(ElmRuntime.Render.Utils);
8052−var newElement = Utils.newElement, extract = Utils.extract,
8053− addTransform = Utils.addTransform, removeTransform = Utils.removeTransform,
8054− fromList = Utils.fromList, eq = Utils.eq;
8055−
8056−function setProps(elem, e) {
8057− var props = elem.props;
8058− var element = elem.element;
8059− var width = props.width - (element.adjustWidth || 0);
8060− var height = props.height - (element.adjustHeight || 0);
8061− e.style.width = (width |0) + 'px';
8062− e.style.height = (height|0) + 'px';
8063− if (props.opacity !== 1) {
8064− e.style.opacity = props.opacity;
8065− }
8066− if (props.color.ctor === 'Just') {
8067− e.style.backgroundColor = extract(props.color._0);
8068− }
8069− if (props.tag !== '') { e.id = props.tag; }
8070− if (props.href !== '') {
8071− var a = newElement('a');
8072− a.href = props.href;
8073− a.style.width = '100%';
8074− a.style.height = '100%';
8075− a.style.top = 0;
8076− a.style.left = 0;
8077− a.style.display = 'block';
8078− a.style.position = 'absolute';
8079− e.style.position = 'relative';
8080− e.appendChild(a);
8081− }
8082− if (props.hover.ctor !== '_Tuple0') {
8083− addHover(e, props.hover);
8084− }
8085− if (props.click.ctor !== '_Tuple0') {
8086− addClick(e, props.click);
8087− }
8088− return e;
8089−}
8090−
8091−function addClick(e, handler) {
8092− e.style.pointerEvents = 'auto';
8093− e.elm_click_handler = handler;
8094− function trigger() {
8095− e.elm_click_handler(Utils.Tuple0);
8096− }
8097− e.elm_click_trigger = trigger;
8098− e.addEventListener('click', trigger);
8099−}
8100−
8101−function removeClick(e, handler) {
8102− if (e.elm_click_trigger) {
8103− e.removeEventListener('click', e.elm_click_trigger);
8104− }
8105−}
8106−
8107−function addHover(e, handler) {
8108− e.style.pointerEvents = 'auto';
8109− e.elm_hover_handler = handler;
8110− e.elm_hover_count = 0;
8111−
8112− function over() {
8113− if (e.elm_hover_count++ > 0) return;
8114− e.elm_hover_handler(true);
8115− }
8116− function out(evt) {
8117− if (e.contains(evt.toElement || evt.relatedTarget)) return;
8118− e.elm_hover_count = 0;
8119− e.elm_hover_handler(false);
8120− }
8121− e.elm_hover_over = over;
8122− e.elm_hover_out = out;
8123− e.addEventListener('mouseover', over);
8124− e.addEventListener('mouseout', out);
8125−}
8126−
8127−function removeHover(e) {
8128− if (e.elm_hover_over) {
8129− e.removeEventListener('mouseover', e.elm_hover_over);
8130− }
8131− if (e.elm_hover_out) {
8132− e.removeEventListener('mouseout', e.elm_hover_out);
8133− }
8134−}
8135−
8136−function image(props, img) {
8137− switch (img._0.ctor) {
8138− case 'Plain': return plainImage(img._3);
8139− case 'Fitted': return fittedImage(props.width, props.height, img._3);
8140− case 'Cropped': return croppedImage(img,props.width,props.height,img._3);
8141− case 'Tiled': return tiledImage(img._3);
8142− }
8143−}
8144−
8145−function plainImage(src) {
8146− var img = newElement('img');
8147− img.src = src;
8148− img.name = src;
8149− img.style.display = "block";
8150− return img;
8151−}
8152−
8153−function tiledImage(src) {
8154− var div = newElement('div');
8155− div.style.backgroundImage = 'url(' + src + ')';
8156− return div;
8157−}
8158−
8159−function fittedImage(w, h, src) {
8160− var div = newElement('div');
8161− div.style.background = 'url(' + src + ') no-repeat center';
8162− div.style.webkitBackgroundSize = 'cover';
8163− div.style.MozBackgroundSize = 'cover';
8164− div.style.OBackgroundSize = 'cover';
8165− div.style.backgroundSize = 'cover';
8166− return div;
8167−}
8168−
8169−function croppedImage(elem, w, h, src) {
8170− var pos = elem._0._0;
8171− var e = newElement('div');
8172− e.style.overflow = "hidden";
8173−
8174− var img = newElement('img');
8175− img.onload = function() {
8176− var sw = w / elem._1, sh = h / elem._2;
8177− img.style.width = ((this.width * sw)|0) + 'px';
8178− img.style.height = ((this.height * sh)|0) + 'px';
8179− img.style.marginLeft = ((- pos._0 * sw)|0) + 'px';
8180− img.style.marginTop = ((- pos._1 * sh)|0) + 'px';
8181− };
8182− img.src = src;
8183− img.name = src;
8184− e.appendChild(img);
8185− return e;
8186−}
8187−
8188−function goIn(e) { e.style.position = 'absolute'; return e; }
8189−function goDown(e) { return e }
8190−function goRight(e) { e.style.styleFloat = e.style.cssFloat = "left"; return e; }
8191−function flowWith(f, array) {
8192− var container = newElement('div');
8193− if (f == goIn) container.style.pointerEvents = 'none';
8194−
8195− for (var i = array.length; i--; ) {
8196− container.appendChild(f(render(array[i])));
8197− }
8198− return container;
8199−}
8200−
8201−function flow(dir,elist) {
8202− var array = fromList(elist);
8203− switch(dir.ctor) {
8204− case "DDown": array.reverse();
8205− case "DUp": return flowWith(goDown,array);
8206− case "DRight": array.reverse();
8207− case "DLeft": return flowWith(goRight,array);
8208− case "DOut": array.reverse();
8209− case "DIn": return flowWith(goIn,array);
8210− }
8211−}
8212−
8213−function toPos(pos) {
8214− switch(pos.ctor) {
8215− case "Absolute": return pos._0 + "px";
8216− case "Relative": return (pos._0 * 100) + "%";
8217− }
8218−}
8219−
8220−// must clear right, left, top, bottom, and transform
8221−// before calling this function
8222−function setPos(pos,elem,e) {
8223− var element = elem.element;
8224− var props = elem.props;
8225− var w = props.width + (element.adjustWidth ? element.adjustWidth : 0);
8226− var h = props.height + (element.adjustHeight ? element.adjustHeight : 0);
8227−
8228− e.style.position = 'absolute';
8229− e.style.margin = 'auto';
8230− var transform = '';
8231− switch(pos.horizontal.ctor) {
8232− case 'P': e.style.right = toPos(pos.x); e.style.removeProperty('left'); break;
8233− case 'Z': transform = 'translateX(' + ((-w/2)|0) + 'px) ';
8234− case 'N': e.style.left = toPos(pos.x); e.style.removeProperty('right'); break;
8235− }
8236− switch(pos.vertical.ctor) {
8237− case 'N': e.style.bottom = toPos(pos.y); e.style.removeProperty('top'); break;
8238− case 'Z': transform += 'translateY(' + ((-h/2)|0) + 'px)';
8239− case 'P': e.style.top = toPos(pos.y); e.style.removeProperty('bottom'); break;
8240− }
8241− if (transform !== '') addTransform(e.style, transform);
8242− return e;
8243−}
8244−
8245−function container(pos,elem) {
8246− var e = render(elem);
8247− setPos(pos, elem, e);
8248− var div = newElement('div');
8249− div.style.position = 'relative';
8250− div.style.overflow = 'hidden';
8251− div.appendChild(e);
8252− return div;
8253−}
8254−
8255−function rawHtml(elem) {
8256− var html = elem.html;
8257− var args = elem.args;
8258− var guid = elem.guid;
8259− var align = elem.align;
8260−
8261− var div = newElement('div');
8262− div.innerHTML = html;
8263− div.style.visibility = "hidden";
8264− if (align) div.style.textAlign = align;
8265− document.body.appendChild(div);
8266−
8267− for (var i = args.length; i--; ) {
8268− var arg = args[i];
8269− var span = document.getElementById('md-' + guid + '-' + i);
8270− if (arg.isText) {
8271− span.innerHTML = arg;
8272− } else {
8273− span.style.display = 'block';
8274− span.style.width = arg.props.width + 'px';
8275− span.style.height = arg.props.height + 'px';
8276− span.appendChild(render(arg));
8277− }
8278− }
8279− document.body.removeChild(div);
8280− div.style.visibility = 'visible';
8281− return div;
8282−}
8283−
8284−function render(elem) { return setProps(elem, makeElement(elem)); }
8285−function makeElement(e) {
8286− var elem = e.element;
8287− switch(elem.ctor) {
8288− case 'Image': return image(e.props, elem);
8289− case 'Flow': return flow(elem._0, elem._1);
8290− case 'Container': return container(elem._0, elem._1);
8291− case 'Spacer': return newElement('div');
8292− case 'RawHtml': return rawHtml(elem);
8293− case 'Custom': return elem.render(elem.model);
8294− }
8295−}
8296−
8297−function update(node, curr, next) {
8298− if (node.tagName === 'A') { node = node.firstChild; }
8299− if (curr.props.id === next.props.id) return updateProps(node, curr, next);
8300− if (curr.element.ctor !== next.element.ctor) {
8301− node.parentNode.replaceChild(render(next),node);
8302− return true;
8303− }
8304− var nextE = next.element, currE = curr.element;
8305− switch(nextE.ctor) {
8306− case "Spacer": break;
8307− case "RawHtml":
8308− // only markdown blocks have guids, so this must be a text block
8309− if (nextE.guid === null) {
8310− if(currE.html.valueOf() !== nextE.html.valueOf()) {
8311− node.innerHTML = nextE.html;
8312− }
8313− break;
8314− }
8315− if (nextE.guid !== currE.guid) {
8316− node.parentNode.replaceChild(render(next),node);
8317− return true;
8318− }
8319− var nargs = nextE.args;
8320− var cargs = currE.args;
8321− for (var i = nargs.length; i--; ) {
8322− var narg = nargs[i];
8323− var carg = cargs[i]
8324− if (narg == carg) continue;
8325− var span = document.getElementById('md-' + currE.guid + '-' + i);
8326− if (narg.isElement) {
8327− if (carg.isElement) {
8328− update(span, carg, narg);
8329− } else {
8330− span.style.display = 'block';
8331− var e = render(narg);
8332− span.innerHTML = '';
8333− span.appendChild(e);
8334− }
8335− } else {
8336− span.style.display = 'inline';
8337− span.innerHTML = narg;
8338− }
8339− }
8340− break;
8341− case "Image":
8342− if (nextE._0.ctor === 'Plain') {
8343− if (nextE._3 !== currE._3) node.src = nextE._3;
8344− } else if (!eq(nextE,currE) ||
8345− next.props.width !== curr.props.width ||
8346− next.props.height !== curr.props.height) {
8347− node.parentNode.replaceChild(render(next),node);
8348− return true;
8349− }
8350− break;
8351− case "Flow":
8352− var arr = fromList(nextE._1);
8353− for (var i = arr.length; i--; ) { arr[i] = arr[i].element.ctor; }
8354− if (nextE._0.ctor !== currE._0.ctor) {
8355− node.parentNode.replaceChild(render(next),node);
8356− return true;
8357− }
8358− var nexts = fromList(nextE._1);
8359− var kids = node.childNodes;
8360− if (nexts.length !== kids.length) {
8361− node.parentNode.replaceChild(render(next),node);
8362− return true;
8363− }
8364− var currs = fromList(currE._1);
8365− var goDir = function(x) { return x; };
8366− switch(nextE._0.ctor) {
8367− case "DDown": case "DUp": goDir = goDown; break;
8368− case "DRight": case "DLeft": goDir = goRight; break;
8369− case "DOut": case "DIn": goDir = goIn; break;
8370− }
8371− for (var i = kids.length; i-- ;) {
8372− update(kids[i],currs[i],nexts[i]);
8373− goDir(kids[i]);
8374− }
8375− break;
8376− case "Container":
8377− update(node.firstChild, currE._1, nextE._1);
8378− setPos(nextE._0, nextE._1, node.firstChild);
8379− break;
8380− case "Custom":
8381− if (currE.type === nextE.type) {
8382− var done = nextE.update(node, currE.model, nextE.model);
8383− if (done) return;
8384− } else {
8385− return node.parentNode.replaceChild(render(next), node);
8386− }
8387− }
8388− updateProps(node, curr, next);
8389−}
8390−
8391−function updateProps(node, curr, next) {
8392− var props = next.props;
8393− var currP = curr.props;
8394− var e = node;
8395− var element = next.element;
8396− var width = props.width - (element.adjustWidth || 0);
8397− var height = props.height - (element.adjustHeight || 0);
8398− if (width !== currP.width) {
8399− e.style.width = (width|0) + 'px';
8400− }
8401− if (height !== currP.height) {
8402− e.style.height = (height|0) + 'px';
8403− }
8404− if (props.opacity !== currP.opacity) {
8405− e.style.opacity = props.opacity;
8406− }
8407− var nextColor = (props.color.ctor === 'Just' ?
8408− extract(props.color._0) : '');
8409− if (e.style.backgroundColor !== nextColor) {
8410− e.style.backgroundColor = (nextColor === '' ? 'transparent' : nextColor);
8411− }
8412− if (props.tag !== currP.tag) { e.id = props.tag; }
8413− if (props.href !== currP.href) {
8414− if (currP.href === '') {
8415− var a = newElement('a');
8416− a.href = props.href;
8417− a.style.width = '100%';
8418− a.style.height = '100%';
8419− a.style.top = 0;
8420− a.style.left = 0;
8421− a.style.display = 'block';
8422− a.style.position = 'absolute';
8423− e.style.position = 'relative';
8424− e.appendChild(a);
8425− } else {
8426− node.lastNode.href = props.href;
8427− }
8428− }
8429−
8430− // update hover handlers
8431− if (props.hover.ctor === '_Tuple0') {
8432− removeHover(e);
8433− } else if (e.elm_hover_handler) {
8434− e.elm_hover_handler = props.hover;
8435− } else {
8436− addHover(e, props.hover);
8437− }
8438−
8439− // update click handlers
8440− if (props.click.ctor === '_Tuple0') {
8441− removeClick(e);
8442− } else if (e.elm_click_handler) {
8443− e.elm_click_handler = props.click;
8444− } else {
8445− addClick(e, props.click);
8446− }
8447−}
8448−
8449−return { render:render, update:update };
8450−
8451−};
8452−ElmRuntime.Render.Utils = function() {
8453− function newElement(elementType) {
8454− var e = document.createElement(elementType);
8455− e.style.padding = "0";
8456− e.style.margin = "0";
8457− return e;
8458− }
8459−
8460− function addTo(container, elem) {
8461− container.appendChild(elem);
8462− }
8463−
8464− function extract(c) {
8465− if (c._3 === 1) { return 'rgb(' + c._0 + ', ' + c._1 + ', ' + c._2 + ')'; }
8466− return 'rgba(' + c._0 + ', ' + c._1 + ', ' + c._2 + ', ' + c._3 + ')';
8467− }
8468−
8469− function addTransform(style, trans) {
8470− style.transform = trans;
8471− style.msTransform = trans;
8472− style.MozTransform = trans;
8473− style.webkitTransform = trans;
8474− style.OTransform = trans;
8475− }
8476−
8477− function removeTransform(style) {
8478− style.transform = 'none';
8479− style.msTransform = 'none';
8480− style.MozTransform = 'none';
8481− style.webkitTransform = 'none';
8482− style.OTransform = 'none';
8483− }
8484−
8485− var List = Elm.Native.List.make({});
8486−
8487− return {addTo:addTo,
8488− newElement:newElement,
8489− extract : extract,
8490− fromList: List.toArray,
8491− fromString: function(s) { return s; },
8492− toString: function(s) { return s; },
8493− eq: Elm.Native.Utils.make({}).eq,
8494− addTransform: addTransform,
8495− removeTransform: removeTransform};
8496−};
8497−
8498−ElmRuntime.Render.Collage = function() {
8499−
8500−var Render = ElmRuntime.use(ElmRuntime.Render.Element);
8501−var Transform = Elm.Transform2D.make({});
8502−var Utils = ElmRuntime.use(ElmRuntime.Render.Utils);
8503−var newElement = Utils.newElement,
8504− extract = Utils.extract, fromList = Utils.fromList,
8505− fromString = Utils.fromString, addTransform = Utils.addTransform;
8506−
8507−function trace(ctx, path) {
8508− var points = fromList(path);
8509− var i = points.length - 1;
8510− if (i <= 0) return;
8511− ctx.moveTo(points[i]._0, points[i]._1);
8512− while (i--) { ctx.lineTo(points[i]._0, points[i]._1); }
8513− if (path.closed) {
8514− i = points.length - 1;
8515− ctx.lineTo(points[i]._0, points[i]._1);
8516− }
8517−}
8518−
8519−function line(ctx,style,path) {
8520− style.dashing.ctor === 'Nil' ? trace(ctx, path) : customLineHelp(ctx, style, path);
8521− ctx.scale(1,-1);
8522− ctx.stroke();
8523−}
8524−
8525−function customLineHelp(ctx, style, path) {
8526− var points = fromList(path);
8527− if (path.closed) points.push(points[0]);
8528− var pattern = fromList(style.dashing);
8529− var i = points.length - 1;
8530− if (i <= 0) return;
8531− var x0 = points[i]._0, y0 = points[i]._1;
8532− var x1=0, y1=0, dx=0, dy=0, remaining=0, nx=0, ny=0;
8533− var pindex = 0, plen = pattern.length;
8534− var draw = true, segmentLength = pattern[0];
8535− ctx.moveTo(x0,y0);
8536− while (i--) {
8537− x1 = points[i]._0; y1 = points[i]._1;
8538− dx = x1 - x0; dy = y1 - y0;
8539− remaining = Math.sqrt(dx * dx + dy * dy);
8540− while (segmentLength <= remaining) {
8541− x0 += dx * segmentLength / remaining;
8542− y0 += dy * segmentLength / remaining;
8543− ctx[draw ? 'lineTo' : 'moveTo'](x0, y0);
8544− // update starting position
8545− dx = x1 - x0; dy = y1 - y0;
8546− remaining = Math.sqrt(dx * dx + dy * dy);
8547− // update pattern
8548− draw = !draw;
8549− pindex = (pindex + 1) % plen;
8550− segmentLength = pattern[pindex];
8551− }
8552− if (remaining > 0) {
8553− ctx[draw ? 'lineTo' : 'moveTo'](x1, y1);
8554− segmentLength -= remaining;
8555− }
8556− x0 = x1; y0 = y1;
8557− }
8558−}
8559−
8560−function drawLine(ctx, style, path) {
8561− ctx.lineWidth = style.width;
8562− var cap = style.cap.ctor;
8563− ctx.lineCap = cap === 'Flat' ? 'butt' :
8564− cap === 'Round' ? 'round' : 'square';
8565− var join = style.join.ctor;
8566− ctx.lineJoin = join === 'Smooth' ? 'round' :
8567− join === 'Sharp' ? 'miter' : 'bevel';
8568− ctx.miterLimit = style.join._0 || 10;
8569− ctx.strokeStyle = extract(style.color);
8570− return line(ctx, style, path);
8571−}
8572−
8573−function texture(redo, ctx, src) {
8574− var img = new Image();
8575− img.src = fromString(src);
8576− img.onload = redo;
8577− return ctx.createPattern(img, 'repeat');
8578−}
8579−
8580−function gradient(ctx, grad) {
8581− var g;
8582− var stops = [];
8583− if (grad.ctor === 'Linear') {
8584− var p0 = grad._0, p1 = grad._1;
8585− g = ctx.createLinearGradient(p0._0, -p0._1, p1._0, -p1._1);
8586− stops = fromList(grad._2);
8587− } else {
8588− var p0 = grad._0, p2 = grad._2;
8589− g = ctx.createRadialGradient(p0._0, -p0._1, grad._1, p2._0, -p2._1, grad._3);
8590− stops = fromList(grad._4);
8591− }
8592− var len = stops.length;
8593− for (var i = 0; i < len; ++i) {
8594− var stop = stops[i];
8595− g.addColorStop(stop._0, extract(stop._1));
8596− }
8597− return g;
8598−}
8599−
8600−function drawShape(redo, ctx, style, path) {
8601− trace(ctx, path);
8602− var sty = style.ctor;
8603− ctx.fillStyle =
8604− sty === 'Solid' ? extract(style._0) :
8605− sty === 'Texture' ? texture(redo, ctx, style._0) : gradient(ctx, style._0);
8606− ctx.scale(1,-1);
8607− ctx.fill();
8608−}
8609−
8610−function drawImage(redo, ctx, form) {
8611− var img = new Image();
8612− img.onload = redo;
8613− img.src = fromString(form._3);
8614− var w = form._0,
8615− h = form._1,
8616− pos = form._2,
8617− srcX = pos._0,
8618− srcY = pos._1,
8619− srcW = w,
8620− srcH = h,
8621− destX = -w/2,
8622− destY = -h/2,
8623− destW = w,
8624− destH = h;
8625−
8626− ctx.scale(1,-1);
8627− ctx.drawImage(img, srcX, srcY, srcW, srcH, destX, destY, destW, destH);
8628−}
8629−
8630−function renderForm(redo, ctx, form) {
8631− ctx.save();
8632− var x = form.x, y = form.y, theta = form.theta, scale = form.scale;
8633− if (x !== 0 || y !== 0) ctx.translate(x, y);
8634− if (theta !== 0) ctx.rotate(theta);
8635− if (scale !== 1) ctx.scale(scale,scale);
8636− if (form.alpha !== 1) ctx.globalAlpha = ctx.globalAlpha * form.alpha;
8637− ctx.beginPath();
8638− var f = form.form;
8639− switch(f.ctor) {
8640− case 'FPath' : drawLine(ctx, f._0, f._1); break;
8641− case 'FImage': drawImage(redo, ctx, f); break;
8642− case 'FShape':
8643− if (f._0.ctor === 'Left') {
8644− f._1.closed = true;
8645− drawLine(ctx, f._0._0, f._1);
8646− } else {
8647− drawShape(redo, ctx, f._0._0, f._1);
8648− }
8649− break;
8650− }
8651− ctx.restore();
8652−}
8653−
8654−function formToMatrix(form) {
8655− var scale = form.scale;
8656− var matrix = A6( Transform.matrix, scale, 0, 0, scale, form.x, form.y );
8657−
8658− var theta = form.theta
8659− if (theta !== 0)
8660− matrix = A2( Transform.multiply, matrix, Transform.rotation(theta) );
8661−
8662− return matrix;
8663−}
8664−
8665−function str(n) {
8666− if (n < 0.00001 && n > -0.00001) return 0;
8667− return n;
8668−}
8669−
8670−function makeTransform(w, h, form, matrices) {
8671− var props = form.form._0.props;
8672− var m = A6( Transform.matrix, 1, 0, 0, -1,
8673− (w - props.width ) / 2,
8674− (h - props.height) / 2 );
8675− var len = matrices.length;
8676− for (var i = 0; i < len; ++i) { m = A2( Transform.multiply, m, matrices[i] ); }
8677− m = A2( Transform.multiply, m, formToMatrix(form) );
8678−
8679− return 'matrix(' + str( m[0]) + ', ' + str( m[3]) + ', ' +
8680− str(-m[1]) + ', ' + str(-m[4]) + ', ' +
8681− str( m[2]) + ', ' + str( m[5]) + ')';
8682−}
8683−
8684−function stepperHelp(list) {
8685− var arr = fromList(list);
8686− var i = 0;
8687− function peekNext() {
8688− return i < arr.length ? arr[i].form.ctor : '';
8689− }
8690− // assumes that there is a next element
8691− function next() {
8692− var out = arr[i];
8693− ++i;
8694− return out;
8695− }
8696− return { peekNext:peekNext, next:next };
8697−}
8698−
8699−function formStepper(forms) {
8700− var ps = [stepperHelp(forms)];
8701− var matrices = [];
8702− var alphas = [];
8703− function peekNext() {
8704− var len = ps.length;
8705− var formType = '';
8706− for (var i = 0; i < len; ++i ) {
8707− if (formType = ps[i].peekNext()) return formType;
8708− }
8709− return '';
8710− }
8711− // assumes that there is a next element
8712− function next(ctx) {
8713− while (!ps[0].peekNext()) {
8714− ps.shift();
8715− matrices.pop();
8716− alphas.shift();
8717− if (ctx) { ctx.restore(); }
8718− }
8719− var out = ps[0].next();
8720− var f = out.form;
8721− if (f.ctor === 'FGroup') {
8722− ps.unshift(stepperHelp(f._1));
8723− var m = A2(Transform.multiply, f._0, formToMatrix(out));
8724− ctx.save();
8725− ctx.transform(m[0], m[3], m[1], m[4], m[2], m[5]);
8726− matrices.push(m);
8727−
8728− var alpha = (alphas[0] || 1) * out.alpha;
8729− alphas.unshift(alpha);
8730− ctx.globalAlpha = alpha;
8731− }
8732− return out;
8733− }
8734− function transforms() { return matrices; }
8735− function alpha() { return alphas[0] || 1; }
8736− return { peekNext:peekNext, next:next, transforms:transforms, alpha:alpha };
8737−}
8738−
8739−function makeCanvas(w,h) {
8740− var canvas = newElement('canvas');
8741− canvas.style.width = w + 'px';
8742− canvas.style.height = h + 'px';
8743− canvas.style.display = "block";
8744− canvas.style.position = "absolute";
8745− canvas.width = w;
8746− canvas.height = h;
8747− return canvas;
8748−}
8749−
8750−function render(model) {
8751− var div = newElement('div');
8752− div.style.overflow = 'hidden';
8753− div.style.position = 'relative';
8754− update(div, model, model);
8755− return div;
8756−}
8757−
8758−function nodeStepper(w,h,div) {
8759− var kids = div.childNodes;
8760− var i = 0;
8761− function transform(transforms, ctx) {
8762− ctx.translate(w/2, h/2);
8763− ctx.scale(1,-1);
8764− var len = transforms.length;
8765− for (var i = 0; i < len; ++i) {
8766− var m = transforms[i];
8767− ctx.save();
8768− ctx.transform(m[0], m[3], m[1], m[4], m[2], m[5]);
8769− }
8770− return ctx;
8771− }
8772− function nextContext(transforms) {
8773− while (i < kids.length) {
8774− var node = kids[i];
8775− if (node.getContext) {
8776− node.width = w;
8777− node.height = h;
8778− node.style.width = w + 'px';
8779− node.style.height = h + 'px';
8780− ++i;
8781− return transform(transforms, node.getContext('2d'));
8782− }
8783− div.removeChild(node);
8784− }
8785− var canvas = makeCanvas(w,h);
8786− div.appendChild(canvas);
8787− // we have added a new node, so we must step our position
8788− ++i;
8789− return transform(transforms, canvas.getContext('2d'));
8790− }
8791− function addElement(matrices, alpha, form) {
8792− var kid = kids[i];
8793− var elem = form.form._0;
8794−
8795− var node = (!kid || kid.getContext)
8796− ? Render.render(elem)
8797− : (Render.update(kid, kid.oldElement, elem), kids[i]);
8798−
8799− node.style.position = 'absolute';
8800− node.style.opacity = alpha * form.alpha;
8801− addTransform(node.style, makeTransform(w, h, form, matrices));
8802− node.oldElement = elem;
8803− ++i;
8804− if (!kid) {
8805− div.appendChild(node);
8806− } else if (kid.getContext) {
8807− div.insertBefore(node, kid);
8808− }
8809− }
8810− function clearRest() {
8811− while (i < kids.length) {
8812− div.removeChild(kids[i]);
8813− }
8814− }
8815− return { nextContext:nextContext, addElement:addElement, clearRest:clearRest };
8816−}
8817−
8818−
8819−function update(div, _, model) {
8820− var w = model.w;
8821− var h = model.h;
8822−
8823− var forms = formStepper(model.forms);
8824− var nodes = nodeStepper(w,h,div);
8825− var ctx = null;
8826− var formType = '';
8827−
8828− while (formType = forms.peekNext()) {
8829− // make sure we have context if we need it
8830− if (ctx === null && formType !== 'FElement') {
8831− ctx = nodes.nextContext(forms.transforms());
8832− ctx.globalAlpha = forms.alpha();
8833− }
8834−
8835− var form = forms.next(ctx);
8836− // if it is FGroup, all updates are made within formStepper when next is called.
8837− if (formType === 'FElement') {
8838− // update or insert an element, get a new context
8839− nodes.addElement(forms.transforms(), forms.alpha(), form);
8840− ctx = null;
8841− } else if (formType !== 'FGroup') {
8842− renderForm(function() { update(div, model, model); }, ctx, form);
8843− }
8844− }
8845− nodes.clearRest();
8846− return false;
8847−}
8848−
8849−return { render:render, update:update };
8850−
8851−};
8852−Elm.Main = Elm.Main || {};
8853−Elm.Main.make = function (_elm) {
8854− "use strict";
8855− _elm.Main = _elm.Main || {};
8856− if (_elm.Main.values)
8857− return _elm.Main.values;
8858− var _N = Elm.Native,
8859− _U = _N.Utils.make(_elm),
8860− _L = _N.List.make(_elm),
8861− _E = _N.Error.make(_elm),
8862− $moduleName = "Main";
8863− var Basics = Elm.Basics.make(_elm);
8864− var Color = Elm.Color.make(_elm);
8865− var ElmTest = ElmTest || {};
8866− ElmTest.Assertion = Elm.ElmTest.Assertion.make(_elm);
8867− var ElmTest = ElmTest || {};
8868− ElmTest.Run = Elm.ElmTest.Run.make(_elm);
8869− var ElmTest = ElmTest || {};
8870− ElmTest.Runner = ElmTest.Runner || {};
8871− ElmTest.Runner.Console = Elm.ElmTest.Runner.Console.make(_elm);
8872− var ElmTest = ElmTest || {};
8873− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
8874− var Graphics = Graphics || {};
8875− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
8876− var Graphics = Graphics || {};
8877− Graphics.Element = Elm.Graphics.Element.make(_elm);
8878− var IO = IO || {};
8879− IO.IO = Elm.IO.IO.make(_elm);
8880− var IO = IO || {};
8881− IO.Runner = Elm.IO.Runner.make(_elm);
8882− var List = Elm.List.make(_elm);
8883− var Maybe = Elm.Maybe.make(_elm);
8884− var Native = Native || {};
8885− Native.Json = Elm.Native.Json.make(_elm);
8886− var Native = Native || {};
8887− Native.Ports = Elm.Native.Ports.make(_elm);
8888− var Signal = Elm.Signal.make(_elm);
8889− var String = Elm.String.make(_elm);
8890− var Text = Elm.Text.make(_elm);
8891− var Time = Elm.Time.make(_elm);
8892− var _op = {};
8893− var responses = Native.Ports.portIn("responses",
8894− Native.Ports.incomingSignal(function (v) {
8895− return v === null ? Maybe.Nothing : Maybe.Just(typeof v === "string" || typeof v === "object" && v instanceof String ? v : _E.raise("invalid input, expecting JSString but got " + v));
8896− }));
8897− var tests = _L.fromArray([A2(ElmTest.Test.equals,
8898− 0,
8899− 1)]);
8900− var console = ElmTest.Runner.Console.runDisplay(tests);
8901− var requests = Native.Ports.portOut("requests",
8902− Native.Ports.outgoingSignal(function (v) {
8903− return _L.toArray(v).map(function (v) {
8904− return {mPut: v.mPut.ctor === "Nothing" ? null : v.mPut._0
8905− ,mExit: v.mExit.ctor === "Nothing" ? null : v.mExit._0
8906− ,mGet: v.mGet};
8907− });
8908− }),
8909− A2(IO.Runner.run,
8910− responses,
8911− console));
8912− _elm.Main.values = {_op: _op
8913− ,tests: tests
8914− ,console: console};
8915− return _elm.Main.values;
8916−};Elm.IO = Elm.IO || {};
8917−Elm.IO.Runner = Elm.IO.Runner || {};
8918−Elm.IO.Runner.make = function (_elm) {
8919− "use strict";
8920− _elm.IO = _elm.IO || {};
8921− _elm.IO.Runner = _elm.IO.Runner || {};
8922− if (_elm.IO.Runner.values)
8923− return _elm.IO.Runner.values;
8924− var _N = Elm.Native,
8925− _U = _N.Utils.make(_elm),
8926− _L = _N.List.make(_elm),
8927− _E = _N.Error.make(_elm),
8928− $moduleName = "IO.Runner";
8929− var Automaton = Elm.Automaton.make(_elm);
8930− var Basics = Elm.Basics.make(_elm);
8931− var Color = Elm.Color.make(_elm);
8932− var Either = Elm.Either.make(_elm);
8933− var Graphics = Graphics || {};
8934− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
8935− var Graphics = Graphics || {};
8936− Graphics.Element = Elm.Graphics.Element.make(_elm);
8937− var IO = IO || {};
8938− IO.IO = Elm.IO.IO.make(_elm);
8939− var List = Elm.List.make(_elm);
8940− var Maybe = Elm.Maybe.make(_elm);
8941− var Native = Native || {};
8942− Native.Json = Elm.Native.Json.make(_elm);
8943− var Native = Native || {};
8944− Native.Ports = Elm.Native.Ports.make(_elm);
8945− var Signal = Elm.Signal.make(_elm);
8946− var String = Elm.String.make(_elm);
8947− var Text = Elm.Text.make(_elm);
8948− var Time = Elm.Time.make(_elm);
8949− var _op = {};
8950− var put = F2(function (s,_v0) {
8951− return function () {
8952− return {ctor: "_Tuple2"
8953− ,_0: s
8954− ,_1: {ctor: "_Tuple0"}};
8955− }();
8956− });
8957− var ask = function (s) {
8958− return {ctor: "_Tuple2"
8959− ,_0: s
8960− ,_1: s};
8961− };
8962− _op[">>="] = F3(function (f,
8963− k,
8964− s) {
8965− return function () {
8966− var $ = f(s),
8967− s$ = $._0,
8968− y = $._1;
8969− return A2(k,y,s$);
8970− }();
8971− });
8972− var pure = F2(function (x,s) {
8973− return {ctor: "_Tuple2"
8974− ,_0: s
8975− ,_1: x};
8976− });
8977− var empty = {_: {}
8978− ,mExit: Maybe.Nothing
8979− ,mGet: false
8980− ,mPut: Maybe.Nothing};
8981− var putS = function (s) {
8982− return _U.replace([["mPut"
8983− ,Maybe.Just(s)]],
8984− empty);
8985− };
8986− var exit = function (n) {
8987− return _U.replace([["mExit"
8988− ,Maybe.Just(n)]],
8989− empty);
8990− };
8991− var getS = _U.replace([["mGet"
8992− ,true]],
8993− empty);
8994− var extractRequests = function (io) {
8995− return function () {
8996− switch (io.ctor)
8997− {case "Impure":
8998− return function () {
8999− switch (io._0.ctor)
9000− {case "Exit":
9001− return pure({ctor: "_Tuple2"
9002− ,_0: _L.fromArray([exit(io._0._0)])
9003− ,_1: io});
9004− case "GetC":
9005− return A2(_op[">>="],
9006− ask,
9007− function (st) {
9008− return function () {
9009− var _v10 = String.uncons(st.buffer);
9010− switch (_v10.ctor)
9011− {case "Just":
9012− switch (_v10._0.ctor)
9013− {case "_Tuple2":
9014− return A2(_op[">>="],
9015− put({_: {},buffer: _v10._0._1}),
9016− function (_v14) {
9017− return function () {
9018− return extractRequests(io._0._0(_v10._0._0));
9019− }();
9020− });}
9021− break;
9022− case "Nothing":
9023− return pure({ctor: "_Tuple2"
9024− ,_0: _L.fromArray([getS])
9025− ,_1: io});}
9026− _E.Case($moduleName,
9027− "between lines 51 and 55");
9028− }();
9029− });
9030− case "PutC":
9031− return A2(_op[">>="],
9032− extractRequests(io._0._1),
9033− function (_v16) {
9034− return function () {
9035− switch (_v16.ctor)
9036− {case "_Tuple2":
9037− return pure({ctor: "_Tuple2"
9038− ,_0: {ctor: "::"
9039− ,_0: putS(A2(String.cons,
9040− io._0._0,
9041− ""))
9042− ,_1: _v16._0}
9043− ,_1: _v16._1});}
9044− _E.Case($moduleName,
9045− "on line 47, column 22 to 61");
9046− }();
9047− });}
9048− _E.Case($moduleName,
9049− "between lines 45 and 55");
9050− }();
9051− case "Pure":
9052− return pure({ctor: "_Tuple2"
9053− ,_0: _L.fromArray([exit(0)])
9054− ,_1: IO.IO.Pure(io._0)});}
9055− _E.Case($moduleName,
9056− "between lines 43 and 55");
9057− }();
9058− };
9059− var step = F2(function (resp,
9060− _v20) {
9061− return function () {
9062− switch (_v20.ctor)
9063− {case "_Tuple2":
9064− return function () {
9065− var newST = function () {
9066− switch (resp.ctor)
9067− {case "Just":
9068− return _U.replace([["buffer"
9069− ,A2(String.append,
9070− _v20._1.buffer,
9071− resp._0)]],
9072− _v20._1);
9073− case "Nothing": return _v20._1;}
9074− _E.Case($moduleName,
9075− "between lines 59 and 62");
9076− }();
9077− var _ = A2(extractRequests,
9078− _v20._0,
9079− newST);
9080− var k = function () {
9081− switch (_.ctor)
9082− {case "_Tuple2":
9083− switch (_._1.ctor)
9084− {case "_Tuple2":
9085− return _._1._1;}
9086− break;}
9087− _E.Case($moduleName,
9088− "on line 62, column 27 to 51");
9089− }();
9090− var newST$ = function () {
9091− switch (_.ctor)
9092− {case "_Tuple2":
9093− switch (_._1.ctor)
9094− {case "_Tuple2": return _._0;}
9095− break;}
9096− _E.Case($moduleName,
9097− "on line 62, column 27 to 51");
9098− }();
9099− var rs = function () {
9100− switch (_.ctor)
9101− {case "_Tuple2":
9102− switch (_._1.ctor)
9103− {case "_Tuple2":
9104− return _._1._0;}
9105− break;}
9106− _E.Case($moduleName,
9107− "on line 62, column 27 to 51");
9108− }();
9109− return {ctor: "_Tuple2"
9110− ,_0: {ctor: "_Tuple2"
9111− ,_0: k
9112− ,_1: newST$}
9113− ,_1: rs};
9114− }();}
9115− _E.Case($moduleName,
9116− "between lines 59 and 63");
9117− }();
9118− });
9119− var start = {_: {},buffer: ""};
9120− var run = F2(function (resps,
9121− io) {
9122− return A3(Automaton.run,
9123− A2(Automaton.hiddenState,
9124− {ctor: "_Tuple2"
9125− ,_0: io
9126− ,_1: start},
9127− step),
9128− _L.fromArray([]),
9129− resps);
9130− });
9131− var orSig = F2(function (s1,
9132− s2) {
9133− return A2(Signal.merge,
9134− A2(Signal._op["<~"],
9135− Either.Left,
9136− s1),
9137− A2(Signal._op["<~"],
9138− Either.Right,
9139− s2));
9140− });
9141− var IOState = function (a) {
9142− return {_: {},buffer: a};
9143− };
9144− var Request = F3(function (a,
9145− b,
9146− c) {
9147− return {_: {}
9148− ,mExit: b
9149− ,mGet: c
9150− ,mPut: a};
9151− });
9152− _elm.IO.Runner.values = {_op: _op
9153− ,orSig: orSig
9154− ,start: start
9155− ,run: run
9156− ,empty: empty
9157− ,putS: putS
9158− ,exit: exit
9159− ,getS: getS
9160− ,extractRequests: extractRequests
9161− ,step: step
9162− ,pure: pure
9163− ,ask: ask
9164− ,put: put
9165− ,Request: Request
9166− ,IOState: IOState};
9167− return _elm.IO.Runner.values;
9168−};Elm.Automaton = Elm.Automaton || {};
9169−Elm.Automaton.make = function (_elm) {
9170− "use strict";
9171− _elm.Automaton = _elm.Automaton || {};
9172− if (_elm.Automaton.values)
9173− return _elm.Automaton.values;
9174− var _N = Elm.Native,
9175− _U = _N.Utils.make(_elm),
9176− _L = _N.List.make(_elm),
9177− _E = _N.Error.make(_elm),
9178− $moduleName = "Automaton";
9179− var Basics = Elm.Basics.make(_elm);
9180− var Color = Elm.Color.make(_elm);
9181− var Graphics = Graphics || {};
9182− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
9183− var Graphics = Graphics || {};
9184− Graphics.Element = Elm.Graphics.Element.make(_elm);
9185− var List = Elm.List.make(_elm);
9186− var Maybe = Elm.Maybe.make(_elm);
9187− var Native = Native || {};
9188− Native.Json = Elm.Native.Json.make(_elm);
9189− var Native = Native || {};
9190− Native.Ports = Elm.Native.Ports.make(_elm);
9191− var Signal = Elm.Signal.make(_elm);
9192− var String = Elm.String.make(_elm);
9193− var Text = Elm.Text.make(_elm);
9194− var Time = Elm.Time.make(_elm);
9195− var _op = {};
9196− var dequeue = function (q) {
9197− return function () {
9198− switch (q.ctor)
9199− {case "_Tuple2":
9200− switch (q._0.ctor)
9201− {case "[]": switch (q._1.ctor)
9202− {case "[]":
9203− return Maybe.Nothing;}
9204− break;}
9205− switch (q._1.ctor)
9206− {case "::":
9207− return Maybe.Just({ctor: "_Tuple2"
9208− ,_0: q._1._0
9209− ,_1: {ctor: "_Tuple2"
9210− ,_0: q._0
9211− ,_1: q._1._1}});
9212− case "[]":
9213− return dequeue({ctor: "_Tuple2"
9214− ,_0: _L.fromArray([])
9215− ,_1: List.reverse(q._0)});}
9216− break;}
9217− _E.Case($moduleName,
9218− "between lines 116 and 121");
9219− }();
9220− };
9221− var enqueue = F2(function (x,
9222− _v5) {
9223− return function () {
9224− switch (_v5.ctor)
9225− {case "_Tuple2":
9226− return {ctor: "_Tuple2"
9227− ,_0: {ctor: "::"
9228− ,_0: x
9229− ,_1: _v5._0}
9230− ,_1: _v5._1};}
9231− _E.Case($moduleName,
9232− "on line 115, column 22 to 31");
9233− }();
9234− });
9235− var empty = {ctor: "_Tuple2"
9236− ,_0: _L.fromArray([])
9237− ,_1: _L.fromArray([])};
9238− var Step = function (a) {
9239− return {ctor: "Step",_0: a};
9240− };
9241− var run = F3(function (auto,
9242− base,
9243− inputs) {
9244− return function () {
9245− var step = F2(function (a,
9246− _v9) {
9247− return function () {
9248− switch (_v9.ctor)
9249− {case "_Tuple2":
9250− switch (_v9._0.ctor)
9251− {case "Step":
9252− return _v9._0._0(a);}
9253− break;}
9254− _E.Case($moduleName,
9255− "on line 43, column 28 to 31");
9256− }();
9257− });
9258− return A2(Signal.lift,
9259− function (_v14) {
9260− return function () {
9261− switch (_v14.ctor)
9262− {case "_Tuple2":
9263− return _v14._1;}
9264− _E.Case($moduleName,
9265− "on line 44, column 23 to 24");
9266− }();
9267− },
9268− A3(Signal.foldp,
9269− step,
9270− {ctor: "_Tuple2"
9271− ,_0: auto
9272− ,_1: base},
9273− inputs));
9274− }();
9275− });
9276− var step = F2(function (a,
9277− _v18) {
9278− return function () {
9279− switch (_v18.ctor)
9280− {case "Step":
9281− return _v18._0(a);}
9282− _E.Case($moduleName,
9283− "on line 48, column 19 to 22");
9284− }();
9285− });
9286− var andThen = F2(function (f,
9287− g) {
9288− return Step(function (a) {
9289− return function () {
9290− var $ = A2(step,a,f),
9291− f$ = $._0,
9292− b = $._1;
9293− var $ = A2(step,b,g),
9294− g$ = $._0,
9295− c = $._1;
9296− return {ctor: "_Tuple2"
9297− ,_0: A2(andThen,f$,g$)
9298− ,_1: c};
9299− }();
9300− });
9301− });
9302− var loop = F2(function (state,
9303− auto) {
9304− return Step(function (input) {
9305− return function () {
9306− var _ = A2(step,
9307− {ctor: "_Tuple2"
9308− ,_0: input
9309− ,_1: state},
9310− auto);
9311− var auto$ = function () {
9312− switch (_.ctor)
9313− {case "_Tuple2":
9314− switch (_._1.ctor)
9315− {case "_Tuple2": return _._0;}
9316− break;}
9317− _E.Case($moduleName,
9318− "on line 68, column 54 to 77");
9319− }();
9320− var output = function () {
9321− switch (_.ctor)
9322− {case "_Tuple2":
9323− switch (_._1.ctor)
9324− {case "_Tuple2":
9325− return _._1._0;}
9326− break;}
9327− _E.Case($moduleName,
9328− "on line 68, column 54 to 77");
9329− }();
9330− var state$ = function () {
9331− switch (_.ctor)
9332− {case "_Tuple2":
9333− switch (_._1.ctor)
9334− {case "_Tuple2":
9335− return _._1._1;}
9336− break;}
9337− _E.Case($moduleName,
9338− "on line 68, column 54 to 77");
9339− }();
9340− return {ctor: "_Tuple2"
9341− ,_0: A2(loop,state$,auto$)
9342− ,_1: output};
9343− }();
9344− });
9345− });
9346− var combine = function (autos) {
9347− return Step(function (a) {
9348− return function () {
9349− var $ = List.unzip(A2(List.map,
9350− step(a),
9351− autos)),
9352− autos$ = $._0,
9353− bs = $._1;
9354− return {ctor: "_Tuple2"
9355− ,_0: combine(autos$)
9356− ,_1: bs};
9357− }();
9358− });
9359− };
9360− var pure = function (f) {
9361− return Step(function (x) {
9362− return {ctor: "_Tuple2"
9363− ,_0: pure(f)
9364− ,_1: f(x)};
9365− });
9366− };
9367− var state = F2(function (s,f) {
9368− return Step(function (x) {
9369− return function () {
9370− var s$ = A2(f,x,s);
9371− return {ctor: "_Tuple2"
9372− ,_0: A2(state,s$,f)
9373− ,_1: s$};
9374− }();
9375− });
9376− });
9377− var count = A2(state,
9378− 0,
9379− F2(function (_v36,c) {
9380− return function () {
9381− return c + 1;
9382− }();
9383− }));
9384− var hiddenState = F2(function (s,
9385− f) {
9386− return Step(function (x) {
9387− return function () {
9388− var $ = A2(f,x,s),
9389− s$ = $._0,
9390− out = $._1;
9391− return {ctor: "_Tuple2"
9392− ,_0: A2(hiddenState,s$,f)
9393− ,_1: out};
9394− }();
9395− });
9396− });
9397− var average = function (k) {
9398− return function () {
9399− var stepFull = F2(function (n,
9400− _v38) {
9401− return function () {
9402− switch (_v38.ctor)
9403− {case "_Tuple3":
9404− return function () {
9405− var _v43 = dequeue(_v38._0);
9406− switch (_v43.ctor)
9407− {case "Just":
9408− switch (_v43._0.ctor)
9409− {case "_Tuple2":
9410− return function () {
9411− var sum$ = _v38._2 + n - _v43._0._0;
9412− return {ctor: "_Tuple2"
9413− ,_0: {ctor: "_Tuple3"
9414− ,_0: A2(enqueue,n,_v43._0._1)
9415− ,_1: _v38._1
9416− ,_2: sum$}
9417− ,_1: sum$ / Basics.toFloat(_v38._1)};
9418− }();}
9419− break;
9420− case "Nothing":
9421− return {ctor: "_Tuple2"
9422− ,_0: {ctor: "_Tuple3"
9423− ,_0: _v38._0
9424− ,_1: _v38._1
9425− ,_2: _v38._2}
9426− ,_1: 0};}
9427− _E.Case($moduleName,
9428− "between lines 128 and 132");
9429− }();}
9430− _E.Case($moduleName,
9431− "between lines 128 and 132");
9432− }();
9433− });
9434− var step = F2(function (n,
9435− _v47) {
9436− return function () {
9437− switch (_v47.ctor)
9438− {case "_Tuple3":
9439− return _U.eq(_v47._1,
9440− k) ? A2(stepFull,
9441− n,
9442− {ctor: "_Tuple3"
9443− ,_0: _v47._0
9444− ,_1: _v47._1
9445− ,_2: _v47._2}) : {ctor: "_Tuple2"
9446− ,_0: {ctor: "_Tuple3"
9447− ,_0: A2(enqueue,n,_v47._0)
9448− ,_1: _v47._1 + 1
9449− ,_2: _v47._2 + n}
9450− ,_1: (_v47._2 + n) / (Basics.toFloat(_v47._1) + 1)};}
9451− _E.Case($moduleName,
9452− "between lines 125 and 126");
9453− }();
9454− });
9455− return A2(hiddenState,
9456− {ctor: "_Tuple3"
9457− ,_0: empty
9458− ,_1: 0
9459− ,_2: 0},
9460− step);
9461− }();
9462− };
9463− _elm.Automaton.values = {_op: _op
9464− ,pure: pure
9465− ,state: state
9466− ,hiddenState: hiddenState
9467− ,run: run
9468− ,step: step
9469− ,andThen: andThen
9470− ,combine: combine
9471− ,loop: loop
9472− ,count: count
9473− ,average: average};
9474− return _elm.Automaton.values;
9475−};Elm.ElmTest = Elm.ElmTest || {};
9476−Elm.ElmTest.Runner = Elm.ElmTest.Runner || {};
9477−Elm.ElmTest.Runner.Console = Elm.ElmTest.Runner.Console || {};
9478−Elm.ElmTest.Runner.Console.make = function (_elm) {
9479− "use strict";
9480− _elm.ElmTest = _elm.ElmTest || {};
9481− _elm.ElmTest.Runner = _elm.ElmTest.Runner || {};
9482− _elm.ElmTest.Runner.Console = _elm.ElmTest.Runner.Console || {};
9483− if (_elm.ElmTest.Runner.Console.values)
9484− return _elm.ElmTest.Runner.Console.values;
9485− var _N = Elm.Native,
9486− _U = _N.Utils.make(_elm),
9487− _L = _N.List.make(_elm),
9488− _E = _N.Error.make(_elm),
9489− $moduleName = "ElmTest.Runner.Console";
9490− var Basics = Elm.Basics.make(_elm);
9491− var Color = Elm.Color.make(_elm);
9492− var ElmTest = ElmTest || {};
9493− ElmTest.Runner = ElmTest.Runner || {};
9494− ElmTest.Runner.String = Elm.ElmTest.Runner.String.make(_elm);
9495− var ElmTest = ElmTest || {};
9496− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
9497− var Graphics = Graphics || {};
9498− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
9499− var Graphics = Graphics || {};
9500− Graphics.Element = Elm.Graphics.Element.make(_elm);
9501− var IO = IO || {};
9502− IO.IO = Elm.IO.IO.make(_elm);
9503− var List = Elm.List.make(_elm);
9504− var Maybe = Elm.Maybe.make(_elm);
9505− var Native = Native || {};
9506− Native.Json = Elm.Native.Json.make(_elm);
9507− var Native = Native || {};
9508− Native.Ports = Elm.Native.Ports.make(_elm);
9509− var Signal = Elm.Signal.make(_elm);
9510− var String = Elm.String.make(_elm);
9511− var Text = Elm.Text.make(_elm);
9512− var Time = Elm.Time.make(_elm);
9513− var _op = {};
9514− var runDisplay = function (tests) {
9515− return function () {
9516− var $ = ElmTest.Runner.String.runDisplay(tests),
9517− allPassed = $._0,
9518− results = $._1;
9519− return A2(IO.IO._op[">>"],
9520− IO.IO.putStrLn(results),
9521− function () {
9522− switch (allPassed)
9523− {case false:
9524− return IO.IO.exit(1);
9525− case true:
9526− return IO.IO.exit(0);}
9527− _E.Case($moduleName,
9528− "between lines 23 and 25");
9529− }());
9530− }();
9531− };
9532− _elm.ElmTest.Runner.Console.values = {_op: _op
9533− ,runDisplay: runDisplay};
9534− return _elm.ElmTest.Runner.Console.values;
9535−};Elm.ElmTest = Elm.ElmTest || {};
9536−Elm.ElmTest.Runner = Elm.ElmTest.Runner || {};
9537−Elm.ElmTest.Runner.String = Elm.ElmTest.Runner.String || {};
9538−Elm.ElmTest.Runner.String.make = function (_elm) {
9539− "use strict";
9540− _elm.ElmTest = _elm.ElmTest || {};
9541− _elm.ElmTest.Runner = _elm.ElmTest.Runner || {};
9542− _elm.ElmTest.Runner.String = _elm.ElmTest.Runner.String || {};
9543− if (_elm.ElmTest.Runner.String.values)
9544− return _elm.ElmTest.Runner.String.values;
9545− var _N = Elm.Native,
9546− _U = _N.Utils.make(_elm),
9547− _L = _N.List.make(_elm),
9548− _E = _N.Error.make(_elm),
9549− $moduleName = "ElmTest.Runner.String";
9550− var Basics = Elm.Basics.make(_elm);
9551− var Color = Elm.Color.make(_elm);
9552− var ElmTest = ElmTest || {};
9553− ElmTest.Run = Elm.ElmTest.Run.make(_elm);
9554− var ElmTest = ElmTest || {};
9555− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
9556− var Graphics = Graphics || {};
9557− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
9558− var Graphics = Graphics || {};
9559− Graphics.Element = Elm.Graphics.Element.make(_elm);
9560− var List = Elm.List.make(_elm);
9561− var Maybe = Elm.Maybe.make(_elm);
9562− var Native = Native || {};
9563− Native.Json = Elm.Native.Json.make(_elm);
9564− var Native = Native || {};
9565− Native.Ports = Elm.Native.Ports.make(_elm);
9566− var Signal = Elm.Signal.make(_elm);
9567− var String = Elm.String.make(_elm);
9568− var Text = Elm.Text.make(_elm);
9569− var Time = Elm.Time.make(_elm);
9570− var _op = {};
9571− var pretty = F2(function (_v0,
9572− r) {
9573− return function () {
9574− switch (_v0.ctor)
9575− {case "TestCase":
9576− return function () {
9577− switch (r.ctor)
9578− {case "Just":
9579− return _L.append(_v0._0,
9580− _L.append(": FAILED. ",r._0));
9581− case "Nothing":
9582− return _L.append(_v0._0,
9583− ": passed.");}
9584− _E.Case($moduleName,
9585− "between lines 29 and 33");
9586− }();}
9587− _E.Case($moduleName,
9588− "between lines 29 and 33");
9589− }();
9590− });
9591− var replicate = F2(function (n,
9592− c) {
9593− return function () {
9594− var go = function (n) {
9595− return _U.cmp(n,
9596− 0) < 1 ? _L.fromArray([]) : {ctor: "::"
9597− ,_0: c
9598− ,_1: go(n - 1)};
9599− };
9600− return String.fromList(go(n));
9601− }();
9602− });
9603− var vcat = function ($) {
9604− return List.concat(List.intersperse("\n")($));
9605− };
9606− var indent = function (n) {
9607− return function () {
9608− var indents = A2(replicate,
9609− n,
9610− _U.chr(" "));
9611− return function ($) {
9612− return vcat(List.map(String.append(indents))(String.lines($)));
9613− };
9614− }();
9615− };
9616− var runDisplay = function (ts) {
9617− return function () {
9618− var r = ElmTest.Run.report(ts);
9619− var passed = List.length(r.passes);
9620− var failed = List.length(r.failures);
9621− var summary = vcat(List.map(indent(2))(_L.fromArray([_L.append(String.show(List.length(ts)),
9622− " tests executed")
9623− ,_L.append(String.show(passed),
9624− " tests passed")
9625− ,_L.append(String.show(failed),
9626− " tests failed")])));
9627− var pass = _U.eq(failed,0);
9628− var results = pass ? _L.fromArray([]) : A3(List.zipWith,
9629− pretty,
9630− ts,
9631− r.results);
9632− return {ctor: "_Tuple2"
9633− ,_0: pass
9634− ,_1: vcat({ctor: "::"
9635− ,_0: summary
9636− ,_1: results})};
9637− }();
9638− };
9639− _elm.ElmTest.Runner.String.values = {_op: _op
9640− ,runDisplay: runDisplay};
9641− return _elm.ElmTest.Runner.String.values;
9642−};Elm.ElmTest = Elm.ElmTest || {};
9643−Elm.ElmTest.Run = Elm.ElmTest.Run || {};
9644−Elm.ElmTest.Run.make = function (_elm) {
9645− "use strict";
9646− _elm.ElmTest = _elm.ElmTest || {};
9647− _elm.ElmTest.Run = _elm.ElmTest.Run || {};
9648− if (_elm.ElmTest.Run.values)
9649− return _elm.ElmTest.Run.values;
9650− var _N = Elm.Native,
9651− _U = _N.Utils.make(_elm),
9652− _L = _N.List.make(_elm),
9653− _E = _N.Error.make(_elm),
9654− $moduleName = "ElmTest.Run";
9655− var Basics = Elm.Basics.make(_elm);
9656− var Color = Elm.Color.make(_elm);
9657− var ElmTest = ElmTest || {};
9658− ElmTest.Assertion = Elm.ElmTest.Assertion.make(_elm);
9659− var ElmTest = ElmTest || {};
9660− ElmTest.Test = Elm.ElmTest.Test.make(_elm);
9661− var Graphics = Graphics || {};
9662− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
9663− var Graphics = Graphics || {};
9664− Graphics.Element = Elm.Graphics.Element.make(_elm);
9665− var List = Elm.List.make(_elm);
9666− var Maybe = Elm.Maybe.make(_elm);
9667− var Native = Native || {};
9668− Native.Json = Elm.Native.Json.make(_elm);
9669− var Native = Native || {};
9670− Native.Ports = Elm.Native.Ports.make(_elm);
9671− var Signal = Elm.Signal.make(_elm);
9672− var String = Elm.String.make(_elm);
9673− var Text = Elm.Text.make(_elm);
9674− var Time = Elm.Time.make(_elm);
9675− var _op = {};
9676− var pass = function (m) {
9677− return function () {
9678− switch (m.ctor)
9679− {case "Just": return false;
9680− case "Nothing": return true;}
9681− _E.Case($moduleName,
9682− "between lines 33 and 37");
9683− }();
9684− };
9685− var fail = function ($) {
9686− return Basics.not(pass($));
9687− };
9688− var run = function (_v2) {
9689− return function () {
9690− switch (_v2.ctor)
9691− {case "TestCase":
9692− return function () {
9693− var runAssertion = F2(function (t,
9694− m) {
9695− return t({ctor: "_Tuple0"}) ? Maybe.Nothing : Maybe.Just(m);
9696− });
9697− return function () {
9698− switch (_v2._1.ctor)
9699− {case "AssertEqual":
9700− return runAssertion(_v2._1._0)(_L.append("Expected: ",
9701− _L.append(_v2._1._1,
9702− _L.append("; got: ",
9703− _v2._1._2))));
9704− case "AssertFalse":
9705− return runAssertion(_v2._1._0)("not False");
9706− case "AssertNotEqual":
9707− return runAssertion(_v2._1._0)(_L.append(_v2._1._1,
9708− _L.append(" equals ",
9709− _v2._1._2)));
9710− case "AssertTrue":
9711− return runAssertion(_v2._1._0)("not True");}
9712− _E.Case($moduleName,
9713− "between lines 25 and 31");
9714− }();
9715− }();}
9716− _E.Case($moduleName,
9717− "between lines 22 and 31");
9718− }();
9719− };
9720− var report = function (ts) {
9721− return function () {
9722− var results = A2(List.map,
9723− run,
9724− ts);
9725− var $ = A2(List.partition,
9726− pass,
9727− results),
9728− passes = $._0,
9729− fails = $._1;
9730− return {_: {}
9731− ,failures: fails
9732− ,passes: passes
9733− ,results: results};
9734− }();
9735− };
9736− var Report = F3(function (a,
9737− b,
9738− c) {
9739− return {_: {}
9740− ,failures: c
9741− ,passes: b
9742− ,results: a};
9743− });
9744− _elm.ElmTest.Run.values = {_op: _op
9745− ,run: run
9746− ,pass: pass
9747− ,fail: fail
9748− ,report: report
9749− ,Report: Report};
9750− return _elm.ElmTest.Run.values;
9751−};Elm.ElmTest = Elm.ElmTest || {};
9752−Elm.ElmTest.Test = Elm.ElmTest.Test || {};
9753−Elm.ElmTest.Test.make = function (_elm) {
9754− "use strict";
9755− _elm.ElmTest = _elm.ElmTest || {};
9756− _elm.ElmTest.Test = _elm.ElmTest.Test || {};
9757− if (_elm.ElmTest.Test.values)
9758− return _elm.ElmTest.Test.values;
9759− var _N = Elm.Native,
9760− _U = _N.Utils.make(_elm),
9761− _L = _N.List.make(_elm),
9762− _E = _N.Error.make(_elm),
9763− $moduleName = "ElmTest.Test";
9764− var Basics = Elm.Basics.make(_elm);
9765− var Color = Elm.Color.make(_elm);
9766− var ElmTest = ElmTest || {};
9767− ElmTest.Assertion = Elm.ElmTest.Assertion.make(_elm);
9768− var Graphics = Graphics || {};
9769− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
9770− var Graphics = Graphics || {};
9771− Graphics.Element = Elm.Graphics.Element.make(_elm);
9772− var List = Elm.List.make(_elm);
9773− var Maybe = Elm.Maybe.make(_elm);
9774− var Native = Native || {};
9775− Native.Json = Elm.Native.Json.make(_elm);
9776− var Native = Native || {};
9777− Native.Ports = Elm.Native.Ports.make(_elm);
9778− var Signal = Elm.Signal.make(_elm);
9779− var String = Elm.String.make(_elm);
9780− var Text = Elm.Text.make(_elm);
9781− var Time = Elm.Time.make(_elm);
9782− var _op = {};
9783− var TestCase = F2(function (a,
9784− b) {
9785− return {ctor: "TestCase"
9786− ,_0: a
9787− ,_1: b};
9788− });
9789− var test = F2(function (name,
9790− a) {
9791− return A2(TestCase,name,a);
9792− });
9793− var defaultTest = function (a) {
9794− return function () {
9795− var name = function () {
9796− switch (a.ctor)
9797− {case "AssertEqual":
9798− return _L.append(a._1,
9799− _L.append(" == ",a._2));
9800− case "AssertNotEqual":
9801− return _L.append(a._1,
9802− _L.append(" /= ",a._2));
9803− case "AssertTrue":
9804− return "True";}
9805− _E.Case($moduleName,
9806− "between lines 25 and 30");
9807− }();
9808− return A2(test,name,a);
9809− }();
9810− };
9811− var equals = F2(function (a,b) {
9812− return defaultTest(A2(ElmTest.Assertion.assertEqual,
9813− a,
9814− b));
9815− });
9816− _elm.ElmTest.Test.values = {_op: _op
9817− ,equals: equals
9818− ,test: test
9819− ,defaultTest: defaultTest
9820− ,TestCase: TestCase};
9821− return _elm.ElmTest.Test.values;
9822−};Elm.ElmTest = Elm.ElmTest || {};
9823−Elm.ElmTest.Assertion = Elm.ElmTest.Assertion || {};
9824−Elm.ElmTest.Assertion.make = function (_elm) {
9825− "use strict";
9826− _elm.ElmTest = _elm.ElmTest || {};
9827− _elm.ElmTest.Assertion = _elm.ElmTest.Assertion || {};
9828− if (_elm.ElmTest.Assertion.values)
9829− return _elm.ElmTest.Assertion.values;
9830− var _N = Elm.Native,
9831− _U = _N.Utils.make(_elm),
9832− _L = _N.List.make(_elm),
9833− _E = _N.Error.make(_elm),
9834− $moduleName = "ElmTest.Assertion";
9835− var Basics = Elm.Basics.make(_elm);
9836− var Color = Elm.Color.make(_elm);
9837− var Graphics = Graphics || {};
9838− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
9839− var Graphics = Graphics || {};
9840− Graphics.Element = Elm.Graphics.Element.make(_elm);
9841− var List = Elm.List.make(_elm);
9842− var Maybe = Elm.Maybe.make(_elm);
9843− var Native = Native || {};
9844− Native.Json = Elm.Native.Json.make(_elm);
9845− var Native = Native || {};
9846− Native.Ports = Elm.Native.Ports.make(_elm);
9847− var Signal = Elm.Signal.make(_elm);
9848− var String = Elm.String.make(_elm);
9849− var Text = Elm.Text.make(_elm);
9850− var Time = Elm.Time.make(_elm);
9851− var _op = {};
9852− var AssertNotEqual = F3(function (a,
9853− b,
9854− c) {
9855− return {ctor: "AssertNotEqual"
9856− ,_0: a
9857− ,_1: b
9858− ,_2: c};
9859− });
9860− var assertNotEqual = F2(function (a,
9861− b) {
9862− return A3(AssertNotEqual,
9863− function (_v0) {
9864− return function () {
9865− return !_U.eq(a,b);
9866− }();
9867− },
9868− String.show(a),
9869− String.show(b));
9870− });
9871− var AssertEqual = F3(function (a,
9872− b,
9873− c) {
9874− return {ctor: "AssertEqual"
9875− ,_0: a
9876− ,_1: b
9877− ,_2: c};
9878− });
9879− var assertEqual = F2(function (a,
9880− b) {
9881− return A3(AssertEqual,
9882− function (_v2) {
9883− return function () {
9884− return _U.eq(a,b);
9885− }();
9886− },
9887− String.show(a),
9888− String.show(b));
9889− });
9890− var assertionList = F2(function (xs,
9891− ys) {
9892− return A3(List.zipWith,
9893− assertEqual,
9894− xs,
9895− ys);
9896− });
9897− var AssertFalse = function (a) {
9898− return {ctor: "AssertFalse"
9899− ,_0: a};
9900− };
9901− var AssertTrue = function (a) {
9902− return {ctor: "AssertTrue"
9903− ,_0: a};
9904− };
9905− var assertT = AssertTrue;
9906− var assert = function (b) {
9907− return AssertTrue(function (_v4) {
9908− return function () {
9909− return b;
9910− }();
9911− });
9912− };
9913− _elm.ElmTest.Assertion.values = {_op: _op
9914− ,assertT: assertT
9915− ,assert: assert
9916− ,assertEqual: assertEqual
9917− ,assertionList: assertionList
9918− ,assertNotEqual: assertNotEqual
9919− ,AssertTrue: AssertTrue
9920− ,AssertFalse: AssertFalse
9921− ,AssertEqual: AssertEqual
9922− ,AssertNotEqual: AssertNotEqual};
9923− return _elm.ElmTest.Assertion.values;
9924−};Elm.IO = Elm.IO || {};
9925−Elm.IO.IO = Elm.IO.IO || {};
9926−Elm.IO.IO.make = function (_elm) {
9927− "use strict";
9928− _elm.IO = _elm.IO || {};
9929− _elm.IO.IO = _elm.IO.IO || {};
9930− if (_elm.IO.IO.values)
9931− return _elm.IO.IO.values;
9932− var _N = Elm.Native,
9933− _U = _N.Utils.make(_elm),
9934− _L = _N.List.make(_elm),
9935− _E = _N.Error.make(_elm),
9936− $moduleName = "IO.IO";
9937− var Basics = Elm.Basics.make(_elm);
9938− var Color = Elm.Color.make(_elm);
9939− var Graphics = Graphics || {};
9940− Graphics.Collage = Elm.Graphics.Collage.make(_elm);
9941− var Graphics = Graphics || {};
9942− Graphics.Element = Elm.Graphics.Element.make(_elm);
9943− var List = Elm.List.make(_elm);
9944− var Maybe = Elm.Maybe.make(_elm);
9945− var Native = Native || {};
9946− Native.Json = Elm.Native.Json.make(_elm);
9947− var Native = Native || {};
9948− Native.Ports = Elm.Native.Ports.make(_elm);
9949− var Signal = Elm.Signal.make(_elm);
9950− var String = Elm.String.make(_elm);
9951− var Text = Elm.Text.make(_elm);
9952− var Time = Elm.Time.make(_elm);
9953− var _op = {};
9954− var Impure = function (a) {
9955− return {ctor: "Impure"
9956− ,_0: a};
9957− };
9958− var Pure = function (a) {
9959− return {ctor: "Pure",_0: a};
9960− };
9961− var Exit = function (a) {
9962− return {ctor: "Exit",_0: a};
9963− };
9964− var GetC = function (a) {
9965− return {ctor: "GetC",_0: a};
9966− };
9967− var PutC = F2(function (a,b) {
9968− return {ctor: "PutC"
9969− ,_0: a
9970− ,_1: b};
9971− });
9972− var mapF = F2(function (f,iof) {
9973− return function () {
9974− switch (iof.ctor)
9975− {case "Exit":
9976− return Exit(iof._0);
9977− case "GetC":
9978− return GetC(function ($) {
9979− return f(iof._0($));
9980− });
9981− case "PutC": return A2(PutC,
9982− iof._0,
9983− f(iof._1));}
9984− _E.Case($moduleName,
9985− "between lines 77 and 80");
9986− }();
9987− });
9988− var foldIO = F3(function (pur,
9989− impur,
9990− io) {
9991− return function () {
9992− switch (io.ctor)
9993− {case "Impure":
9994− return impur(A2(mapF,
9995− A2(foldIO,pur,impur),
9996− io._0));
9997− case "Pure": return pur(io._0);}
9998− _E.Case($moduleName,
9999− "between lines 84 and 86");
10000− }();
10001− });
10002− var bind = F2(function (io,f) {
10003− return function () {
10004− switch (io.ctor)
10005− {case "Impure":
10006− return Impure(A2(mapF,
10007− A2(Basics.flip,bind,f),
10008− io._0));
10009− case "Pure": return f(io._0);}
10010− _E.Case($moduleName,
10011− "between lines 52 and 54");
10012− }();
10013− });
10014− _op[">>="] = bind;
10015− var seq = F2(function (x,y) {
10016− return A2(_op[">>="],
10017− x,
10018− function (_v11) {
10019− return function () {
10020− return y;
10021− }();
10022− });
10023− });
10024− _op[">>"] = seq;
10025− var forever = function (m) {
10026− return A2(_op[">>="],
10027− m,
10028− function (_v13) {
10029− return function () {
10030− return forever(m);
10031− }();
10032− });
10033− };
10034− var pure = Pure;
10035− var apply = F2(function (iof,
10036− iom) {
10037− return A2(_op[">>="],
10038− iof,
10039− function (f) {
10040− return A2(_op[">>="],
10041− iom,
10042− function (m) {
10043− return pure(f(m));
10044− });
10045− });
10046− });
10047− _op["<*>"] = apply;
10048− var mapIO = F2(function (f,xs) {
10049− return A3(List.foldr,
10050− function ($) {
10051− return F2(function (x,y) {
10052− return A2(_op[">>"],x,y);
10053− })(f($));
10054− },
10055− pure({ctor: "_Tuple0"}),
10056− xs);
10057− });
10058− var map = F2(function (f,io) {
10059− return function () {
10060− switch (io.ctor)
10061− {case "Impure":
10062− return Impure(A2(mapF,
10063− map(f),
10064− io._0));
10065− case "Pure":
10066− return Pure(f(io._0));}
10067− _E.Case($moduleName,
10068− "between lines 33 and 35");
10069− }();
10070− });
10071− var exit = function ($) {
10072− return Impure(Exit($));
10073− };
10074− var getChar = Impure(GetC(Pure));
10075− var readUntil = function (end) {
10076− return function () {
10077− var go = function (s) {
10078− return A2(_op[">>="],
10079− getChar,
10080− function (c) {
10081− return _U.eq(c,
10082− end) ? pure(s) : go(A2(String.append,
10083− s,
10084− A2(String.cons,c,"")));
10085− });
10086− };
10087− return go("");
10088− }();
10089− };
10090− var getLine = readUntil(_U.chr("\n"));
10091− var putChar = function (c) {
10092− return Impure(A2(PutC,
10093− c,
10094− Pure({ctor: "_Tuple0"})));
10095− };
10096− var putStr = function ($) {
10097− return mapIO(putChar)(String.toList($));
10098− };
10099− var putStrLn = function (s) {
10100− return A2(_op[">>"],
10101− putStr(s),
10102− putChar(_U.chr("\n")));
10103− };
10104− _elm.IO.IO.values = {_op: _op
10105− ,putChar: putChar
10106− ,getChar: getChar
10107− ,exit: exit
10108− ,putStr: putStr
10109− ,putStrLn: putStrLn
10110− ,readUntil: readUntil
10111− ,getLine: getLine
10112− ,map: map
10113− ,mapIO: mapIO
10114− ,pure: pure
10115− ,apply: apply
10116− ,bind: bind
10117− ,seq: seq
10118− ,forever: forever
10119− ,mapF: mapF
10120− ,foldIO: foldIO
10121− ,PutC: PutC
10122− ,GetC: GetC
10123− ,Exit: Exit
10124− ,Pure: Pure
10125− ,Impure: Impure};
10126− return _elm.IO.IO.values;
10127−};
10128−// Elm goes there ^
10129−(function(){
10130− var stdin = process.stdin;
10131− var handle = function(request) {
10132− // Debugging:
10133− //console.log("Bleh: %j", request);
10134− if (!(request.mPut === null)) {
10135− process.stdout.write(request.mPut);
10136− } else if (!(request.mExit === null)) {
10137− process.exit(request.mExit);
10138− } else if (request.mGet) {
10139− stdin.resume();
10140− }
10141− }
10142− var handler = function(reqs) {
10143− for (var i = 0; i < reqs.length; i++) {
10144− handle(reqs[i]);
10145− }
10146− }
10147− var worker = Elm.worker(Elm.Main
10148− , {responses: null }
10149− );
10150− worker.ports.requests.subscribe(handler);
10151−
10152− // Read
10153− stdin.on('data', function(chunk) {
10154− //console.log('Got' + chunk);
10155− stdin.pause();
10156− worker.ports.responses.send(chunk.toString());
10157− })
10158−
10159− // Start msg
10160− worker.ports.responses.send(null);
10161−})();
10162−} // Close the callback
10163−// Run!
10164−jsdom.env('<p>bleh</p>', [], callback);