@@ -0,0 +1,4569 @@
1+// Generated by purs bundle 0.11.7
2+var PS = {};
3+(function(exports) {
4+ "use strict";
5+
6+ exports.arrayMap = function (f) {
7+ return function (arr) {
8+ var l = arr.length;
9+ var result = new Array(l);
10+ for (var i = 0; i < l; i++) {
11+ result[i] = f(arr[i]);
12+ }
13+ return result;
14+ };
15+ };
16+})(PS["Data.Functor"] = PS["Data.Functor"] || {});
17+(function(exports) {
18+ // Generated by purs version 0.11.7
19+ "use strict";
20+ var Semigroupoid = function (compose) {
21+ this.compose = compose;
22+ };
23+ var semigroupoidFn = new Semigroupoid(function (f) {
24+ return function (g) {
25+ return function (x) {
26+ return f(g(x));
27+ };
28+ };
29+ });
30+ var compose = function (dict) {
31+ return dict.compose;
32+ };
33+ exports["compose"] = compose;
34+ exports["Semigroupoid"] = Semigroupoid;
35+ exports["semigroupoidFn"] = semigroupoidFn;
36+})(PS["Control.Semigroupoid"] = PS["Control.Semigroupoid"] || {});
37+(function(exports) {
38+ // Generated by purs version 0.11.7
39+ "use strict";
40+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
41+ var Category = function (Semigroupoid0, id) {
42+ this.Semigroupoid0 = Semigroupoid0;
43+ this.id = id;
44+ };
45+ var id = function (dict) {
46+ return dict.id;
47+ };
48+ var categoryFn = new Category(function () {
49+ return Control_Semigroupoid.semigroupoidFn;
50+ }, function (x) {
51+ return x;
52+ });
53+ exports["Category"] = Category;
54+ exports["id"] = id;
55+ exports["categoryFn"] = categoryFn;
56+})(PS["Control.Category"] = PS["Control.Category"] || {});
57+(function(exports) {
58+ // Generated by purs version 0.11.7
59+ "use strict";
60+ var Control_Category = PS["Control.Category"];
61+ var on = function (f) {
62+ return function (g) {
63+ return function (x) {
64+ return function (y) {
65+ return f(g(x))(g(y));
66+ };
67+ };
68+ };
69+ };
70+ var flip = function (f) {
71+ return function (b) {
72+ return function (a) {
73+ return f(a)(b);
74+ };
75+ };
76+ };
77+ var $$const = function (a) {
78+ return function (v) {
79+ return a;
80+ };
81+ };
82+ var applyFlipped = function (x) {
83+ return function (f) {
84+ return f(x);
85+ };
86+ };
87+ exports["flip"] = flip;
88+ exports["const"] = $$const;
89+ exports["applyFlipped"] = applyFlipped;
90+ exports["on"] = on;
91+})(PS["Data.Function"] = PS["Data.Function"] || {});
92+(function(exports) {
93+ "use strict";
94+
95+ exports.unit = {};
96+})(PS["Data.Unit"] = PS["Data.Unit"] || {});
97+(function(exports) {
98+ "use strict";
99+
100+ exports.showIntImpl = function (n) {
101+ return n.toString();
102+ };
103+
104+ exports.showStringImpl = function (s) {
105+ var l = s.length;
106+ return "\"" + s.replace(
107+ /[\0-\x1F\x7F"\\]/g, // eslint-disable-line no-control-regex
108+ function (c, i) {
109+ switch (c) {
110+ case "\"":
111+ case "\\":
112+ return "\\" + c;
113+ case "\x07": return "\\a";
114+ case "\b": return "\\b";
115+ case "\f": return "\\f";
116+ case "\n": return "\\n";
117+ case "\r": return "\\r";
118+ case "\t": return "\\t";
119+ case "\v": return "\\v";
120+ }
121+ var k = i + 1;
122+ var empty = k < l && s[k] >= "0" && s[k] <= "9" ? "\\&" : "";
123+ return "\\" + c.charCodeAt(0).toString(10) + empty;
124+ }
125+ ) + "\"";
126+ };
127+})(PS["Data.Show"] = PS["Data.Show"] || {});
128+(function(exports) {
129+ // Generated by purs version 0.11.7
130+ "use strict";
131+ var $foreign = PS["Data.Show"];
132+ var Show = function (show) {
133+ this.show = show;
134+ };
135+ var showString = new Show($foreign.showStringImpl);
136+ var showInt = new Show($foreign.showIntImpl);
137+ var show = function (dict) {
138+ return dict.show;
139+ };
140+ exports["Show"] = Show;
141+ exports["show"] = show;
142+ exports["showInt"] = showInt;
143+ exports["showString"] = showString;
144+})(PS["Data.Show"] = PS["Data.Show"] || {});
145+(function(exports) {
146+ // Generated by purs version 0.11.7
147+ "use strict";
148+ var $foreign = PS["Data.Unit"];
149+ var Data_Show = PS["Data.Show"];
150+ exports["unit"] = $foreign.unit;
151+})(PS["Data.Unit"] = PS["Data.Unit"] || {});
152+(function(exports) {
153+ // Generated by purs version 0.11.7
154+ "use strict";
155+ var $foreign = PS["Data.Functor"];
156+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
157+ var Data_Function = PS["Data.Function"];
158+ var Data_Unit = PS["Data.Unit"];
159+ var Functor = function (map) {
160+ this.map = map;
161+ };
162+ var map = function (dict) {
163+ return dict.map;
164+ };
165+ var $$void = function (dictFunctor) {
166+ return map(dictFunctor)(Data_Function["const"](Data_Unit.unit));
167+ };
168+ var functorFn = new Functor(Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn));
169+ var functorArray = new Functor($foreign.arrayMap);
170+ exports["Functor"] = Functor;
171+ exports["map"] = map;
172+ exports["void"] = $$void;
173+ exports["functorFn"] = functorFn;
174+ exports["functorArray"] = functorArray;
175+})(PS["Data.Functor"] = PS["Data.Functor"] || {});
176+(function(exports) {
177+ "use strict";
178+
179+ exports.concatString = function (s1) {
180+ return function (s2) {
181+ return s1 + s2;
182+ };
183+ };
184+})(PS["Data.Semigroup"] = PS["Data.Semigroup"] || {});
185+(function(exports) {
186+ // Generated by purs version 0.11.7
187+ "use strict";
188+ var $foreign = PS["Data.Semigroup"];
189+ var Data_Unit = PS["Data.Unit"];
190+ var Data_Void = PS["Data.Void"];
191+ var Semigroup = function (append) {
192+ this.append = append;
193+ };
194+ var semigroupString = new Semigroup($foreign.concatString);
195+ var append = function (dict) {
196+ return dict.append;
197+ };
198+ exports["Semigroup"] = Semigroup;
199+ exports["append"] = append;
200+ exports["semigroupString"] = semigroupString;
201+})(PS["Data.Semigroup"] = PS["Data.Semigroup"] || {});
202+(function(exports) {
203+ // Generated by purs version 0.11.7
204+ "use strict";
205+ var Data_Functor = PS["Data.Functor"];
206+ var Data_Semigroup = PS["Data.Semigroup"];
207+ var Alt = function (Functor0, alt) {
208+ this.Functor0 = Functor0;
209+ this.alt = alt;
210+ };
211+ var alt = function (dict) {
212+ return dict.alt;
213+ };
214+ exports["Alt"] = Alt;
215+ exports["alt"] = alt;
216+})(PS["Control.Alt"] = PS["Control.Alt"] || {});
217+(function(exports) {
218+ // Generated by purs version 0.11.7
219+ "use strict";
220+ var $foreign = PS["Control.Apply"];
221+ var Control_Category = PS["Control.Category"];
222+ var Data_Function = PS["Data.Function"];
223+ var Data_Functor = PS["Data.Functor"];
224+ var Apply = function (Functor0, apply) {
225+ this.Functor0 = Functor0;
226+ this.apply = apply;
227+ };
228+ var apply = function (dict) {
229+ return dict.apply;
230+ };
231+ var applySecond = function (dictApply) {
232+ return function (a) {
233+ return function (b) {
234+ return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Data_Function["const"](Control_Category.id(Control_Category.categoryFn)))(a))(b);
235+ };
236+ };
237+ };
238+ exports["Apply"] = Apply;
239+ exports["apply"] = apply;
240+ exports["applySecond"] = applySecond;
241+})(PS["Control.Apply"] = PS["Control.Apply"] || {});
242+(function(exports) {
243+ // Generated by purs version 0.11.7
244+ "use strict";
245+ var Control_Apply = PS["Control.Apply"];
246+ var Data_Functor = PS["Data.Functor"];
247+ var Data_Unit = PS["Data.Unit"];
248+ var Applicative = function (Apply0, pure) {
249+ this.Apply0 = Apply0;
250+ this.pure = pure;
251+ };
252+ var pure = function (dict) {
253+ return dict.pure;
254+ };
255+ var liftA1 = function (dictApplicative) {
256+ return function (f) {
257+ return function (a) {
258+ return Control_Apply.apply(dictApplicative.Apply0())(pure(dictApplicative)(f))(a);
259+ };
260+ };
261+ };
262+ exports["Applicative"] = Applicative;
263+ exports["pure"] = pure;
264+ exports["liftA1"] = liftA1;
265+})(PS["Control.Applicative"] = PS["Control.Applicative"] || {});
266+(function(exports) {
267+ // Generated by purs version 0.11.7
268+ "use strict";
269+ var $foreign = PS["Control.Bind"];
270+ var Control_Applicative = PS["Control.Applicative"];
271+ var Control_Apply = PS["Control.Apply"];
272+ var Control_Category = PS["Control.Category"];
273+ var Data_Function = PS["Data.Function"];
274+ var Data_Functor = PS["Data.Functor"];
275+ var Data_Unit = PS["Data.Unit"];
276+ var Bind = function (Apply0, bind) {
277+ this.Apply0 = Apply0;
278+ this.bind = bind;
279+ };
280+ var Discard = function (discard) {
281+ this.discard = discard;
282+ };
283+ var discard = function (dict) {
284+ return dict.discard;
285+ };
286+ var bind = function (dict) {
287+ return dict.bind;
288+ };
289+ var bindFlipped = function (dictBind) {
290+ return Data_Function.flip(bind(dictBind));
291+ };
292+ var composeKleisliFlipped = function (dictBind) {
293+ return function (f) {
294+ return function (g) {
295+ return function (a) {
296+ return bindFlipped(dictBind)(f)(g(a));
297+ };
298+ };
299+ };
300+ };
301+ var discardUnit = new Discard(function (dictBind) {
302+ return bind(dictBind);
303+ });
304+ exports["Bind"] = Bind;
305+ exports["bind"] = bind;
306+ exports["bindFlipped"] = bindFlipped;
307+ exports["Discard"] = Discard;
308+ exports["discard"] = discard;
309+ exports["composeKleisliFlipped"] = composeKleisliFlipped;
310+ exports["discardUnit"] = discardUnit;
311+})(PS["Control.Bind"] = PS["Control.Bind"] || {});
312+(function(exports) {
313+ // Generated by purs version 0.11.7
314+ "use strict";
315+ var Control_Applicative = PS["Control.Applicative"];
316+ var Control_Apply = PS["Control.Apply"];
317+ var Control_Bind = PS["Control.Bind"];
318+ var Data_Functor = PS["Data.Functor"];
319+ var Data_Unit = PS["Data.Unit"];
320+ var Monad = function (Applicative0, Bind1) {
321+ this.Applicative0 = Applicative0;
322+ this.Bind1 = Bind1;
323+ };
324+ var ap = function (dictMonad) {
325+ return function (f) {
326+ return function (a) {
327+ return Control_Bind.bind(dictMonad.Bind1())(f)(function (v) {
328+ return Control_Bind.bind(dictMonad.Bind1())(a)(function (v1) {
329+ return Control_Applicative.pure(dictMonad.Applicative0())(v(v1));
330+ });
331+ });
332+ };
333+ };
334+ };
335+ exports["Monad"] = Monad;
336+ exports["ap"] = ap;
337+})(PS["Control.Monad"] = PS["Control.Monad"] || {});
338+(function(exports) {
339+ /* globals setImmediate, clearImmediate, setTimeout, clearTimeout */
340+ /* jshint -W083, -W098, -W003 */
341+ "use strict";
342+
343+ var Aff = function () {
344+ // A unique value for empty.
345+ var EMPTY = {};
346+
347+ /*
348+
349+ An awkward approximation. We elide evidence we would otherwise need in PS for
350+ efficiency sake.
351+
352+ data Aff eff a
353+ = Pure a
354+ | Throw Error
355+ | Catch (Aff eff a) (Error -> Aff eff a)
356+ | Sync (Eff eff a)
357+ | Async ((Either Error a -> Eff eff Unit) -> Eff eff (Canceler eff))
358+ | forall b. Bind (Aff eff b) (b -> Aff eff a)
359+ | forall b. Bracket (Aff eff b) (BracketConditions eff b) (b -> Aff eff a)
360+ | forall b. Fork Boolean (Aff eff b) ?(Fiber eff b -> a)
361+ | Sequential (ParAff aff a)
362+
363+ */
364+ var PURE = "Pure";
365+ var THROW = "Throw";
366+ var CATCH = "Catch";
367+ var SYNC = "Sync";
368+ var ASYNC = "Async";
369+ var BIND = "Bind";
370+ var BRACKET = "Bracket";
371+ var FORK = "Fork";
372+ var SEQ = "Sequential";
373+
374+ /*
375+
376+ data ParAff eff a
377+ = forall b. Map (b -> a) (ParAff eff b)
378+ | forall b. Apply (ParAff eff (b -> a)) (ParAff eff b)
379+ | Alt (ParAff eff a) (ParAff eff a)
380+ | ?Par (Aff eff a)
381+
382+ */
383+ var MAP = "Map";
384+ var APPLY = "Apply";
385+ var ALT = "Alt";
386+
387+ // Various constructors used in interpretation
388+ var CONS = "Cons"; // Cons-list, for stacks
389+ var RESUME = "Resume"; // Continue indiscriminately
390+ var RELEASE = "Release"; // Continue with bracket finalizers
391+ var FINALIZER = "Finalizer"; // A non-interruptible effect
392+ var FINALIZED = "Finalized"; // Marker for finalization
393+ var FORKED = "Forked"; // Reference to a forked fiber, with resumption stack
394+ var FIBER = "Fiber"; // Actual fiber reference
395+ var THUNK = "Thunk"; // Primed effect, ready to invoke
396+
397+ function Aff(tag, _1, _2, _3) {
398+ this.tag = tag;
399+ this._1 = _1;
400+ this._2 = _2;
401+ this._3 = _3;
402+ }
403+
404+ function AffCtr(tag) {
405+ var fn = function (_1, _2, _3) {
406+ return new Aff(tag, _1, _2, _3);
407+ };
408+ fn.tag = tag;
409+ return fn;
410+ }
411+
412+ function nonCanceler(error) {
413+ return new Aff(PURE, void 0);
414+ }
415+
416+ function runEff(eff) {
417+ try {
418+ eff();
419+ } catch (error) {
420+ setTimeout(function () {
421+ throw error;
422+ }, 0);
423+ }
424+ }
425+
426+ function runSync(left, right, eff) {
427+ try {
428+ return right(eff());
429+ } catch (error) {
430+ return left(error);
431+ }
432+ }
433+
434+ function runAsync(left, eff, k) {
435+ try {
436+ return eff(k)();
437+ } catch (error) {
438+ k(left(error))();
439+ return nonCanceler;
440+ }
441+ }
442+
443+ var Scheduler = function () {
444+ var limit = 1024;
445+ var size = 0;
446+ var ix = 0;
447+ var queue = new Array(limit);
448+ var draining = false;
449+
450+ function drain() {
451+ var thunk;
452+ draining = true;
453+ while (size !== 0) {
454+ size--;
455+ thunk = queue[ix];
456+ queue[ix] = void 0;
457+ ix = (ix + 1) % limit;
458+ thunk();
459+ }
460+ draining = false;
461+ }
462+
463+ return {
464+ isDraining: function () {
465+ return draining;
466+ },
467+ enqueue: function (cb) {
468+ var i, tmp;
469+ if (size === limit) {
470+ tmp = draining;
471+ drain();
472+ draining = tmp;
473+ }
474+
475+ queue[(ix + size) % limit] = cb;
476+ size++;
477+
478+ if (!draining) {
479+ drain();
480+ }
481+ }
482+ };
483+ }();
484+
485+ function Supervisor(util) {
486+ var fibers = {};
487+ var fiberId = 0;
488+ var count = 0;
489+
490+ return {
491+ register: function (fiber) {
492+ var fid = fiberId++;
493+ fiber.onComplete({
494+ rethrow: true,
495+ handler: function (result) {
496+ return function () {
497+ count--;
498+ delete fibers[fid];
499+ };
500+ }
501+ });
502+ fibers[fid] = fiber;
503+ count++;
504+ },
505+ isEmpty: function () {
506+ return count === 0;
507+ },
508+ killAll: function (killError, cb) {
509+ return function () {
510+ var killCount = 0;
511+ var kills = {};
512+
513+ function kill(fid) {
514+ kills[fid] = fibers[fid].kill(killError, function (result) {
515+ return function () {
516+ delete kills[fid];
517+ killCount--;
518+ if (util.isLeft(result) && util.fromLeft(result)) {
519+ setTimeout(function () {
520+ throw util.fromLeft(result);
521+ }, 0);
522+ }
523+ if (killCount === 0) {
524+ cb();
525+ }
526+ };
527+ })();
528+ }
529+
530+ for (var k in fibers) {
531+ if (fibers.hasOwnProperty(k)) {
532+ killCount++;
533+ kill(k);
534+ }
535+ }
536+
537+ fibers = {};
538+ fiberId = 0;
539+ count = 0;
540+
541+ return function (error) {
542+ return new Aff(SYNC, function () {
543+ for (var k in kills) {
544+ if (kills.hasOwnProperty(k)) {
545+ kills[k]();
546+ }
547+ }
548+ });
549+ };
550+ };
551+ }
552+ };
553+ }
554+
555+ // Fiber state machine
556+ var SUSPENDED = 0; // Suspended, pending a join.
557+ var CONTINUE = 1; // Interpret the next instruction.
558+ var STEP_BIND = 2; // Apply the next bind.
559+ var STEP_RESULT = 3; // Handle potential failure from a result.
560+ var PENDING = 4; // An async effect is running.
561+ var RETURN = 5; // The current stack has returned.
562+ var COMPLETED = 6; // The entire fiber has completed.
563+
564+ function Fiber(util, supervisor, aff) {
565+ // Monotonically increasing tick, increased on each asynchronous turn.
566+ var runTick = 0;
567+
568+ // The current branch of the state machine.
569+ var status = SUSPENDED;
570+
571+ // The current point of interest for the state machine branch.
572+ var step = aff; // Successful step
573+ var fail = null; // Failure step
574+ var interrupt = null; // Asynchronous interrupt
575+
576+ // Stack of continuations for the current fiber.
577+ var bhead = null;
578+ var btail = null;
579+
580+ // Stack of attempts and finalizers for error recovery. Every `Cons` is also
581+ // tagged with current `interrupt` state. We use this to track which items
582+ // should be ignored or evaluated as a result of a kill.
583+ var attempts = null;
584+
585+ // A special state is needed for Bracket, because it cannot be killed. When
586+ // we enter a bracket acquisition or finalizer, we increment the counter,
587+ // and then decrement once complete.
588+ var bracketCount = 0;
589+
590+ // Each join gets a new id so they can be revoked.
591+ var joinId = 0;
592+ var joins = null;
593+ var rethrow = true;
594+
595+ // Each invocation of `run` requires a tick. When an asynchronous effect is
596+ // resolved, we must check that the local tick coincides with the fiber
597+ // tick before resuming. This prevents multiple async continuations from
598+ // accidentally resuming the same fiber. A common example may be invoking
599+ // the provided callback in `makeAff` more than once, but it may also be an
600+ // async effect resuming after the fiber was already cancelled.
601+ function run(localRunTick) {
602+ var tmp, result, attempt, canceler;
603+ while (true) {
604+ tmp = null;
605+ result = null;
606+ attempt = null;
607+ canceler = null;
608+
609+ switch (status) {
610+ case STEP_BIND:
611+ status = CONTINUE;
612+ step = bhead(step);
613+ if (btail === null) {
614+ bhead = null;
615+ } else {
616+ bhead = btail._1;
617+ btail = btail._2;
618+ }
619+ break;
620+
621+ case STEP_RESULT:
622+ if (util.isLeft(step)) {
623+ status = RETURN;
624+ fail = step;
625+ step = null;
626+ } else if (bhead === null) {
627+ status = RETURN;
628+ } else {
629+ status = STEP_BIND;
630+ step = util.fromRight(step);
631+ }
632+ break;
633+
634+ case CONTINUE:
635+ switch (step.tag) {
636+ case BIND:
637+ if (bhead) {
638+ btail = new Aff(CONS, bhead, btail);
639+ }
640+ bhead = step._2;
641+ status = CONTINUE;
642+ step = step._1;
643+ break;
644+
645+ case PURE:
646+ if (bhead === null) {
647+ status = RETURN;
648+ step = util.right(step._1);
649+ } else {
650+ status = STEP_BIND;
651+ step = step._1;
652+ }
653+ break;
654+
655+ case SYNC:
656+ status = STEP_RESULT;
657+ step = runSync(util.left, util.right, step._1);
658+ break;
659+
660+ case ASYNC:
661+ status = PENDING;
662+ step = runAsync(util.left, step._1, function (result) {
663+ return function () {
664+ if (runTick !== localRunTick) {
665+ return;
666+ }
667+ runTick++;
668+ Scheduler.enqueue(function () {
669+ status = STEP_RESULT;
670+ step = result;
671+ run(runTick);
672+ });
673+ };
674+ });
675+ return;
676+
677+ case THROW:
678+ status = RETURN;
679+ fail = util.left(step._1);
680+ step = null;
681+ break;
682+
683+ // Enqueue the Catch so that we can call the error handler later on
684+ // in case of an exception.
685+ case CATCH:
686+ if (bhead === null) {
687+ attempts = new Aff(CONS, step, attempts, interrupt);
688+ } else {
689+ attempts = new Aff(CONS, step, new Aff(CONS, new Aff(RESUME, bhead, btail), attempts, interrupt), interrupt);
690+ }
691+ bhead = null;
692+ btail = null;
693+ status = CONTINUE;
694+ step = step._1;
695+ break;
696+
697+ // Enqueue the Bracket so that we can call the appropriate handlers
698+ // after resource acquisition.
699+ case BRACKET:
700+ bracketCount++;
701+ if (bhead === null) {
702+ attempts = new Aff(CONS, step, attempts, interrupt);
703+ } else {
704+ attempts = new Aff(CONS, step, new Aff(CONS, new Aff(RESUME, bhead, btail), attempts, interrupt), interrupt);
705+ }
706+ bhead = null;
707+ btail = null;
708+ status = CONTINUE;
709+ step = step._1;
710+ break;
711+
712+ case FORK:
713+ status = STEP_BIND;
714+ tmp = Fiber(util, supervisor, step._2);
715+ if (supervisor) {
716+ supervisor.register(tmp);
717+ }
718+ if (step._1) {
719+ tmp.run();
720+ }
721+ step = tmp;
722+ break;
723+
724+ case SEQ:
725+ status = CONTINUE;
726+ step = sequential(util, supervisor, step._1);
727+ break;
728+ }
729+ break;
730+
731+ case RETURN:
732+ bhead = null;
733+ btail = null;
734+ // If the current stack has returned, and we have no other stacks to
735+ // resume or finalizers to run, the fiber has halted and we can
736+ // invoke all join callbacks. Otherwise we need to resume.
737+ if (attempts === null) {
738+ status = COMPLETED;
739+ step = interrupt || fail || step;
740+ } else {
741+ // The interrupt status for the enqueued item.
742+ tmp = attempts._3;
743+ attempt = attempts._1;
744+ attempts = attempts._2;
745+
746+ switch (attempt.tag) {
747+ // We cannot recover from an interrupt. Otherwise we should
748+ // continue stepping, or run the exception handler if an exception
749+ // was raised.
750+ case CATCH:
751+ // We should compare the interrupt status as well because we
752+ // only want it to apply if there has been an interrupt since
753+ // enqueuing the catch.
754+ if (interrupt && interrupt !== tmp) {
755+ status = RETURN;
756+ } else if (fail) {
757+ status = CONTINUE;
758+ step = attempt._2(util.fromLeft(fail));
759+ fail = null;
760+ }
761+ break;
762+
763+ // We cannot resume from an interrupt or exception.
764+ case RESUME:
765+ // As with Catch, we only want to ignore in the case of an
766+ // interrupt since enqueing the item.
767+ if (interrupt && interrupt !== tmp || fail) {
768+ status = RETURN;
769+ } else {
770+ bhead = attempt._1;
771+ btail = attempt._2;
772+ status = STEP_BIND;
773+ step = util.fromRight(step);
774+ }
775+ break;
776+
777+ // If we have a bracket, we should enqueue the handlers,
778+ // and continue with the success branch only if the fiber has
779+ // not been interrupted. If the bracket acquisition failed, we
780+ // should not run either.
781+ case BRACKET:
782+ bracketCount--;
783+ if (fail === null) {
784+ result = util.fromRight(step);
785+ // We need to enqueue the Release with the same interrupt
786+ // status as the Bracket that is initiating it.
787+ attempts = new Aff(CONS, new Aff(RELEASE, attempt._2, result), attempts, tmp);
788+ // We should only coninue as long as the interrupt status has not changed or
789+ // we are currently within a non-interruptable finalizer.
790+ if (interrupt === tmp || bracketCount > 0) {
791+ status = CONTINUE;
792+ step = attempt._3(result);
793+ }
794+ }
795+ break;
796+
797+ // Enqueue the appropriate handler. We increase the bracket count
798+ // because it should not be cancelled.
799+ case RELEASE:
800+ bracketCount++;
801+ attempts = new Aff(CONS, new Aff(FINALIZED, step), attempts, interrupt);
802+ status = CONTINUE;
803+ // It has only been killed if the interrupt status has changed
804+ // since we enqueued the item.
805+ if (interrupt && interrupt !== tmp) {
806+ step = attempt._1.killed(util.fromLeft(interrupt))(attempt._2);
807+ } else if (fail) {
808+ step = attempt._1.failed(util.fromLeft(fail))(attempt._2);
809+ } else {
810+ step = attempt._1.completed(util.fromRight(step))(attempt._2);
811+ }
812+ break;
813+
814+ case FINALIZER:
815+ bracketCount++;
816+ attempts = new Aff(CONS, new Aff(FINALIZED, step), attempts, interrupt);
817+ status = CONTINUE;
818+ step = attempt._1;
819+ break;
820+
821+ case FINALIZED:
822+ bracketCount--;
823+ status = RETURN;
824+ step = attempt._1;
825+ break;
826+ }
827+ }
828+ break;
829+
830+ case COMPLETED:
831+ for (var k in joins) {
832+ if (joins.hasOwnProperty(k)) {
833+ rethrow = rethrow && joins[k].rethrow;
834+ runEff(joins[k].handler(step));
835+ }
836+ }
837+ joins = null;
838+ // If we have an interrupt and a fail, then the thread threw while
839+ // running finalizers. This should always rethrow in a fresh stack.
840+ if (interrupt && fail) {
841+ setTimeout(function () {
842+ throw util.fromLeft(fail);
843+ }, 0);
844+ // If we have an unhandled exception, and no other fiber has joined
845+ // then we need to throw the exception in a fresh stack.
846+ } else if (util.isLeft(step) && rethrow) {
847+ setTimeout(function () {
848+ // Guard on reathrow because a completely synchronous fiber can
849+ // still have an observer which was added after-the-fact.
850+ if (rethrow) {
851+ throw util.fromLeft(step);
852+ }
853+ }, 0);
854+ }
855+ return;
856+ case SUSPENDED:
857+ status = CONTINUE;
858+ break;
859+ case PENDING: return;
860+ }
861+ }
862+ }
863+
864+ function onComplete(join) {
865+ return function () {
866+ if (status === COMPLETED) {
867+ rethrow = rethrow && join.rethrow;
868+ join.handler(step)();
869+ return function () {};
870+ }
871+
872+ var jid = joinId++;
873+ joins = joins || {};
874+ joins[jid] = join;
875+
876+ return function() {
877+ if (joins !== null) {
878+ delete joins[jid];
879+ }
880+ };
881+ };
882+ }
883+
884+ function kill(error, cb) {
885+ return function () {
886+ if (status === COMPLETED) {
887+ cb(util.right(void 0))();
888+ return function () {};
889+ }
890+
891+ var canceler = onComplete({
892+ rethrow: false,
893+ handler: function (/* unused */) {
894+ return cb(util.right(void 0));
895+ }
896+ })();
897+
898+ switch (status) {
899+ case SUSPENDED:
900+ interrupt = util.left(error);
901+ status = COMPLETED;
902+ step = interrupt;
903+ run(runTick);
904+ break;
905+ case PENDING:
906+ if (interrupt === null) {
907+ interrupt = util.left(error);
908+ }
909+ if (bracketCount === 0) {
910+ if (status === PENDING) {
911+ attempts = new Aff(CONS, new Aff(FINALIZER, step(error)), attempts, interrupt);
912+ }
913+ status = RETURN;
914+ step = null;
915+ fail = null;
916+ run(++runTick);
917+ }
918+ break;
919+ default:
920+ if (interrupt === null) {
921+ interrupt = util.left(error);
922+ }
923+ if (bracketCount === 0) {
924+ status = RETURN;
925+ step = null;
926+ fail = null;
927+ }
928+ }
929+
930+ return canceler;
931+ };
932+ }
933+
934+ function join(cb) {
935+ return function () {
936+ var canceler = onComplete({
937+ rethrow: false,
938+ handler: cb
939+ })();
940+ if (status === SUSPENDED) {
941+ run(runTick);
942+ }
943+ return canceler;
944+ };
945+ }
946+
947+ return {
948+ kill: kill,
949+ join: join,
950+ onComplete: onComplete,
951+ isSuspended: function () {
952+ return status === SUSPENDED;
953+ },
954+ run: function () {
955+ if (status === SUSPENDED) {
956+ if (!Scheduler.isDraining()) {
957+ Scheduler.enqueue(function () {
958+ run(runTick);
959+ });
960+ } else {
961+ run(runTick);
962+ }
963+ }
964+ }
965+ };
966+ }
967+
968+ function runPar(util, supervisor, par, cb) {
969+ // Table of all forked fibers.
970+ var fiberId = 0;
971+ var fibers = {};
972+
973+ // Table of currently running cancelers, as a product of `Alt` behavior.
974+ var killId = 0;
975+ var kills = {};
976+
977+ // Error used for early cancelation on Alt branches.
978+ var early = new Error("[ParAff] Early exit");
979+
980+ // Error used to kill the entire tree.
981+ var interrupt = null;
982+
983+ // The root pointer of the tree.
984+ var root = EMPTY;
985+
986+ // Walks a tree, invoking all the cancelers. Returns the table of pending
987+ // cancellation fibers.
988+ function kill(error, par, cb) {
989+ var step = par;
990+ var head = null;
991+ var tail = null;
992+ var count = 0;
993+ var kills = {};
994+ var tmp, kid;
995+
996+ loop: while (true) {
997+ tmp = null;
998+
999+ switch (step.tag) {
1000+ case FORKED:
1001+ if (step._3 === EMPTY) {
1002+ tmp = fibers[step._1];
1003+ kills[count++] = tmp.kill(error, function (result) {
1004+ return function () {
1005+ count--;
1006+ if (count === 0) {
1007+ cb(result)();
1008+ }
1009+ };
1010+ });
1011+ }
1012+ // Terminal case.
1013+ if (head === null) {
1014+ break loop;
1015+ }
1016+ // Go down the right side of the tree.
1017+ step = head._2;
1018+ if (tail === null) {
1019+ head = null;
1020+ } else {
1021+ head = tail._1;
1022+ tail = tail._2;
1023+ }
1024+ break;
1025+ case MAP:
1026+ step = step._2;
1027+ break;
1028+ case APPLY:
1029+ case ALT:
1030+ if (head) {
1031+ tail = new Aff(CONS, head, tail);
1032+ }
1033+ head = step;
1034+ step = step._1;
1035+ break;
1036+ }
1037+ }
1038+
1039+ if (count === 0) {
1040+ cb(util.right(void 0))();
1041+ } else {
1042+ // Run the cancelation effects. We alias `count` because it's mutable.
1043+ kid = 0;
1044+ tmp = count;
1045+ for (; kid < tmp; kid++) {
1046+ kills[kid] = kills[kid]();
1047+ }
1048+ }
1049+
1050+ return kills;
1051+ }
1052+
1053+ // When a fiber resolves, we need to bubble back up the tree with the
1054+ // result, computing the applicative nodes.
1055+ function join(result, head, tail) {
1056+ var fail, step, lhs, rhs, tmp, kid;
1057+
1058+ if (util.isLeft(result)) {
1059+ fail = result;
1060+ step = null;
1061+ } else {
1062+ step = result;
1063+ fail = null;
1064+ }
1065+
1066+ loop: while (true) {
1067+ lhs = null;
1068+ rhs = null;
1069+ tmp = null;
1070+ kid = null;
1071+
1072+ // We should never continue if the entire tree has been interrupted.
1073+ if (interrupt !== null) {
1074+ return;
1075+ }
1076+
1077+ // We've made it all the way to the root of the tree, which means
1078+ // the tree has fully evaluated.
1079+ if (head === null) {
1080+ cb(fail || step)();
1081+ return;
1082+ }
1083+
1084+ // The tree has already been computed, so we shouldn't try to do it
1085+ // again. This should never happen.
1086+ // TODO: Remove this?
1087+ if (head._3 !== EMPTY) {
1088+ return;
1089+ }
1090+
1091+ switch (head.tag) {
1092+ case MAP:
1093+ if (fail === null) {
1094+ head._3 = util.right(head._1(util.fromRight(step)));
1095+ step = head._3;
1096+ } else {
1097+ head._3 = fail;
1098+ }
1099+ break;
1100+ case APPLY:
1101+ lhs = head._1._3;
1102+ rhs = head._2._3;
1103+ // If we have a failure we should kill the other side because we
1104+ // can't possible yield a result anymore.
1105+ if (fail) {
1106+ head._3 = fail;
1107+ tmp = true;
1108+ kid = killId++;
1109+
1110+ kills[kid] = kill(early, fail === lhs ? head._2 : head._1, function (/* unused */) {
1111+ return function () {
1112+ delete kills[kid];
1113+ if (tmp) {
1114+ tmp = false;
1115+ } else if (tail === null) {
1116+ join(step, null, null);
1117+ } else {
1118+ join(step, tail._1, tail._2);
1119+ }
1120+ };
1121+ });
1122+
1123+ if (tmp) {
1124+ tmp = false;
1125+ return;
1126+ }
1127+ } else if (lhs === EMPTY || rhs === EMPTY) {
1128+ // We can only proceed if both sides have resolved.
1129+ return;
1130+ } else {
1131+ step = util.right(util.fromRight(lhs)(util.fromRight(rhs)));
1132+ head._3 = step;
1133+ }
1134+ break;
1135+ case ALT:
1136+ lhs = head._1._3;
1137+ rhs = head._2._3;
1138+ // We can only proceed if both have resolved or we have a success
1139+ if (lhs === EMPTY && util.isLeft(rhs) || rhs === EMPTY && util.isLeft(lhs)) {
1140+ return;
1141+ }
1142+ // If both sides resolve with an error, we should continue with the
1143+ // first error
1144+ if (lhs !== EMPTY && util.isLeft(lhs) && rhs !== EMPTY && util.isLeft(rhs)) {
1145+ fail = step === lhs ? rhs : lhs;
1146+ step = null;
1147+ head._3 = fail;
1148+ } else {
1149+ head._3 = step;
1150+ tmp = true;
1151+ kid = killId++;
1152+ // Once a side has resolved, we need to cancel the side that is still
1153+ // pending before we can continue.
1154+ kills[kid] = kill(early, step === lhs ? head._2 : head._1, function (/* unused */) {
1155+ return function () {
1156+ delete kills[kid];
1157+ if (tmp) {
1158+ tmp = false;
1159+ } else if (tail === null) {
1160+ join(step, null, null);
1161+ } else {
1162+ join(step, tail._1, tail._2);
1163+ }
1164+ };
1165+ });
1166+
1167+ if (tmp) {
1168+ tmp = false;
1169+ return;
1170+ }
1171+ }
1172+ break;
1173+ }
1174+
1175+ if (tail === null) {
1176+ head = null;
1177+ } else {
1178+ head = tail._1;
1179+ tail = tail._2;
1180+ }
1181+ }
1182+ }
1183+
1184+ function resolve(fiber) {
1185+ return function (result) {
1186+ return function () {
1187+ delete fibers[fiber._1];
1188+ fiber._3 = result;
1189+ join(result, fiber._2._1, fiber._2._2);
1190+ };
1191+ };
1192+ }
1193+
1194+ // Walks the applicative tree, substituting non-applicative nodes with
1195+ // `FORKED` nodes. In this tree, all applicative nodes use the `_3` slot
1196+ // as a mutable slot for memoization. In an unresolved state, the `_3`
1197+ // slot is `EMPTY`. In the cases of `ALT` and `APPLY`, we always walk
1198+ // the left side first, because both operations are left-associative. As
1199+ // we `RETURN` from those branches, we then walk the right side.
1200+ function run() {
1201+ var status = CONTINUE;
1202+ var step = par;
1203+ var head = null;
1204+ var tail = null;
1205+ var tmp, fid;
1206+
1207+ loop: while (true) {
1208+ tmp = null;
1209+ fid = null;
1210+
1211+ switch (status) {
1212+ case CONTINUE:
1213+ switch (step.tag) {
1214+ case MAP:
1215+ if (head) {
1216+ tail = new Aff(CONS, head, tail);
1217+ }
1218+ head = new Aff(MAP, step._1, EMPTY, EMPTY);
1219+ step = step._2;
1220+ break;
1221+ case APPLY:
1222+ if (head) {
1223+ tail = new Aff(CONS, head, tail);
1224+ }
1225+ head = new Aff(APPLY, EMPTY, step._2, EMPTY);
1226+ step = step._1;
1227+ break;
1228+ case ALT:
1229+ if (head) {
1230+ tail = new Aff(CONS, head, tail);
1231+ }
1232+ head = new Aff(ALT, EMPTY, step._2, EMPTY);
1233+ step = step._1;
1234+ break;
1235+ default:
1236+ // When we hit a leaf value, we suspend the stack in the `FORKED`.
1237+ // When the fiber resolves, it can bubble back up the tree.
1238+ fid = fiberId++;
1239+ status = RETURN;
1240+ tmp = step;
1241+ step = new Aff(FORKED, fid, new Aff(CONS, head, tail), EMPTY);
1242+ tmp = Fiber(util, supervisor, tmp);
1243+ tmp.onComplete({
1244+ rethrow: false,
1245+ handler: resolve(step)
1246+ })();
1247+ fibers[fid] = tmp;
1248+ if (supervisor) {
1249+ supervisor.register(tmp);
1250+ }
1251+ }
1252+ break;
1253+ case RETURN:
1254+ // Terminal case, we are back at the root.
1255+ if (head === null) {
1256+ break loop;
1257+ }
1258+ // If we are done with the right side, we need to continue down the
1259+ // left. Otherwise we should continue up the stack.
1260+ if (head._1 === EMPTY) {
1261+ head._1 = step;
1262+ status = CONTINUE;
1263+ step = head._2;
1264+ head._2 = EMPTY;
1265+ } else {
1266+ head._2 = step;
1267+ step = head;
1268+ if (tail === null) {
1269+ head = null;
1270+ } else {
1271+ head = tail._1;
1272+ tail = tail._2;
1273+ }
1274+ }
1275+ }
1276+ }
1277+
1278+ // Keep a reference to the tree root so it can be cancelled.
1279+ root = step;
1280+
1281+ for (fid = 0; fid < fiberId; fid++) {
1282+ fibers[fid].run();
1283+ }
1284+ }
1285+
1286+ // Cancels the entire tree. If there are already subtrees being canceled,
1287+ // we need to first cancel those joins. We will then add fresh joins for
1288+ // all pending branches including those that were in the process of being
1289+ // canceled.
1290+ function cancel(error, cb) {
1291+ interrupt = util.left(error);
1292+ var innerKills;
1293+ for (var kid in kills) {
1294+ if (kills.hasOwnProperty(kid)) {
1295+ innerKills = kills[kid];
1296+ for (kid in innerKills) {
1297+ if (innerKills.hasOwnProperty(kid)) {
1298+ innerKills[kid]();
1299+ }
1300+ }
1301+ }
1302+ }
1303+
1304+ kills = null;
1305+ var newKills = kill(error, root, cb);
1306+
1307+ return function (killError) {
1308+ return new Aff(ASYNC, function (killCb) {
1309+ return function () {
1310+ for (var kid in newKills) {
1311+ if (newKills.hasOwnProperty(kid)) {
1312+ newKills[kid]();
1313+ }
1314+ }
1315+ return nonCanceler;
1316+ };
1317+ });
1318+ };
1319+ }
1320+
1321+ run();
1322+
1323+ return function (killError) {
1324+ return new Aff(ASYNC, function (killCb) {
1325+ return function () {
1326+ return cancel(killError, killCb);
1327+ };
1328+ });
1329+ };
1330+ }
1331+
1332+ function sequential(util, supervisor, par) {
1333+ return new Aff(ASYNC, function (cb) {
1334+ return function () {
1335+ return runPar(util, supervisor, par, cb);
1336+ };
1337+ });
1338+ }
1339+
1340+ Aff.EMPTY = EMPTY;
1341+ Aff.Pure = AffCtr(PURE);
1342+ Aff.Throw = AffCtr(THROW);
1343+ Aff.Catch = AffCtr(CATCH);
1344+ Aff.Sync = AffCtr(SYNC);
1345+ Aff.Async = AffCtr(ASYNC);
1346+ Aff.Bind = AffCtr(BIND);
1347+ Aff.Bracket = AffCtr(BRACKET);
1348+ Aff.Fork = AffCtr(FORK);
1349+ Aff.Seq = AffCtr(SEQ);
1350+ Aff.ParMap = AffCtr(MAP);
1351+ Aff.ParApply = AffCtr(APPLY);
1352+ Aff.ParAlt = AffCtr(ALT);
1353+ Aff.Fiber = Fiber;
1354+ Aff.Supervisor = Supervisor;
1355+ Aff.Scheduler = Scheduler;
1356+ Aff.nonCanceler = nonCanceler;
1357+
1358+ return Aff;
1359+ }();
1360+
1361+ exports._pure = Aff.Pure;
1362+
1363+ exports._throwError = Aff.Throw;
1364+
1365+ exports._map = function (f) {
1366+ return function (aff) {
1367+ if (aff.tag === Aff.Pure.tag) {
1368+ return Aff.Pure(f(aff._1));
1369+ } else {
1370+ return Aff.Bind(aff, function (value) {
1371+ return Aff.Pure(f(value));
1372+ });
1373+ }
1374+ };
1375+ };
1376+
1377+ exports._bind = function (aff) {
1378+ return function (k) {
1379+ return Aff.Bind(aff, k);
1380+ };
1381+ };
1382+
1383+ exports.makeAff = Aff.Async;
1384+
1385+ exports._makeFiber = function (util, aff) {
1386+ return function () {
1387+ return Aff.Fiber(util, null, aff);
1388+ };
1389+ };
1390+})(PS["Control.Monad.Aff"] = PS["Control.Monad.Aff"] || {});
1391+(function(exports) {
1392+ "use strict";
1393+
1394+ exports.pureE = function (a) {
1395+ return function () {
1396+ return a;
1397+ };
1398+ };
1399+
1400+ exports.bindE = function (a) {
1401+ return function (f) {
1402+ return function () {
1403+ return f(a())();
1404+ };
1405+ };
1406+ };
1407+
1408+ exports.runPure = function (f) {
1409+ return f();
1410+ };
1411+
1412+ exports.foreachE = function (as) {
1413+ return function (f) {
1414+ return function () {
1415+ for (var i = 0, l = as.length; i < l; i++) {
1416+ f(as[i])();
1417+ }
1418+ };
1419+ };
1420+ };
1421+})(PS["Control.Monad.Eff"] = PS["Control.Monad.Eff"] || {});
1422+(function(exports) {
1423+ // Generated by purs version 0.11.7
1424+ "use strict";
1425+ var otherwise = true;
1426+ exports["otherwise"] = otherwise;
1427+})(PS["Data.Boolean"] = PS["Data.Boolean"] || {});
1428+(function(exports) {
1429+ "use strict";
1430+
1431+ exports.refEq = function (r1) {
1432+ return function (r2) {
1433+ return r1 === r2;
1434+ };
1435+ };
1436+})(PS["Data.Eq"] = PS["Data.Eq"] || {});
1437+(function(exports) {
1438+ // Generated by purs version 0.11.7
1439+ "use strict";
1440+ var $foreign = PS["Data.Eq"];
1441+ var Data_Unit = PS["Data.Unit"];
1442+ var Data_Void = PS["Data.Void"];
1443+ var Eq = function (eq) {
1444+ this.eq = eq;
1445+ };
1446+ var eqString = new Eq($foreign.refEq);
1447+ var eq = function (dict) {
1448+ return dict.eq;
1449+ };
1450+ exports["Eq"] = Eq;
1451+ exports["eq"] = eq;
1452+ exports["eqString"] = eqString;
1453+})(PS["Data.Eq"] = PS["Data.Eq"] || {});
1454+(function(exports) {
1455+ // Generated by purs version 0.11.7
1456+ "use strict";
1457+ var Data_Boolean = PS["Data.Boolean"];
1458+ var Data_Eq = PS["Data.Eq"];
1459+ var Data_EuclideanRing = PS["Data.EuclideanRing"];
1460+ var Data_Function = PS["Data.Function"];
1461+ var Data_Ord = PS["Data.Ord"];
1462+ var Data_Ordering = PS["Data.Ordering"];
1463+ var Data_Semigroup = PS["Data.Semigroup"];
1464+ var Data_Unit = PS["Data.Unit"];
1465+ var Prelude = PS["Prelude"];
1466+ var Monoid = function (Semigroup0, mempty) {
1467+ this.Semigroup0 = Semigroup0;
1468+ this.mempty = mempty;
1469+ };
1470+ var monoidString = new Monoid(function () {
1471+ return Data_Semigroup.semigroupString;
1472+ }, "");
1473+ var mempty = function (dict) {
1474+ return dict.mempty;
1475+ };
1476+ exports["Monoid"] = Monoid;
1477+ exports["mempty"] = mempty;
1478+ exports["monoidString"] = monoidString;
1479+})(PS["Data.Monoid"] = PS["Data.Monoid"] || {});
1480+(function(exports) {
1481+ // Generated by purs version 0.11.7
1482+ "use strict";
1483+ var $foreign = PS["Control.Monad.Eff"];
1484+ var Control_Applicative = PS["Control.Applicative"];
1485+ var Control_Apply = PS["Control.Apply"];
1486+ var Control_Bind = PS["Control.Bind"];
1487+ var Control_Monad = PS["Control.Monad"];
1488+ var Data_Functor = PS["Data.Functor"];
1489+ var Data_Monoid = PS["Data.Monoid"];
1490+ var Data_Semigroup = PS["Data.Semigroup"];
1491+ var Data_Unit = PS["Data.Unit"];
1492+ var monadEff = new Control_Monad.Monad(function () {
1493+ return applicativeEff;
1494+ }, function () {
1495+ return bindEff;
1496+ });
1497+ var bindEff = new Control_Bind.Bind(function () {
1498+ return applyEff;
1499+ }, $foreign.bindE);
1500+ var applyEff = new Control_Apply.Apply(function () {
1501+ return functorEff;
1502+ }, Control_Monad.ap(monadEff));
1503+ var applicativeEff = new Control_Applicative.Applicative(function () {
1504+ return applyEff;
1505+ }, $foreign.pureE);
1506+ var functorEff = new Data_Functor.Functor(Control_Applicative.liftA1(applicativeEff));
1507+ exports["functorEff"] = functorEff;
1508+ exports["applyEff"] = applyEff;
1509+ exports["applicativeEff"] = applicativeEff;
1510+ exports["bindEff"] = bindEff;
1511+ exports["monadEff"] = monadEff;
1512+ exports["runPure"] = $foreign.runPure;
1513+ exports["foreachE"] = $foreign.foreachE;
1514+})(PS["Control.Monad.Eff"] = PS["Control.Monad.Eff"] || {});
1515+(function(exports) {
1516+ "use strict";
1517+
1518+ exports.error = function (msg) {
1519+ return new Error(msg);
1520+ };
1521+})(PS["Control.Monad.Eff.Exception"] = PS["Control.Monad.Eff.Exception"] || {});
1522+(function(exports) {
1523+ // Generated by purs version 0.11.7
1524+ "use strict";
1525+ var Control_Category = PS["Control.Category"];
1526+ var Bifunctor = function (bimap) {
1527+ this.bimap = bimap;
1528+ };
1529+ var bimap = function (dict) {
1530+ return dict.bimap;
1531+ };
1532+ var lmap = function (dictBifunctor) {
1533+ return function (f) {
1534+ return bimap(dictBifunctor)(f)(Control_Category.id(Control_Category.categoryFn));
1535+ };
1536+ };
1537+ exports["bimap"] = bimap;
1538+ exports["Bifunctor"] = Bifunctor;
1539+ exports["lmap"] = lmap;
1540+})(PS["Data.Bifunctor"] = PS["Data.Bifunctor"] || {});
1541+(function(exports) {
1542+ "use strict";
1543+
1544+ exports.foldrArray = function (f) {
1545+ return function (init) {
1546+ return function (xs) {
1547+ var acc = init;
1548+ var len = xs.length;
1549+ for (var i = len - 1; i >= 0; i--) {
1550+ acc = f(xs[i])(acc);
1551+ }
1552+ return acc;
1553+ };
1554+ };
1555+ };
1556+
1557+ exports.foldlArray = function (f) {
1558+ return function (init) {
1559+ return function (xs) {
1560+ var acc = init;
1561+ var len = xs.length;
1562+ for (var i = 0; i < len; i++) {
1563+ acc = f(acc)(xs[i]);
1564+ }
1565+ return acc;
1566+ };
1567+ };
1568+ };
1569+})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
1570+(function(exports) {
1571+ // Generated by purs version 0.11.7
1572+ "use strict";
1573+ var Control_Alt = PS["Control.Alt"];
1574+ var Data_Functor = PS["Data.Functor"];
1575+ var Plus = function (Alt0, empty) {
1576+ this.Alt0 = Alt0;
1577+ this.empty = empty;
1578+ };
1579+ var empty = function (dict) {
1580+ return dict.empty;
1581+ };
1582+ exports["Plus"] = Plus;
1583+ exports["empty"] = empty;
1584+})(PS["Control.Plus"] = PS["Control.Plus"] || {});
1585+(function(exports) {
1586+ "use strict";
1587+
1588+ exports.boolConj = function (b1) {
1589+ return function (b2) {
1590+ return b1 && b2;
1591+ };
1592+ };
1593+
1594+ exports.boolDisj = function (b1) {
1595+ return function (b2) {
1596+ return b1 || b2;
1597+ };
1598+ };
1599+
1600+ exports.boolNot = function (b) {
1601+ return !b;
1602+ };
1603+})(PS["Data.HeytingAlgebra"] = PS["Data.HeytingAlgebra"] || {});
1604+(function(exports) {
1605+ // Generated by purs version 0.11.7
1606+ "use strict";
1607+ var $foreign = PS["Data.HeytingAlgebra"];
1608+ var Data_Unit = PS["Data.Unit"];
1609+ var HeytingAlgebra = function (conj, disj, ff, implies, not, tt) {
1610+ this.conj = conj;
1611+ this.disj = disj;
1612+ this.ff = ff;
1613+ this.implies = implies;
1614+ this.not = not;
1615+ this.tt = tt;
1616+ };
1617+ var tt = function (dict) {
1618+ return dict.tt;
1619+ };
1620+ var not = function (dict) {
1621+ return dict.not;
1622+ };
1623+ var implies = function (dict) {
1624+ return dict.implies;
1625+ };
1626+ var ff = function (dict) {
1627+ return dict.ff;
1628+ };
1629+ var disj = function (dict) {
1630+ return dict.disj;
1631+ };
1632+ var heytingAlgebraBoolean = new HeytingAlgebra($foreign.boolConj, $foreign.boolDisj, false, function (a) {
1633+ return function (b) {
1634+ return disj(heytingAlgebraBoolean)(not(heytingAlgebraBoolean)(a))(b);
1635+ };
1636+ }, $foreign.boolNot, true);
1637+ var conj = function (dict) {
1638+ return dict.conj;
1639+ };
1640+ exports["HeytingAlgebra"] = HeytingAlgebra;
1641+ exports["tt"] = tt;
1642+ exports["ff"] = ff;
1643+ exports["implies"] = implies;
1644+ exports["conj"] = conj;
1645+ exports["disj"] = disj;
1646+ exports["not"] = not;
1647+ exports["heytingAlgebraBoolean"] = heytingAlgebraBoolean;
1648+})(PS["Data.HeytingAlgebra"] = PS["Data.HeytingAlgebra"] || {});
1649+(function(exports) {
1650+ // Generated by purs version 0.11.7
1651+ "use strict";
1652+ var Control_Alt = PS["Control.Alt"];
1653+ var Control_Alternative = PS["Control.Alternative"];
1654+ var Control_Applicative = PS["Control.Applicative"];
1655+ var Control_Apply = PS["Control.Apply"];
1656+ var Control_Bind = PS["Control.Bind"];
1657+ var Control_Category = PS["Control.Category"];
1658+ var Control_Extend = PS["Control.Extend"];
1659+ var Control_Monad = PS["Control.Monad"];
1660+ var Control_MonadZero = PS["Control.MonadZero"];
1661+ var Control_Plus = PS["Control.Plus"];
1662+ var Data_Bounded = PS["Data.Bounded"];
1663+ var Data_Eq = PS["Data.Eq"];
1664+ var Data_Function = PS["Data.Function"];
1665+ var Data_Functor = PS["Data.Functor"];
1666+ var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
1667+ var Data_Monoid = PS["Data.Monoid"];
1668+ var Data_Ord = PS["Data.Ord"];
1669+ var Data_Ordering = PS["Data.Ordering"];
1670+ var Data_Semigroup = PS["Data.Semigroup"];
1671+ var Data_Show = PS["Data.Show"];
1672+ var Data_Unit = PS["Data.Unit"];
1673+ var Prelude = PS["Prelude"];
1674+ var Nothing = (function () {
1675+ function Nothing() {
1676+
1677+ };
1678+ Nothing.value = new Nothing();
1679+ return Nothing;
1680+ })();
1681+ var Just = (function () {
1682+ function Just(value0) {
1683+ this.value0 = value0;
1684+ };
1685+ Just.create = function (value0) {
1686+ return new Just(value0);
1687+ };
1688+ return Just;
1689+ })();
1690+ var maybe = function (v) {
1691+ return function (v1) {
1692+ return function (v2) {
1693+ if (v2 instanceof Nothing) {
1694+ return v;
1695+ };
1696+ if (v2 instanceof Just) {
1697+ return v1(v2.value0);
1698+ };
1699+ throw new Error("Failed pattern match at Data.Maybe line 219, column 1 - line 219, column 51: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
1700+ };
1701+ };
1702+ };
1703+ var functorMaybe = new Data_Functor.Functor(function (v) {
1704+ return function (v1) {
1705+ if (v1 instanceof Just) {
1706+ return new Just(v(v1.value0));
1707+ };
1708+ return Nothing.value;
1709+ };
1710+ });
1711+ exports["Nothing"] = Nothing;
1712+ exports["Just"] = Just;
1713+ exports["maybe"] = maybe;
1714+ exports["functorMaybe"] = functorMaybe;
1715+})(PS["Data.Maybe"] = PS["Data.Maybe"] || {});
1716+(function(exports) {
1717+ // Generated by purs version 0.11.7
1718+ "use strict";
1719+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
1720+ var Data_Function = PS["Data.Function"];
1721+ var Data_Functor = PS["Data.Functor"];
1722+ var Prelude = PS["Prelude"];
1723+ var Newtype = function (unwrap, wrap) {
1724+ this.unwrap = unwrap;
1725+ this.wrap = wrap;
1726+ };
1727+ var wrap = function (dict) {
1728+ return dict.wrap;
1729+ };
1730+ var unwrap = function (dict) {
1731+ return dict.unwrap;
1732+ };
1733+ var alaF = function (dictFunctor) {
1734+ return function (dictFunctor1) {
1735+ return function (dictNewtype) {
1736+ return function (dictNewtype1) {
1737+ return function (v) {
1738+ return function (f) {
1739+ return function ($64) {
1740+ return Data_Functor.map(dictFunctor1)(unwrap(dictNewtype1))(f(Data_Functor.map(dictFunctor)(wrap(dictNewtype))($64)));
1741+ };
1742+ };
1743+ };
1744+ };
1745+ };
1746+ };
1747+ };
1748+ exports["unwrap"] = unwrap;
1749+ exports["wrap"] = wrap;
1750+ exports["Newtype"] = Newtype;
1751+ exports["alaF"] = alaF;
1752+})(PS["Data.Newtype"] = PS["Data.Newtype"] || {});
1753+(function(exports) {
1754+ // Generated by purs version 0.11.7
1755+ "use strict";
1756+ var Control_Applicative = PS["Control.Applicative"];
1757+ var Control_Apply = PS["Control.Apply"];
1758+ var Control_Bind = PS["Control.Bind"];
1759+ var Control_Comonad = PS["Control.Comonad"];
1760+ var Control_Extend = PS["Control.Extend"];
1761+ var Control_Monad = PS["Control.Monad"];
1762+ var Data_Bounded = PS["Data.Bounded"];
1763+ var Data_Eq = PS["Data.Eq"];
1764+ var Data_Functor = PS["Data.Functor"];
1765+ var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
1766+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
1767+ var Data_Monoid = PS["Data.Monoid"];
1768+ var Data_Newtype = PS["Data.Newtype"];
1769+ var Data_Ord = PS["Data.Ord"];
1770+ var Data_Semigroup = PS["Data.Semigroup"];
1771+ var Data_Semiring = PS["Data.Semiring"];
1772+ var Data_Show = PS["Data.Show"];
1773+ var Prelude = PS["Prelude"];
1774+ var Disj = function (x) {
1775+ return x;
1776+ };
1777+ var semigroupDisj = function (dictHeytingAlgebra) {
1778+ return new Data_Semigroup.Semigroup(function (v) {
1779+ return function (v1) {
1780+ return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);
1781+ };
1782+ });
1783+ };
1784+ var newtypeDisj = new Data_Newtype.Newtype(function (n) {
1785+ return n;
1786+ }, Disj);
1787+ var monoidDisj = function (dictHeytingAlgebra) {
1788+ return new Data_Monoid.Monoid(function () {
1789+ return semigroupDisj(dictHeytingAlgebra);
1790+ }, Data_HeytingAlgebra.ff(dictHeytingAlgebra));
1791+ };
1792+ exports["Disj"] = Disj;
1793+ exports["newtypeDisj"] = newtypeDisj;
1794+ exports["semigroupDisj"] = semigroupDisj;
1795+ exports["monoidDisj"] = monoidDisj;
1796+})(PS["Data.Monoid.Disj"] = PS["Data.Monoid.Disj"] || {});
1797+(function(exports) {
1798+ // Generated by purs version 0.11.7
1799+ "use strict";
1800+ var $foreign = PS["Data.Foldable"];
1801+ var Control_Alt = PS["Control.Alt"];
1802+ var Control_Applicative = PS["Control.Applicative"];
1803+ var Control_Apply = PS["Control.Apply"];
1804+ var Control_Bind = PS["Control.Bind"];
1805+ var Control_Category = PS["Control.Category"];
1806+ var Control_Plus = PS["Control.Plus"];
1807+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
1808+ var Data_Eq = PS["Data.Eq"];
1809+ var Data_Function = PS["Data.Function"];
1810+ var Data_Functor = PS["Data.Functor"];
1811+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
1812+ var Data_Maybe = PS["Data.Maybe"];
1813+ var Data_Maybe_First = PS["Data.Maybe.First"];
1814+ var Data_Maybe_Last = PS["Data.Maybe.Last"];
1815+ var Data_Monoid = PS["Data.Monoid"];
1816+ var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
1817+ var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
1818+ var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
1819+ var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
1820+ var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
1821+ var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
1822+ var Data_Newtype = PS["Data.Newtype"];
1823+ var Data_Ord = PS["Data.Ord"];
1824+ var Data_Ordering = PS["Data.Ordering"];
1825+ var Data_Semigroup = PS["Data.Semigroup"];
1826+ var Data_Semiring = PS["Data.Semiring"];
1827+ var Data_Unit = PS["Data.Unit"];
1828+ var Prelude = PS["Prelude"];
1829+ var Foldable = function (foldMap, foldl, foldr) {
1830+ this.foldMap = foldMap;
1831+ this.foldl = foldl;
1832+ this.foldr = foldr;
1833+ };
1834+ var foldr = function (dict) {
1835+ return dict.foldr;
1836+ };
1837+ var traverse_ = function (dictApplicative) {
1838+ return function (dictFoldable) {
1839+ return function (f) {
1840+ return foldr(dictFoldable)(function ($195) {
1841+ return Control_Apply.applySecond(dictApplicative.Apply0())(f($195));
1842+ })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
1843+ };
1844+ };
1845+ };
1846+ var for_ = function (dictApplicative) {
1847+ return function (dictFoldable) {
1848+ return Data_Function.flip(traverse_(dictApplicative)(dictFoldable));
1849+ };
1850+ };
1851+ var foldl = function (dict) {
1852+ return dict.foldl;
1853+ };
1854+ var intercalate = function (dictFoldable) {
1855+ return function (dictMonoid) {
1856+ return function (sep) {
1857+ return function (xs) {
1858+ var go = function (v) {
1859+ return function (x) {
1860+ if (v.init) {
1861+ return {
1862+ init: false,
1863+ acc: x
1864+ };
1865+ };
1866+ return {
1867+ init: false,
1868+ acc: Data_Semigroup.append(dictMonoid.Semigroup0())(v.acc)(Data_Semigroup.append(dictMonoid.Semigroup0())(sep)(x))
1869+ };
1870+ };
1871+ };
1872+ return (foldl(dictFoldable)(go)({
1873+ init: true,
1874+ acc: Data_Monoid.mempty(dictMonoid)
1875+ })(xs)).acc;
1876+ };
1877+ };
1878+ };
1879+ };
1880+ var foldMapDefaultR = function (dictFoldable) {
1881+ return function (dictMonoid) {
1882+ return function (f) {
1883+ return foldr(dictFoldable)(function (x) {
1884+ return function (acc) {
1885+ return Data_Semigroup.append(dictMonoid.Semigroup0())(f(x))(acc);
1886+ };
1887+ })(Data_Monoid.mempty(dictMonoid));
1888+ };
1889+ };
1890+ };
1891+ var foldableArray = new Foldable(function (dictMonoid) {
1892+ return foldMapDefaultR(foldableArray)(dictMonoid);
1893+ }, $foreign.foldlArray, $foreign.foldrArray);
1894+ var foldMap = function (dict) {
1895+ return dict.foldMap;
1896+ };
1897+ var any = function (dictFoldable) {
1898+ return function (dictHeytingAlgebra) {
1899+ return Data_Newtype.alaF(Data_Functor.functorFn)(Data_Functor.functorFn)(Data_Monoid_Disj.newtypeDisj)(Data_Monoid_Disj.newtypeDisj)(Data_Monoid_Disj.Disj)(foldMap(dictFoldable)(Data_Monoid_Disj.monoidDisj(dictHeytingAlgebra)));
1900+ };
1901+ };
1902+ exports["Foldable"] = Foldable;
1903+ exports["foldr"] = foldr;
1904+ exports["foldl"] = foldl;
1905+ exports["foldMap"] = foldMap;
1906+ exports["foldMapDefaultR"] = foldMapDefaultR;
1907+ exports["traverse_"] = traverse_;
1908+ exports["for_"] = for_;
1909+ exports["intercalate"] = intercalate;
1910+ exports["any"] = any;
1911+ exports["foldableArray"] = foldableArray;
1912+})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
1913+(function(exports) {
1914+ // Generated by purs version 0.11.7
1915+ "use strict";
1916+ var $foreign = PS["Data.Traversable"];
1917+ var Control_Applicative = PS["Control.Applicative"];
1918+ var Control_Apply = PS["Control.Apply"];
1919+ var Control_Category = PS["Control.Category"];
1920+ var Data_Foldable = PS["Data.Foldable"];
1921+ var Data_Functor = PS["Data.Functor"];
1922+ var Data_Maybe = PS["Data.Maybe"];
1923+ var Data_Maybe_First = PS["Data.Maybe.First"];
1924+ var Data_Maybe_Last = PS["Data.Maybe.Last"];
1925+ var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
1926+ var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
1927+ var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
1928+ var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
1929+ var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
1930+ var Data_Traversable_Accum = PS["Data.Traversable.Accum"];
1931+ var Data_Traversable_Accum_Internal = PS["Data.Traversable.Accum.Internal"];
1932+ var Prelude = PS["Prelude"];
1933+ var Traversable = function (Foldable1, Functor0, sequence, traverse) {
1934+ this.Foldable1 = Foldable1;
1935+ this.Functor0 = Functor0;
1936+ this.sequence = sequence;
1937+ this.traverse = traverse;
1938+ };
1939+ var traverse = function (dict) {
1940+ return dict.traverse;
1941+ };
1942+ var sequence = function (dict) {
1943+ return dict.sequence;
1944+ };
1945+ exports["Traversable"] = Traversable;
1946+ exports["traverse"] = traverse;
1947+ exports["sequence"] = sequence;
1948+})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
1949+(function(exports) {
1950+ // Generated by purs version 0.11.7
1951+ "use strict";
1952+ var Control_Alt = PS["Control.Alt"];
1953+ var Control_Applicative = PS["Control.Applicative"];
1954+ var Control_Apply = PS["Control.Apply"];
1955+ var Control_Bind = PS["Control.Bind"];
1956+ var Control_Extend = PS["Control.Extend"];
1957+ var Control_Monad = PS["Control.Monad"];
1958+ var Data_Bifoldable = PS["Data.Bifoldable"];
1959+ var Data_Bifunctor = PS["Data.Bifunctor"];
1960+ var Data_Bitraversable = PS["Data.Bitraversable"];
1961+ var Data_Bounded = PS["Data.Bounded"];
1962+ var Data_Eq = PS["Data.Eq"];
1963+ var Data_Foldable = PS["Data.Foldable"];
1964+ var Data_Function = PS["Data.Function"];
1965+ var Data_Functor = PS["Data.Functor"];
1966+ var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
1967+ var Data_Maybe = PS["Data.Maybe"];
1968+ var Data_Monoid = PS["Data.Monoid"];
1969+ var Data_Ord = PS["Data.Ord"];
1970+ var Data_Ordering = PS["Data.Ordering"];
1971+ var Data_Semigroup = PS["Data.Semigroup"];
1972+ var Data_Semiring = PS["Data.Semiring"];
1973+ var Data_Show = PS["Data.Show"];
1974+ var Data_Traversable = PS["Data.Traversable"];
1975+ var Prelude = PS["Prelude"];
1976+ var Left = (function () {
1977+ function Left(value0) {
1978+ this.value0 = value0;
1979+ };
1980+ Left.create = function (value0) {
1981+ return new Left(value0);
1982+ };
1983+ return Left;
1984+ })();
1985+ var Right = (function () {
1986+ function Right(value0) {
1987+ this.value0 = value0;
1988+ };
1989+ Right.create = function (value0) {
1990+ return new Right(value0);
1991+ };
1992+ return Right;
1993+ })();
1994+ var functorEither = new Data_Functor.Functor(function (v) {
1995+ return function (v1) {
1996+ if (v1 instanceof Left) {
1997+ return new Left(v1.value0);
1998+ };
1999+ if (v1 instanceof Right) {
2000+ return new Right(v(v1.value0));
2001+ };
2002+ throw new Error("Failed pattern match at Data.Either line 36, column 1 - line 36, column 45: " + [ v.constructor.name, v1.constructor.name ]);
2003+ };
2004+ });
2005+ var foldableEither = new Data_Foldable.Foldable(function (dictMonoid) {
2006+ return function (f) {
2007+ return function (v) {
2008+ if (v instanceof Left) {
2009+ return Data_Monoid.mempty(dictMonoid);
2010+ };
2011+ if (v instanceof Right) {
2012+ return f(v.value0);
2013+ };
2014+ throw new Error("Failed pattern match at Data.Either line 184, column 1 - line 184, column 47: " + [ f.constructor.name, v.constructor.name ]);
2015+ };
2016+ };
2017+ }, function (v) {
2018+ return function (z) {
2019+ return function (v1) {
2020+ if (v1 instanceof Left) {
2021+ return z;
2022+ };
2023+ if (v1 instanceof Right) {
2024+ return v(z)(v1.value0);
2025+ };
2026+ throw new Error("Failed pattern match at Data.Either line 184, column 1 - line 184, column 47: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
2027+ };
2028+ };
2029+ }, function (v) {
2030+ return function (z) {
2031+ return function (v1) {
2032+ if (v1 instanceof Left) {
2033+ return z;
2034+ };
2035+ if (v1 instanceof Right) {
2036+ return v(v1.value0)(z);
2037+ };
2038+ throw new Error("Failed pattern match at Data.Either line 184, column 1 - line 184, column 47: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
2039+ };
2040+ };
2041+ });
2042+ var either = function (v) {
2043+ return function (v1) {
2044+ return function (v2) {
2045+ if (v2 instanceof Left) {
2046+ return v(v2.value0);
2047+ };
2048+ if (v2 instanceof Right) {
2049+ return v1(v2.value0);
2050+ };
2051+ throw new Error("Failed pattern match at Data.Either line 229, column 1 - line 229, column 64: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
2052+ };
2053+ };
2054+ };
2055+ var bifunctorEither = new Data_Bifunctor.Bifunctor(function (v) {
2056+ return function (v1) {
2057+ return function (v2) {
2058+ if (v2 instanceof Left) {
2059+ return new Left(v(v2.value0));
2060+ };
2061+ if (v2 instanceof Right) {
2062+ return new Right(v1(v2.value0));
2063+ };
2064+ throw new Error("Failed pattern match at Data.Either line 43, column 1 - line 43, column 45: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
2065+ };
2066+ };
2067+ });
2068+ var applyEither = new Control_Apply.Apply(function () {
2069+ return functorEither;
2070+ }, function (v) {
2071+ return function (v1) {
2072+ if (v instanceof Left) {
2073+ return new Left(v.value0);
2074+ };
2075+ if (v instanceof Right) {
2076+ return Data_Functor.map(functorEither)(v.value0)(v1);
2077+ };
2078+ throw new Error("Failed pattern match at Data.Either line 79, column 1 - line 79, column 41: " + [ v.constructor.name, v1.constructor.name ]);
2079+ };
2080+ });
2081+ var bindEither = new Control_Bind.Bind(function () {
2082+ return applyEither;
2083+ }, either(function (e) {
2084+ return function (v) {
2085+ return new Left(e);
2086+ };
2087+ })(function (a) {
2088+ return function (f) {
2089+ return f(a);
2090+ };
2091+ }));
2092+ var applicativeEither = new Control_Applicative.Applicative(function () {
2093+ return applyEither;
2094+ }, Right.create);
2095+ exports["Left"] = Left;
2096+ exports["Right"] = Right;
2097+ exports["either"] = either;
2098+ exports["functorEither"] = functorEither;
2099+ exports["bifunctorEither"] = bifunctorEither;
2100+ exports["applyEither"] = applyEither;
2101+ exports["applicativeEither"] = applicativeEither;
2102+ exports["bindEither"] = bindEither;
2103+ exports["foldableEither"] = foldableEither;
2104+})(PS["Data.Either"] = PS["Data.Either"] || {});
2105+(function(exports) {
2106+ // Generated by purs version 0.11.7
2107+ "use strict";
2108+ var $foreign = PS["Control.Monad.Eff.Exception"];
2109+ var Control_Applicative = PS["Control.Applicative"];
2110+ var Control_Monad_Eff = PS["Control.Monad.Eff"];
2111+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
2112+ var Data_Either = PS["Data.Either"];
2113+ var Data_Functor = PS["Data.Functor"];
2114+ var Data_Maybe = PS["Data.Maybe"];
2115+ var Data_Show = PS["Data.Show"];
2116+ var Prelude = PS["Prelude"];
2117+ exports["error"] = $foreign.error;
2118+})(PS["Control.Monad.Eff.Exception"] = PS["Control.Monad.Eff.Exception"] || {});
2119+(function(exports) {
2120+ // Generated by purs version 0.11.7
2121+ "use strict";
2122+ var Control_Applicative = PS["Control.Applicative"];
2123+ var Control_Bind = PS["Control.Bind"];
2124+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
2125+ var Data_Either = PS["Data.Either"];
2126+ var Data_Function = PS["Data.Function"];
2127+ var Data_Functor = PS["Data.Functor"];
2128+ var Data_Maybe = PS["Data.Maybe"];
2129+ var Data_Unit = PS["Data.Unit"];
2130+ var Prelude = PS["Prelude"];
2131+ var MonadThrow = function (Monad0, throwError) {
2132+ this.Monad0 = Monad0;
2133+ this.throwError = throwError;
2134+ };
2135+ var throwError = function (dict) {
2136+ return dict.throwError;
2137+ };
2138+ exports["throwError"] = throwError;
2139+ exports["MonadThrow"] = MonadThrow;
2140+})(PS["Control.Monad.Error.Class"] = PS["Control.Monad.Error.Class"] || {});
2141+(function(exports) {
2142+ "use strict";
2143+
2144+ exports.runFn4 = function (fn) {
2145+ return function (a) {
2146+ return function (b) {
2147+ return function (c) {
2148+ return function (d) {
2149+ return fn(a, b, c, d);
2150+ };
2151+ };
2152+ };
2153+ };
2154+ };
2155+})(PS["Data.Function.Uncurried"] = PS["Data.Function.Uncurried"] || {});
2156+(function(exports) {
2157+ // Generated by purs version 0.11.7
2158+ "use strict";
2159+ var $foreign = PS["Data.Function.Uncurried"];
2160+ var Data_Unit = PS["Data.Unit"];
2161+ exports["runFn4"] = $foreign.runFn4;
2162+})(PS["Data.Function.Uncurried"] = PS["Data.Function.Uncurried"] || {});
2163+(function(exports) {
2164+ "use strict";
2165+
2166+ // module Partial.Unsafe
2167+
2168+ exports.unsafePartial = function (f) {
2169+ return f();
2170+ };
2171+})(PS["Partial.Unsafe"] = PS["Partial.Unsafe"] || {});
2172+(function(exports) {
2173+ "use strict";
2174+
2175+ // module Partial
2176+
2177+ exports.crashWith = function () {
2178+ return function (msg) {
2179+ throw new Error(msg);
2180+ };
2181+ };
2182+})(PS["Partial"] = PS["Partial"] || {});
2183+(function(exports) {
2184+ // Generated by purs version 0.11.7
2185+ "use strict";
2186+ var $foreign = PS["Partial"];
2187+ exports["crashWith"] = $foreign.crashWith;
2188+})(PS["Partial"] = PS["Partial"] || {});
2189+(function(exports) {
2190+ // Generated by purs version 0.11.7
2191+ "use strict";
2192+ var $foreign = PS["Partial.Unsafe"];
2193+ var Partial = PS["Partial"];
2194+ var unsafeCrashWith = function (msg) {
2195+ return $foreign.unsafePartial(function (dictPartial) {
2196+ return Partial.crashWith(dictPartial)(msg);
2197+ });
2198+ };
2199+ exports["unsafeCrashWith"] = unsafeCrashWith;
2200+})(PS["Partial.Unsafe"] = PS["Partial.Unsafe"] || {});
2201+(function(exports) {
2202+ // Generated by purs version 0.11.7
2203+ "use strict";
2204+ var $foreign = PS["Control.Monad.Aff"];
2205+ var Control_Alt = PS["Control.Alt"];
2206+ var Control_Alternative = PS["Control.Alternative"];
2207+ var Control_Applicative = PS["Control.Applicative"];
2208+ var Control_Apply = PS["Control.Apply"];
2209+ var Control_Bind = PS["Control.Bind"];
2210+ var Control_Monad = PS["Control.Monad"];
2211+ var Control_Monad_Eff = PS["Control.Monad.Eff"];
2212+ var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
2213+ var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
2214+ var Control_Monad_Eff_Unsafe = PS["Control.Monad.Eff.Unsafe"];
2215+ var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
2216+ var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
2217+ var Control_Parallel = PS["Control.Parallel"];
2218+ var Control_Parallel_Class = PS["Control.Parallel.Class"];
2219+ var Control_Plus = PS["Control.Plus"];
2220+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
2221+ var Data_Either = PS["Data.Either"];
2222+ var Data_Foldable = PS["Data.Foldable"];
2223+ var Data_Function = PS["Data.Function"];
2224+ var Data_Function_Uncurried = PS["Data.Function.Uncurried"];
2225+ var Data_Functor = PS["Data.Functor"];
2226+ var Data_Monoid = PS["Data.Monoid"];
2227+ var Data_Newtype = PS["Data.Newtype"];
2228+ var Data_Semigroup = PS["Data.Semigroup"];
2229+ var Data_Time_Duration = PS["Data.Time.Duration"];
2230+ var Data_Unit = PS["Data.Unit"];
2231+ var Partial_Unsafe = PS["Partial.Unsafe"];
2232+ var Prelude = PS["Prelude"];
2233+ var Unsafe_Coerce = PS["Unsafe.Coerce"];
2234+ var functorAff = new Data_Functor.Functor($foreign._map);
2235+ var ffiUtil = (function () {
2236+ var unsafeFromRight = function (v) {
2237+ if (v instanceof Data_Either.Right) {
2238+ return v.value0;
2239+ };
2240+ if (v instanceof Data_Either.Left) {
2241+ return Partial_Unsafe.unsafeCrashWith("unsafeFromRight: Left");
2242+ };
2243+ throw new Error("Failed pattern match at Control.Monad.Aff line 398, column 21 - line 400, column 31: " + [ v.constructor.name ]);
2244+ };
2245+ var unsafeFromLeft = function (v) {
2246+ if (v instanceof Data_Either.Left) {
2247+ return v.value0;
2248+ };
2249+ if (v instanceof Data_Either.Right) {
2250+ return Partial_Unsafe.unsafeCrashWith("unsafeFromLeft: Right");
2251+ };
2252+ throw new Error("Failed pattern match at Control.Monad.Aff line 393, column 20 - line 397, column 3: " + [ v.constructor.name ]);
2253+ };
2254+ var isLeft = function (v) {
2255+ if (v instanceof Data_Either.Left) {
2256+ return true;
2257+ };
2258+ if (v instanceof Data_Either.Right) {
2259+ return false;
2260+ };
2261+ throw new Error("Failed pattern match at Control.Monad.Aff line 388, column 12 - line 390, column 20: " + [ v.constructor.name ]);
2262+ };
2263+ return {
2264+ isLeft: isLeft,
2265+ fromLeft: unsafeFromLeft,
2266+ fromRight: unsafeFromRight,
2267+ left: Data_Either.Left.create,
2268+ right: Data_Either.Right.create
2269+ };
2270+ })();
2271+ var makeFiber = function (aff) {
2272+ return $foreign._makeFiber(ffiUtil, aff);
2273+ };
2274+ var launchAff = function (aff) {
2275+ return function __do() {
2276+ var v = makeFiber(aff)();
2277+ v.run();
2278+ return v;
2279+ };
2280+ };
2281+ var monadAff = new Control_Monad.Monad(function () {
2282+ return applicativeAff;
2283+ }, function () {
2284+ return bindAff;
2285+ });
2286+ var bindAff = new Control_Bind.Bind(function () {
2287+ return applyAff;
2288+ }, $foreign._bind);
2289+ var applyAff = new Control_Apply.Apply(function () {
2290+ return functorAff;
2291+ }, Control_Monad.ap(monadAff));
2292+ var applicativeAff = new Control_Applicative.Applicative(function () {
2293+ return applyAff;
2294+ }, $foreign._pure);
2295+ var monadThrowAff = new Control_Monad_Error_Class.MonadThrow(function () {
2296+ return monadAff;
2297+ }, $foreign._throwError);
2298+ var nonCanceler = Data_Function["const"](Control_Applicative.pure(applicativeAff)(Data_Unit.unit));
2299+ exports["launchAff"] = launchAff;
2300+ exports["nonCanceler"] = nonCanceler;
2301+ exports["functorAff"] = functorAff;
2302+ exports["applyAff"] = applyAff;
2303+ exports["applicativeAff"] = applicativeAff;
2304+ exports["bindAff"] = bindAff;
2305+ exports["monadAff"] = monadAff;
2306+ exports["monadThrowAff"] = monadThrowAff;
2307+ exports["makeAff"] = $foreign.makeAff;
2308+})(PS["Control.Monad.Aff"] = PS["Control.Monad.Aff"] || {});
2309+(function(exports) {
2310+ "use strict";
2311+
2312+ exports.mkEffFn1 = function mkEffFn1(fn) {
2313+ return function(x) {
2314+ return fn(x)();
2315+ };
2316+ };
2317+
2318+ exports.runEffFn2 = function runEffFn2(fn) {
2319+ return function(a) {
2320+ return function(b) {
2321+ return function() {
2322+ return fn(a, b);
2323+ };
2324+ };
2325+ };
2326+ };
2327+
2328+ exports.runEffFn3 = function runEffFn3(fn) {
2329+ return function(a) {
2330+ return function(b) {
2331+ return function(c) {
2332+ return function() {
2333+ return fn(a, b, c);
2334+ };
2335+ };
2336+ };
2337+ };
2338+ };
2339+})(PS["Control.Monad.Eff.Uncurried"] = PS["Control.Monad.Eff.Uncurried"] || {});
2340+(function(exports) {
2341+ // Generated by purs version 0.11.7
2342+ "use strict";
2343+ var $foreign = PS["Control.Monad.Eff.Uncurried"];
2344+ var Control_Monad_Eff = PS["Control.Monad.Eff"];
2345+ exports["mkEffFn1"] = $foreign.mkEffFn1;
2346+ exports["runEffFn2"] = $foreign.runEffFn2;
2347+ exports["runEffFn3"] = $foreign.runEffFn3;
2348+})(PS["Control.Monad.Eff.Uncurried"] = PS["Control.Monad.Eff.Uncurried"] || {});
2349+(function(exports) {
2350+ // Generated by purs version 0.11.7
2351+ "use strict";
2352+ var Control_Applicative = PS["Control.Applicative"];
2353+ var Control_Bind = PS["Control.Bind"];
2354+ var Control_Monad_Aff = PS["Control.Monad.Aff"];
2355+ var Control_Monad_Eff = PS["Control.Monad.Eff"];
2356+ var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
2357+ var Control_Monad_Eff_Uncurried = PS["Control.Monad.Eff.Uncurried"];
2358+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
2359+ var Data_Either = PS["Data.Either"];
2360+ var Data_Function = PS["Data.Function"];
2361+ var Prelude = PS["Prelude"];
2362+ var fromEffFnAff = function (v) {
2363+ return Control_Monad_Aff.makeAff(function (k) {
2364+ return function __do() {
2365+ var v1 = Control_Monad_Eff_Uncurried.runEffFn2(v)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($4) {
2366+ return k(Data_Either.Left.create($4));
2367+ }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($5) {
2368+ return k(Data_Either.Right.create($5));
2369+ }))();
2370+ return function (e) {
2371+ return Control_Monad_Aff.makeAff(function (k2) {
2372+ return function __do() {
2373+ Control_Monad_Eff_Uncurried.runEffFn3(v1)(e)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($6) {
2374+ return k2(Data_Either.Left.create($6));
2375+ }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($7) {
2376+ return k2(Data_Either.Right.create($7));
2377+ }))();
2378+ return Control_Monad_Aff.nonCanceler;
2379+ };
2380+ });
2381+ };
2382+ };
2383+ });
2384+ };
2385+ exports["fromEffFnAff"] = fromEffFnAff;
2386+})(PS["Control.Monad.Aff.Compat"] = PS["Control.Monad.Aff.Compat"] || {});
2387+(function(exports) {
2388+ // Generated by purs version 0.11.7
2389+ "use strict";
2390+ var Control_Applicative = PS["Control.Applicative"];
2391+ var Control_Apply = PS["Control.Apply"];
2392+ var Control_Biapplicative = PS["Control.Biapplicative"];
2393+ var Control_Biapply = PS["Control.Biapply"];
2394+ var Control_Bind = PS["Control.Bind"];
2395+ var Control_Comonad = PS["Control.Comonad"];
2396+ var Control_Extend = PS["Control.Extend"];
2397+ var Control_Lazy = PS["Control.Lazy"];
2398+ var Control_Monad = PS["Control.Monad"];
2399+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
2400+ var Data_Bifoldable = PS["Data.Bifoldable"];
2401+ var Data_Bifunctor = PS["Data.Bifunctor"];
2402+ var Data_Bitraversable = PS["Data.Bitraversable"];
2403+ var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
2404+ var Data_Bounded = PS["Data.Bounded"];
2405+ var Data_CommutativeRing = PS["Data.CommutativeRing"];
2406+ var Data_Distributive = PS["Data.Distributive"];
2407+ var Data_Eq = PS["Data.Eq"];
2408+ var Data_Foldable = PS["Data.Foldable"];
2409+ var Data_Function = PS["Data.Function"];
2410+ var Data_Functor = PS["Data.Functor"];
2411+ var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
2412+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
2413+ var Data_Maybe = PS["Data.Maybe"];
2414+ var Data_Maybe_First = PS["Data.Maybe.First"];
2415+ var Data_Monoid = PS["Data.Monoid"];
2416+ var Data_Newtype = PS["Data.Newtype"];
2417+ var Data_Ord = PS["Data.Ord"];
2418+ var Data_Ordering = PS["Data.Ordering"];
2419+ var Data_Ring = PS["Data.Ring"];
2420+ var Data_Semigroup = PS["Data.Semigroup"];
2421+ var Data_Semiring = PS["Data.Semiring"];
2422+ var Data_Show = PS["Data.Show"];
2423+ var Data_Traversable = PS["Data.Traversable"];
2424+ var Data_Unit = PS["Data.Unit"];
2425+ var Prelude = PS["Prelude"];
2426+ var Type_Equality = PS["Type.Equality"];
2427+ var Tuple = (function () {
2428+ function Tuple(value0, value1) {
2429+ this.value0 = value0;
2430+ this.value1 = value1;
2431+ };
2432+ Tuple.create = function (value0) {
2433+ return function (value1) {
2434+ return new Tuple(value0, value1);
2435+ };
2436+ };
2437+ return Tuple;
2438+ })();
2439+ var uncurry = function (f) {
2440+ return function (v) {
2441+ return f(v.value0)(v.value1);
2442+ };
2443+ };
2444+ var snd = function (v) {
2445+ return v.value1;
2446+ };
2447+ var fst = function (v) {
2448+ return v.value0;
2449+ };
2450+ exports["Tuple"] = Tuple;
2451+ exports["fst"] = fst;
2452+ exports["snd"] = snd;
2453+ exports["uncurry"] = uncurry;
2454+})(PS["Data.Tuple"] = PS["Data.Tuple"] || {});
2455+(function(exports) {
2456+ // Generated by purs version 0.11.7
2457+ "use strict";
2458+ var Control_Alt = PS["Control.Alt"];
2459+ var Control_Alternative = PS["Control.Alternative"];
2460+ var Control_Applicative = PS["Control.Applicative"];
2461+ var Control_Apply = PS["Control.Apply"];
2462+ var Control_Bind = PS["Control.Bind"];
2463+ var Control_Category = PS["Control.Category"];
2464+ var Control_Monad = PS["Control.Monad"];
2465+ var Control_Monad_Cont_Class = PS["Control.Monad.Cont.Class"];
2466+ var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
2467+ var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
2468+ var Control_Monad_Reader_Class = PS["Control.Monad.Reader.Class"];
2469+ var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
2470+ var Control_Monad_State_Class = PS["Control.Monad.State.Class"];
2471+ var Control_Monad_Trans_Class = PS["Control.Monad.Trans.Class"];
2472+ var Control_Monad_Writer_Class = PS["Control.Monad.Writer.Class"];
2473+ var Control_MonadPlus = PS["Control.MonadPlus"];
2474+ var Control_MonadZero = PS["Control.MonadZero"];
2475+ var Control_Plus = PS["Control.Plus"];
2476+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
2477+ var Data_Either = PS["Data.Either"];
2478+ var Data_Function = PS["Data.Function"];
2479+ var Data_Functor = PS["Data.Functor"];
2480+ var Data_Monoid = PS["Data.Monoid"];
2481+ var Data_Newtype = PS["Data.Newtype"];
2482+ var Data_Semigroup = PS["Data.Semigroup"];
2483+ var Data_Tuple = PS["Data.Tuple"];
2484+ var Prelude = PS["Prelude"];
2485+ var ExceptT = function (x) {
2486+ return x;
2487+ };
2488+ var runExceptT = function (v) {
2489+ return v;
2490+ };
2491+ var mapExceptT = function (f) {
2492+ return function (v) {
2493+ return f(v);
2494+ };
2495+ };
2496+ var functorExceptT = function (dictFunctor) {
2497+ return new Data_Functor.Functor(function (f) {
2498+ return mapExceptT(Data_Functor.map(dictFunctor)(Data_Functor.map(Data_Either.functorEither)(f)));
2499+ });
2500+ };
2501+ var monadExceptT = function (dictMonad) {
2502+ return new Control_Monad.Monad(function () {
2503+ return applicativeExceptT(dictMonad);
2504+ }, function () {
2505+ return bindExceptT(dictMonad);
2506+ });
2507+ };
2508+ var bindExceptT = function (dictMonad) {
2509+ return new Control_Bind.Bind(function () {
2510+ return applyExceptT(dictMonad);
2511+ }, function (v) {
2512+ return function (k) {
2513+ return Control_Bind.bind(dictMonad.Bind1())(v)(Data_Either.either(function ($97) {
2514+ return Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Left.create($97));
2515+ })(function (a) {
2516+ var v1 = k(a);
2517+ return v1;
2518+ }));
2519+ };
2520+ });
2521+ };
2522+ var applyExceptT = function (dictMonad) {
2523+ return new Control_Apply.Apply(function () {
2524+ return functorExceptT(((dictMonad.Bind1()).Apply0()).Functor0());
2525+ }, Control_Monad.ap(monadExceptT(dictMonad)));
2526+ };
2527+ var applicativeExceptT = function (dictMonad) {
2528+ return new Control_Applicative.Applicative(function () {
2529+ return applyExceptT(dictMonad);
2530+ }, function ($98) {
2531+ return ExceptT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Right.create($98)));
2532+ });
2533+ };
2534+ var monadThrowExceptT = function (dictMonad) {
2535+ return new Control_Monad_Error_Class.MonadThrow(function () {
2536+ return monadExceptT(dictMonad);
2537+ }, function ($102) {
2538+ return ExceptT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Left.create($102)));
2539+ });
2540+ };
2541+ exports["ExceptT"] = ExceptT;
2542+ exports["runExceptT"] = runExceptT;
2543+ exports["mapExceptT"] = mapExceptT;
2544+ exports["functorExceptT"] = functorExceptT;
2545+ exports["applyExceptT"] = applyExceptT;
2546+ exports["applicativeExceptT"] = applicativeExceptT;
2547+ exports["bindExceptT"] = bindExceptT;
2548+ exports["monadExceptT"] = monadExceptT;
2549+ exports["monadThrowExceptT"] = monadThrowExceptT;
2550+})(PS["Control.Monad.Except.Trans"] = PS["Control.Monad.Except.Trans"] || {});
2551+(function(exports) {
2552+ // Generated by purs version 0.11.7
2553+ "use strict";
2554+ var Control_Alt = PS["Control.Alt"];
2555+ var Control_Applicative = PS["Control.Applicative"];
2556+ var Control_Apply = PS["Control.Apply"];
2557+ var Control_Bind = PS["Control.Bind"];
2558+ var Control_Comonad = PS["Control.Comonad"];
2559+ var Control_Extend = PS["Control.Extend"];
2560+ var Control_Lazy = PS["Control.Lazy"];
2561+ var Control_Monad = PS["Control.Monad"];
2562+ var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
2563+ var Data_Bounded = PS["Data.Bounded"];
2564+ var Data_CommutativeRing = PS["Data.CommutativeRing"];
2565+ var Data_Eq = PS["Data.Eq"];
2566+ var Data_EuclideanRing = PS["Data.EuclideanRing"];
2567+ var Data_Field = PS["Data.Field"];
2568+ var Data_Foldable = PS["Data.Foldable"];
2569+ var Data_Functor = PS["Data.Functor"];
2570+ var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
2571+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
2572+ var Data_Monoid = PS["Data.Monoid"];
2573+ var Data_Newtype = PS["Data.Newtype"];
2574+ var Data_Ord = PS["Data.Ord"];
2575+ var Data_Ring = PS["Data.Ring"];
2576+ var Data_Semigroup = PS["Data.Semigroup"];
2577+ var Data_Semiring = PS["Data.Semiring"];
2578+ var Data_Show = PS["Data.Show"];
2579+ var Data_Traversable = PS["Data.Traversable"];
2580+ var Prelude = PS["Prelude"];
2581+ var Identity = function (x) {
2582+ return x;
2583+ };
2584+ var newtypeIdentity = new Data_Newtype.Newtype(function (n) {
2585+ return n;
2586+ }, Identity);
2587+ var functorIdentity = new Data_Functor.Functor(function (f) {
2588+ return function (v) {
2589+ return f(v);
2590+ };
2591+ });
2592+ var applyIdentity = new Control_Apply.Apply(function () {
2593+ return functorIdentity;
2594+ }, function (v) {
2595+ return function (v1) {
2596+ return v(v1);
2597+ };
2598+ });
2599+ var bindIdentity = new Control_Bind.Bind(function () {
2600+ return applyIdentity;
2601+ }, function (v) {
2602+ return function (f) {
2603+ return f(v);
2604+ };
2605+ });
2606+ var applicativeIdentity = new Control_Applicative.Applicative(function () {
2607+ return applyIdentity;
2608+ }, Identity);
2609+ var monadIdentity = new Control_Monad.Monad(function () {
2610+ return applicativeIdentity;
2611+ }, function () {
2612+ return bindIdentity;
2613+ });
2614+ exports["Identity"] = Identity;
2615+ exports["newtypeIdentity"] = newtypeIdentity;
2616+ exports["functorIdentity"] = functorIdentity;
2617+ exports["applyIdentity"] = applyIdentity;
2618+ exports["applicativeIdentity"] = applicativeIdentity;
2619+ exports["bindIdentity"] = bindIdentity;
2620+ exports["monadIdentity"] = monadIdentity;
2621+})(PS["Data.Identity"] = PS["Data.Identity"] || {});
2622+(function(exports) {
2623+ // Generated by purs version 0.11.7
2624+ "use strict";
2625+ var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
2626+ var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
2627+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
2628+ var Data_Either = PS["Data.Either"];
2629+ var Data_Identity = PS["Data.Identity"];
2630+ var Data_Newtype = PS["Data.Newtype"];
2631+ var Prelude = PS["Prelude"];
2632+ var runExcept = function ($0) {
2633+ return Data_Newtype.unwrap(Data_Identity.newtypeIdentity)(Control_Monad_Except_Trans.runExceptT($0));
2634+ };
2635+ exports["runExcept"] = runExcept;
2636+})(PS["Control.Monad.Except"] = PS["Control.Monad.Except"] || {});
2637+(function(exports) {
2638+ "use strict";
2639+
2640+ function id(x) {
2641+ return x;
2642+ }
2643+ exports.fromString = id;
2644+ exports.fromObject = id;
2645+
2646+ exports.stringify = function (j) {
2647+ return JSON.stringify(j);
2648+ };
2649+
2650+ var objToString = Object.prototype.toString;
2651+
2652+ function isArray(a) {
2653+ return objToString.call(a) === "[object Array]";
2654+ }
2655+
2656+ exports._foldJson = function (isNull, isBool, isNum, isStr, isArr, isObj, j) {
2657+ if (j == null) return isNull(null);
2658+ else if (typeof j === "boolean") return isBool(j);
2659+ else if (typeof j === "number") return isNum(j);
2660+ else if (typeof j === "string") return isStr(j);
2661+ else if (objToString.call(j) === "[object Array]")
2662+ return isArr(j);
2663+ else return isObj(j);
2664+ };
2665+})(PS["Data.Argonaut.Core"] = PS["Data.Argonaut.Core"] || {});
2666+(function(exports) {
2667+ "use strict";
2668+
2669+ exports._copyEff = function (m) {
2670+ return function () {
2671+ var r = {};
2672+ for (var k in m) {
2673+ if (hasOwnProperty.call(m, k)) {
2674+ r[k] = m[k];
2675+ }
2676+ }
2677+ return r;
2678+ };
2679+ };
2680+
2681+ exports.empty = {};
2682+
2683+ exports.runST = function (f) {
2684+ return f;
2685+ };
2686+
2687+ exports._fmapStrMap = function (m0, f) {
2688+ var m = {};
2689+ for (var k in m0) {
2690+ if (hasOwnProperty.call(m0, k)) {
2691+ m[k] = f(m0[k]);
2692+ }
2693+ }
2694+ return m;
2695+ };
2696+
2697+ exports._mapWithKey = function (m0, f) {
2698+ var m = {};
2699+ for (var k in m0) {
2700+ if (hasOwnProperty.call(m0, k)) {
2701+ m[k] = f(k)(m0[k]);
2702+ }
2703+ }
2704+ return m;
2705+ };
2706+
2707+ exports._foldM = function (bind) {
2708+ return function (f) {
2709+ return function (mz) {
2710+ return function (m) {
2711+ var acc = mz;
2712+ function g(k) {
2713+ return function (z) {
2714+ return f(z)(k)(m[k]);
2715+ };
2716+ }
2717+ for (var k in m) {
2718+ if (hasOwnProperty.call(m, k)) {
2719+ acc = bind(acc)(g(k));
2720+ }
2721+ }
2722+ return acc;
2723+ };
2724+ };
2725+ };
2726+ };
2727+
2728+ exports._lookup = function (no, yes, k, m) {
2729+ return k in m ? yes(m[k]) : no;
2730+ };
2731+
2732+ function toArrayWithKey(f) {
2733+ return function (m) {
2734+ var r = [];
2735+ for (var k in m) {
2736+ if (hasOwnProperty.call(m, k)) {
2737+ r.push(f(k)(m[k]));
2738+ }
2739+ }
2740+ return r;
2741+ };
2742+ }
2743+
2744+ exports.toArrayWithKey = toArrayWithKey;
2745+})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
2746+(function(exports) {
2747+ "use strict";
2748+
2749+ exports.fromFoldableImpl = (function () {
2750+ function Cons(head, tail) {
2751+ this.head = head;
2752+ this.tail = tail;
2753+ }
2754+ var emptyList = {};
2755+
2756+ function curryCons(head) {
2757+ return function (tail) {
2758+ return new Cons(head, tail);
2759+ };
2760+ }
2761+
2762+ function listToArray(list) {
2763+ var result = [];
2764+ var count = 0;
2765+ var xs = list;
2766+ while (xs !== emptyList) {
2767+ result[count++] = xs.head;
2768+ xs = xs.tail;
2769+ }
2770+ return result;
2771+ }
2772+
2773+ return function (foldr) {
2774+ return function (xs) {
2775+ return listToArray(foldr(curryCons)(emptyList)(xs));
2776+ };
2777+ };
2778+ })();
2779+
2780+ exports.snoc = function (l) {
2781+ return function (e) {
2782+ var l1 = l.slice();
2783+ l1.push(e);
2784+ return l1;
2785+ };
2786+ };
2787+
2788+ //------------------------------------------------------------------------------
2789+ // Subarrays -------------------------------------------------------------------
2790+ //------------------------------------------------------------------------------
2791+
2792+ exports.slice = function (s) {
2793+ return function (e) {
2794+ return function (l) {
2795+ return l.slice(s, e);
2796+ };
2797+ };
2798+ };
2799+})(PS["Data.Array"] = PS["Data.Array"] || {});
2800+(function(exports) {
2801+ // Generated by purs version 0.11.7
2802+ "use strict";
2803+ var $foreign = PS["Data.FunctorWithIndex"];
2804+ var Data_Function = PS["Data.Function"];
2805+ var Data_Functor = PS["Data.Functor"];
2806+ var Data_Maybe = PS["Data.Maybe"];
2807+ var Data_Maybe_First = PS["Data.Maybe.First"];
2808+ var Data_Maybe_Last = PS["Data.Maybe.Last"];
2809+ var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
2810+ var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
2811+ var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
2812+ var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
2813+ var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
2814+ var Data_Unit = PS["Data.Unit"];
2815+ var Prelude = PS["Prelude"];
2816+ var FunctorWithIndex = function (Functor0, mapWithIndex) {
2817+ this.Functor0 = Functor0;
2818+ this.mapWithIndex = mapWithIndex;
2819+ };
2820+ var mapWithIndex = function (dict) {
2821+ return dict.mapWithIndex;
2822+ };
2823+ exports["FunctorWithIndex"] = FunctorWithIndex;
2824+ exports["mapWithIndex"] = mapWithIndex;
2825+})(PS["Data.FunctorWithIndex"] = PS["Data.FunctorWithIndex"] || {});
2826+(function(exports) {
2827+ // Generated by purs version 0.11.7
2828+ "use strict";
2829+ var Control_Applicative = PS["Control.Applicative"];
2830+ var Control_Apply = PS["Control.Apply"];
2831+ var Control_Bind = PS["Control.Bind"];
2832+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
2833+ var Data_Foldable = PS["Data.Foldable"];
2834+ var Data_Function = PS["Data.Function"];
2835+ var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
2836+ var Data_Maybe = PS["Data.Maybe"];
2837+ var Data_Maybe_First = PS["Data.Maybe.First"];
2838+ var Data_Maybe_Last = PS["Data.Maybe.Last"];
2839+ var Data_Monoid = PS["Data.Monoid"];
2840+ var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
2841+ var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
2842+ var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
2843+ var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
2844+ var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
2845+ var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
2846+ var Data_Newtype = PS["Data.Newtype"];
2847+ var Data_Semigroup = PS["Data.Semigroup"];
2848+ var Data_Unit = PS["Data.Unit"];
2849+ var Prelude = PS["Prelude"];
2850+ var FoldableWithIndex = function (Foldable0, foldMapWithIndex, foldlWithIndex, foldrWithIndex) {
2851+ this.Foldable0 = Foldable0;
2852+ this.foldMapWithIndex = foldMapWithIndex;
2853+ this.foldlWithIndex = foldlWithIndex;
2854+ this.foldrWithIndex = foldrWithIndex;
2855+ };
2856+ var foldrWithIndex = function (dict) {
2857+ return dict.foldrWithIndex;
2858+ };
2859+ var foldlWithIndex = function (dict) {
2860+ return dict.foldlWithIndex;
2861+ };
2862+ var foldMapWithIndex = function (dict) {
2863+ return dict.foldMapWithIndex;
2864+ };
2865+ exports["FoldableWithIndex"] = FoldableWithIndex;
2866+ exports["foldrWithIndex"] = foldrWithIndex;
2867+ exports["foldlWithIndex"] = foldlWithIndex;
2868+ exports["foldMapWithIndex"] = foldMapWithIndex;
2869+})(PS["Data.FoldableWithIndex"] = PS["Data.FoldableWithIndex"] || {});
2870+(function(exports) {
2871+ // Generated by purs version 0.11.7
2872+ "use strict";
2873+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
2874+ var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
2875+ var Data_Function = PS["Data.Function"];
2876+ var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
2877+ var Data_Maybe = PS["Data.Maybe"];
2878+ var Data_Maybe_First = PS["Data.Maybe.First"];
2879+ var Data_Maybe_Last = PS["Data.Maybe.Last"];
2880+ var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
2881+ var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
2882+ var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
2883+ var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
2884+ var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
2885+ var Data_Traversable = PS["Data.Traversable"];
2886+ var Data_Traversable_Accum = PS["Data.Traversable.Accum"];
2887+ var Data_Traversable_Accum_Internal = PS["Data.Traversable.Accum.Internal"];
2888+ var Data_Unit = PS["Data.Unit"];
2889+ var Prelude = PS["Prelude"];
2890+ var TraversableWithIndex = function (FoldableWithIndex1, FunctorWithIndex0, Traversable2, traverseWithIndex) {
2891+ this.FoldableWithIndex1 = FoldableWithIndex1;
2892+ this.FunctorWithIndex0 = FunctorWithIndex0;
2893+ this.Traversable2 = Traversable2;
2894+ this.traverseWithIndex = traverseWithIndex;
2895+ };
2896+ var traverseWithIndex = function (dict) {
2897+ return dict.traverseWithIndex;
2898+ };
2899+ exports["TraversableWithIndex"] = TraversableWithIndex;
2900+ exports["traverseWithIndex"] = traverseWithIndex;
2901+})(PS["Data.TraversableWithIndex"] = PS["Data.TraversableWithIndex"] || {});
2902+(function(exports) {
2903+ // Generated by purs version 0.11.7
2904+ "use strict";
2905+ var Control_Alt = PS["Control.Alt"];
2906+ var Control_Alternative = PS["Control.Alternative"];
2907+ var Control_Applicative = PS["Control.Applicative"];
2908+ var Control_Apply = PS["Control.Apply"];
2909+ var Control_Category = PS["Control.Category"];
2910+ var Control_Plus = PS["Control.Plus"];
2911+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
2912+ var Data_Eq = PS["Data.Eq"];
2913+ var Data_Foldable = PS["Data.Foldable"];
2914+ var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
2915+ var Data_Functor = PS["Data.Functor"];
2916+ var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
2917+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
2918+ var Data_Maybe = PS["Data.Maybe"];
2919+ var Data_Ord = PS["Data.Ord"];
2920+ var Data_Ordering = PS["Data.Ordering"];
2921+ var Data_Semigroup = PS["Data.Semigroup"];
2922+ var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
2923+ var Data_Show = PS["Data.Show"];
2924+ var Data_Traversable = PS["Data.Traversable"];
2925+ var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
2926+ var Prelude = PS["Prelude"];
2927+ var NonEmpty = (function () {
2928+ function NonEmpty(value0, value1) {
2929+ this.value0 = value0;
2930+ this.value1 = value1;
2931+ };
2932+ NonEmpty.create = function (value0) {
2933+ return function (value1) {
2934+ return new NonEmpty(value0, value1);
2935+ };
2936+ };
2937+ return NonEmpty;
2938+ })();
2939+ var singleton = function (dictPlus) {
2940+ return function (a) {
2941+ return new NonEmpty(a, Control_Plus.empty(dictPlus));
2942+ };
2943+ };
2944+ var showNonEmpty = function (dictShow) {
2945+ return function (dictShow1) {
2946+ return new Data_Show.Show(function (v) {
2947+ return "(NonEmpty " + (Data_Show.show(dictShow)(v.value0) + (" " + (Data_Show.show(dictShow1)(v.value1) + ")")));
2948+ });
2949+ };
2950+ };
2951+ exports["NonEmpty"] = NonEmpty;
2952+ exports["singleton"] = singleton;
2953+ exports["showNonEmpty"] = showNonEmpty;
2954+})(PS["Data.NonEmpty"] = PS["Data.NonEmpty"] || {});
2955+(function(exports) {
2956+ // Generated by purs version 0.11.7
2957+ "use strict";
2958+ var $foreign = PS["Data.Array"];
2959+ var Control_Alt = PS["Control.Alt"];
2960+ var Control_Alternative = PS["Control.Alternative"];
2961+ var Control_Applicative = PS["Control.Applicative"];
2962+ var Control_Apply = PS["Control.Apply"];
2963+ var Control_Bind = PS["Control.Bind"];
2964+ var Control_Category = PS["Control.Category"];
2965+ var Control_Lazy = PS["Control.Lazy"];
2966+ var Control_Monad_Eff = PS["Control.Monad.Eff"];
2967+ var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
2968+ var Control_Monad_ST = PS["Control.Monad.ST"];
2969+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
2970+ var Data_Array_ST = PS["Data.Array.ST"];
2971+ var Data_Array_ST_Iterator = PS["Data.Array.ST.Iterator"];
2972+ var Data_Boolean = PS["Data.Boolean"];
2973+ var Data_Eq = PS["Data.Eq"];
2974+ var Data_Foldable = PS["Data.Foldable"];
2975+ var Data_Function = PS["Data.Function"];
2976+ var Data_Functor = PS["Data.Functor"];
2977+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
2978+ var Data_Maybe = PS["Data.Maybe"];
2979+ var Data_NonEmpty = PS["Data.NonEmpty"];
2980+ var Data_Ord = PS["Data.Ord"];
2981+ var Data_Ordering = PS["Data.Ordering"];
2982+ var Data_Ring = PS["Data.Ring"];
2983+ var Data_Semigroup = PS["Data.Semigroup"];
2984+ var Data_Semiring = PS["Data.Semiring"];
2985+ var Data_Traversable = PS["Data.Traversable"];
2986+ var Data_Tuple = PS["Data.Tuple"];
2987+ var Data_Unfoldable = PS["Data.Unfoldable"];
2988+ var Partial_Unsafe = PS["Partial.Unsafe"];
2989+ var Prelude = PS["Prelude"];
2990+ var fromFoldable = function (dictFoldable) {
2991+ return $foreign.fromFoldableImpl(Data_Foldable.foldr(dictFoldable));
2992+ };
2993+ exports["fromFoldable"] = fromFoldable;
2994+ exports["snoc"] = $foreign.snoc;
2995+})(PS["Data.Array"] = PS["Data.Array"] || {});
2996+(function(exports) {
2997+ "use strict";
2998+
2999+ exports["new"] = function () {
3000+ return {};
3001+ };
3002+
3003+ exports.poke = function (m) {
3004+ return function (k) {
3005+ return function (v) {
3006+ return function () {
3007+ m[k] = v;
3008+ return m;
3009+ };
3010+ };
3011+ };
3012+ };
3013+})(PS["Data.StrMap.ST"] = PS["Data.StrMap.ST"] || {});
3014+(function(exports) {
3015+ // Generated by purs version 0.11.7
3016+ "use strict";
3017+ var $foreign = PS["Data.StrMap.ST"];
3018+ var Control_Monad_Eff = PS["Control.Monad.Eff"];
3019+ var Control_Monad_ST = PS["Control.Monad.ST"];
3020+ var Data_Maybe = PS["Data.Maybe"];
3021+ exports["new"] = $foreign["new"];
3022+ exports["poke"] = $foreign.poke;
3023+})(PS["Data.StrMap.ST"] = PS["Data.StrMap.ST"] || {});
3024+(function(exports) {
3025+ // Generated by purs version 0.11.7
3026+ "use strict";
3027+ var $foreign = PS["Data.StrMap"];
3028+ var Control_Applicative = PS["Control.Applicative"];
3029+ var Control_Apply = PS["Control.Apply"];
3030+ var Control_Bind = PS["Control.Bind"];
3031+ var Control_Category = PS["Control.Category"];
3032+ var Control_Monad_Eff = PS["Control.Monad.Eff"];
3033+ var Control_Monad_ST = PS["Control.Monad.ST"];
3034+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
3035+ var Data_Array = PS["Data.Array"];
3036+ var Data_Eq = PS["Data.Eq"];
3037+ var Data_Foldable = PS["Data.Foldable"];
3038+ var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
3039+ var Data_Function = PS["Data.Function"];
3040+ var Data_Function_Uncurried = PS["Data.Function.Uncurried"];
3041+ var Data_Functor = PS["Data.Functor"];
3042+ var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
3043+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
3044+ var Data_Maybe = PS["Data.Maybe"];
3045+ var Data_Monoid = PS["Data.Monoid"];
3046+ var Data_Ord = PS["Data.Ord"];
3047+ var Data_Semigroup = PS["Data.Semigroup"];
3048+ var Data_Show = PS["Data.Show"];
3049+ var Data_StrMap_ST = PS["Data.StrMap.ST"];
3050+ var Data_Traversable = PS["Data.Traversable"];
3051+ var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
3052+ var Data_Tuple = PS["Data.Tuple"];
3053+ var Data_Unfoldable = PS["Data.Unfoldable"];
3054+ var Prelude = PS["Prelude"];
3055+ var values = $foreign.toArrayWithKey(function (v) {
3056+ return function (v1) {
3057+ return v1;
3058+ };
3059+ });
3060+ var thawST = $foreign._copyEff;
3061+ var pureST = function (f) {
3062+ return Control_Monad_Eff.runPure($foreign.runST(f));
3063+ };
3064+ var mutate = function (f) {
3065+ return function (m) {
3066+ return pureST(function __do() {
3067+ var v = thawST(m)();
3068+ var v1 = f(v)();
3069+ return v;
3070+ });
3071+ };
3072+ };
3073+ var mapWithKey = function (f) {
3074+ return function (m) {
3075+ return $foreign._mapWithKey(m, f);
3076+ };
3077+ };
3078+ var lookup = Data_Function_Uncurried.runFn4($foreign._lookup)(Data_Maybe.Nothing.value)(Data_Maybe.Just.create);
3079+ var insert = function (k) {
3080+ return function (v) {
3081+ return mutate(function (s) {
3082+ return Data_Functor["void"](Control_Monad_Eff.functorEff)(Data_StrMap_ST.poke(s)(k)(v));
3083+ });
3084+ };
3085+ };
3086+ var functorStrMap = new Data_Functor.Functor(function (f) {
3087+ return function (m) {
3088+ return $foreign._fmapStrMap(m, f);
3089+ };
3090+ });
3091+ var functorWithIndexStrMap = new Data_FunctorWithIndex.FunctorWithIndex(function () {
3092+ return functorStrMap;
3093+ }, mapWithKey);
3094+ var fromFoldable = function (dictFoldable) {
3095+ return function (l) {
3096+ return pureST(function __do() {
3097+ var v = Data_StrMap_ST["new"]();
3098+ Control_Monad_Eff.foreachE(Data_Array.fromFoldable(dictFoldable)(l))(function (v1) {
3099+ return Data_Functor["void"](Control_Monad_Eff.functorEff)(Data_StrMap_ST.poke(v)(v1.value0)(v1.value1));
3100+ })();
3101+ return v;
3102+ });
3103+ };
3104+ };
3105+ var fold = $foreign._foldM(Data_Function.applyFlipped);
3106+ var foldMap = function (dictMonoid) {
3107+ return function (f) {
3108+ return fold(function (acc) {
3109+ return function (k) {
3110+ return function (v) {
3111+ return Data_Semigroup.append(dictMonoid.Semigroup0())(acc)(f(k)(v));
3112+ };
3113+ };
3114+ })(Data_Monoid.mempty(dictMonoid));
3115+ };
3116+ };
3117+ var foldableStrMap = new Data_Foldable.Foldable(function (dictMonoid) {
3118+ return function (f) {
3119+ return foldMap(dictMonoid)(Data_Function["const"](f));
3120+ };
3121+ }, function (f) {
3122+ return fold(function (z) {
3123+ return function (v) {
3124+ return f(z);
3125+ };
3126+ });
3127+ }, function (f) {
3128+ return function (z) {
3129+ return function (m) {
3130+ return Data_Foldable.foldr(Data_Foldable.foldableArray)(f)(z)(values(m));
3131+ };
3132+ };
3133+ });
3134+ var foldableWithIndexStrMap = new Data_FoldableWithIndex.FoldableWithIndex(function () {
3135+ return foldableStrMap;
3136+ }, function (dictMonoid) {
3137+ return foldMap(dictMonoid);
3138+ }, function (f) {
3139+ return fold(Data_Function.flip(f));
3140+ }, function (f) {
3141+ return function (z) {
3142+ return function (m) {
3143+ return Data_Foldable.foldr(Data_Foldable.foldableArray)(Data_Tuple.uncurry(f))(z)($foreign.toArrayWithKey(Data_Tuple.Tuple.create)(m));
3144+ };
3145+ };
3146+ });
3147+ var traversableWithIndexStrMap = new Data_TraversableWithIndex.TraversableWithIndex(function () {
3148+ return foldableWithIndexStrMap;
3149+ }, function () {
3150+ return functorWithIndexStrMap;
3151+ }, function () {
3152+ return traversableStrMap;
3153+ }, function (dictApplicative) {
3154+ return function (f) {
3155+ return function (ms) {
3156+ return fold(function (acc) {
3157+ return function (k) {
3158+ return function (v) {
3159+ return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Function.flip(insert(k)))(acc))(f(k)(v));
3160+ };
3161+ };
3162+ })(Control_Applicative.pure(dictApplicative)($foreign.empty))(ms);
3163+ };
3164+ };
3165+ });
3166+ var traversableStrMap = new Data_Traversable.Traversable(function () {
3167+ return foldableStrMap;
3168+ }, function () {
3169+ return functorStrMap;
3170+ }, function (dictApplicative) {
3171+ return Data_Traversable.traverse(traversableStrMap)(dictApplicative)(Control_Category.id(Control_Category.categoryFn));
3172+ }, function (dictApplicative) {
3173+ return function ($48) {
3174+ return Data_TraversableWithIndex.traverseWithIndex(traversableWithIndexStrMap)(dictApplicative)(Data_Function["const"]($48));
3175+ };
3176+ });
3177+ exports["insert"] = insert;
3178+ exports["lookup"] = lookup;
3179+ exports["fromFoldable"] = fromFoldable;
3180+ exports["mapWithKey"] = mapWithKey;
3181+ exports["values"] = values;
3182+ exports["fold"] = fold;
3183+ exports["foldMap"] = foldMap;
3184+ exports["thawST"] = thawST;
3185+ exports["pureST"] = pureST;
3186+ exports["functorStrMap"] = functorStrMap;
3187+ exports["functorWithIndexStrMap"] = functorWithIndexStrMap;
3188+ exports["foldableStrMap"] = foldableStrMap;
3189+ exports["foldableWithIndexStrMap"] = foldableWithIndexStrMap;
3190+ exports["traversableStrMap"] = traversableStrMap;
3191+ exports["traversableWithIndexStrMap"] = traversableWithIndexStrMap;
3192+})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
3193+(function(exports) {
3194+ // Generated by purs version 0.11.7
3195+ "use strict";
3196+ var $foreign = PS["Data.Argonaut.Core"];
3197+ var Data_Eq = PS["Data.Eq"];
3198+ var Data_Function = PS["Data.Function"];
3199+ var Data_Function_Uncurried = PS["Data.Function.Uncurried"];
3200+ var Data_Maybe = PS["Data.Maybe"];
3201+ var Data_Ord = PS["Data.Ord"];
3202+ var Data_Ordering = PS["Data.Ordering"];
3203+ var Data_Show = PS["Data.Show"];
3204+ var Data_StrMap = PS["Data.StrMap"];
3205+ var Data_Tuple = PS["Data.Tuple"];
3206+ var Prelude = PS["Prelude"];
3207+ var Unsafe_Coerce = PS["Unsafe.Coerce"];
3208+ var verbJsonType = function (def) {
3209+ return function (f) {
3210+ return function (fold) {
3211+ return fold(def)(f);
3212+ };
3213+ };
3214+ };
3215+ var toJsonType = verbJsonType(Data_Maybe.Nothing.value)(Data_Maybe.Just.create);
3216+ var showJson = new Data_Show.Show($foreign.stringify);
3217+ var foldJsonString = function (d) {
3218+ return function (f) {
3219+ return function (j) {
3220+ return $foreign._foldJson(Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), f, Data_Function["const"](d), Data_Function["const"](d), j);
3221+ };
3222+ };
3223+ };
3224+ var foldJsonObject = function (d) {
3225+ return function (f) {
3226+ return function (j) {
3227+ return $foreign._foldJson(Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), f, j);
3228+ };
3229+ };
3230+ };
3231+ var toObject = toJsonType(foldJsonObject);
3232+ exports["foldJsonString"] = foldJsonString;
3233+ exports["foldJsonObject"] = foldJsonObject;
3234+ exports["toObject"] = toObject;
3235+ exports["showJson"] = showJson;
3236+ exports["fromString"] = $foreign.fromString;
3237+ exports["fromObject"] = $foreign.fromObject;
3238+})(PS["Data.Argonaut.Core"] = PS["Data.Argonaut.Core"] || {});
3239+(function(exports) {
3240+ // Generated by purs version 0.11.7
3241+ "use strict";
3242+ var Control_Alt = PS["Control.Alt"];
3243+ var Control_Alternative = PS["Control.Alternative"];
3244+ var Control_Applicative = PS["Control.Applicative"];
3245+ var Control_Apply = PS["Control.Apply"];
3246+ var Control_Bind = PS["Control.Bind"];
3247+ var Control_Category = PS["Control.Category"];
3248+ var Control_Comonad = PS["Control.Comonad"];
3249+ var Control_Extend = PS["Control.Extend"];
3250+ var Control_Monad = PS["Control.Monad"];
3251+ var Control_MonadPlus = PS["Control.MonadPlus"];
3252+ var Control_MonadZero = PS["Control.MonadZero"];
3253+ var Control_Plus = PS["Control.Plus"];
3254+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
3255+ var Data_Eq = PS["Data.Eq"];
3256+ var Data_Foldable = PS["Data.Foldable"];
3257+ var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
3258+ var Data_Function = PS["Data.Function"];
3259+ var Data_Functor = PS["Data.Functor"];
3260+ var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
3261+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
3262+ var Data_Maybe = PS["Data.Maybe"];
3263+ var Data_Monoid = PS["Data.Monoid"];
3264+ var Data_Newtype = PS["Data.Newtype"];
3265+ var Data_NonEmpty = PS["Data.NonEmpty"];
3266+ var Data_Ord = PS["Data.Ord"];
3267+ var Data_Ordering = PS["Data.Ordering"];
3268+ var Data_Ring = PS["Data.Ring"];
3269+ var Data_Semigroup = PS["Data.Semigroup"];
3270+ var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
3271+ var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
3272+ var Data_Semiring = PS["Data.Semiring"];
3273+ var Data_Show = PS["Data.Show"];
3274+ var Data_Traversable = PS["Data.Traversable"];
3275+ var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
3276+ var Data_Tuple = PS["Data.Tuple"];
3277+ var Data_Unfoldable = PS["Data.Unfoldable"];
3278+ var Prelude = PS["Prelude"];
3279+ var Nil = (function () {
3280+ function Nil() {
3281+
3282+ };
3283+ Nil.value = new Nil();
3284+ return Nil;
3285+ })();
3286+ var Cons = (function () {
3287+ function Cons(value0, value1) {
3288+ this.value0 = value0;
3289+ this.value1 = value1;
3290+ };
3291+ Cons.create = function (value0) {
3292+ return function (value1) {
3293+ return new Cons(value0, value1);
3294+ };
3295+ };
3296+ return Cons;
3297+ })();
3298+ var NonEmptyList = function (x) {
3299+ return x;
3300+ };
3301+ var foldableList = new Data_Foldable.Foldable(function (dictMonoid) {
3302+ return function (f) {
3303+ return Data_Foldable.foldl(foldableList)(function (acc) {
3304+ return function ($158) {
3305+ return Data_Semigroup.append(dictMonoid.Semigroup0())(acc)(f($158));
3306+ };
3307+ })(Data_Monoid.mempty(dictMonoid));
3308+ };
3309+ }, function (f) {
3310+ var go = function ($copy_b) {
3311+ return function ($copy_v) {
3312+ var $tco_var_b = $copy_b;
3313+ var $tco_done = false;
3314+ var $tco_result;
3315+ function $tco_loop(b, v) {
3316+ if (v instanceof Nil) {
3317+ $tco_done = true;
3318+ return b;
3319+ };
3320+ if (v instanceof Cons) {
3321+ $tco_var_b = f(b)(v.value0);
3322+ $copy_v = v.value1;
3323+ return;
3324+ };
3325+ throw new Error("Failed pattern match at Data.List.Types line 81, column 12 - line 83, column 30: " + [ v.constructor.name ]);
3326+ };
3327+ while (!$tco_done) {
3328+ $tco_result = $tco_loop($tco_var_b, $copy_v);
3329+ };
3330+ return $tco_result;
3331+ };
3332+ };
3333+ return go;
3334+ }, function (f) {
3335+ return function (b) {
3336+ var rev = Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value);
3337+ return function ($159) {
3338+ return Data_Foldable.foldl(foldableList)(Data_Function.flip(f))(b)(rev($159));
3339+ };
3340+ };
3341+ });
3342+ var functorList = new Data_Functor.Functor(function (f) {
3343+ return Data_Foldable.foldr(foldableList)(function (x) {
3344+ return function (acc) {
3345+ return new Cons(f(x), acc);
3346+ };
3347+ })(Nil.value);
3348+ });
3349+ var semigroupList = new Data_Semigroup.Semigroup(function (xs) {
3350+ return function (ys) {
3351+ return Data_Foldable.foldr(foldableList)(Cons.create)(ys)(xs);
3352+ };
3353+ });
3354+ var showList = function (dictShow) {
3355+ return new Data_Show.Show(function (v) {
3356+ if (v instanceof Nil) {
3357+ return "Nil";
3358+ };
3359+ return "(" + (Data_Foldable.intercalate(foldableList)(Data_Monoid.monoidString)(" : ")(Data_Functor.map(functorList)(Data_Show.show(dictShow))(v)) + " : Nil)");
3360+ });
3361+ };
3362+ var showNonEmptyList = function (dictShow) {
3363+ return new Data_Show.Show(function (v) {
3364+ return "(NonEmptyList " + (Data_Show.show(Data_NonEmpty.showNonEmpty(dictShow)(showList(dictShow)))(v) + ")");
3365+ });
3366+ };
3367+ var altList = new Control_Alt.Alt(function () {
3368+ return functorList;
3369+ }, Data_Semigroup.append(semigroupList));
3370+ var plusList = new Control_Plus.Plus(function () {
3371+ return altList;
3372+ }, Nil.value);
3373+ exports["Nil"] = Nil;
3374+ exports["Cons"] = Cons;
3375+ exports["NonEmptyList"] = NonEmptyList;
3376+ exports["showList"] = showList;
3377+ exports["semigroupList"] = semigroupList;
3378+ exports["functorList"] = functorList;
3379+ exports["foldableList"] = foldableList;
3380+ exports["altList"] = altList;
3381+ exports["plusList"] = plusList;
3382+ exports["showNonEmptyList"] = showNonEmptyList;
3383+})(PS["Data.List.Types"] = PS["Data.List.Types"] || {});
3384+(function(exports) {
3385+ // Generated by purs version 0.11.7
3386+ "use strict";
3387+ var Control_Applicative = PS["Control.Applicative"];
3388+ var Control_Apply = PS["Control.Apply"];
3389+ var Control_Bind = PS["Control.Bind"];
3390+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
3391+ var Data_Argonaut_Core = PS["Data.Argonaut.Core"];
3392+ var Data_Bifunctor = PS["Data.Bifunctor"];
3393+ var Data_Boolean = PS["Data.Boolean"];
3394+ var Data_Either = PS["Data.Either"];
3395+ var Data_Foldable = PS["Data.Foldable"];
3396+ var Data_Function = PS["Data.Function"];
3397+ var Data_Functor = PS["Data.Functor"];
3398+ var Data_Int = PS["Data.Int"];
3399+ var Data_List = PS["Data.List"];
3400+ var Data_List_Types = PS["Data.List.Types"];
3401+ var Data_Map = PS["Data.Map"];
3402+ var Data_Maybe = PS["Data.Maybe"];
3403+ var Data_Semigroup = PS["Data.Semigroup"];
3404+ var Data_Show = PS["Data.Show"];
3405+ var Data_StrMap = PS["Data.StrMap"];
3406+ var Data_String = PS["Data.String"];
3407+ var Data_Traversable = PS["Data.Traversable"];
3408+ var Data_Tuple = PS["Data.Tuple"];
3409+ var Data_Unit = PS["Data.Unit"];
3410+ var Prelude = PS["Prelude"];
3411+ var DecodeJson = function (decodeJson) {
3412+ this.decodeJson = decodeJson;
3413+ };
3414+ var decodeJsonString = new DecodeJson(Data_Argonaut_Core.foldJsonString(new Data_Either.Left("Value is not a String"))(Data_Either.Right.create));
3415+ var decodeJsonJson = new DecodeJson(Data_Either.Right.create);
3416+ var decodeJson = function (dict) {
3417+ return dict.decodeJson;
3418+ };
3419+ var decodeJObject = function ($33) {
3420+ return Data_Maybe.maybe(new Data_Either.Left("Value is not an Object"))(Data_Either.Right.create)(Data_Argonaut_Core.toObject($33));
3421+ };
3422+ var decodeStrMap = function (dictDecodeJson) {
3423+ return new DecodeJson(function ($34) {
3424+ return Data_Bifunctor.lmap(Data_Either.bifunctorEither)(function (v) {
3425+ return "Couldn't decode StrMap: " + v;
3426+ })(Control_Bind.composeKleisliFlipped(Data_Either.bindEither)(Data_Traversable.traverse(Data_StrMap.traversableStrMap)(Data_Either.applicativeEither)(decodeJson(dictDecodeJson)))(decodeJObject)($34));
3427+ });
3428+ };
3429+ exports["DecodeJson"] = DecodeJson;
3430+ exports["decodeJson"] = decodeJson;
3431+ exports["decodeJsonString"] = decodeJsonString;
3432+ exports["decodeJsonJson"] = decodeJsonJson;
3433+ exports["decodeStrMap"] = decodeStrMap;
3434+})(PS["Data.Argonaut.Decode.Class"] = PS["Data.Argonaut.Decode.Class"] || {});
3435+(function(exports) {
3436+ // Generated by purs version 0.11.7
3437+ "use strict";
3438+ var Control_Applicative = PS["Control.Applicative"];
3439+ var Data_Argonaut_Core = PS["Data.Argonaut.Core"];
3440+ var Data_Argonaut_Decode_Class = PS["Data.Argonaut.Decode.Class"];
3441+ var Data_Either = PS["Data.Either"];
3442+ var Data_Function = PS["Data.Function"];
3443+ var Data_Functor = PS["Data.Functor"];
3444+ var Data_Maybe = PS["Data.Maybe"];
3445+ var Data_Semigroup = PS["Data.Semigroup"];
3446+ var Data_Show = PS["Data.Show"];
3447+ var Data_StrMap = PS["Data.StrMap"];
3448+ var Prelude = PS["Prelude"];
3449+ var getField = function (dictDecodeJson) {
3450+ return function (o) {
3451+ return function (s) {
3452+ return Data_Maybe.maybe(Data_Either.Left.create("Expected field " + Data_Show.show(Data_Show.showString)(s)))(Data_Argonaut_Decode_Class.decodeJson(dictDecodeJson))(Data_StrMap.lookup(s)(o));
3453+ };
3454+ };
3455+ };
3456+ exports["getField"] = getField;
3457+})(PS["Data.Argonaut.Decode.Combinators"] = PS["Data.Argonaut.Decode.Combinators"] || {});
3458+(function(exports) {
3459+ // Generated by purs version 0.11.7
3460+ "use strict";
3461+ var Control_Category = PS["Control.Category"];
3462+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
3463+ var Data_Argonaut_Core = PS["Data.Argonaut.Core"];
3464+ var Data_Either = PS["Data.Either"];
3465+ var Data_Function = PS["Data.Function"];
3466+ var Data_Functor = PS["Data.Functor"];
3467+ var Data_Int = PS["Data.Int"];
3468+ var Data_List = PS["Data.List"];
3469+ var Data_List_Types = PS["Data.List.Types"];
3470+ var Data_Map = PS["Data.Map"];
3471+ var Data_Maybe = PS["Data.Maybe"];
3472+ var Data_StrMap = PS["Data.StrMap"];
3473+ var Data_String = PS["Data.String"];
3474+ var Data_Tuple = PS["Data.Tuple"];
3475+ var Data_Unfoldable = PS["Data.Unfoldable"];
3476+ var Data_Void = PS["Data.Void"];
3477+ var Prelude = PS["Prelude"];
3478+ var EncodeJson = function (encodeJson) {
3479+ this.encodeJson = encodeJson;
3480+ };
3481+ var encodeJsonJString = new EncodeJson(Data_Argonaut_Core.fromString);
3482+ var encodeJson = function (dict) {
3483+ return dict.encodeJson;
3484+ };
3485+ var encodeStrMap = function (dictEncodeJson) {
3486+ return new EncodeJson(function ($23) {
3487+ return Data_Argonaut_Core.fromObject(Data_Functor.map(Data_StrMap.functorStrMap)(encodeJson(dictEncodeJson))($23));
3488+ });
3489+ };
3490+ exports["encodeJson"] = encodeJson;
3491+ exports["EncodeJson"] = EncodeJson;
3492+ exports["encodeJsonJString"] = encodeJsonJString;
3493+ exports["encodeStrMap"] = encodeStrMap;
3494+})(PS["Data.Argonaut.Encode.Class"] = PS["Data.Argonaut.Encode.Class"] || {});
3495+(function(exports) {
3496+ "use strict";
3497+
3498+ exports._jsonParser = function (fail, succ, s) {
3499+ try {
3500+ return succ(JSON.parse(s));
3501+ }
3502+ catch (e) {
3503+ return fail(e.message);
3504+ }
3505+ };
3506+})(PS["Data.Argonaut.Parser"] = PS["Data.Argonaut.Parser"] || {});
3507+(function(exports) {
3508+ // Generated by purs version 0.11.7
3509+ "use strict";
3510+ var $foreign = PS["Data.Argonaut.Parser"];
3511+ var Data_Argonaut_Core = PS["Data.Argonaut.Core"];
3512+ var Data_Either = PS["Data.Either"];
3513+ var Data_Function_Uncurried = PS["Data.Function.Uncurried"];
3514+ var jsonParser = function (j) {
3515+ return $foreign._jsonParser(Data_Either.Left.create, Data_Either.Right.create, j);
3516+ };
3517+ exports["jsonParser"] = jsonParser;
3518+})(PS["Data.Argonaut.Parser"] = PS["Data.Argonaut.Parser"] || {});
3519+(function(exports) {
3520+ "use strict";
3521+
3522+ exports.toForeign = function (value) {
3523+ return value;
3524+ };
3525+
3526+ exports.unsafeFromForeign = function (value) {
3527+ return value;
3528+ };
3529+
3530+ exports.tagOf = function (value) {
3531+ return Object.prototype.toString.call(value).slice(8, -1);
3532+ };
3533+})(PS["Data.Foreign"] = PS["Data.Foreign"] || {});
3534+(function(exports) {
3535+ // Generated by purs version 0.11.7
3536+ "use strict";
3537+ var Control_Bind = PS["Control.Bind"];
3538+ var Control_Category = PS["Control.Category"];
3539+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
3540+ var Data_Boolean = PS["Data.Boolean"];
3541+ var Data_Eq = PS["Data.Eq"];
3542+ var Data_Foldable = PS["Data.Foldable"];
3543+ var Data_Function = PS["Data.Function"];
3544+ var Data_Functor = PS["Data.Functor"];
3545+ var Data_List = PS["Data.List"];
3546+ var Data_List_Types = PS["Data.List.Types"];
3547+ var Data_Maybe = PS["Data.Maybe"];
3548+ var Data_NonEmpty = PS["Data.NonEmpty"];
3549+ var Data_Ord = PS["Data.Ord"];
3550+ var Data_Ring = PS["Data.Ring"];
3551+ var Data_Semigroup = PS["Data.Semigroup"];
3552+ var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
3553+ var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
3554+ var Data_Semiring = PS["Data.Semiring"];
3555+ var Data_Traversable = PS["Data.Traversable"];
3556+ var Data_Tuple = PS["Data.Tuple"];
3557+ var Data_Unfoldable = PS["Data.Unfoldable"];
3558+ var Partial_Unsafe = PS["Partial.Unsafe"];
3559+ var Prelude = PS["Prelude"];
3560+ var singleton = function ($160) {
3561+ return Data_List_Types.NonEmptyList(Data_NonEmpty.singleton(Data_List_Types.plusList)($160));
3562+ };
3563+ exports["singleton"] = singleton;
3564+})(PS["Data.List.NonEmpty"] = PS["Data.List.NonEmpty"] || {});
3565+(function(exports) {
3566+ // Generated by purs version 0.11.7
3567+ "use strict";
3568+ var $foreign = PS["Data.Foreign"];
3569+ var Control_Applicative = PS["Control.Applicative"];
3570+ var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
3571+ var Control_Monad_Except = PS["Control.Monad.Except"];
3572+ var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
3573+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
3574+ var Data_Boolean = PS["Data.Boolean"];
3575+ var Data_Either = PS["Data.Either"];
3576+ var Data_Eq = PS["Data.Eq"];
3577+ var Data_Function = PS["Data.Function"];
3578+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
3579+ var Data_Identity = PS["Data.Identity"];
3580+ var Data_Int = PS["Data.Int"];
3581+ var Data_List_NonEmpty = PS["Data.List.NonEmpty"];
3582+ var Data_Maybe = PS["Data.Maybe"];
3583+ var Data_Ord = PS["Data.Ord"];
3584+ var Data_Ordering = PS["Data.Ordering"];
3585+ var Data_Semigroup = PS["Data.Semigroup"];
3586+ var Data_Show = PS["Data.Show"];
3587+ var Data_String = PS["Data.String"];
3588+ var Prelude = PS["Prelude"];
3589+ var ForeignError = (function () {
3590+ function ForeignError(value0) {
3591+ this.value0 = value0;
3592+ };
3593+ ForeignError.create = function (value0) {
3594+ return new ForeignError(value0);
3595+ };
3596+ return ForeignError;
3597+ })();
3598+ var TypeMismatch = (function () {
3599+ function TypeMismatch(value0, value1) {
3600+ this.value0 = value0;
3601+ this.value1 = value1;
3602+ };
3603+ TypeMismatch.create = function (value0) {
3604+ return function (value1) {
3605+ return new TypeMismatch(value0, value1);
3606+ };
3607+ };
3608+ return TypeMismatch;
3609+ })();
3610+ var ErrorAtIndex = (function () {
3611+ function ErrorAtIndex(value0, value1) {
3612+ this.value0 = value0;
3613+ this.value1 = value1;
3614+ };
3615+ ErrorAtIndex.create = function (value0) {
3616+ return function (value1) {
3617+ return new ErrorAtIndex(value0, value1);
3618+ };
3619+ };
3620+ return ErrorAtIndex;
3621+ })();
3622+ var ErrorAtProperty = (function () {
3623+ function ErrorAtProperty(value0, value1) {
3624+ this.value0 = value0;
3625+ this.value1 = value1;
3626+ };
3627+ ErrorAtProperty.create = function (value0) {
3628+ return function (value1) {
3629+ return new ErrorAtProperty(value0, value1);
3630+ };
3631+ };
3632+ return ErrorAtProperty;
3633+ })();
3634+ var JSONError = (function () {
3635+ function JSONError(value0) {
3636+ this.value0 = value0;
3637+ };
3638+ JSONError.create = function (value0) {
3639+ return new JSONError(value0);
3640+ };
3641+ return JSONError;
3642+ })();
3643+ var showForeignError = new Data_Show.Show(function (v) {
3644+ if (v instanceof ForeignError) {
3645+ return "(ForeignError " + (Data_Show.show(Data_Show.showString)(v.value0) + ")");
3646+ };
3647+ if (v instanceof ErrorAtIndex) {
3648+ return "(ErrorAtIndex " + (Data_Show.show(Data_Show.showInt)(v.value0) + (" " + (Data_Show.show(showForeignError)(v.value1) + ")")));
3649+ };
3650+ if (v instanceof ErrorAtProperty) {
3651+ return "(ErrorAtProperty " + (Data_Show.show(Data_Show.showString)(v.value0) + (" " + (Data_Show.show(showForeignError)(v.value1) + ")")));
3652+ };
3653+ if (v instanceof JSONError) {
3654+ return "(JSONError " + (Data_Show.show(Data_Show.showString)(v.value0) + ")");
3655+ };
3656+ if (v instanceof TypeMismatch) {
3657+ return "(TypeMismatch " + (Data_Show.show(Data_Show.showString)(v.value0) + (" " + (Data_Show.show(Data_Show.showString)(v.value1) + ")")));
3658+ };
3659+ throw new Error("Failed pattern match at Data.Foreign line 64, column 1 - line 64, column 47: " + [ v.constructor.name ]);
3660+ });
3661+ var fail = function ($121) {
3662+ return Control_Monad_Error_Class.throwError(Control_Monad_Except_Trans.monadThrowExceptT(Data_Identity.monadIdentity))(Data_List_NonEmpty.singleton($121));
3663+ };
3664+ var unsafeReadTagged = function (tag) {
3665+ return function (value) {
3666+ if ($foreign.tagOf(value) === tag) {
3667+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))($foreign.unsafeFromForeign(value));
3668+ };
3669+ if (Data_Boolean.otherwise) {
3670+ return fail(new TypeMismatch(tag, $foreign.tagOf(value)));
3671+ };
3672+ throw new Error("Failed pattern match at Data.Foreign line 104, column 1 - line 104, column 55: " + [ tag.constructor.name, value.constructor.name ]);
3673+ };
3674+ };
3675+ var readString = unsafeReadTagged("String");
3676+ exports["ForeignError"] = ForeignError;
3677+ exports["TypeMismatch"] = TypeMismatch;
3678+ exports["ErrorAtIndex"] = ErrorAtIndex;
3679+ exports["ErrorAtProperty"] = ErrorAtProperty;
3680+ exports["JSONError"] = JSONError;
3681+ exports["unsafeReadTagged"] = unsafeReadTagged;
3682+ exports["readString"] = readString;
3683+ exports["fail"] = fail;
3684+ exports["showForeignError"] = showForeignError;
3685+ exports["toForeign"] = $foreign.toForeign;
3686+})(PS["Data.Foreign"] = PS["Data.Foreign"] || {});
3687+(function(exports) {
3688+ // Generated by purs version 0.11.7
3689+ "use strict";
3690+ var Control_Apply = PS["Control.Apply"];
3691+ var Data_Either = PS["Data.Either"];
3692+ var Data_Eq = PS["Data.Eq"];
3693+ var Data_Generic = PS["Data.Generic"];
3694+ var Data_Maybe = PS["Data.Maybe"];
3695+ var Data_Ord = PS["Data.Ord"];
3696+ var Data_Ordering = PS["Data.Ordering"];
3697+ var Data_Semigroup = PS["Data.Semigroup"];
3698+ var Data_Show = PS["Data.Show"];
3699+ var Data_String = PS["Data.String"];
3700+ var Data_Unit = PS["Data.Unit"];
3701+ var Prelude = PS["Prelude"];
3702+ var OPTIONS = (function () {
3703+ function OPTIONS() {
3704+
3705+ };
3706+ OPTIONS.value = new OPTIONS();
3707+ return OPTIONS;
3708+ })();
3709+ var GET = (function () {
3710+ function GET() {
3711+
3712+ };
3713+ GET.value = new GET();
3714+ return GET;
3715+ })();
3716+ var HEAD = (function () {
3717+ function HEAD() {
3718+
3719+ };
3720+ HEAD.value = new HEAD();
3721+ return HEAD;
3722+ })();
3723+ var POST = (function () {
3724+ function POST() {
3725+
3726+ };
3727+ POST.value = new POST();
3728+ return POST;
3729+ })();
3730+ var PUT = (function () {
3731+ function PUT() {
3732+
3733+ };
3734+ PUT.value = new PUT();
3735+ return PUT;
3736+ })();
3737+ var DELETE = (function () {
3738+ function DELETE() {
3739+
3740+ };
3741+ DELETE.value = new DELETE();
3742+ return DELETE;
3743+ })();
3744+ var TRACE = (function () {
3745+ function TRACE() {
3746+
3747+ };
3748+ TRACE.value = new TRACE();
3749+ return TRACE;
3750+ })();
3751+ var CONNECT = (function () {
3752+ function CONNECT() {
3753+
3754+ };
3755+ CONNECT.value = new CONNECT();
3756+ return CONNECT;
3757+ })();
3758+ var PROPFIND = (function () {
3759+ function PROPFIND() {
3760+
3761+ };
3762+ PROPFIND.value = new PROPFIND();
3763+ return PROPFIND;
3764+ })();
3765+ var PROPPATCH = (function () {
3766+ function PROPPATCH() {
3767+
3768+ };
3769+ PROPPATCH.value = new PROPPATCH();
3770+ return PROPPATCH;
3771+ })();
3772+ var MKCOL = (function () {
3773+ function MKCOL() {
3774+
3775+ };
3776+ MKCOL.value = new MKCOL();
3777+ return MKCOL;
3778+ })();
3779+ var COPY = (function () {
3780+ function COPY() {
3781+
3782+ };
3783+ COPY.value = new COPY();
3784+ return COPY;
3785+ })();
3786+ var MOVE = (function () {
3787+ function MOVE() {
3788+
3789+ };
3790+ MOVE.value = new MOVE();
3791+ return MOVE;
3792+ })();
3793+ var LOCK = (function () {
3794+ function LOCK() {
3795+
3796+ };
3797+ LOCK.value = new LOCK();
3798+ return LOCK;
3799+ })();
3800+ var UNLOCK = (function () {
3801+ function UNLOCK() {
3802+
3803+ };
3804+ UNLOCK.value = new UNLOCK();
3805+ return UNLOCK;
3806+ })();
3807+ var PATCH = (function () {
3808+ function PATCH() {
3809+
3810+ };
3811+ PATCH.value = new PATCH();
3812+ return PATCH;
3813+ })();
3814+ var unCustomMethod = function (v) {
3815+ return v;
3816+ };
3817+ var showMethod = new Data_Show.Show(function (v) {
3818+ if (v instanceof OPTIONS) {
3819+ return "OPTIONS";
3820+ };
3821+ if (v instanceof GET) {
3822+ return "GET";
3823+ };
3824+ if (v instanceof HEAD) {
3825+ return "HEAD";
3826+ };
3827+ if (v instanceof POST) {
3828+ return "POST";
3829+ };
3830+ if (v instanceof PUT) {
3831+ return "PUT";
3832+ };
3833+ if (v instanceof DELETE) {
3834+ return "DELETE";
3835+ };
3836+ if (v instanceof TRACE) {
3837+ return "TRACE";
3838+ };
3839+ if (v instanceof CONNECT) {
3840+ return "CONNECT";
3841+ };
3842+ if (v instanceof PROPFIND) {
3843+ return "PROPFIND";
3844+ };
3845+ if (v instanceof PROPPATCH) {
3846+ return "PROPPATCH";
3847+ };
3848+ if (v instanceof MKCOL) {
3849+ return "MKCOL";
3850+ };
3851+ if (v instanceof COPY) {
3852+ return "COPY";
3853+ };
3854+ if (v instanceof MOVE) {
3855+ return "MOVE";
3856+ };
3857+ if (v instanceof LOCK) {
3858+ return "LOCK";
3859+ };
3860+ if (v instanceof UNLOCK) {
3861+ return "UNLOCK";
3862+ };
3863+ if (v instanceof PATCH) {
3864+ return "PATCH";
3865+ };
3866+ throw new Error("Failed pattern match at Data.HTTP.Method line 42, column 1 - line 42, column 35: " + [ v.constructor.name ]);
3867+ });
3868+ var print = Data_Either.either(Data_Show.show(showMethod))(unCustomMethod);
3869+ exports["OPTIONS"] = OPTIONS;
3870+ exports["GET"] = GET;
3871+ exports["HEAD"] = HEAD;
3872+ exports["POST"] = POST;
3873+ exports["PUT"] = PUT;
3874+ exports["DELETE"] = DELETE;
3875+ exports["TRACE"] = TRACE;
3876+ exports["CONNECT"] = CONNECT;
3877+ exports["PROPFIND"] = PROPFIND;
3878+ exports["PROPPATCH"] = PROPPATCH;
3879+ exports["MKCOL"] = MKCOL;
3880+ exports["COPY"] = COPY;
3881+ exports["MOVE"] = MOVE;
3882+ exports["LOCK"] = LOCK;
3883+ exports["UNLOCK"] = UNLOCK;
3884+ exports["PATCH"] = PATCH;
3885+ exports["unCustomMethod"] = unCustomMethod;
3886+ exports["print"] = print;
3887+ exports["showMethod"] = showMethod;
3888+})(PS["Data.HTTP.Method"] = PS["Data.HTTP.Method"] || {});
3889+(function(exports) {
3890+ // Generated by purs version 0.11.7
3891+ "use strict";
3892+ var Control_Apply = PS["Control.Apply"];
3893+ var Data_Eq = PS["Data.Eq"];
3894+ var Data_Generic = PS["Data.Generic"];
3895+ var Data_Maybe = PS["Data.Maybe"];
3896+ var Data_Newtype = PS["Data.Newtype"];
3897+ var Data_Ord = PS["Data.Ord"];
3898+ var Data_Semigroup = PS["Data.Semigroup"];
3899+ var Data_Show = PS["Data.Show"];
3900+ var Data_Unit = PS["Data.Unit"];
3901+ var Prelude = PS["Prelude"];
3902+ var MediaType = function (x) {
3903+ return x;
3904+ };
3905+ var newtypeMediaType = new Data_Newtype.Newtype(function (n) {
3906+ return n;
3907+ }, MediaType);
3908+ exports["MediaType"] = MediaType;
3909+ exports["newtypeMediaType"] = newtypeMediaType;
3910+})(PS["Data.MediaType"] = PS["Data.MediaType"] || {});
3911+(function(exports) {
3912+ // Generated by purs version 0.11.7
3913+ "use strict";
3914+ var Data_MediaType = PS["Data.MediaType"];
3915+ var applicationJSON = "application/json";
3916+ exports["applicationJSON"] = applicationJSON;
3917+})(PS["Data.MediaType.Common"] = PS["Data.MediaType.Common"] || {});
3918+(function(exports) {
3919+ "use strict";
3920+
3921+ exports["null"] = null;
3922+
3923+ exports.notNull = function (x) {
3924+ return x;
3925+ };
3926+})(PS["Data.Nullable"] = PS["Data.Nullable"] || {});
3927+(function(exports) {
3928+ // Generated by purs version 0.11.7
3929+ "use strict";
3930+ var $foreign = PS["Data.Nullable"];
3931+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
3932+ var Data_Eq = PS["Data.Eq"];
3933+ var Data_Function = PS["Data.Function"];
3934+ var Data_Function_Uncurried = PS["Data.Function.Uncurried"];
3935+ var Data_Maybe = PS["Data.Maybe"];
3936+ var Data_Ord = PS["Data.Ord"];
3937+ var Data_Show = PS["Data.Show"];
3938+ var Prelude = PS["Prelude"];
3939+ var toNullable = Data_Maybe.maybe($foreign["null"])($foreign.notNull);
3940+ exports["toNullable"] = toNullable;
3941+})(PS["Data.Nullable"] = PS["Data.Nullable"] || {});
3942+(function(exports) {
3943+ "use strict";
3944+
3945+ // Alias require to prevent webpack or browserify from actually requiring.
3946+ var req = typeof module === "undefined" ? undefined : module.require;
3947+ var util = req === undefined ? undefined : req("util");
3948+
3949+ exports.traceAny = function () {
3950+ return function (x) {
3951+ return function (k) {
3952+ // node only recurses two levels into an object before printing
3953+ // "[object]" for further objects when using console.log()
3954+ if (util !== undefined) {
3955+ console.log(util.inspect(x, { depth: null, colors: true }));
3956+ } else {
3957+ console.log(x);
3958+ }
3959+ return k({});
3960+ };
3961+ };
3962+ };
3963+})(PS["Debug.Trace"] = PS["Debug.Trace"] || {});
3964+(function(exports) {
3965+ // Generated by purs version 0.11.7
3966+ "use strict";
3967+ var $foreign = PS["Debug.Trace"];
3968+ var Control_Applicative = PS["Control.Applicative"];
3969+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
3970+ var Data_Show = PS["Data.Show"];
3971+ var Data_Unit = PS["Data.Unit"];
3972+ var Prelude = PS["Prelude"];
3973+ var DebugWarning = {};
3974+ var warn = function (dictWarn) {
3975+ return DebugWarning;
3976+ };
3977+ var traceAnyA = function (dictDebugWarning) {
3978+ return function (dictApplicative) {
3979+ return function (s) {
3980+ return $foreign.traceAny(dictDebugWarning)(s)(function (v) {
3981+ return Control_Applicative.pure(dictApplicative)(Data_Unit.unit);
3982+ });
3983+ };
3984+ };
3985+ };
3986+ exports["DebugWarning"] = DebugWarning;
3987+ exports["traceAnyA"] = traceAnyA;
3988+ exports["warn"] = warn;
3989+})(PS["Debug.Trace"] = PS["Debug.Trace"] || {});
3990+(function(exports) {
3991+ /* global exports */
3992+ /* global XMLHttpRequest */
3993+ /* global module */
3994+ /* global process */
3995+ "use strict";
3996+
3997+ exports._ajax = function () {
3998+ var platformSpecific = { };
3999+ if (typeof module !== "undefined" && module.require && !(typeof process !== "undefined" && process.versions["electron"])) {
4000+ // We are on node.js
4001+ platformSpecific.newXHR = function () {
4002+ var XHR = module.require("xhr2");
4003+ return new XHR();
4004+ };
4005+
4006+ platformSpecific.fixupUrl = function (url) {
4007+ var urllib = module.require("url");
4008+ var u = urllib.parse(url);
4009+ u.protocol = u.protocol || "http:";
4010+ u.hostname = u.hostname || "localhost";
4011+ return urllib.format(u);
4012+ };
4013+
4014+ platformSpecific.getResponse = function (xhr) {
4015+ return xhr.response;
4016+ };
4017+ } else {
4018+ // We are in the browser
4019+ platformSpecific.newXHR = function () {
4020+ return new XMLHttpRequest();
4021+ };
4022+
4023+ platformSpecific.fixupUrl = function (url) {
4024+ return url || "/";
4025+ };
4026+
4027+ platformSpecific.getResponse = function (xhr) {
4028+ return xhr.response;
4029+ };
4030+ }
4031+
4032+ return function (mkHeader, options) {
4033+ return function (errback, callback) {
4034+ var xhr = platformSpecific.newXHR();
4035+ var fixedUrl = platformSpecific.fixupUrl(options.url);
4036+ xhr.open(options.method || "GET", fixedUrl, true, options.username, options.password);
4037+ if (options.headers) {
4038+ try {
4039+ for (var i = 0, header; (header = options.headers[i]) != null; i++) {
4040+ xhr.setRequestHeader(header.field, header.value);
4041+ }
4042+ } catch (e) {
4043+ errback(e);
4044+ }
4045+ }
4046+ xhr.onerror = function () {
4047+ errback(new Error("AJAX request failed: " + options.method + " " + options.url));
4048+ };
4049+ xhr.onload = function () {
4050+ callback({
4051+ status: xhr.status,
4052+ headers: xhr.getAllResponseHeaders().split("\r\n")
4053+ .filter(function (header) {
4054+ return header.length > 0;
4055+ })
4056+ .map(function (header) {
4057+ var i = header.indexOf(":");
4058+ return mkHeader(header.substring(0, i))(header.substring(i + 2));
4059+ }),
4060+ response: platformSpecific.getResponse(xhr)
4061+ });
4062+ };
4063+ xhr.responseType = options.responseType;
4064+ xhr.withCredentials = options.withCredentials;
4065+ xhr.send(options.content);
4066+
4067+ return function (/* error */) {
4068+ return function (cancelErrback, cancelCallback) {
4069+ try {
4070+ xhr.abort();
4071+ } catch (e) {
4072+ return cancelErrback(e);
4073+ }
4074+ return cancelCallback();
4075+ };
4076+ };
4077+ };
4078+ };
4079+ }();
4080+})(PS["Network.HTTP.Affjax"] = PS["Network.HTTP.Affjax"] || {});
4081+(function(exports) {
4082+ // Generated by purs version 0.11.7
4083+ "use strict";
4084+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
4085+ var DOM_File_Types = PS["DOM.File.Types"];
4086+ var DOM_Node_Types = PS["DOM.Node.Types"];
4087+ var DOM_XHR_Types = PS["DOM.XHR.Types"];
4088+ var Data_Argonaut_Core = PS["Data.Argonaut.Core"];
4089+ var Data_ArrayBuffer_Types = PS["Data.ArrayBuffer.Types"];
4090+ var Data_FormURLEncoded = PS["Data.FormURLEncoded"];
4091+ var Data_Maybe = PS["Data.Maybe"];
4092+ var Data_MediaType = PS["Data.MediaType"];
4093+ var Data_MediaType_Common = PS["Data.MediaType.Common"];
4094+ var Data_Show = PS["Data.Show"];
4095+ var Data_Tuple = PS["Data.Tuple"];
4096+ var Prelude = PS["Prelude"];
4097+ var Unsafe_Coerce = PS["Unsafe.Coerce"];
4098+ var Requestable = function (toRequest) {
4099+ this.toRequest = toRequest;
4100+ };
4101+ var toRequest = function (dict) {
4102+ return dict.toRequest;
4103+ };
4104+ var requestableJson = new Requestable(function (json) {
4105+ return new Data_Tuple.Tuple(new Data_Maybe.Just(Data_MediaType_Common.applicationJSON), Data_Show.show(Data_Argonaut_Core.showJson)(json));
4106+ });
4107+ var defaultToRequest = function ($0) {
4108+ return Data_Tuple.Tuple.create(Data_Maybe.Nothing.value)($0);
4109+ };
4110+ var requestableUnit = new Requestable(defaultToRequest);
4111+ exports["Requestable"] = Requestable;
4112+ exports["toRequest"] = toRequest;
4113+ exports["requestableJson"] = requestableJson;
4114+ exports["requestableUnit"] = requestableUnit;
4115+})(PS["Network.HTTP.Affjax.Request"] = PS["Network.HTTP.Affjax.Request"] || {});
4116+(function(exports) {
4117+ // Generated by purs version 0.11.7
4118+ "use strict";
4119+ var Control_Applicative = PS["Control.Applicative"];
4120+ var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
4121+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
4122+ var DOM_File_Types = PS["DOM.File.Types"];
4123+ var DOM_Node_Types = PS["DOM.Node.Types"];
4124+ var Data_Argonaut_Core = PS["Data.Argonaut.Core"];
4125+ var Data_ArrayBuffer_Types = PS["Data.ArrayBuffer.Types"];
4126+ var Data_Eq = PS["Data.Eq"];
4127+ var Data_Foreign = PS["Data.Foreign"];
4128+ var Data_Function = PS["Data.Function"];
4129+ var Data_Identity = PS["Data.Identity"];
4130+ var Data_Maybe = PS["Data.Maybe"];
4131+ var Data_MediaType = PS["Data.MediaType"];
4132+ var Data_MediaType_Common = PS["Data.MediaType.Common"];
4133+ var Data_Show = PS["Data.Show"];
4134+ var Data_Tuple = PS["Data.Tuple"];
4135+ var Data_Unit = PS["Data.Unit"];
4136+ var Prelude = PS["Prelude"];
4137+ var Unsafe_Coerce = PS["Unsafe.Coerce"];
4138+ var ArrayBufferResponse = (function () {
4139+ function ArrayBufferResponse() {
4140+
4141+ };
4142+ ArrayBufferResponse.value = new ArrayBufferResponse();
4143+ return ArrayBufferResponse;
4144+ })();
4145+ var BlobResponse = (function () {
4146+ function BlobResponse() {
4147+
4148+ };
4149+ BlobResponse.value = new BlobResponse();
4150+ return BlobResponse;
4151+ })();
4152+ var DocumentResponse = (function () {
4153+ function DocumentResponse() {
4154+
4155+ };
4156+ DocumentResponse.value = new DocumentResponse();
4157+ return DocumentResponse;
4158+ })();
4159+ var JSONResponse = (function () {
4160+ function JSONResponse() {
4161+
4162+ };
4163+ JSONResponse.value = new JSONResponse();
4164+ return JSONResponse;
4165+ })();
4166+ var StringResponse = (function () {
4167+ function StringResponse() {
4168+
4169+ };
4170+ StringResponse.value = new StringResponse();
4171+ return StringResponse;
4172+ })();
4173+ var Respondable = function (fromResponse, responseType) {
4174+ this.fromResponse = fromResponse;
4175+ this.responseType = responseType;
4176+ };
4177+ var responseTypeToString = function (v) {
4178+ if (v instanceof ArrayBufferResponse) {
4179+ return "arraybuffer";
4180+ };
4181+ if (v instanceof BlobResponse) {
4182+ return "blob";
4183+ };
4184+ if (v instanceof DocumentResponse) {
4185+ return "document";
4186+ };
4187+ if (v instanceof JSONResponse) {
4188+ return "text";
4189+ };
4190+ if (v instanceof StringResponse) {
4191+ return "text";
4192+ };
4193+ throw new Error("Failed pattern match at Network.HTTP.Affjax.Response line 48, column 1 - line 48, column 61: " + [ v.constructor.name ]);
4194+ };
4195+ var responseType = function (dict) {
4196+ return dict.responseType;
4197+ };
4198+ var responsableString = new Respondable(Data_Foreign.readString, new Data_Tuple.Tuple(Data_Maybe.Nothing.value, StringResponse.value));
4199+ var responsableJson = new Respondable(function ($8) {
4200+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))($8);
4201+ }, new Data_Tuple.Tuple(new Data_Maybe.Just(Data_MediaType_Common.applicationJSON), JSONResponse.value));
4202+ var fromResponse = function (dict) {
4203+ return dict.fromResponse;
4204+ };
4205+ exports["ArrayBufferResponse"] = ArrayBufferResponse;
4206+ exports["BlobResponse"] = BlobResponse;
4207+ exports["DocumentResponse"] = DocumentResponse;
4208+ exports["JSONResponse"] = JSONResponse;
4209+ exports["StringResponse"] = StringResponse;
4210+ exports["responseTypeToString"] = responseTypeToString;
4211+ exports["Respondable"] = Respondable;
4212+ exports["responseType"] = responseType;
4213+ exports["fromResponse"] = fromResponse;
4214+ exports["responsableString"] = responsableString;
4215+ exports["responsableJson"] = responsableJson;
4216+})(PS["Network.HTTP.Affjax.Response"] = PS["Network.HTTP.Affjax.Response"] || {});
4217+(function(exports) {
4218+ // Generated by purs version 0.11.7
4219+ "use strict";
4220+ var Data_Eq = PS["Data.Eq"];
4221+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
4222+ var Data_MediaType = PS["Data.MediaType"];
4223+ var Data_Newtype = PS["Data.Newtype"];
4224+ var Data_Semigroup = PS["Data.Semigroup"];
4225+ var Data_Show = PS["Data.Show"];
4226+ var Prelude = PS["Prelude"];
4227+ var Accept = (function () {
4228+ function Accept(value0) {
4229+ this.value0 = value0;
4230+ };
4231+ Accept.create = function (value0) {
4232+ return new Accept(value0);
4233+ };
4234+ return Accept;
4235+ })();
4236+ var ContentType = (function () {
4237+ function ContentType(value0) {
4238+ this.value0 = value0;
4239+ };
4240+ ContentType.create = function (value0) {
4241+ return new ContentType(value0);
4242+ };
4243+ return ContentType;
4244+ })();
4245+ var RequestHeader = (function () {
4246+ function RequestHeader(value0, value1) {
4247+ this.value0 = value0;
4248+ this.value1 = value1;
4249+ };
4250+ RequestHeader.create = function (value0) {
4251+ return function (value1) {
4252+ return new RequestHeader(value0, value1);
4253+ };
4254+ };
4255+ return RequestHeader;
4256+ })();
4257+ var requestHeaderValue = function (v) {
4258+ if (v instanceof Accept) {
4259+ return Data_Newtype.unwrap(Data_MediaType.newtypeMediaType)(v.value0);
4260+ };
4261+ if (v instanceof ContentType) {
4262+ return Data_Newtype.unwrap(Data_MediaType.newtypeMediaType)(v.value0);
4263+ };
4264+ if (v instanceof RequestHeader) {
4265+ return v.value1;
4266+ };
4267+ throw new Error("Failed pattern match at Network.HTTP.RequestHeader line 29, column 1 - line 29, column 46: " + [ v.constructor.name ]);
4268+ };
4269+ var requestHeaderName = function (v) {
4270+ if (v instanceof Accept) {
4271+ return "Accept";
4272+ };
4273+ if (v instanceof ContentType) {
4274+ return "Content-Type";
4275+ };
4276+ if (v instanceof RequestHeader) {
4277+ return v.value0;
4278+ };
4279+ throw new Error("Failed pattern match at Network.HTTP.RequestHeader line 24, column 1 - line 24, column 45: " + [ v.constructor.name ]);
4280+ };
4281+ exports["Accept"] = Accept;
4282+ exports["ContentType"] = ContentType;
4283+ exports["RequestHeader"] = RequestHeader;
4284+ exports["requestHeaderName"] = requestHeaderName;
4285+ exports["requestHeaderValue"] = requestHeaderValue;
4286+})(PS["Network.HTTP.RequestHeader"] = PS["Network.HTTP.RequestHeader"] || {});
4287+(function(exports) {
4288+ // Generated by purs version 0.11.7
4289+ "use strict";
4290+ var Control_Apply = PS["Control.Apply"];
4291+ var Data_Eq = PS["Data.Eq"];
4292+ var Data_Generic = PS["Data.Generic"];
4293+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
4294+ var Data_Maybe = PS["Data.Maybe"];
4295+ var Data_Semigroup = PS["Data.Semigroup"];
4296+ var Data_Show = PS["Data.Show"];
4297+ var Data_Unit = PS["Data.Unit"];
4298+ var Prelude = PS["Prelude"];
4299+ var ResponseHeader = (function () {
4300+ function ResponseHeader(value0, value1) {
4301+ this.value0 = value0;
4302+ this.value1 = value1;
4303+ };
4304+ ResponseHeader.create = function (value0) {
4305+ return function (value1) {
4306+ return new ResponseHeader(value0, value1);
4307+ };
4308+ };
4309+ return ResponseHeader;
4310+ })();
4311+ var responseHeader = function (field) {
4312+ return function (value) {
4313+ return new ResponseHeader(field, value);
4314+ };
4315+ };
4316+ exports["responseHeader"] = responseHeader;
4317+})(PS["Network.HTTP.ResponseHeader"] = PS["Network.HTTP.ResponseHeader"] || {});
4318+(function(exports) {
4319+ // Generated by purs version 0.11.7
4320+ "use strict";
4321+ var $foreign = PS["Network.HTTP.Affjax"];
4322+ var Control_Applicative = PS["Control.Applicative"];
4323+ var Control_Bind = PS["Control.Bind"];
4324+ var Control_Monad_Aff = PS["Control.Monad.Aff"];
4325+ var Control_Monad_Aff_Compat = PS["Control.Monad.Aff.Compat"];
4326+ var Control_Monad_Eff = PS["Control.Monad.Eff"];
4327+ var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
4328+ var Control_Monad_Eff_Exception = PS["Control.Monad.Eff.Exception"];
4329+ var Control_Monad_Eff_Ref = PS["Control.Monad.Eff.Ref"];
4330+ var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
4331+ var Control_Monad_Except = PS["Control.Monad.Except"];
4332+ var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
4333+ var Control_Parallel = PS["Control.Parallel"];
4334+ var Control_Semigroupoid = PS["Control.Semigroupoid"];
4335+ var Data_Argonaut_Parser = PS["Data.Argonaut.Parser"];
4336+ var Data_Array = PS["Data.Array"];
4337+ var Data_Either = PS["Data.Either"];
4338+ var Data_Eq = PS["Data.Eq"];
4339+ var Data_Foldable = PS["Data.Foldable"];
4340+ var Data_Foreign = PS["Data.Foreign"];
4341+ var Data_Function = PS["Data.Function"];
4342+ var Data_Function_Uncurried = PS["Data.Function.Uncurried"];
4343+ var Data_Functor = PS["Data.Functor"];
4344+ var Data_HTTP_Method = PS["Data.HTTP.Method"];
4345+ var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
4346+ var Data_Identity = PS["Data.Identity"];
4347+ var Data_Int = PS["Data.Int"];
4348+ var Data_List_Types = PS["Data.List.Types"];
4349+ var Data_Maybe = PS["Data.Maybe"];
4350+ var Data_MediaType = PS["Data.MediaType"];
4351+ var Data_Nullable = PS["Data.Nullable"];
4352+ var Data_Ring = PS["Data.Ring"];
4353+ var Data_Semiring = PS["Data.Semiring"];
4354+ var Data_Show = PS["Data.Show"];
4355+ var Data_Time_Duration = PS["Data.Time.Duration"];
4356+ var Data_Tuple = PS["Data.Tuple"];
4357+ var $$Math = PS["Math"];
4358+ var Network_HTTP_Affjax_Request = PS["Network.HTTP.Affjax.Request"];
4359+ var Network_HTTP_Affjax_Response = PS["Network.HTTP.Affjax.Response"];
4360+ var Network_HTTP_RequestHeader = PS["Network.HTTP.RequestHeader"];
4361+ var Network_HTTP_ResponseHeader = PS["Network.HTTP.ResponseHeader"];
4362+ var Network_HTTP_StatusCode = PS["Network.HTTP.StatusCode"];
4363+ var Prelude = PS["Prelude"];
4364+ var defaultRequest = {
4365+ method: new Data_Either.Left(Data_HTTP_Method.GET.value),
4366+ url: "/",
4367+ headers: [ ],
4368+ content: Data_Maybe.Nothing.value,
4369+ username: Data_Maybe.Nothing.value,
4370+ password: Data_Maybe.Nothing.value,
4371+ withCredentials: false
4372+ };
4373+ var affjax = function (dictRequestable) {
4374+ return function (dictRespondable) {
4375+ return function (req) {
4376+ var responseSettings = Network_HTTP_Affjax_Response.responseType(dictRespondable);
4377+ var requestSettings = (function () {
4378+ var v = Data_Functor.map(Data_Maybe.functorMaybe)(Network_HTTP_Affjax_Request.toRequest(dictRequestable))(req.content);
4379+ if (v instanceof Data_Maybe.Nothing) {
4380+ return new Data_Tuple.Tuple(Data_Maybe.Nothing.value, Data_Maybe.Nothing.value);
4381+ };
4382+ if (v instanceof Data_Maybe.Just) {
4383+ return new Data_Tuple.Tuple(v.value0.value0, new Data_Maybe.Just(v.value0.value1));
4384+ };
4385+ throw new Error("Failed pattern match at Network.HTTP.Affjax line 250, column 21 - line 252, column 49: " + [ v.constructor.name ]);
4386+ })();
4387+ var parseJSON = function ($98) {
4388+ return Data_Either.either(function ($99) {
4389+ return Data_Foreign.fail(Data_Foreign.JSONError.create($99));
4390+ })(function ($100) {
4391+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_Foreign.toForeign($100));
4392+ })(Data_Argonaut_Parser.jsonParser($98));
4393+ };
4394+ var fromResponse$prime = (function () {
4395+ var v = Data_Tuple.snd(responseSettings);
4396+ if (v instanceof Network_HTTP_Affjax_Response.JSONResponse) {
4397+ return Control_Bind.composeKleisliFlipped(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Network_HTTP_Affjax_Response.fromResponse(dictRespondable))(Control_Bind.composeKleisliFlipped(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(parseJSON)(Data_Foreign.readString));
4398+ };
4399+ return Network_HTTP_Affjax_Response.fromResponse(dictRespondable);
4400+ })();
4401+ var addHeader = function (mh) {
4402+ return function (hs) {
4403+ if (mh instanceof Data_Maybe.Just && !Data_Foldable.any(Data_Foldable.foldableArray)(Data_HeytingAlgebra.heytingAlgebraBoolean)(Data_Function.on(Data_Eq.eq(Data_Eq.eqString))(Network_HTTP_RequestHeader.requestHeaderName)(mh.value0))(hs)) {
4404+ return Data_Array.snoc(hs)(mh.value0);
4405+ };
4406+ return hs;
4407+ };
4408+ };
4409+ var headers = addHeader(Data_Functor.map(Data_Maybe.functorMaybe)(Network_HTTP_RequestHeader.ContentType.create)(Data_Tuple.fst(requestSettings)))(addHeader(Data_Functor.map(Data_Maybe.functorMaybe)(Network_HTTP_RequestHeader.Accept.create)(Data_Tuple.fst(responseSettings)))(req.headers));
4410+ var req$prime = {
4411+ method: Data_HTTP_Method.print(req.method),
4412+ url: req.url,
4413+ headers: Data_Functor.map(Data_Functor.functorArray)(function (h) {
4414+ return {
4415+ field: Network_HTTP_RequestHeader.requestHeaderName(h),
4416+ value: Network_HTTP_RequestHeader.requestHeaderValue(h)
4417+ };
4418+ })(headers),
4419+ content: Data_Nullable.toNullable(Data_Tuple.snd(requestSettings)),
4420+ responseType: Network_HTTP_Affjax_Response.responseTypeToString(Data_Tuple.snd(responseSettings)),
4421+ username: Data_Nullable.toNullable(req.username),
4422+ password: Data_Nullable.toNullable(req.password),
4423+ withCredentials: req.withCredentials
4424+ };
4425+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff_Compat.fromEffFnAff($foreign._ajax(Network_HTTP_ResponseHeader.responseHeader, req$prime)))(function (v) {
4426+ var v1 = Data_Functor.map(Data_Either.functorEither)(function (v2) {
4427+ var $68 = {};
4428+ for (var $69 in v) {
4429+ if ({}.hasOwnProperty.call(v, $69)) {
4430+ $68[$69] = v[$69];
4431+ };
4432+ };
4433+ $68.response = v2;
4434+ return $68;
4435+ })(Control_Monad_Except.runExcept(fromResponse$prime(v.response)));
4436+ if (v1 instanceof Data_Either.Left) {
4437+ return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadThrowAff)(Control_Monad_Eff_Exception.error(Data_Show.show(Data_List_Types.showNonEmptyList(Data_Foreign.showForeignError))(v1.value0)));
4438+ };
4439+ if (v1 instanceof Data_Either.Right) {
4440+ return Control_Applicative.pure(Control_Monad_Aff.applicativeAff)(v1.value0);
4441+ };
4442+ throw new Error("Failed pattern match at Network.HTTP.Affjax line 232, column 3 - line 234, column 28: " + [ v1.constructor.name ]);
4443+ });
4444+ };
4445+ };
4446+ };
4447+ var $$delete = function (dictRespondable) {
4448+ return function (u) {
4449+ return affjax(Network_HTTP_Affjax_Request.requestableUnit)(dictRespondable)((function () {
4450+ var $74 = {};
4451+ for (var $75 in defaultRequest) {
4452+ if ({}.hasOwnProperty.call(defaultRequest, $75)) {
4453+ $74[$75] = defaultRequest[$75];
4454+ };
4455+ };
4456+ $74.method = new Data_Either.Left(Data_HTTP_Method.DELETE.value);
4457+ $74.url = u;
4458+ return $74;
4459+ })());
4460+ };
4461+ };
4462+ var get = function (dictRespondable) {
4463+ return function (u) {
4464+ return affjax(Network_HTTP_Affjax_Request.requestableUnit)(dictRespondable)((function () {
4465+ var $77 = {};
4466+ for (var $78 in defaultRequest) {
4467+ if ({}.hasOwnProperty.call(defaultRequest, $78)) {
4468+ $77[$78] = defaultRequest[$78];
4469+ };
4470+ };
4471+ $77.url = u;
4472+ return $77;
4473+ })());
4474+ };
4475+ };
4476+ var post = function (dictRequestable) {
4477+ return function (dictRespondable) {
4478+ return function (u) {
4479+ return function (c) {
4480+ return affjax(dictRequestable)(dictRespondable)((function () {
4481+ var $86 = {};
4482+ for (var $87 in defaultRequest) {
4483+ if ({}.hasOwnProperty.call(defaultRequest, $87)) {
4484+ $86[$87] = defaultRequest[$87];
4485+ };
4486+ };
4487+ $86.method = new Data_Either.Left(Data_HTTP_Method.POST.value);
4488+ $86.url = u;
4489+ $86.content = new Data_Maybe.Just(c);
4490+ return $86;
4491+ })());
4492+ };
4493+ };
4494+ };
4495+ };
4496+ exports["defaultRequest"] = defaultRequest;
4497+ exports["affjax"] = affjax;
4498+ exports["get"] = get;
4499+ exports["post"] = post;
4500+ exports["delete"] = $$delete;
4501+})(PS["Network.HTTP.Affjax"] = PS["Network.HTTP.Affjax"] || {});
4502+(function(exports) {
4503+ "use strict";
4504+ var Control_Bind = PS["Control.Bind"];
4505+ var Control_Monad_Aff = PS["Control.Monad.Aff"];
4506+ var Control_Monad_Eff = PS["Control.Monad.Eff"];
4507+ var Data_Argonaut = PS["Data.Argonaut"];
4508+ var Data_Argonaut_Decode_Class = PS["Data.Argonaut.Decode.Class"];
4509+ var Data_Argonaut_Decode_Combinators = PS["Data.Argonaut.Decode.Combinators"];
4510+ var Data_Argonaut_Encode_Class = PS["Data.Argonaut.Encode.Class"];
4511+ var Data_Either = PS["Data.Either"];
4512+ var Data_Foldable = PS["Data.Foldable"];
4513+ var Data_Function = PS["Data.Function"];
4514+ var Data_Functor = PS["Data.Functor"];
4515+ var Data_Semigroup = PS["Data.Semigroup"];
4516+ var Data_StrMap = PS["Data.StrMap"];
4517+ var Data_Tuple = PS["Data.Tuple"];
4518+ var Debug_Trace = PS["Debug.Trace"];
4519+ var Network_HTTP_Affjax = PS["Network.HTTP.Affjax"];
4520+ var Network_HTTP_Affjax_Request = PS["Network.HTTP.Affjax.Request"];
4521+ var Network_HTTP_Affjax_Response = PS["Network.HTTP.Affjax.Response"];
4522+ var Prelude = PS["Prelude"];
4523+ var main = Data_Functor["void"](Control_Monad_Eff.functorEff)(Control_Monad_Aff.launchAff(Control_Bind.bind(Control_Monad_Aff.bindAff)(Network_HTTP_Affjax.get(Network_HTTP_Affjax_Response.responsableString)("http://localhost:4444/wd/hub/status"))(function (v) {
4524+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Network_HTTP_Affjax.post(Network_HTTP_Affjax_Request.requestableJson)(Network_HTTP_Affjax_Response.responsableJson)("http://localhost:4444/wd/hub/session")(Data_Argonaut_Encode_Class.encodeJson(Data_Argonaut_Encode_Class.encodeStrMap(Data_Argonaut_Encode_Class.encodeStrMap(Data_Argonaut_Encode_Class.encodeJsonJString)))(Data_StrMap.fromFoldable(Data_Foldable.foldableArray)([ Data_Tuple.Tuple.create("desiredCapabilities")(Data_StrMap.fromFoldable(Data_Foldable.foldableArray)([ new Data_Tuple.Tuple("browserName", "MicrosoftEdge") ])) ]))))(function (v1) {
4525+ var eitherSessionId = Control_Bind.bind(Data_Either.bindEither)(Data_Argonaut_Decode_Class.decodeJson(Data_Argonaut_Decode_Class.decodeStrMap(Data_Argonaut_Decode_Class.decodeJsonJson))(v1.response))(function (v2) {
4526+ return Data_Argonaut_Decode_Combinators.getField(Data_Argonaut_Decode_Class.decodeJsonString)(v2)("sessionId");
4527+ });
4528+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Data_Foldable.for_(Control_Monad_Aff.applicativeAff)(Data_Either.foldableEither)(eitherSessionId)(function (sessId) {
4529+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Network_HTTP_Affjax.post(Network_HTTP_Affjax_Request.requestableJson)(Network_HTTP_Affjax_Response.responsableJson)("http://localhost:4444/wd/hub/session/" + (sessId + "/url"))(Data_Argonaut_Encode_Class.encodeJson(Data_Argonaut_Encode_Class.encodeStrMap(Data_Argonaut_Encode_Class.encodeJsonJString))(Data_StrMap.fromFoldable(Data_Foldable.foldableArray)([ new Data_Tuple.Tuple("url", "https://www.w3.org/TR/webdriver/") ]))))(function (v2) {
4530+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)(v2))(function () {
4531+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)(v2.response))(function () {
4532+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Network_HTTP_Affjax.post(Network_HTTP_Affjax_Request.requestableJson)(Network_HTTP_Affjax_Response.responsableJson)("http://localhost:4444/wd/hub/session/" + (sessId + "/element"))(Data_Argonaut_Encode_Class.encodeJson(Data_Argonaut_Encode_Class.encodeStrMap(Data_Argonaut_Encode_Class.encodeJsonJString))(Data_StrMap.fromFoldable(Data_Foldable.foldableArray)([ new Data_Tuple.Tuple("using", "css selector"), new Data_Tuple.Tuple("value", "#respecDocument") ]))))(function (v3) {
4533+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)("ELEMENT "))(function () {
4534+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)(v3.response))(function () {
4535+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Network_HTTP_Affjax.post(Network_HTTP_Affjax_Request.requestableJson)(Network_HTTP_Affjax_Response.responsableJson)("http://localhost:4444/wd/hub/session/" + (sessId + "/element"))(Data_Argonaut_Encode_Class.encodeJson(Data_Argonaut_Encode_Class.encodeStrMap(Data_Argonaut_Encode_Class.encodeJsonJString))(Data_StrMap.fromFoldable(Data_Foldable.foldableArray)([ new Data_Tuple.Tuple("using", "css selector"), new Data_Tuple.Tuple("value", "title ") ]))))(function (v4) {
4536+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)("ELEMENT "))(function () {
4537+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)(v4.response))(function () {
4538+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)("========================================"))(function () {
4539+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Network_HTTP_Affjax["delete"](Network_HTTP_Affjax_Response.responsableJson)("http://localhost:4444/wd/hub/session/" + sessId))(function (v5) {
4540+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)(v5))(function () {
4541+ return Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)(v5.response);
4542+ });
4543+ });
4544+ });
4545+ });
4546+ });
4547+ });
4548+ });
4549+ });
4550+ });
4551+ });
4552+ });
4553+ });
4554+ }))(function () {
4555+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)(v))(function () {
4556+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)(v.response))(function () {
4557+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)(v1))(function () {
4558+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)(v1.response))(function () {
4559+ return Debug_Trace.traceAnyA(Debug_Trace.warn())(Control_Monad_Aff.applicativeAff)("HEHEY!");
4560+ });
4561+ });
4562+ });
4563+ });
4564+ });
4565+ });
4566+ })));
4567+ exports["main"] = main;
4568+})(PS["Main"] = PS["Main"] || {});
4569+PS["Main"].main();