@@ -0,0 +1,736 @@
1+"use strict";
2+var Unit = {
3+ create: function (value) {
4+ return value;
5+ }
6+};
7+function LT() {
8+
9+};
10+LT.value = new LT();
11+function GT() {
12+
13+};
14+GT.value = new GT();
15+function EQ() {
16+
17+};
18+EQ.value = new EQ();
19+function Semigroupoid($less$less$less) {
20+ this["<<<"] = $less$less$less;
21+};
22+function Category(__superclass_Prelude$dotSemigroupoid_0, id) {
23+ this["__superclass_Prelude.Semigroupoid_0"] = __superclass_Prelude$dotSemigroupoid_0;
24+ this.id = id;
25+};
26+function Show(show) {
27+ this.show = show;
28+};
29+function Functor($less$dollar$greater) {
30+ this["<$>"] = $less$dollar$greater;
31+};
32+function Apply($less$times$greater, __superclass_Prelude$dotFunctor_0) {
33+ this["<*>"] = $less$times$greater;
34+ this["__superclass_Prelude.Functor_0"] = __superclass_Prelude$dotFunctor_0;
35+};
36+function Applicative(__superclass_Prelude$dotApply_0, pure) {
37+ this["__superclass_Prelude.Apply_0"] = __superclass_Prelude$dotApply_0;
38+ this.pure = pure;
39+};
40+function Alternative($less$bar$greater, empty) {
41+ this["<|>"] = $less$bar$greater;
42+ this.empty = empty;
43+};
44+function Bind($greater$greater$eq, __superclass_Prelude$dotApply_0) {
45+ this[">>="] = $greater$greater$eq;
46+ this["__superclass_Prelude.Apply_0"] = __superclass_Prelude$dotApply_0;
47+};
48+function Monad(__superclass_Prelude$dotApplicative_0, __superclass_Prelude$dotBind_1) {
49+ this["__superclass_Prelude.Applicative_0"] = __superclass_Prelude$dotApplicative_0;
50+ this["__superclass_Prelude.Bind_1"] = __superclass_Prelude$dotBind_1;
51+};
52+function Num($percent, $times, $plus, $minus, $div, negate) {
53+ this["%"] = $percent;
54+ this["*"] = $times;
55+ this["+"] = $plus;
56+ this["-"] = $minus;
57+ this["/"] = $div;
58+ this.negate = negate;
59+};
60+function Eq($div$eq, $eq$eq) {
61+ this["/="] = $div$eq;
62+ this["=="] = $eq$eq;
63+};
64+function Ord(__superclass_Prelude$dotEq_0, compare) {
65+ this["__superclass_Prelude.Eq_0"] = __superclass_Prelude$dotEq_0;
66+ this.compare = compare;
67+};
68+function Bits($amp, $up, complement, shl, shr, zshr, $bar) {
69+ this["&"] = $amp;
70+ this["^"] = $up;
71+ this.complement = complement;
72+ this.shl = shl;
73+ this.shr = shr;
74+ this.zshr = zshr;
75+ this["|"] = $bar;
76+};
77+function BoolLike($amp$amp, not, $bar$bar) {
78+ this["&&"] = $amp$amp;
79+ this.not = not;
80+ this["||"] = $bar$bar;
81+};
82+function Semigroup($less$greater) {
83+ this["<>"] = $less$greater;
84+};
85+function cons(e) { return function (l) { return [e].concat(l); };};
86+function showStringImpl(s) { return JSON.stringify(s);};
87+function showNumberImpl(n) { return n.toString();};
88+function showArrayImpl (f) { return function (xs) { var ss = []; for (var i = 0, l = xs.length; i < l; i++) { ss[i] = f(xs[i]); } return '[' + ss.join(',') + ']'; };};
89+function numAdd(n1) { return function(n2) { return n1 + n2; };};
90+function numSub(n1) { return function(n2) { return n1 - n2; };};
91+function numMul(n1) { return function(n2) { return n1 * n2; };};
92+function numDiv(n1) { return function(n2) { return n1 / n2; };};
93+function numMod(n1) { return function(n2) { return n1 % n2; };};
94+function numNegate(n) { return -n;};
95+function refEq(r1) { return function(r2) { return r1 === r2; };};
96+function refIneq(r1) { return function(r2) { return r1 !== r2; };};
97+function eqArrayImpl(f) { return function(xs) { return function(ys) { if (xs.length !== ys.length) return false; for (var i = 0; i < xs.length; i++) { if (!f(xs[i])(ys[i])) return false; } return true; }; };};
98+function unsafeCompareImpl(lt) { return function (eq) { return function (gt) { return function (x) { return function (y) { return x < y ? lt : x > y ? gt : eq; }; }; }; };};
99+function numShl(n1) { return function(n2) { return n1 << n2; };};
100+function numShr(n1) { return function(n2) { return n1 >> n2; };};
101+function numZshr(n1) { return function(n2) { return n1 >>> n2; };};
102+function numAnd(n1) { return function(n2) { return n1 & n2; };};
103+function numOr(n1) { return function(n2) { return n1 | n2; };};
104+function numXor(n1) { return function(n2) { return n1 ^ n2; };};
105+function numComplement(n) { return ~n;};
106+function boolAnd(b1) { return function(b2) { return b1 && b2; };};
107+function boolOr(b1) { return function(b2) { return b1 || b2; };};
108+function boolNot(b) { return !b;};
109+function concatString(s1) { return function(s2) { return s1 + s2; };};
110+var $bar$bar = function (dict) {
111+ return dict["||"];
112+};
113+var $bar = function (dict) {
114+ return dict["|"];
115+};
116+var $up = function (dict) {
117+ return dict["^"];
118+};
119+var $greater$greater$eq = function (dict) {
120+ return dict[">>="];
121+};
122+var $eq$eq = function (dict) {
123+ return dict["=="];
124+};
125+var $less$bar$greater = function (dict) {
126+ return dict["<|>"];
127+};
128+var $less$greater = function (dict) {
129+ return dict["<>"];
130+};
131+var $less$less$less = function (dict) {
132+ return dict["<<<"];
133+};
134+var $greater$greater$greater = function (__dict_Semigroupoid_0) {
135+ return function (f) {
136+ return function (g) {
137+ return $less$less$less(__dict_Semigroupoid_0)(g)(f);
138+ };
139+ };
140+};
141+var $less$times$greater = function (dict) {
142+ return dict["<*>"];
143+};
144+var $less$dollar$greater = function (dict) {
145+ return dict["<$>"];
146+};
147+var $colon = cons;
148+var $div$eq = function (dict) {
149+ return dict["/="];
150+};
151+var $div = function (dict) {
152+ return dict["/"];
153+};
154+var $minus = function (dict) {
155+ return dict["-"];
156+};
157+var $plus$plus = function (__dict_Semigroup_1) {
158+ return $less$greater(__dict_Semigroup_1);
159+};
160+var $plus = function (dict) {
161+ return dict["+"];
162+};
163+var $times = function (dict) {
164+ return dict["*"];
165+};
166+var $amp$amp = function (dict) {
167+ return dict["&&"];
168+};
169+var $amp = function (dict) {
170+ return dict["&"];
171+};
172+var $percent = function (dict) {
173+ return dict["%"];
174+};
175+var $dollar = function (f) {
176+ return function (x) {
177+ return f(x);
178+ };
179+};
180+var $hash = function (x) {
181+ return function (f) {
182+ return f(x);
183+ };
184+};
185+var zshr = function (dict) {
186+ return dict.zshr;
187+};
188+var unsafeCompare = unsafeCompareImpl(LT.value)(EQ.value)(GT.value);
189+var unit = {};
190+var shr = function (dict) {
191+ return dict.shr;
192+};
193+var showUnit = function (_) {
194+ return new Show(function (_7) {
195+ return (function (_29) {
196+ return "Unit {}";
197+ throw new Error("Failed pattern match");
198+ })(_7);
199+ });
200+};
201+var showString = function (_) {
202+ return new Show(showStringImpl);
203+};
204+var showOrdering = function (_) {
205+ return new Show(function (_15) {
206+ return (function (_30) {
207+ if (_30 instanceof LT) {
208+ return "LT";
209+ };
210+ if (_30 instanceof GT) {
211+ return "GT";
212+ };
213+ if (_30 instanceof EQ) {
214+ return "EQ";
215+ };
216+ throw new Error("Failed pattern match");
217+ })(_15);
218+ });
219+};
220+var showNumber = function (_) {
221+ return new Show(showNumberImpl);
222+};
223+var showBoolean = function (_) {
224+ return new Show(function (_8) {
225+ return (function (_31) {
226+ if (_31) {
227+ return "true";
228+ };
229+ if (!_31) {
230+ return "false";
231+ };
232+ throw new Error("Failed pattern match");
233+ })(_8);
234+ });
235+};
236+var show = function (dict) {
237+ return dict.show;
238+};
239+var showArray = function (__dict_Show_2) {
240+ return new Show(showArrayImpl(show(__dict_Show_2)));
241+};
242+var shl = function (dict) {
243+ return dict.shl;
244+};
245+var semigroupoidArr = function (_) {
246+ return new Semigroupoid(function (f) {
247+ return function (g) {
248+ return function (x) {
249+ return f(g(x));
250+ };
251+ };
252+ });
253+};
254+var semigroupUnit = function (_) {
255+ return new Semigroup(function (_22) {
256+ return function (_23) {
257+ return (function (_32, _33) {
258+ return {};
259+ throw new Error("Failed pattern match");
260+ })(_22, _23);
261+ };
262+ });
263+};
264+var semigroupString = function (_) {
265+ return new Semigroup(concatString);
266+};
267+var semigroupArr = function (__dict_Semigroup_3) {
268+ return new Semigroup(function (f) {
269+ return function (g) {
270+ return function (x) {
271+ return $less$greater(__dict_Semigroup_3)(f(x))(g(x));
272+ };
273+ };
274+ });
275+};
276+var pure = function (dict) {
277+ return dict.pure;
278+};
279+var $$return = function (__dict_Monad_4) {
280+ return pure(__dict_Monad_4["__superclass_Prelude.Applicative_0"]({}));
281+};
282+var numNumber = function (_) {
283+ return new Num(numMod, numMul, numAdd, numSub, numDiv, numNegate);
284+};
285+var not = function (dict) {
286+ return dict.not;
287+};
288+var negate = function (dict) {
289+ return dict.negate;
290+};
291+var liftM1 = function (__dict_Monad_5) {
292+ return function (f) {
293+ return function (a) {
294+ return $greater$greater$eq(__dict_Monad_5["__superclass_Prelude.Bind_1"]({}))(a)(function (_0) {
295+ return (function (_34) {
296+ var a$prime = _34;
297+ return $$return(__dict_Monad_5)(f(a$prime));
298+ throw new Error("Failed pattern match");
299+ })(_0);
300+ });
301+ };
302+ };
303+};
304+var liftA1 = function (__dict_Applicative_6) {
305+ return function (f) {
306+ return function (a) {
307+ return $less$times$greater(__dict_Applicative_6["__superclass_Prelude.Apply_0"]({}))(pure(__dict_Applicative_6)(f))(a);
308+ };
309+ };
310+};
311+var id = function (dict) {
312+ return dict.id;
313+};
314+var functorArr = function (_) {
315+ return new Functor($less$less$less(semigroupoidArr({})));
316+};
317+var flip = function (f) {
318+ return function (b) {
319+ return function (a) {
320+ return f(a)(b);
321+ };
322+ };
323+};
324+var eqUnit = function (_) {
325+ return new Eq(function (_11) {
326+ return function (_12) {
327+ return (function (_35, _36) {
328+ return false;
329+ throw new Error("Failed pattern match");
330+ })(_11, _12);
331+ };
332+ }, function (_9) {
333+ return function (_10) {
334+ return (function (_37, _38) {
335+ return true;
336+ throw new Error("Failed pattern match");
337+ })(_9, _10);
338+ };
339+ });
340+};
341+var ordUnit = function (_) {
342+ return new Ord(function (_) {
343+ return eqUnit({});
344+ }, function (_16) {
345+ return function (_17) {
346+ return (function (_39, _40) {
347+ return EQ.value;
348+ throw new Error("Failed pattern match");
349+ })(_16, _17);
350+ };
351+ });
352+};
353+var eqString = function (_) {
354+ return new Eq(refIneq, refEq);
355+};
356+var ordString = function (_) {
357+ return new Ord(function (_) {
358+ return eqString({});
359+ }, unsafeCompare);
360+};
361+var eqNumber = function (_) {
362+ return new Eq(refIneq, refEq);
363+};
364+var ordNumber = function (_) {
365+ return new Ord(function (_) {
366+ return eqNumber({});
367+ }, unsafeCompare);
368+};
369+var eqBoolean = function (_) {
370+ return new Eq(refIneq, refEq);
371+};
372+var ordBoolean = function (_) {
373+ return new Ord(function (_) {
374+ return eqBoolean({});
375+ }, function (_18) {
376+ return function (_19) {
377+ return (function (_41, _42) {
378+ if (!_41) {
379+ if (!_42) {
380+ return EQ.value;
381+ };
382+ };
383+ if (!_41) {
384+ if (_42) {
385+ return LT.value;
386+ };
387+ };
388+ if (_41) {
389+ if (_42) {
390+ return EQ.value;
391+ };
392+ };
393+ if (_41) {
394+ if (!_42) {
395+ return GT.value;
396+ };
397+ };
398+ throw new Error("Failed pattern match");
399+ })(_18, _19);
400+ };
401+ });
402+};
403+var empty = function (dict) {
404+ return dict.empty;
405+};
406+var $$const = function (_3) {
407+ return function (_4) {
408+ return (function (_43, _44) {
409+ var a = _43;
410+ return a;
411+ throw new Error("Failed pattern match");
412+ })(_3, _4);
413+ };
414+};
415+var $$void = function (__dict_Functor_8) {
416+ return function (fa) {
417+ return $less$dollar$greater(__dict_Functor_8)($$const(unit))(fa);
418+ };
419+};
420+var complement = function (dict) {
421+ return dict.complement;
422+};
423+var compare = function (dict) {
424+ return dict.compare;
425+};
426+var $less = function (__dict_Ord_10) {
427+ return function (a1) {
428+ return function (a2) {
429+ return (function (_45) {
430+ if (_45 instanceof LT) {
431+ return true;
432+ };
433+ return false;
434+ throw new Error("Failed pattern match");
435+ })(compare(__dict_Ord_10)(a1)(a2));
436+ };
437+ };
438+};
439+var $less$eq = function (__dict_Ord_11) {
440+ return function (a1) {
441+ return function (a2) {
442+ return (function (_46) {
443+ if (_46 instanceof GT) {
444+ return false;
445+ };
446+ return true;
447+ throw new Error("Failed pattern match");
448+ })(compare(__dict_Ord_11)(a1)(a2));
449+ };
450+ };
451+};
452+var $greater = function (__dict_Ord_12) {
453+ return function (a1) {
454+ return function (a2) {
455+ return (function (_47) {
456+ if (_47 instanceof GT) {
457+ return true;
458+ };
459+ return false;
460+ throw new Error("Failed pattern match");
461+ })(compare(__dict_Ord_12)(a1)(a2));
462+ };
463+ };
464+};
465+var $greater$eq = function (__dict_Ord_13) {
466+ return function (a1) {
467+ return function (a2) {
468+ return (function (_48) {
469+ if (_48 instanceof LT) {
470+ return false;
471+ };
472+ return true;
473+ throw new Error("Failed pattern match");
474+ })(compare(__dict_Ord_13)(a1)(a2));
475+ };
476+ };
477+};
478+var categoryArr = function (_) {
479+ return new Category(function (_) {
480+ return semigroupoidArr({});
481+ }, function (x) {
482+ return x;
483+ });
484+};
485+var boolLikeBoolean = function (_) {
486+ return new BoolLike(boolAnd, boolNot, boolOr);
487+};
488+var eqArray = function (__dict_Eq_7) {
489+ return new Eq(function (xs) {
490+ return function (ys) {
491+ return not(boolLikeBoolean({}))($eq$eq(eqArray(__dict_Eq_7))(xs)(ys));
492+ };
493+ }, function (xs) {
494+ return function (ys) {
495+ return eqArrayImpl($eq$eq(__dict_Eq_7))(xs)(ys);
496+ };
497+ });
498+};
499+var ordArray = function (__dict_Ord_9) {
500+ return new Ord(function (_) {
501+ return eqArray(__dict_Ord_9["__superclass_Prelude.Eq_0"]({}));
502+ }, function (_20) {
503+ return function (_21) {
504+ return (function (_49, _50) {
505+ if (_49.length === 0) {
506+ if (_50.length === 0) {
507+ return EQ.value;
508+ };
509+ };
510+ if (_49.length === 0) {
511+ return LT.value;
512+ };
513+ if (_50.length === 0) {
514+ return GT.value;
515+ };
516+ if (_49.length > 0) {
517+ var _54 = _49[0];
518+ var _55 = _49.slice(1);
519+ var xs = _55;
520+ var x = _54;
521+ if (_50.length > 0) {
522+ var _52 = _50[0];
523+ var _53 = _50.slice(1);
524+ var ys = _53;
525+ var y = _52;
526+ return (function (_51) {
527+ if (_51 instanceof EQ) {
528+ return compare(ordArray(__dict_Ord_9))(xs)(ys);
529+ };
530+ var other = _51;
531+ return other;
532+ throw new Error("Failed pattern match");
533+ })(compare(__dict_Ord_9)(x)(y));
534+ };
535+ };
536+ throw new Error("Failed pattern match");
537+ })(_20, _21);
538+ };
539+ });
540+};
541+var eqOrdering = function (_) {
542+ return new Eq(function (x) {
543+ return function (y) {
544+ return not(boolLikeBoolean({}))($eq$eq(eqOrdering({}))(x)(y));
545+ };
546+ }, function (_13) {
547+ return function (_14) {
548+ return (function (_56, _57) {
549+ if (_56 instanceof LT) {
550+ if (_57 instanceof LT) {
551+ return true;
552+ };
553+ };
554+ if (_56 instanceof GT) {
555+ if (_57 instanceof GT) {
556+ return true;
557+ };
558+ };
559+ if (_56 instanceof EQ) {
560+ if (_57 instanceof EQ) {
561+ return true;
562+ };
563+ };
564+ var _ = _56;
565+ return false;
566+ throw new Error("Failed pattern match");
567+ })(_13, _14);
568+ };
569+ });
570+};
571+var bitsNumber = function (_) {
572+ return new Bits(numAnd, numXor, numComplement, numShl, numShr, numZshr, numOr);
573+};
574+var asTypeOf = function (_5) {
575+ return function (_6) {
576+ return (function (_58, _59) {
577+ var x = _58;
578+ return x;
579+ throw new Error("Failed pattern match");
580+ })(_5, _6);
581+ };
582+};
583+var applyArr = function (_) {
584+ return new Apply(function (f) {
585+ return function (g) {
586+ return function (x) {
587+ return f(x)(g(x));
588+ };
589+ };
590+ }, function (_) {
591+ return functorArr({});
592+ });
593+};
594+var bindArr = function (_) {
595+ return new Bind(function (m) {
596+ return function (f) {
597+ return function (x) {
598+ return f(m(x))(x);
599+ };
600+ };
601+ }, function (_) {
602+ return applyArr({});
603+ });
604+};
605+var applicativeArr = function (_) {
606+ return new Applicative(function (_) {
607+ return applyArr({});
608+ }, $$const);
609+};
610+var monadArr = function (_) {
611+ return new Monad(function (_) {
612+ return applicativeArr({});
613+ }, function (_) {
614+ return bindArr({});
615+ });
616+};
617+var ap = function (__dict_Monad_14) {
618+ return function (f) {
619+ return function (a) {
620+ return $greater$greater$eq(__dict_Monad_14["__superclass_Prelude.Bind_1"]({}))(f)(function (_2) {
621+ return (function (_60) {
622+ var f$prime = _60;
623+ return $greater$greater$eq(__dict_Monad_14["__superclass_Prelude.Bind_1"]({}))(a)(function (_1) {
624+ return (function (_61) {
625+ var a$prime = _61;
626+ return $$return(__dict_Monad_14)(f$prime(a$prime));
627+ throw new Error("Failed pattern match");
628+ })(_1);
629+ });
630+ throw new Error("Failed pattern match");
631+ })(_2);
632+ });
633+ };
634+ };
635+};
636+module.exports = {
637+ Unit: Unit,
638+ LT: LT,
639+ GT: GT,
640+ EQ: EQ,
641+ Semigroup: Semigroup,
642+ BoolLike: BoolLike,
643+ Bits: Bits,
644+ Ord: Ord,
645+ Eq: Eq,
646+ Num: Num,
647+ Monad: Monad,
648+ Bind: Bind,
649+ Alternative: Alternative,
650+ Applicative: Applicative,
651+ Apply: Apply,
652+ Functor: Functor,
653+ Show: Show,
654+ Category: Category,
655+ Semigroupoid: Semigroupoid,
656+ unit: unit,
657+ "++": $plus$plus,
658+ "<>": $less$greater,
659+ not: not,
660+ "||": $bar$bar,
661+ "&&": $amp$amp,
662+ complement: complement,
663+ zshr: zshr,
664+ shr: shr,
665+ shl: shl,
666+ "^": $up,
667+ "|": $bar,
668+ "&": $amp,
669+ ">=": $greater$eq,
670+ "<=": $less$eq,
671+ ">": $greater,
672+ "<": $less,
673+ compare: compare,
674+ refIneq: refIneq,
675+ refEq: refEq,
676+ "/=": $div$eq,
677+ "==": $eq$eq,
678+ negate: negate,
679+ "%": $percent,
680+ "/": $div,
681+ "*": $times,
682+ "-": $minus,
683+ "+": $plus,
684+ ap: ap,
685+ liftM1: liftM1,
686+ "return": $$return,
687+ ">>=": $greater$greater$eq,
688+ "<|>": $less$bar$greater,
689+ empty: empty,
690+ liftA1: liftA1,
691+ pure: pure,
692+ "<*>": $less$times$greater,
693+ "void": $$void,
694+ "<$>": $less$dollar$greater,
695+ show: show,
696+ cons: cons,
697+ ":": $colon,
698+ "#": $hash,
699+ "$": $dollar,
700+ id: id,
701+ ">>>": $greater$greater$greater,
702+ "<<<": $less$less$less,
703+ asTypeOf: asTypeOf,
704+ "const": $$const,
705+ flip: flip,
706+ semigroupoidArr: semigroupoidArr,
707+ categoryArr: categoryArr,
708+ showUnit: showUnit,
709+ showString: showString,
710+ showBoolean: showBoolean,
711+ showNumber: showNumber,
712+ showArray: showArray,
713+ functorArr: functorArr,
714+ applyArr: applyArr,
715+ applicativeArr: applicativeArr,
716+ bindArr: bindArr,
717+ monadArr: monadArr,
718+ numNumber: numNumber,
719+ eqUnit: eqUnit,
720+ eqString: eqString,
721+ eqNumber: eqNumber,
722+ eqBoolean: eqBoolean,
723+ eqArray: eqArray,
724+ eqOrdering: eqOrdering,
725+ showOrdering: showOrdering,
726+ ordUnit: ordUnit,
727+ ordBoolean: ordBoolean,
728+ ordNumber: ordNumber,
729+ ordString: ordString,
730+ ordArray: ordArray,
731+ bitsNumber: bitsNumber,
732+ boolLikeBoolean: boolLikeBoolean,
733+ semigroupUnit: semigroupUnit,
734+ semigroupString: semigroupString,
735+ semigroupArr: semigroupArr
736+};