git.iko.soy/elk
on master help sign in
Add Basic Library Testing Support (with failing test case as proof!)
0078e5aMax New
Elm.cabal+13−3
compare with master
unifiedsplit
@@ -236,10 +236,10 @@ Executable elm-doc
236 text,
236 text,
237 union-find
237 union-find
238
238
239−Test-Suite test-elm
239+Test-Suite compiler-tests
240 Type: exitcode-stdio-1.0
240 Type: exitcode-stdio-1.0
241− Hs-Source-Dirs: tests, compiler
241+ Hs-Source-Dirs: tests/hs, compiler
242− Main-is: Main.hs
242+ Main-is: CompilerTest.hs
243 other-modules: Tests.Compiler
243 other-modules: Tests.Compiler
244 Tests.Property
244 Tests.Property
245 Tests.Property.Arbitrary
245 Tests.Property.Arbitrary
@@ -276,3 +276,13 @@ Test-Suite test-elm
276 transformers >= 0.2,
276 transformers >= 0.2,
277 union-find,
277 union-find,
278 unordered-containers
278 unordered-containers
279+
280+Test-Suite lib-tests
281+ Type: exitcode-stdio-1.0
282+ Hs-Source-Dirs: tests/hs
283+ Main-is: LibTest.hs
284+ build-depends: base,
285+ directory,
286+ Elm,
287+ filepath,
288+ process >= 1.2
tests/elm/Test.elmnew file+25
@@ -0,0 +1,25 @@
1+module Main where
2+
3+import ElmTest.Assertion as A
4+import ElmTest.Run as R
5+import ElmTest.Runner.Console (runDisplay)
6+import ElmTest.Test (..)
7+
8+import IO.IO (..)
9+import IO.Runner (Request, Response)
10+import IO.Runner as Run
11+
12+{- Failing test to get it going -}
13+tests : [Test]
14+tests = [ 0 `equals` 1 ]
15+
16+console : IO ()
17+console = runDisplay tests
18+
19+port requests : Signal [{ mPut : Maybe String
20+ , mExit : Maybe Int
21+ , mGet : Bool
22+ }]
23+port requests = Run.run responses console
24+
25+port responses : Signal (Maybe String)
tests/elm/build/Test.htmlnew file+1277
@@ -0,0 +1,1277 @@
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.jsnew file+1276
@@ -0,0 +1,1276 @@
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.jsnew file+10164
@@ -0,0 +1,10164 @@
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);
tests/Main.hs → tests/hs/CompilerTest.hsrenamed

The content is the same.

tests/hs/LibTest.hsnew file+27
@@ -0,0 +1,27 @@
1+module Main where
2+
3+import System.Directory
4+import System.Exit
5+import System.FilePath
6+import System.Process
7+
8+import Elm.Internal.Paths as Elm
9+
10+main :: IO ()
11+main = do
12+ top <- getCurrentDirectory
13+ let ioScript s = top</>"IO"</>s
14+ runCmd "git submodule init"
15+ --runCmd "npm install jsdom"
16+ setCurrentDirectory $ top</>"tests"</>"elm"
17+ runCmd $ concat ["elm --make --only-js --src-dir=" , top</>"automaton", " --src-dir=", top</>"IO", " --src-dir=", top</>"Elm-Test", " Test.elm"]
18+ runCmd $ unwords ["cat ", ioScript "prescript.js", Elm.runtime, "build"</>"Test.js", ioScript "handler.js", "> exe.js"]
19+ exitWith =<< waitForProcess =<< (runCommand "node exe.js")
20+ where runCmd cmd = do
21+ putStrLn cmd
22+ exitCode <- waitForProcess =<< runCommand cmd
23+ case exitCode of
24+ ExitSuccess -> return ()
25+ ExitFailure _ -> error "something went wrong"
26+
27+
tests/Tests/Compiler.hs → tests/hs/Tests/Compiler.hsrenamed

The content is the same.

tests/Tests/Property.hs → tests/hs/Tests/Property.hsrenamed

The content is the same.

tests/Tests/Property/Arbitrary.hs → tests/hs/Tests/Property/Arbitrary.hsrenamed

The content is the same.

tests/test-files/bad/BBTArgs → tests/hs/test-files/bad/BBTArgsrenamed

The content is the same.

tests/test-files/bad/InfiniteType.elm → tests/hs/test-files/bad/InfiniteType.elmrenamed

The content is the same.

tests/test-files/bad/NonElementMain.elm → tests/hs/test-files/bad/NonElementMain.elmrenamed

The content is the same.

tests/test-files/bad/Strings/ExtraClose.elm → tests/hs/test-files/bad/Strings/ExtraClose.elmrenamed

The content is the same.

tests/test-files/good/AliasSubstitution.elm → tests/hs/test-files/good/AliasSubstitution.elmrenamed

The content is the same.

tests/test-files/good/NoExpressions.elm → tests/hs/test-files/good/NoExpressions.elmrenamed

The content is the same.

tests/test-files/good/Otherwise.elm → tests/hs/test-files/good/Otherwise.elmrenamed

The content is the same.

tests/test-files/good/Ports.elm → tests/hs/test-files/good/Ports.elmrenamed

The content is the same.

tests/test-files/good/QuotesAndComments.elm → tests/hs/test-files/good/QuotesAndComments.elmrenamed

The content is the same.

tests/test-files/good/Soundness/Apply.elm → tests/hs/test-files/good/Soundness/Apply.elmrenamed

The content is the same.

tests/test-files/good/Soundness/ApplyAnnotated.elm → tests/hs/test-files/good/Soundness/ApplyAnnotated.elmrenamed

The content is the same.

tests/test-files/good/Soundness/Id.elm → tests/hs/test-files/good/Soundness/Id.elmrenamed

The content is the same.

tests/test-files/good/Soundness/IdAnnotated.elm → tests/hs/test-files/good/Soundness/IdAnnotated.elmrenamed

The content is the same.

tests/test-files/good/Soundness/TrickyId.elm → tests/hs/test-files/good/Soundness/TrickyId.elmrenamed

The content is the same.

tests/test-files/good/Soundness/TrickyIdAnnotated.elm → tests/hs/test-files/good/Soundness/TrickyIdAnnotated.elmrenamed

The content is the same.

tests/test-files/good/Strings/Multiline.elm → tests/hs/test-files/good/Strings/Multiline.elmrenamed

The content is the same.

tests/test-files/good/Strings/MultilineNormal.elm → tests/hs/test-files/good/Strings/MultilineNormal.elmrenamed

The content is the same.

tests/test-files/good/Unify/LockedVars.elm → tests/hs/test-files/good/Unify/LockedVars.elmrenamed

The content is the same.

tests/test-files/good/Unify/NonHomogeneousRecords.elm → tests/hs/test-files/good/Unify/NonHomogeneousRecords.elmrenamed

The content is the same.