@@ -1,493 +1,871 @@
1−// Generated by purs bundle 0.13.6
2−var PS = {};
3−(function($PS) {
4− // Generated by purs version 0.13.6
5− "use strict";
6− $PS["Control.Apply"] = $PS["Control.Apply"] || {};
7− var exports = $PS["Control.Apply"];
8− var Apply = function (Functor0, apply) {
9− this.Functor0 = Functor0;
10− this.apply = apply;
11− };
12− var apply = function (dict) {
13− return dict.apply;
14− };
15− exports["Apply"] = Apply;
16− exports["apply"] = apply;
17−})(PS);
18−(function($PS) {
19− // Generated by purs version 0.13.6
20− "use strict";
21− $PS["Control.Applicative"] = $PS["Control.Applicative"] || {};
22− var exports = $PS["Control.Applicative"];
23− var Control_Apply = $PS["Control.Apply"];
24− var Applicative = function (Apply0, pure) {
25− this.Apply0 = Apply0;
26− this.pure = pure;
27− };
28− var pure = function (dict) {
29− return dict.pure;
30− };
31− var liftA1 = function (dictApplicative) {
32− return function (f) {
33− return function (a) {
34− return Control_Apply.apply(dictApplicative.Apply0())(pure(dictApplicative)(f))(a);
35− };
1+/* Generated by Spago v0.93.40 */
2+(() => {
3+ // output/Control.Semigroupoid/index.js
4+ var semigroupoidFn = {
5+ compose: function(f) {
6+ return function(g) {
7+ return function(x) {
8+ return f(g(x));
9+ };
3610 };
11+ }
3712 };
38− exports["Applicative"] = Applicative;
39− exports["pure"] = pure;
40− exports["liftA1"] = liftA1;
41−})(PS);
42−(function($PS) {
43− // Generated by purs version 0.13.6
44− "use strict";
45− $PS["Data.Function"] = $PS["Data.Function"] || {};
46− var exports = $PS["Data.Function"];
47− var flip = function (f) {
48− return function (b) {
49− return function (a) {
50− return f(a)(b);
51− };
52− };
13+
14+ // output/Control.Category/index.js
15+ var identity = function(dict) {
16+ return dict.identity;
5317 };
54− var $$const = function (a) {
55− return function (v) {
56− return a;
57− };
18+ var categoryFn = {
19+ identity: function(x) {
20+ return x;
21+ },
22+ Semigroupoid0: function() {
23+ return semigroupoidFn;
24+ }
5825 };
59− exports["flip"] = flip;
60− exports["const"] = $$const;
61−})(PS);
62−(function($PS) {
63− // Generated by purs version 0.13.6
64− "use strict";
65− $PS["Control.Bind"] = $PS["Control.Bind"] || {};
66− var exports = $PS["Control.Bind"];
67− var Data_Function = $PS["Data.Function"];
68− var Discard = function (discard) {
69− this.discard = discard;
70− };
71− var Bind = function (Apply0, bind) {
72− this.Apply0 = Apply0;
73− this.bind = bind;
74− };
75− var discard = function (dict) {
76− return dict.discard;
77− };
78− var bind = function (dict) {
79− return dict.bind;
80− };
81− var bindFlipped = function (dictBind) {
82− return Data_Function.flip(bind(dictBind));
83− };
84− var discardUnit = new Discard(function (dictBind) {
85− return bind(dictBind);
86− });
87− exports["Bind"] = Bind;
88− exports["bind"] = bind;
89− exports["bindFlipped"] = bindFlipped;
90− exports["discard"] = discard;
91− exports["discardUnit"] = discardUnit;
92−})(PS);
93−(function($PS) {
94− // Generated by purs version 0.13.6
95− "use strict";
96− $PS["Control.Monad"] = $PS["Control.Monad"] || {};
97− var exports = $PS["Control.Monad"];
98− var Control_Applicative = $PS["Control.Applicative"];
99− var Control_Bind = $PS["Control.Bind"];
100− var Monad = function (Applicative0, Bind1) {
101− this.Applicative0 = Applicative0;
102− this.Bind1 = Bind1;
103− };
104− var ap = function (dictMonad) {
105− return function (f) {
106− return function (a) {
107− return Control_Bind.bind(dictMonad.Bind1())(f)(function (f$prime) {
108− return Control_Bind.bind(dictMonad.Bind1())(a)(function (a$prime) {
109− return Control_Applicative.pure(dictMonad.Applicative0())(f$prime(a$prime));
110− });
111− });
112− };
26+
27+ // output/Data.Boolean/index.js
28+ var otherwise = true;
29+
30+ // output/Data.Function/index.js
31+ var flip = function(f) {
32+ return function(b) {
33+ return function(a) {
34+ return f(a)(b);
11335 };
36+ };
11437 };
115− exports["Monad"] = Monad;
116− exports["ap"] = ap;
117−})(PS);
118−(function($PS) {
119− // Generated by purs version 0.13.6
120− "use strict";
121− $PS["Data.Either"] = $PS["Data.Either"] || {};
122− var exports = $PS["Data.Either"];
123− var Left = (function () {
124− function Left(value0) {
125− this.value0 = value0;
126− };
127− Left.create = function (value0) {
128− return new Left(value0);
129− };
130− return Left;
131− })();
132− var Right = (function () {
133− function Right(value0) {
134− this.value0 = value0;
135− };
136− Right.create = function (value0) {
137− return new Right(value0);
138− };
139− return Right;
140− })();
141− exports["Left"] = Left;
142− exports["Right"] = Right;
143−})(PS);
144−(function(exports) {
145− "use strict";
38+ var $$const = function(a) {
39+ return function(v) {
40+ return a;
41+ };
42+ };
43+
44+ // output/Data.Unit/foreign.js
45+ var unit = void 0;
14646
147− exports.unit = {};
148−})(PS["Data.Unit"] = PS["Data.Unit"] || {});
149−(function($PS) {
150− // Generated by purs version 0.13.6
151− "use strict";
152− $PS["Data.Unit"] = $PS["Data.Unit"] || {};
153− var exports = $PS["Data.Unit"];
154− var $foreign = $PS["Data.Unit"];
155− exports["unit"] = $foreign.unit;
156−})(PS);
157−(function($PS) {
158− // Generated by purs version 0.13.6
159− "use strict";
160− $PS["Data.Functor"] = $PS["Data.Functor"] || {};
161− var exports = $PS["Data.Functor"];
162− var Data_Function = $PS["Data.Function"];
163− var Data_Unit = $PS["Data.Unit"];
164− var Functor = function (map) {
165− this.map = map;
166− };
167− var map = function (dict) {
168− return dict.map;
169− };
170− var $$void = function (dictFunctor) {
171− return map(dictFunctor)(Data_Function["const"](Data_Unit.unit));
172− };
173− var voidRight = function (dictFunctor) {
174− return function (x) {
175− return map(dictFunctor)(Data_Function["const"](x));
47+ // output/Data.Functor/index.js
48+ var map = function(dict) {
49+ return dict.map;
50+ };
51+ var $$void = function(dictFunctor) {
52+ return map(dictFunctor)($$const(unit));
53+ };
54+ var voidRight = function(dictFunctor) {
55+ var map1 = map(dictFunctor);
56+ return function(x) {
57+ return map1($$const(x));
58+ };
59+ };
60+
61+ // output/Control.Apply/index.js
62+ var identity2 = /* @__PURE__ */ identity(categoryFn);
63+ var apply = function(dict) {
64+ return dict.apply;
65+ };
66+ var applySecond = function(dictApply) {
67+ var apply1 = apply(dictApply);
68+ var map3 = map(dictApply.Functor0());
69+ return function(a) {
70+ return function(b) {
71+ return apply1(map3($$const(identity2))(a))(b);
17672 };
73+ };
17774 };
178− exports["Functor"] = Functor;
179− exports["map"] = map;
180− exports["void"] = $$void;
181− exports["voidRight"] = voidRight;
182−})(PS);
183−(function($PS) {
184− // Generated by purs version 0.13.6
185− "use strict";
186− $PS["Control.Monad.Error.Class"] = $PS["Control.Monad.Error.Class"] || {};
187− var exports = $PS["Control.Monad.Error.Class"];
188− var Control_Applicative = $PS["Control.Applicative"];
189− var Data_Either = $PS["Data.Either"];
190− var Data_Functor = $PS["Data.Functor"];
191− var MonadThrow = function (Monad0, throwError) {
192− this.Monad0 = Monad0;
193− this.throwError = throwError;
194− };
195− var MonadError = function (MonadThrow0, catchError) {
196− this.MonadThrow0 = MonadThrow0;
197− this.catchError = catchError;
198− };
199− var catchError = function (dict) {
200− return dict.catchError;
201− };
202− var $$try = function (dictMonadError) {
203− return function (a) {
204− return catchError(dictMonadError)(Data_Functor.map(((((dictMonadError.MonadThrow0()).Monad0()).Bind1()).Apply0()).Functor0())(Data_Either.Right.create)(a))((function () {
205− var $17 = Control_Applicative.pure(((dictMonadError.MonadThrow0()).Monad0()).Applicative0());
206− return function ($18) {
207− return $17(Data_Either.Left.create($18));
208− };
209− })());
75+
76+ // output/Control.Applicative/index.js
77+ var pure = function(dict) {
78+ return dict.pure;
79+ };
80+ var liftA1 = function(dictApplicative) {
81+ var apply2 = apply(dictApplicative.Apply0());
82+ var pure1 = pure(dictApplicative);
83+ return function(f) {
84+ return function(a) {
85+ return apply2(pure1(f))(a);
21086 };
87+ };
88+ };
89+
90+ // output/Control.Bind/index.js
91+ var discard = function(dict) {
92+ return dict.discard;
93+ };
94+ var bind = function(dict) {
95+ return dict.bind;
96+ };
97+ var bindFlipped = function(dictBind) {
98+ return flip(bind(dictBind));
99+ };
100+ var discardUnit = {
101+ discard: function(dictBind) {
102+ return bind(dictBind);
103+ }
211104 };
212− exports["MonadThrow"] = MonadThrow;
213− exports["MonadError"] = MonadError;
214− exports["try"] = $$try;
215−})(PS);
216−(function($PS) {
217− // Generated by purs version 0.13.6
218− "use strict";
219− $PS["Crypto.Subtle.Constants.AES"] = $PS["Crypto.Subtle.Constants.AES"] || {};
220− var exports = $PS["Crypto.Subtle.Constants.AES"];
105+
106+ // output/Crypto.Subtle.Constants.AES/index.js
221107 var l256 = 256;
222108 var l192 = 192;
223− var l128 = 128;
109+ var l128 = 128;
224110 var aesKW = "AES-KW";
225111 var aesGCM = "AES-GCM";
226112 var aesCTR = "AES-CTR";
227113 var aesCBC = "AES-CBC";
228− exports["aesCTR"] = aesCTR;
229− exports["aesCBC"] = aesCBC;
230− exports["aesGCM"] = aesGCM;
231− exports["aesKW"] = aesKW;
232− exports["l128"] = l128;
233− exports["l192"] = l192;
234− exports["l256"] = l256;
235−})(PS);
236−(function($PS) {
237− // Generated by purs version 0.13.6
238− "use strict";
239− $PS["Crypto.Subtle.Constants.EC"] = $PS["Crypto.Subtle.Constants.EC"] || {};
240− var exports = $PS["Crypto.Subtle.Constants.EC"];
114+
115+ // output/Crypto.Subtle.Constants.EC/index.js
241116 var p521 = "P-521";
242117 var p384 = "P-384";
243− var p256 = "P-256";
118+ var p256 = "P-256";
244119 var ecdsa = "ECDSA";
245120 var ecdh = "ECDH";
246− exports["ecdsa"] = ecdsa;
247− exports["ecdh"] = ecdh;
248− exports["p256"] = p256;
249− exports["p384"] = p384;
250− exports["p521"] = p521;
251−})(PS);
252−(function($PS) {
253− // Generated by purs version 0.13.6
254− "use strict";
255− $PS["Crypto.Subtle.Constants.RSA"] = $PS["Crypto.Subtle.Constants.RSA"] || {};
256− var exports = $PS["Crypto.Subtle.Constants.RSA"];
121+
122+ // output/Crypto.Subtle.Constants.RSA/index.js
257123 var rsaPSS = "RSA-PSS";
258124 var rsaPKCS1 = "RSASSA-PKCS1-v1_5";
259125 var rsaOAEP = "RSA-OAEP";
260− exports["rsaPKCS1"] = rsaPKCS1;
261− exports["rsaPSS"] = rsaPSS;
262− exports["rsaOAEP"] = rsaOAEP;
263−})(PS);
264−(function($PS) {
265− // Generated by purs version 0.13.6
266− "use strict";
267− $PS["Crypto.Subtle.Hash"] = $PS["Crypto.Subtle.Hash"] || {};
268− var exports = $PS["Crypto.Subtle.Hash"];
269− var sha512 = "SHA-512";
270− var sha384 = "SHA-384";
271− var sha256 = "SHA-256";
272− var sha1 = "SHA-1";
273− exports["sha1"] = sha1;
274− exports["sha256"] = sha256;
275− exports["sha384"] = sha384;
276− exports["sha512"] = sha512;
277−})(PS);
278−(function(exports) {
279− "use strict";
280126
281− exports.generateKeyImpl = function generateKeyImpl (a,e,u) {
282− return crypto.subtle.generateKey(a,e,u);
127+ // output/Control.Promise/foreign.js
128+ function thenImpl(promise2) {
129+ return function(errCB) {
130+ return function(succCB) {
131+ return function() {
132+ promise2.then(succCB, errCB);
133+ };
134+ };
135+ };
136+ }
137+
138+ // output/Data.Semigroup/index.js
139+ var append = function(dict) {
140+ return dict.append;
283141 };
284− exports.exp65537 = new Uint8Array([0x01,0x00,0x01]);
285−})(PS["Crypto.Subtle.Key.Generate"] = PS["Crypto.Subtle.Key.Generate"] || {});
286−(function(exports) {
287− "use strict";
288142
289− exports.pureE = function (a) {
290− return function () {
291− return a;
143+ // output/Data.Bounded/foreign.js
144+ var topChar = String.fromCharCode(65535);
145+ var bottomChar = String.fromCharCode(0);
146+ var topNumber = Number.POSITIVE_INFINITY;
147+ var bottomNumber = Number.NEGATIVE_INFINITY;
148+
149+ // output/Data.Either/index.js
150+ var Left = /* @__PURE__ */ function() {
151+ function Left2(value0) {
152+ this.value0 = value0;
153+ }
154+ ;
155+ Left2.create = function(value0) {
156+ return new Left2(value0);
157+ };
158+ return Left2;
159+ }();
160+ var Right = /* @__PURE__ */ function() {
161+ function Right2(value0) {
162+ this.value0 = value0;
163+ }
164+ ;
165+ Right2.create = function(value0) {
166+ return new Right2(value0);
167+ };
168+ return Right2;
169+ }();
170+ var functorEither = {
171+ map: function(f) {
172+ return function(m) {
173+ if (m instanceof Left) {
174+ return new Left(m.value0);
175+ }
176+ ;
177+ if (m instanceof Right) {
178+ return new Right(f(m.value0));
179+ }
180+ ;
181+ throw new Error("Failed pattern match at Data.Either (line 0, column 0 - line 0, column 0): " + [m.constructor.name]);
182+ };
183+ }
184+ };
185+ var either = function(v) {
186+ return function(v1) {
187+ return function(v2) {
188+ if (v2 instanceof Left) {
189+ return v(v2.value0);
190+ }
191+ ;
192+ if (v2 instanceof Right) {
193+ return v1(v2.value0);
194+ }
195+ ;
196+ throw new Error("Failed pattern match at Data.Either (line 208, column 1 - line 208, column 64): " + [v.constructor.name, v1.constructor.name, v2.constructor.name]);
197+ };
292198 };
293199 };
294200
295− exports.bindE = function (a) {
296− return function (f) {
297− return function () {
201+ // output/Effect/foreign.js
202+ var pureE = function(a) {
203+ return function() {
204+ return a;
205+ };
206+ };
207+ var bindE = function(a) {
208+ return function(f) {
209+ return function() {
298210 return f(a())();
299211 };
300212 };
301213 };
302−})(PS["Effect"] = PS["Effect"] || {});
303−(function($PS) {
304− // Generated by purs version 0.13.6
305− "use strict";
306− $PS["Effect"] = $PS["Effect"] || {};
307− var exports = $PS["Effect"];
308− var $foreign = $PS["Effect"];
309− var Control_Applicative = $PS["Control.Applicative"];
310− var Control_Apply = $PS["Control.Apply"];
311− var Control_Bind = $PS["Control.Bind"];
312− var Control_Monad = $PS["Control.Monad"];
313− var Data_Functor = $PS["Data.Functor"];
314− var monadEffect = new Control_Monad.Monad(function () {
214+
215+ // output/Control.Monad/index.js
216+ var ap = function(dictMonad) {
217+ var bind4 = bind(dictMonad.Bind1());
218+ var pure4 = pure(dictMonad.Applicative0());
219+ return function(f) {
220+ return function(a) {
221+ return bind4(f)(function(f$prime) {
222+ return bind4(a)(function(a$prime) {
223+ return pure4(f$prime(a$prime));
224+ });
225+ });
226+ };
227+ };
228+ };
229+
230+ // output/Data.Monoid/index.js
231+ var mempty = function(dict) {
232+ return dict.mempty;
233+ };
234+
235+ // output/Effect/index.js
236+ var $runtime_lazy = function(name2, moduleName, init2) {
237+ var state2 = 0;
238+ var val;
239+ return function(lineNumber) {
240+ if (state2 === 2) return val;
241+ if (state2 === 1) throw new ReferenceError(name2 + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);
242+ state2 = 1;
243+ val = init2();
244+ state2 = 2;
245+ return val;
246+ };
247+ };
248+ var monadEffect = {
249+ Applicative0: function() {
315250 return applicativeEffect;
316− }, function () {
251+ },
252+ Bind1: function() {
317253 return bindEffect;
254+ }
255+ };
256+ var bindEffect = {
257+ bind: bindE,
258+ Apply0: function() {
259+ return $lazy_applyEffect(0);
260+ }
261+ };
262+ var applicativeEffect = {
263+ pure: pureE,
264+ Apply0: function() {
265+ return $lazy_applyEffect(0);
266+ }
267+ };
268+ var $lazy_functorEffect = /* @__PURE__ */ $runtime_lazy("functorEffect", "Effect", function() {
269+ return {
270+ map: liftA1(applicativeEffect)
271+ };
272+ });
273+ var $lazy_applyEffect = /* @__PURE__ */ $runtime_lazy("applyEffect", "Effect", function() {
274+ return {
275+ apply: ap(monadEffect),
276+ Functor0: function() {
277+ return $lazy_functorEffect(0);
278+ }
279+ };
318280 });
319− var bindEffect = new Control_Bind.Bind(function () {
320− return applyEffect;
321− }, $foreign.bindE);
322− var applyEffect = new Control_Apply.Apply(function () {
323− return functorEffect;
324− }, Control_Monad.ap(monadEffect));
325− var applicativeEffect = new Control_Applicative.Applicative(function () {
326− return applyEffect;
327− }, $foreign.pureE);
328− var functorEffect = new Data_Functor.Functor(Control_Applicative.liftA1(applicativeEffect));
329− exports["functorEffect"] = functorEffect;
330− exports["applicativeEffect"] = applicativeEffect;
331−})(PS);
332−(function(exports) {
333− /* globals setImmediate, clearImmediate, setTimeout, clearTimeout */
334− /* jshint -W083, -W098, -W003 */
335− "use strict";
281+ var functorEffect = /* @__PURE__ */ $lazy_functorEffect(20);
282+
283+ // output/Effect.Exception/foreign.js
284+ function error(msg) {
285+ return new Error(msg);
286+ }
287+ function throwException(e) {
288+ return function() {
289+ throw e;
290+ };
291+ }
336292
337− var Aff = function () {
338− // A unique value for empty.
339− var EMPTY = {};
293+ // output/Control.Monad.Error.Class/index.js
294+ var throwError = function(dict) {
295+ return dict.throwError;
296+ };
297+ var catchError = function(dict) {
298+ return dict.catchError;
299+ };
300+ var $$try = function(dictMonadError) {
301+ var catchError1 = catchError(dictMonadError);
302+ var Monad0 = dictMonadError.MonadThrow0().Monad0();
303+ var map3 = map(Monad0.Bind1().Apply0().Functor0());
304+ var pure4 = pure(Monad0.Applicative0());
305+ return function(a) {
306+ return catchError1(map3(Right.create)(a))(function($52) {
307+ return pure4(Left.create($52));
308+ });
309+ };
310+ };
340311
341− /*
312+ // output/Data.Identity/index.js
313+ var Identity = function(x) {
314+ return x;
315+ };
316+ var functorIdentity = {
317+ map: function(f) {
318+ return function(m) {
319+ return f(m);
320+ };
321+ }
322+ };
323+ var applyIdentity = {
324+ apply: function(v) {
325+ return function(v1) {
326+ return v(v1);
327+ };
328+ },
329+ Functor0: function() {
330+ return functorIdentity;
331+ }
332+ };
333+ var bindIdentity = {
334+ bind: function(v) {
335+ return function(f) {
336+ return f(v);
337+ };
338+ },
339+ Apply0: function() {
340+ return applyIdentity;
341+ }
342+ };
343+ var applicativeIdentity = {
344+ pure: Identity,
345+ Apply0: function() {
346+ return applyIdentity;
347+ }
348+ };
349+ var monadIdentity = {
350+ Applicative0: function() {
351+ return applicativeIdentity;
352+ },
353+ Bind1: function() {
354+ return bindIdentity;
355+ }
356+ };
342357
343− An awkward approximation. We elide evidence we would otherwise need in PS for
344− efficiency sake.
358+ // output/Unsafe.Coerce/foreign.js
359+ var unsafeCoerce2 = function(x) {
360+ return x;
361+ };
345362
346− data Aff eff a
347− = Pure a
348− | Throw Error
349− | Catch (Aff eff a) (Error -> Aff eff a)
350− | Sync (Eff eff a)
351− | Async ((Either Error a -> Eff eff Unit) -> Eff eff (Canceler eff))
352− | forall b. Bind (Aff eff b) (b -> Aff eff a)
353− | forall b. Bracket (Aff eff b) (BracketConditions eff b) (b -> Aff eff a)
354− | forall b. Fork Boolean (Aff eff b) ?(Fiber eff b -> a)
355− | Sequential (ParAff aff a)
363+ // output/Effect.Class/index.js
364+ var liftEffect = function(dict) {
365+ return dict.liftEffect;
366+ };
356367
357− */
358− var PURE = "Pure";
359− var THROW = "Throw";
360− var CATCH = "Catch";
361− var SYNC = "Sync";
362− var ASYNC = "Async";
363− var BIND = "Bind";
364− var BRACKET = "Bracket";
365− var FORK = "Fork";
366− var SEQ = "Sequential";
368+ // output/Control.Monad.Except.Trans/index.js
369+ var map2 = /* @__PURE__ */ map(functorEither);
370+ var ExceptT = function(x) {
371+ return x;
372+ };
373+ var runExceptT = function(v) {
374+ return v;
375+ };
376+ var mapExceptT = function(f) {
377+ return function(v) {
378+ return f(v);
379+ };
380+ };
381+ var functorExceptT = function(dictFunctor) {
382+ var map1 = map(dictFunctor);
383+ return {
384+ map: function(f) {
385+ return mapExceptT(map1(map2(f)));
386+ }
387+ };
388+ };
389+ var monadExceptT = function(dictMonad) {
390+ return {
391+ Applicative0: function() {
392+ return applicativeExceptT(dictMonad);
393+ },
394+ Bind1: function() {
395+ return bindExceptT(dictMonad);
396+ }
397+ };
398+ };
399+ var bindExceptT = function(dictMonad) {
400+ var bind4 = bind(dictMonad.Bind1());
401+ var pure4 = pure(dictMonad.Applicative0());
402+ return {
403+ bind: function(v) {
404+ return function(k) {
405+ return bind4(v)(either(function($193) {
406+ return pure4(Left.create($193));
407+ })(function(a) {
408+ var v1 = k(a);
409+ return v1;
410+ }));
411+ };
412+ },
413+ Apply0: function() {
414+ return applyExceptT(dictMonad);
415+ }
416+ };
417+ };
418+ var applyExceptT = function(dictMonad) {
419+ var functorExceptT1 = functorExceptT(dictMonad.Bind1().Apply0().Functor0());
420+ return {
421+ apply: ap(monadExceptT(dictMonad)),
422+ Functor0: function() {
423+ return functorExceptT1;
424+ }
425+ };
426+ };
427+ var applicativeExceptT = function(dictMonad) {
428+ return {
429+ pure: function() {
430+ var $194 = pure(dictMonad.Applicative0());
431+ return function($195) {
432+ return ExceptT($194(Right.create($195)));
433+ };
434+ }(),
435+ Apply0: function() {
436+ return applyExceptT(dictMonad);
437+ }
438+ };
439+ };
440+ var monadThrowExceptT = function(dictMonad) {
441+ var monadExceptT1 = monadExceptT(dictMonad);
442+ return {
443+ throwError: function() {
444+ var $204 = pure(dictMonad.Applicative0());
445+ return function($205) {
446+ return ExceptT($204(Left.create($205)));
447+ };
448+ }(),
449+ Monad0: function() {
450+ return monadExceptT1;
451+ }
452+ };
453+ };
454+
455+ // output/Safe.Coerce/index.js
456+ var coerce = function() {
457+ return unsafeCoerce2;
458+ };
367459
368− /*
460+ // output/Data.Newtype/index.js
461+ var coerce2 = /* @__PURE__ */ coerce();
462+ var unwrap = function() {
463+ return coerce2;
464+ };
369465
370− data ParAff eff a
371− = forall b. Map (b -> a) (ParAff eff b)
372− | forall b. Apply (ParAff eff (b -> a)) (ParAff eff b)
373− | Alt (ParAff eff a) (ParAff eff a)
374− | ?Par (Aff eff a)
466+ // output/Control.Monad.Except/index.js
467+ var unwrap2 = /* @__PURE__ */ unwrap();
468+ var runExcept = function($3) {
469+ return unwrap2(runExceptT($3));
470+ };
375471
376− */
377− var MAP = "Map";
378− var APPLY = "Apply";
379− var ALT = "Alt";
472+ // output/Data.Foldable/foreign.js
473+ var foldrArray = function(f) {
474+ return function(init2) {
475+ return function(xs) {
476+ var acc = init2;
477+ var len = xs.length;
478+ for (var i = len - 1; i >= 0; i--) {
479+ acc = f(xs[i])(acc);
480+ }
481+ return acc;
482+ };
483+ };
484+ };
485+ var foldlArray = function(f) {
486+ return function(init2) {
487+ return function(xs) {
488+ var acc = init2;
489+ var len = xs.length;
490+ for (var i = 0; i < len; i++) {
491+ acc = f(acc)(xs[i]);
492+ }
493+ return acc;
494+ };
495+ };
496+ };
380497
381− // Various constructors used in interpretation
382− var CONS = "Cons"; // Cons-list, for stacks
383− var RESUME = "Resume"; // Continue indiscriminately
384− var RELEASE = "Release"; // Continue with bracket finalizers
385− var FINALIZER = "Finalizer"; // A non-interruptible effect
386− var FINALIZED = "Finalized"; // Marker for finalization
387− var FORKED = "Forked"; // Reference to a forked fiber, with resumption stack
388− var FIBER = "Fiber"; // Actual fiber reference
389− var THUNK = "Thunk"; // Primed effect, ready to invoke
498+ // output/Control.Plus/index.js
499+ var empty = function(dict) {
500+ return dict.empty;
501+ };
390502
391− function Aff(tag, _1, _2, _3) {
392− this.tag = tag;
393− this._1 = _1;
394− this._2 = _2;
395− this._3 = _3;
503+ // output/Data.Foldable/index.js
504+ var foldr = function(dict) {
505+ return dict.foldr;
506+ };
507+ var traverse_ = function(dictApplicative) {
508+ var applySecond2 = applySecond(dictApplicative.Apply0());
509+ var pure4 = pure(dictApplicative);
510+ return function(dictFoldable) {
511+ var foldr22 = foldr(dictFoldable);
512+ return function(f) {
513+ return foldr22(function($454) {
514+ return applySecond2(f($454));
515+ })(pure4(unit));
516+ };
517+ };
518+ };
519+ var foldl = function(dict) {
520+ return dict.foldl;
521+ };
522+ var foldMapDefaultR = function(dictFoldable) {
523+ var foldr22 = foldr(dictFoldable);
524+ return function(dictMonoid) {
525+ var append2 = append(dictMonoid.Semigroup0());
526+ var mempty3 = mempty(dictMonoid);
527+ return function(f) {
528+ return foldr22(function(x) {
529+ return function(acc) {
530+ return append2(f(x))(acc);
531+ };
532+ })(mempty3);
533+ };
534+ };
535+ };
536+ var foldableArray = {
537+ foldr: foldrArray,
538+ foldl: foldlArray,
539+ foldMap: function(dictMonoid) {
540+ return foldMapDefaultR(foldableArray)(dictMonoid);
541+ }
542+ };
543+
544+ // output/Data.NonEmpty/index.js
545+ var NonEmpty = /* @__PURE__ */ function() {
546+ function NonEmpty2(value0, value1) {
547+ this.value0 = value0;
548+ this.value1 = value1;
549+ }
550+ ;
551+ NonEmpty2.create = function(value0) {
552+ return function(value1) {
553+ return new NonEmpty2(value0, value1);
554+ };
555+ };
556+ return NonEmpty2;
557+ }();
558+ var singleton2 = function(dictPlus) {
559+ var empty2 = empty(dictPlus);
560+ return function(a) {
561+ return new NonEmpty(a, empty2);
562+ };
563+ };
564+
565+ // output/Data.List.Types/index.js
566+ var Nil = /* @__PURE__ */ function() {
567+ function Nil2() {
568+ }
569+ ;
570+ Nil2.value = new Nil2();
571+ return Nil2;
572+ }();
573+ var Cons = /* @__PURE__ */ function() {
574+ function Cons2(value0, value1) {
575+ this.value0 = value0;
576+ this.value1 = value1;
577+ }
578+ ;
579+ Cons2.create = function(value0) {
580+ return function(value1) {
581+ return new Cons2(value0, value1);
582+ };
583+ };
584+ return Cons2;
585+ }();
586+ var NonEmptyList = function(x) {
587+ return x;
588+ };
589+ var listMap = function(f) {
590+ var chunkedRevMap = function($copy_v) {
591+ return function($copy_v1) {
592+ var $tco_var_v = $copy_v;
593+ var $tco_done = false;
594+ var $tco_result;
595+ function $tco_loop(v, v1) {
596+ if (v1 instanceof Cons && (v1.value1 instanceof Cons && v1.value1.value1 instanceof Cons)) {
597+ $tco_var_v = new Cons(v1, v);
598+ $copy_v1 = v1.value1.value1.value1;
599+ return;
600+ }
601+ ;
602+ var unrolledMap = function(v2) {
603+ if (v2 instanceof Cons && (v2.value1 instanceof Cons && v2.value1.value1 instanceof Nil)) {
604+ return new Cons(f(v2.value0), new Cons(f(v2.value1.value0), Nil.value));
605+ }
606+ ;
607+ if (v2 instanceof Cons && v2.value1 instanceof Nil) {
608+ return new Cons(f(v2.value0), Nil.value);
609+ }
610+ ;
611+ return Nil.value;
612+ };
613+ var reverseUnrolledMap = function($copy_v2) {
614+ return function($copy_v3) {
615+ var $tco_var_v2 = $copy_v2;
616+ var $tco_done1 = false;
617+ var $tco_result2;
618+ function $tco_loop2(v2, v3) {
619+ if (v2 instanceof Cons && (v2.value0 instanceof Cons && (v2.value0.value1 instanceof Cons && v2.value0.value1.value1 instanceof Cons))) {
620+ $tco_var_v2 = v2.value1;
621+ $copy_v3 = new Cons(f(v2.value0.value0), new Cons(f(v2.value0.value1.value0), new Cons(f(v2.value0.value1.value1.value0), v3)));
622+ return;
623+ }
624+ ;
625+ $tco_done1 = true;
626+ return v3;
627+ }
628+ ;
629+ while (!$tco_done1) {
630+ $tco_result2 = $tco_loop2($tco_var_v2, $copy_v3);
631+ }
632+ ;
633+ return $tco_result2;
634+ };
635+ };
636+ $tco_done = true;
637+ return reverseUnrolledMap(v)(unrolledMap(v1));
638+ }
639+ ;
640+ while (!$tco_done) {
641+ $tco_result = $tco_loop($tco_var_v, $copy_v1);
642+ }
643+ ;
644+ return $tco_result;
645+ };
646+ };
647+ return chunkedRevMap(Nil.value);
648+ };
649+ var functorList = {
650+ map: listMap
651+ };
652+ var foldableList = {
653+ foldr: function(f) {
654+ return function(b) {
655+ var rev = function() {
656+ var go = function($copy_v) {
657+ return function($copy_v1) {
658+ var $tco_var_v = $copy_v;
659+ var $tco_done = false;
660+ var $tco_result;
661+ function $tco_loop(v, v1) {
662+ if (v1 instanceof Nil) {
663+ $tco_done = true;
664+ return v;
665+ }
666+ ;
667+ if (v1 instanceof Cons) {
668+ $tco_var_v = new Cons(v1.value0, v);
669+ $copy_v1 = v1.value1;
670+ return;
671+ }
672+ ;
673+ throw new Error("Failed pattern match at Data.List.Types (line 107, column 7 - line 107, column 23): " + [v.constructor.name, v1.constructor.name]);
674+ }
675+ ;
676+ while (!$tco_done) {
677+ $tco_result = $tco_loop($tco_var_v, $copy_v1);
678+ }
679+ ;
680+ return $tco_result;
681+ };
682+ };
683+ return go(Nil.value);
684+ }();
685+ var $284 = foldl(foldableList)(flip(f))(b);
686+ return function($285) {
687+ return $284(rev($285));
688+ };
689+ };
690+ },
691+ foldl: function(f) {
692+ var go = function($copy_b) {
693+ return function($copy_v) {
694+ var $tco_var_b = $copy_b;
695+ var $tco_done1 = false;
696+ var $tco_result;
697+ function $tco_loop(b, v) {
698+ if (v instanceof Nil) {
699+ $tco_done1 = true;
700+ return b;
701+ }
702+ ;
703+ if (v instanceof Cons) {
704+ $tco_var_b = f(b)(v.value0);
705+ $copy_v = v.value1;
706+ return;
707+ }
708+ ;
709+ throw new Error("Failed pattern match at Data.List.Types (line 111, column 12 - line 113, column 30): " + [v.constructor.name]);
710+ }
711+ ;
712+ while (!$tco_done1) {
713+ $tco_result = $tco_loop($tco_var_b, $copy_v);
714+ }
715+ ;
716+ return $tco_result;
717+ };
718+ };
719+ return go;
720+ },
721+ foldMap: function(dictMonoid) {
722+ var append2 = append(dictMonoid.Semigroup0());
723+ var mempty3 = mempty(dictMonoid);
724+ return function(f) {
725+ return foldl(foldableList)(function(acc) {
726+ var $286 = append2(acc);
727+ return function($287) {
728+ return $286(f($287));
729+ };
730+ })(mempty3);
731+ };
732+ }
733+ };
734+ var foldr2 = /* @__PURE__ */ foldr(foldableList);
735+ var semigroupList = {
736+ append: function(xs) {
737+ return function(ys) {
738+ return foldr2(Cons.create)(ys)(xs);
739+ };
396740 }
741+ };
742+ var append1 = /* @__PURE__ */ append(semigroupList);
743+ var altList = {
744+ alt: append1,
745+ Functor0: function() {
746+ return functorList;
747+ }
748+ };
749+ var plusList = /* @__PURE__ */ function() {
750+ return {
751+ empty: Nil.value,
752+ Alt0: function() {
753+ return altList;
754+ }
755+ };
756+ }();
397757
758+ // output/Effect.Aff/foreign.js
759+ var Aff = function() {
760+ var EMPTY = {};
761+ var PURE = "Pure";
762+ var THROW = "Throw";
763+ var CATCH = "Catch";
764+ var SYNC = "Sync";
765+ var ASYNC = "Async";
766+ var BIND = "Bind";
767+ var BRACKET = "Bracket";
768+ var FORK = "Fork";
769+ var SEQ = "Sequential";
770+ var MAP = "Map";
771+ var APPLY = "Apply";
772+ var ALT = "Alt";
773+ var CONS = "Cons";
774+ var RESUME = "Resume";
775+ var RELEASE = "Release";
776+ var FINALIZER = "Finalizer";
777+ var FINALIZED = "Finalized";
778+ var FORKED = "Forked";
779+ var FIBER = "Fiber";
780+ var THUNK = "Thunk";
781+ function Aff2(tag, _1, _2, _3) {
782+ this.tag = tag;
783+ this._1 = _1;
784+ this._2 = _2;
785+ this._3 = _3;
786+ }
398787 function AffCtr(tag) {
399− var fn = function (_1, _2, _3) {
400− return new Aff(tag, _1, _2, _3);
788+ var fn = function(_1, _2, _3) {
789+ return new Aff2(tag, _1, _2, _3);
401790 };
402791 fn.tag = tag;
403792 return fn;
404793 }
405−
406− function nonCanceler(error) {
407− return new Aff(PURE, void 0);
794+ function nonCanceler2(error3) {
795+ return new Aff2(PURE, void 0);
408796 }
409−
410797 function runEff(eff) {
411798 try {
412799 eff();
413− } catch (error) {
414− setTimeout(function () {
415− throw error;
800+ } catch (error3) {
801+ setTimeout(function() {
802+ throw error3;
416803 }, 0);
417804 }
418805 }
419−
420806 function runSync(left, right, eff) {
421807 try {
422808 return right(eff());
423− } catch (error) {
424− return left(error);
809+ } catch (error3) {
810+ return left(error3);
425811 }
426812 }
427−
428813 function runAsync(left, eff, k) {
429814 try {
430815 return eff(k)();
431− } catch (error) {
432− k(left(error))();
433− return nonCanceler;
816+ } catch (error3) {
817+ k(left(error3))();
818+ return nonCanceler2;
434819 }
435820 }
436−
437− var Scheduler = function () {
438− var limit = 1024;
439− var size = 0;
440− var ix = 0;
441− var queue = new Array(limit);
821+ var Scheduler = function() {
822+ var limit = 1024;
823+ var size = 0;
824+ var ix = 0;
825+ var queue = new Array(limit);
442826 var draining = false;
443−
444827 function drain() {
445828 var thunk;
446829 draining = true;
447830 while (size !== 0) {
448831 size--;
449− thunk = queue[ix];
832+ thunk = queue[ix];
450833 queue[ix] = void 0;
451− ix = (ix + 1) % limit;
834+ ix = (ix + 1) % limit;
452835 thunk();
453836 }
454837 draining = false;
455838 }
456−
457839 return {
458− isDraining: function () {
840+ isDraining: function() {
459841 return draining;
460842 },
461− enqueue: function (cb) {
843+ enqueue: function(cb) {
462844 var i, tmp;
463845 if (size === limit) {
464846 tmp = draining;
465847 drain();
466848 draining = tmp;
467849 }
468−
469850 queue[(ix + size) % limit] = cb;
470851 size++;
471−
472852 if (!draining) {
473853 drain();
474854 }
475855 }
476856 };
477857 }();
478−
479858 function Supervisor(util) {
480− var fibers = {};
859+ var fibers = {};
481860 var fiberId = 0;
482− var count = 0;
483−
861+ var count = 0;
484862 return {
485− register: function (fiber) {
863+ register: function(fiber) {
486864 var fid = fiberId++;
487865 fiber.onComplete({
488866 rethrow: true,
489− handler: function (result) {
490− return function () {
867+ handler: function(result) {
868+ return function() {
491869 count--;
492870 delete fibers[fid];
493871 };
@@ -496,25 +874,23 @@ var PS = {};
496874 fibers[fid] = fiber;
497875 count++;
498876 },
499− isEmpty: function () {
877+ isEmpty: function() {
500878 return count === 0;
501879 },
502− killAll: function (killError, cb) {
503− return function () {
880+ killAll: function(killError, cb) {
881+ return function() {
504882 if (count === 0) {
505883 return cb();
506884 }
507−
508885 var killCount = 0;
509− var kills = {};
510−
886+ var kills = {};
511887 function kill(fid) {
512− kills[fid] = fibers[fid].kill(killError, function (result) {
513− return function () {
888+ kills[fid] = fibers[fid].kill(killError, function(result) {
889+ return function() {
514890 delete kills[fid];
515891 killCount--;
516892 if (util.isLeft(result) && util.fromLeft(result)) {
517− setTimeout(function () {
893+ setTimeout(function() {
518894 throw util.fromLeft(result);
519895 }, 0);
520896 }
@@ -524,23 +900,20 @@ var PS = {};
524900 };
525901 })();
526902 }
527−
528903 for (var k in fibers) {
529904 if (fibers.hasOwnProperty(k)) {
530905 killCount++;
531906 kill(k);
532907 }
533908 }
534−
535− fibers = {};
909+ fibers = {};
536910 fiberId = 0;
537− count = 0;
538−
539− return function (error) {
540− return new Aff(SYNC, function () {
541− for (var k in kills) {
542− if (kills.hasOwnProperty(k)) {
543− kills[k]();
911+ count = 0;
912+ return function(error3) {
913+ return new Aff2(SYNC, function() {
914+ for (var k2 in kills) {
915+ if (kills.hasOwnProperty(k2)) {
916+ kills[k2]();
544917 }
545918 }
546919 });
@@ -549,343 +922,270 @@ var PS = {};
549922 }
550923 };
551924 }
552−
553− // Fiber state machine
554− var SUSPENDED = 0; // Suspended, pending a join.
555− var CONTINUE = 1; // Interpret the next instruction.
556− var STEP_BIND = 2; // Apply the next bind.
557− var STEP_RESULT = 3; // Handle potential failure from a result.
558− var PENDING = 4; // An async effect is running.
559− var RETURN = 5; // The current stack has returned.
560− var COMPLETED = 6; // The entire fiber has completed.
561−
925+ var SUSPENDED = 0;
926+ var CONTINUE = 1;
927+ var STEP_BIND = 2;
928+ var STEP_RESULT = 3;
929+ var PENDING = 4;
930+ var RETURN = 5;
931+ var COMPLETED = 6;
562932 function Fiber(util, supervisor, aff) {
563− // Monotonically increasing tick, increased on each asynchronous turn.
564933 var runTick = 0;
565−
566− // The current branch of the state machine.
567934 var status = SUSPENDED;
568−
569− // The current point of interest for the state machine branch.
570− var step = aff; // Successful step
571− var fail = null; // Failure step
572− var interrupt = null; // Asynchronous interrupt
573−
574− // Stack of continuations for the current fiber.
935+ var step = aff;
936+ var fail2 = null;
937+ var interrupt = null;
575938 var bhead = null;
576939 var btail = null;
577−
578− // Stack of attempts and finalizers for error recovery. Every `Cons` is also
579− // tagged with current `interrupt` state. We use this to track which items
580− // should be ignored or evaluated as a result of a kill.
581940 var attempts = null;
582−
583− // A special state is needed for Bracket, because it cannot be killed. When
584− // we enter a bracket acquisition or finalizer, we increment the counter,
585− // and then decrement once complete.
586941 var bracketCount = 0;
587−
588− // Each join gets a new id so they can be revoked.
589− var joinId = 0;
590− var joins = null;
942+ var joinId = 0;
943+ var joins = null;
591944 var rethrow = true;
592−
593− // Each invocation of `run` requires a tick. When an asynchronous effect is
594− // resolved, we must check that the local tick coincides with the fiber
595− // tick before resuming. This prevents multiple async continuations from
596− // accidentally resuming the same fiber. A common example may be invoking
597− // the provided callback in `makeAff` more than once, but it may also be an
598− // async effect resuming after the fiber was already cancelled.
599− function run(localRunTick) {
945+ function run2(localRunTick) {
600946 var tmp, result, attempt;
601947 while (true) {
602− tmp = null;
603− result = null;
604− attempt = null;
605−
948+ tmp = null;
949+ result = null;
950+ attempt = null;
606951 switch (status) {
607− case STEP_BIND:
608− status = CONTINUE;
609− try {
610− step = bhead(step);
611− if (btail === null) {
612− bhead = null;
613− } else {
614− bhead = btail._1;
615− btail = btail._2;
616− }
617− } catch (e) {
618− status = RETURN;
619− fail = util.left(e);
620− step = null;
621− }
622− break;
623−
624− case STEP_RESULT:
625− if (util.isLeft(step)) {
626− status = RETURN;
627− fail = step;
628− step = null;
629− } else if (bhead === null) {
630− status = RETURN;
631− } else {
632− status = STEP_BIND;
633− step = util.fromRight(step);
634− }
635− break;
636−
637− case CONTINUE:
638− switch (step.tag) {
639− case BIND:
640− if (bhead) {
641− btail = new Aff(CONS, bhead, btail);
642− }
643− bhead = step._2;
952+ case STEP_BIND:
644953 status = CONTINUE;
645− step = step._1;
954+ try {
955+ step = bhead(step);
956+ if (btail === null) {
957+ bhead = null;
958+ } else {
959+ bhead = btail._1;
960+ btail = btail._2;
961+ }
962+ } catch (e) {
963+ status = RETURN;
964+ fail2 = util.left(e);
965+ step = null;
966+ }
646967 break;
647−
648− case PURE:
649− if (bhead === null) {
968+ case STEP_RESULT:
969+ if (util.isLeft(step)) {
970+ status = RETURN;
971+ fail2 = step;
972+ step = null;
973+ } else if (bhead === null) {
650974 status = RETURN;
651− step = util.right(step._1);
652975 } else {
653976 status = STEP_BIND;
654− step = step._1;
977+ step = util.fromRight(step);
655978 }
656979 break;
657−
658− case SYNC:
659− status = STEP_RESULT;
660− step = runSync(util.left, util.right, step._1);
661− break;
662−
663− case ASYNC:
664− status = PENDING;
665− step = runAsync(util.left, step._1, function (result) {
666− return function () {
667− if (runTick !== localRunTick) {
668− return;
980+ case CONTINUE:
981+ switch (step.tag) {
982+ case BIND:
983+ if (bhead) {
984+ btail = new Aff2(CONS, bhead, btail);
669985 }
670− runTick++;
671− Scheduler.enqueue(function () {
672− // It's possible to interrupt the fiber between enqueuing and
673− // resuming, so we need to check that the runTick is still
674− // valid.
675− if (runTick !== localRunTick + 1) {
676− return;
677− }
678− status = STEP_RESULT;
679− step = result;
680− run(runTick);
986+ bhead = step._2;
987+ status = CONTINUE;
988+ step = step._1;
989+ break;
990+ case PURE:
991+ if (bhead === null) {
992+ status = RETURN;
993+ step = util.right(step._1);
994+ } else {
995+ status = STEP_BIND;
996+ step = step._1;
997+ }
998+ break;
999+ case SYNC:
1000+ status = STEP_RESULT;
1001+ step = runSync(util.left, util.right, step._1);
1002+ break;
1003+ case ASYNC:
1004+ status = PENDING;
1005+ step = runAsync(util.left, step._1, function(result2) {
1006+ return function() {
1007+ if (runTick !== localRunTick) {
1008+ return;
1009+ }
1010+ runTick++;
1011+ Scheduler.enqueue(function() {
1012+ if (runTick !== localRunTick + 1) {
1013+ return;
1014+ }
1015+ status = STEP_RESULT;
1016+ step = result2;
1017+ run2(runTick);
1018+ });
1019+ };
6811020 });
682− };
683− });
684− return;
685−
686− case THROW:
687− status = RETURN;
688− fail = util.left(step._1);
689− step = null;
690− break;
691−
692− // Enqueue the Catch so that we can call the error handler later on
693− // in case of an exception.
694− case CATCH:
695− if (bhead === null) {
696− attempts = new Aff(CONS, step, attempts, interrupt);
697− } else {
698− attempts = new Aff(CONS, step, new Aff(CONS, new Aff(RESUME, bhead, btail), attempts, interrupt), interrupt);
1021+ return;
1022+ case THROW:
1023+ status = RETURN;
1024+ fail2 = util.left(step._1);
1025+ step = null;
1026+ break;
1027+ // Enqueue the Catch so that we can call the error handler later on
1028+ // in case of an exception.
1029+ case CATCH:
1030+ if (bhead === null) {
1031+ attempts = new Aff2(CONS, step, attempts, interrupt);
1032+ } else {
1033+ attempts = new Aff2(CONS, step, new Aff2(CONS, new Aff2(RESUME, bhead, btail), attempts, interrupt), interrupt);
1034+ }
1035+ bhead = null;
1036+ btail = null;
1037+ status = CONTINUE;
1038+ step = step._1;
1039+ break;
1040+ // Enqueue the Bracket so that we can call the appropriate handlers
1041+ // after resource acquisition.
1042+ case BRACKET:
1043+ bracketCount++;
1044+ if (bhead === null) {
1045+ attempts = new Aff2(CONS, step, attempts, interrupt);
1046+ } else {
1047+ attempts = new Aff2(CONS, step, new Aff2(CONS, new Aff2(RESUME, bhead, btail), attempts, interrupt), interrupt);
1048+ }
1049+ bhead = null;
1050+ btail = null;
1051+ status = CONTINUE;
1052+ step = step._1;
1053+ break;
1054+ case FORK:
1055+ status = STEP_RESULT;
1056+ tmp = Fiber(util, supervisor, step._2);
1057+ if (supervisor) {
1058+ supervisor.register(tmp);
1059+ }
1060+ if (step._1) {
1061+ tmp.run();
1062+ }
1063+ step = util.right(tmp);
1064+ break;
1065+ case SEQ:
1066+ status = CONTINUE;
1067+ step = sequential2(util, supervisor, step._1);
1068+ break;
6991069 }
700− bhead = null;
701− btail = null;
702− status = CONTINUE;
703− step = step._1;
7041070 break;
705−
706− // Enqueue the Bracket so that we can call the appropriate handlers
707− // after resource acquisition.
708− case BRACKET:
709− bracketCount++;
710− if (bhead === null) {
711− attempts = new Aff(CONS, step, attempts, interrupt);
1071+ case RETURN:
1072+ bhead = null;
1073+ btail = null;
1074+ if (attempts === null) {
1075+ status = COMPLETED;
1076+ step = interrupt || fail2 || step;
7121077 } else {
713− attempts = new Aff(CONS, step, new Aff(CONS, new Aff(RESUME, bhead, btail), attempts, interrupt), interrupt);
1078+ tmp = attempts._3;
1079+ attempt = attempts._1;
1080+ attempts = attempts._2;
1081+ switch (attempt.tag) {
1082+ // We cannot recover from an unmasked interrupt. Otherwise we should
1083+ // continue stepping, or run the exception handler if an exception
1084+ // was raised.
1085+ case CATCH:
1086+ if (interrupt && interrupt !== tmp && bracketCount === 0) {
1087+ status = RETURN;
1088+ } else if (fail2) {
1089+ status = CONTINUE;
1090+ step = attempt._2(util.fromLeft(fail2));
1091+ fail2 = null;
1092+ }
1093+ break;
1094+ // We cannot resume from an unmasked interrupt or exception.
1095+ case RESUME:
1096+ if (interrupt && interrupt !== tmp && bracketCount === 0 || fail2) {
1097+ status = RETURN;
1098+ } else {
1099+ bhead = attempt._1;
1100+ btail = attempt._2;
1101+ status = STEP_BIND;
1102+ step = util.fromRight(step);
1103+ }
1104+ break;
1105+ // If we have a bracket, we should enqueue the handlers,
1106+ // and continue with the success branch only if the fiber has
1107+ // not been interrupted. If the bracket acquisition failed, we
1108+ // should not run either.
1109+ case BRACKET:
1110+ bracketCount--;
1111+ if (fail2 === null) {
1112+ result = util.fromRight(step);
1113+ attempts = new Aff2(CONS, new Aff2(RELEASE, attempt._2, result), attempts, tmp);
1114+ if (interrupt === tmp || bracketCount > 0) {
1115+ status = CONTINUE;
1116+ step = attempt._3(result);
1117+ }
1118+ }
1119+ break;
1120+ // Enqueue the appropriate handler. We increase the bracket count
1121+ // because it should not be cancelled.
1122+ case RELEASE:
1123+ attempts = new Aff2(CONS, new Aff2(FINALIZED, step, fail2), attempts, interrupt);
1124+ status = CONTINUE;
1125+ if (interrupt && interrupt !== tmp && bracketCount === 0) {
1126+ step = attempt._1.killed(util.fromLeft(interrupt))(attempt._2);
1127+ } else if (fail2) {
1128+ step = attempt._1.failed(util.fromLeft(fail2))(attempt._2);
1129+ } else {
1130+ step = attempt._1.completed(util.fromRight(step))(attempt._2);
1131+ }
1132+ fail2 = null;
1133+ bracketCount++;
1134+ break;
1135+ case FINALIZER:
1136+ bracketCount++;
1137+ attempts = new Aff2(CONS, new Aff2(FINALIZED, step, fail2), attempts, interrupt);
1138+ status = CONTINUE;
1139+ step = attempt._1;
1140+ break;
1141+ case FINALIZED:
1142+ bracketCount--;
1143+ status = RETURN;
1144+ step = attempt._1;
1145+ fail2 = attempt._2;
1146+ break;
1147+ }
7141148 }
715− bhead = null;
716− btail = null;
717− status = CONTINUE;
718− step = step._1;
7191149 break;
720−
721− case FORK:
722− status = STEP_RESULT;
723− tmp = Fiber(util, supervisor, step._2);
724− if (supervisor) {
725− supervisor.register(tmp);
1150+ case COMPLETED:
1151+ for (var k in joins) {
1152+ if (joins.hasOwnProperty(k)) {
1153+ rethrow = rethrow && joins[k].rethrow;
1154+ runEff(joins[k].handler(step));
1155+ }
7261156 }
727− if (step._1) {
728− tmp.run();
1157+ joins = null;
1158+ if (interrupt && fail2) {
1159+ setTimeout(function() {
1160+ throw util.fromLeft(fail2);
1161+ }, 0);
1162+ } else if (util.isLeft(step) && rethrow) {
1163+ setTimeout(function() {
1164+ if (rethrow) {
1165+ throw util.fromLeft(step);
1166+ }
1167+ }, 0);
7291168 }
730− step = util.right(tmp);
731− break;
732−
733− case SEQ:
1169+ return;
1170+ case SUSPENDED:
7341171 status = CONTINUE;
735− step = sequential(util, supervisor, step._1);
7361172 break;
737− }
738− break;
739−
740− case RETURN:
741− bhead = null;
742− btail = null;
743− // If the current stack has returned, and we have no other stacks to
744− // resume or finalizers to run, the fiber has halted and we can
745− // invoke all join callbacks. Otherwise we need to resume.
746− if (attempts === null) {
747− status = COMPLETED;
748− step = interrupt || fail || step;
749− } else {
750− // The interrupt status for the enqueued item.
751− tmp = attempts._3;
752− attempt = attempts._1;
753− attempts = attempts._2;
754−
755− switch (attempt.tag) {
756− // We cannot recover from an unmasked interrupt. Otherwise we should
757− // continue stepping, or run the exception handler if an exception
758− // was raised.
759− case CATCH:
760− // We should compare the interrupt status as well because we
761− // only want it to apply if there has been an interrupt since
762− // enqueuing the catch.
763− if (interrupt && interrupt !== tmp && bracketCount === 0) {
764− status = RETURN;
765− } else if (fail) {
766− status = CONTINUE;
767− step = attempt._2(util.fromLeft(fail));
768− fail = null;
769− }
770− break;
771−
772− // We cannot resume from an unmasked interrupt or exception.
773− case RESUME:
774− // As with Catch, we only want to ignore in the case of an
775− // interrupt since enqueing the item.
776− if (interrupt && interrupt !== tmp && bracketCount === 0 || fail) {
777− status = RETURN;
778− } else {
779− bhead = attempt._1;
780− btail = attempt._2;
781− status = STEP_BIND;
782− step = util.fromRight(step);
783− }
784− break;
785−
786− // If we have a bracket, we should enqueue the handlers,
787− // and continue with the success branch only if the fiber has
788− // not been interrupted. If the bracket acquisition failed, we
789− // should not run either.
790− case BRACKET:
791− bracketCount--;
792− if (fail === null) {
793− result = util.fromRight(step);
794− // We need to enqueue the Release with the same interrupt
795− // status as the Bracket that is initiating it.
796− attempts = new Aff(CONS, new Aff(RELEASE, attempt._2, result), attempts, tmp);
797− // We should only coninue as long as the interrupt status has not changed or
798− // we are currently within a non-interruptable finalizer.
799− if (interrupt === tmp || bracketCount > 0) {
800− status = CONTINUE;
801− step = attempt._3(result);
802− }
803− }
804− break;
805−
806− // Enqueue the appropriate handler. We increase the bracket count
807− // because it should not be cancelled.
808− case RELEASE:
809− attempts = new Aff(CONS, new Aff(FINALIZED, step, fail), attempts, interrupt);
810− status = CONTINUE;
811− // It has only been killed if the interrupt status has changed
812− // since we enqueued the item, and the bracket count is 0. If the
813− // bracket count is non-zero then we are in a masked state so it's
814− // impossible to be killed.
815− if (interrupt && interrupt !== tmp && bracketCount === 0) {
816− step = attempt._1.killed(util.fromLeft(interrupt))(attempt._2);
817− } else if (fail) {
818− step = attempt._1.failed(util.fromLeft(fail))(attempt._2);
819− } else {
820− step = attempt._1.completed(util.fromRight(step))(attempt._2);
821− }
822− fail = null;
823− bracketCount++;
824− break;
825−
826− case FINALIZER:
827− bracketCount++;
828− attempts = new Aff(CONS, new Aff(FINALIZED, step, fail), attempts, interrupt);
829− status = CONTINUE;
830− step = attempt._1;
831− break;
832−
833− case FINALIZED:
834− bracketCount--;
835− status = RETURN;
836− step = attempt._1;
837− fail = attempt._2;
838− break;
839− }
840− }
841− break;
842−
843− case COMPLETED:
844− for (var k in joins) {
845− if (joins.hasOwnProperty(k)) {
846− rethrow = rethrow && joins[k].rethrow;
847− runEff(joins[k].handler(step));
848− }
849− }
850− joins = null;
851− // If we have an interrupt and a fail, then the thread threw while
852− // running finalizers. This should always rethrow in a fresh stack.
853− if (interrupt && fail) {
854− setTimeout(function () {
855− throw util.fromLeft(fail);
856− }, 0);
857− // If we have an unhandled exception, and no other fiber has joined
858− // then we need to throw the exception in a fresh stack.
859− } else if (util.isLeft(step) && rethrow) {
860− setTimeout(function () {
861− // Guard on reathrow because a completely synchronous fiber can
862− // still have an observer which was added after-the-fact.
863− if (rethrow) {
864− throw util.fromLeft(step);
865− }
866− }, 0);
867− }
868− return;
869− case SUSPENDED:
870− status = CONTINUE;
871− break;
872− case PENDING: return;
1173+ case PENDING:
1174+ return;
8731175 }
8741176 }
8751177 }
876−
877− function onComplete(join) {
878− return function () {
1178+ function onComplete(join3) {
1179+ return function() {
8791180 if (status === COMPLETED) {
880− rethrow = rethrow && join.rethrow;
881− join.handler(step)();
882− return function () {};
1181+ rethrow = rethrow && join3.rethrow;
1182+ join3.handler(step)();
1183+ return function() {
1184+ };
8831185 }
884−
885− var jid = joinId++;
886− joins = joins || {};
887− joins[jid] = join;
888−
1186+ var jid = joinId++;
1187+ joins = joins || {};
1188+ joins[jid] = join3;
8891189 return function() {
8901190 if (joins !== null) {
8911191 delete joins[jid];
@@ -893,298 +1193,246 @@ var PS = {};
8931193 };
8941194 };
8951195 }
896−
897− function kill(error, cb) {
898− return function () {
1196+ function kill(error3, cb) {
1197+ return function() {
8991198 if (status === COMPLETED) {
9001199 cb(util.right(void 0))();
901− return function () {};
1200+ return function() {
1201+ };
9021202 }
903−
9041203 var canceler = onComplete({
9051204 rethrow: false,
906− handler: function (/* unused */) {
1205+ handler: function() {
9071206 return cb(util.right(void 0));
9081207 }
9091208 })();
910−
9111209 switch (status) {
912− case SUSPENDED:
913− interrupt = util.left(error);
914− status = COMPLETED;
915− step = interrupt;
916− run(runTick);
917− break;
918− case PENDING:
919− if (interrupt === null) {
920− interrupt = util.left(error);
921− }
922− if (bracketCount === 0) {
923− if (status === PENDING) {
924− attempts = new Aff(CONS, new Aff(FINALIZER, step(error)), attempts, interrupt);
1210+ case SUSPENDED:
1211+ interrupt = util.left(error3);
1212+ status = COMPLETED;
1213+ step = interrupt;
1214+ run2(runTick);
1215+ break;
1216+ case PENDING:
1217+ if (interrupt === null) {
1218+ interrupt = util.left(error3);
1219+ }
1220+ if (bracketCount === 0) {
1221+ if (status === PENDING) {
1222+ attempts = new Aff2(CONS, new Aff2(FINALIZER, step(error3)), attempts, interrupt);
1223+ }
1224+ status = RETURN;
1225+ step = null;
1226+ fail2 = null;
1227+ run2(++runTick);
1228+ }
1229+ break;
1230+ default:
1231+ if (interrupt === null) {
1232+ interrupt = util.left(error3);
1233+ }
1234+ if (bracketCount === 0) {
1235+ status = RETURN;
1236+ step = null;
1237+ fail2 = null;
9251238 }
926− status = RETURN;
927− step = null;
928− fail = null;
929− run(++runTick);
930− }
931− break;
932− default:
933− if (interrupt === null) {
934− interrupt = util.left(error);
935− }
936− if (bracketCount === 0) {
937− status = RETURN;
938− step = null;
939− fail = null;
940− }
9411239 }
942−
9431240 return canceler;
9441241 };
9451242 }
946−
947− function join(cb) {
948− return function () {
1243+ function join2(cb) {
1244+ return function() {
9491245 var canceler = onComplete({
9501246 rethrow: false,
9511247 handler: cb
9521248 })();
9531249 if (status === SUSPENDED) {
954− run(runTick);
1250+ run2(runTick);
9551251 }
9561252 return canceler;
9571253 };
9581254 }
959−
9601255 return {
961− kill: kill,
962− join: join,
963− onComplete: onComplete,
964− isSuspended: function () {
1256+ kill,
1257+ join: join2,
1258+ onComplete,
1259+ isSuspended: function() {
9651260 return status === SUSPENDED;
9661261 },
967− run: function () {
1262+ run: function() {
9681263 if (status === SUSPENDED) {
9691264 if (!Scheduler.isDraining()) {
970− Scheduler.enqueue(function () {
971− run(runTick);
1265+ Scheduler.enqueue(function() {
1266+ run2(runTick);
9721267 });
9731268 } else {
974− run(runTick);
1269+ run2(runTick);
9751270 }
9761271 }
9771272 }
9781273 };
9791274 }
980−
9811275 function runPar(util, supervisor, par, cb) {
982− // Table of all forked fibers.
983− var fiberId = 0;
984− var fibers = {};
985−
986− // Table of currently running cancelers, as a product of `Alt` behavior.
987− var killId = 0;
988− var kills = {};
989−
990− // Error used for early cancelation on Alt branches.
991− var early = new Error("[ParAff] Early exit");
992−
993− // Error used to kill the entire tree.
1276+ var fiberId = 0;
1277+ var fibers = {};
1278+ var killId = 0;
1279+ var kills = {};
1280+ var early = new Error("[ParAff] Early exit");
9941281 var interrupt = null;
995−
996− // The root pointer of the tree.
997− var root = EMPTY;
998−
999− // Walks a tree, invoking all the cancelers. Returns the table of pending
1000− // cancellation fibers.
1001− function kill(error, par, cb) {
1002− var step = par;
1003− var head = null;
1004− var tail = null;
1282+ var root = EMPTY;
1283+ function kill(error3, par2, cb2) {
1284+ var step = par2;
1285+ var head = null;
1286+ var tail = null;
10051287 var count = 0;
1006− var kills = {};
1288+ var kills2 = {};
10071289 var tmp, kid;
1008−
10091290 loop: while (true) {
10101291 tmp = null;
1011−
10121292 switch (step.tag) {
1013− case FORKED:
1014− if (step._3 === EMPTY) {
1015− tmp = fibers[step._1];
1016− kills[count++] = tmp.kill(error, function (result) {
1017− return function () {
1018− count--;
1019− if (count === 0) {
1020− cb(result)();
1021− }
1022− };
1023− });
1024− }
1025− // Terminal case.
1026− if (head === null) {
1027− break loop;
1028− }
1029− // Go down the right side of the tree.
1030− step = head._2;
1031− if (tail === null) {
1032− head = null;
1033− } else {
1034− head = tail._1;
1035− tail = tail._2;
1036− }
1037− break;
1038− case MAP:
1039− step = step._2;
1040− break;
1041− case APPLY:
1042− case ALT:
1043− if (head) {
1044− tail = new Aff(CONS, head, tail);
1045− }
1046− head = step;
1047− step = step._1;
1048− break;
1293+ case FORKED:
1294+ if (step._3 === EMPTY) {
1295+ tmp = fibers[step._1];
1296+ kills2[count++] = tmp.kill(error3, function(result) {
1297+ return function() {
1298+ count--;
1299+ if (count === 0) {
1300+ cb2(result)();
1301+ }
1302+ };
1303+ });
1304+ }
1305+ if (head === null) {
1306+ break loop;
1307+ }
1308+ step = head._2;
1309+ if (tail === null) {
1310+ head = null;
1311+ } else {
1312+ head = tail._1;
1313+ tail = tail._2;
1314+ }
1315+ break;
1316+ case MAP:
1317+ step = step._2;
1318+ break;
1319+ case APPLY:
1320+ case ALT:
1321+ if (head) {
1322+ tail = new Aff2(CONS, head, tail);
1323+ }
1324+ head = step;
1325+ step = step._1;
1326+ break;
10491327 }
10501328 }
1051−
10521329 if (count === 0) {
1053− cb(util.right(void 0))();
1330+ cb2(util.right(void 0))();
10541331 } else {
1055− // Run the cancelation effects. We alias `count` because it's mutable.
10561332 kid = 0;
10571333 tmp = count;
10581334 for (; kid < tmp; kid++) {
1059− kills[kid] = kills[kid]();
1335+ kills2[kid] = kills2[kid]();
10601336 }
10611337 }
1062−
1063− return kills;
1338+ return kills2;
10641339 }
1065−
1066− // When a fiber resolves, we need to bubble back up the tree with the
1067− // result, computing the applicative nodes.
1068− function join(result, head, tail) {
1069− var fail, step, lhs, rhs, tmp, kid;
1070−
1340+ function join2(result, head, tail) {
1341+ var fail2, step, lhs, rhs, tmp, kid;
10711342 if (util.isLeft(result)) {
1072− fail = result;
1343+ fail2 = result;
10731344 step = null;
10741345 } else {
10751346 step = result;
1076− fail = null;
1347+ fail2 = null;
10771348 }
1078−
10791349 loop: while (true) {
10801350 lhs = null;
10811351 rhs = null;
10821352 tmp = null;
10831353 kid = null;
1084−
1085− // We should never continue if the entire tree has been interrupted.
10861354 if (interrupt !== null) {
10871355 return;
10881356 }
1089−
1090− // We've made it all the way to the root of the tree, which means
1091− // the tree has fully evaluated.
10921357 if (head === null) {
1093− cb(fail || step)();
1358+ cb(fail2 || step)();
10941359 return;
10951360 }
1096−
1097− // The tree has already been computed, so we shouldn't try to do it
1098− // again. This should never happen.
1099− // TODO: Remove this?
11001361 if (head._3 !== EMPTY) {
11011362 return;
11021363 }
1103−
11041364 switch (head.tag) {
1105− case MAP:
1106− if (fail === null) {
1107− head._3 = util.right(head._1(util.fromRight(step)));
1108− step = head._3;
1109− } else {
1110− head._3 = fail;
1111− }
1112− break;
1113− case APPLY:
1114− lhs = head._1._3;
1115− rhs = head._2._3;
1116− // If we have a failure we should kill the other side because we
1117− // can't possible yield a result anymore.
1118− if (fail) {
1119− head._3 = fail;
1120− tmp = true;
1121− kid = killId++;
1122−
1123− kills[kid] = kill(early, fail === lhs ? head._2 : head._1, function (/* unused */) {
1124− return function () {
1125− delete kills[kid];
1126− if (tmp) {
1127− tmp = false;
1128− } else if (tail === null) {
1129− join(fail, null, null);
1130− } else {
1131− join(fail, tail._1, tail._2);
1132− }
1133− };
1134− });
1135−
1136− if (tmp) {
1137− tmp = false;
1365+ case MAP:
1366+ if (fail2 === null) {
1367+ head._3 = util.right(head._1(util.fromRight(step)));
1368+ step = head._3;
1369+ } else {
1370+ head._3 = fail2;
1371+ }
1372+ break;
1373+ case APPLY:
1374+ lhs = head._1._3;
1375+ rhs = head._2._3;
1376+ if (fail2) {
1377+ head._3 = fail2;
1378+ tmp = true;
1379+ kid = killId++;
1380+ kills[kid] = kill(early, fail2 === lhs ? head._2 : head._1, function() {
1381+ return function() {
1382+ delete kills[kid];
1383+ if (tmp) {
1384+ tmp = false;
1385+ } else if (tail === null) {
1386+ join2(fail2, null, null);
1387+ } else {
1388+ join2(fail2, tail._1, tail._2);
1389+ }
1390+ };
1391+ });
1392+ if (tmp) {
1393+ tmp = false;
1394+ return;
1395+ }
1396+ } else if (lhs === EMPTY || rhs === EMPTY) {
11381397 return;
1398+ } else {
1399+ step = util.right(util.fromRight(lhs)(util.fromRight(rhs)));
1400+ head._3 = step;
11391401 }
1140− } else if (lhs === EMPTY || rhs === EMPTY) {
1141− // We can only proceed if both sides have resolved.
1142− return;
1143− } else {
1144− step = util.right(util.fromRight(lhs)(util.fromRight(rhs)));
1145− head._3 = step;
1146− }
1147− break;
1148− case ALT:
1149− lhs = head._1._3;
1150− rhs = head._2._3;
1151− // We can only proceed if both have resolved or we have a success
1152− if (lhs === EMPTY && util.isLeft(rhs) || rhs === EMPTY && util.isLeft(lhs)) {
1153− return;
1154− }
1155− // If both sides resolve with an error, we should continue with the
1156− // first error
1157− if (lhs !== EMPTY && util.isLeft(lhs) && rhs !== EMPTY && util.isLeft(rhs)) {
1158− fail = step === lhs ? rhs : lhs;
1159− step = null;
1160− head._3 = fail;
1161− } else {
1162− head._3 = step;
1163− tmp = true;
1164− kid = killId++;
1165− // Once a side has resolved, we need to cancel the side that is still
1166− // pending before we can continue.
1167− kills[kid] = kill(early, step === lhs ? head._2 : head._1, function (/* unused */) {
1168− return function () {
1169− delete kills[kid];
1170− if (tmp) {
1171− tmp = false;
1172− } else if (tail === null) {
1173− join(step, null, null);
1174− } else {
1175− join(step, tail._1, tail._2);
1176− }
1177− };
1178− });
1179−
1180− if (tmp) {
1181− tmp = false;
1402+ break;
1403+ case ALT:
1404+ lhs = head._1._3;
1405+ rhs = head._2._3;
1406+ if (lhs === EMPTY && util.isLeft(rhs) || rhs === EMPTY && util.isLeft(lhs)) {
11821407 return;
11831408 }
1184− }
1185− break;
1409+ if (lhs !== EMPTY && util.isLeft(lhs) && rhs !== EMPTY && util.isLeft(rhs)) {
1410+ fail2 = step === lhs ? rhs : lhs;
1411+ step = null;
1412+ head._3 = fail2;
1413+ } else {
1414+ head._3 = step;
1415+ tmp = true;
1416+ kid = killId++;
1417+ kills[kid] = kill(early, step === lhs ? head._2 : head._1, function() {
1418+ return function() {
1419+ delete kills[kid];
1420+ if (tmp) {
1421+ tmp = false;
1422+ } else if (tail === null) {
1423+ join2(step, null, null);
1424+ } else {
1425+ join2(step, tail._1, tail._2);
1426+ }
1427+ };
1428+ });
1429+ if (tmp) {
1430+ tmp = false;
1431+ return;
1432+ }
1433+ }
1434+ break;
11861435 }
1187−
11881436 if (tail === null) {
11891437 head = null;
11901438 } else {
@@ -1193,115 +1441,92 @@ var PS = {};
11931441 }
11941442 }
11951443 }
1196−
11971444 function resolve(fiber) {
1198− return function (result) {
1199− return function () {
1445+ return function(result) {
1446+ return function() {
12001447 delete fibers[fiber._1];
12011448 fiber._3 = result;
1202− join(result, fiber._2._1, fiber._2._2);
1449+ join2(result, fiber._2._1, fiber._2._2);
12031450 };
12041451 };
12051452 }
1206−
1207− // Walks the applicative tree, substituting non-applicative nodes with
1208− // `FORKED` nodes. In this tree, all applicative nodes use the `_3` slot
1209− // as a mutable slot for memoization. In an unresolved state, the `_3`
1210− // slot is `EMPTY`. In the cases of `ALT` and `APPLY`, we always walk
1211− // the left side first, because both operations are left-associative. As
1212− // we `RETURN` from those branches, we then walk the right side.
1213− function run() {
1453+ function run2() {
12141454 var status = CONTINUE;
1215− var step = par;
1216− var head = null;
1217− var tail = null;
1455+ var step = par;
1456+ var head = null;
1457+ var tail = null;
12181458 var tmp, fid;
1219−
12201459 loop: while (true) {
12211460 tmp = null;
12221461 fid = null;
1223−
12241462 switch (status) {
1225− case CONTINUE:
1226− switch (step.tag) {
1227− case MAP:
1228− if (head) {
1229− tail = new Aff(CONS, head, tail);
1230− }
1231− head = new Aff(MAP, step._1, EMPTY, EMPTY);
1232− step = step._2;
1233− break;
1234− case APPLY:
1235− if (head) {
1236− tail = new Aff(CONS, head, tail);
1237− }
1238− head = new Aff(APPLY, EMPTY, step._2, EMPTY);
1239− step = step._1;
1240− break;
1241− case ALT:
1242− if (head) {
1243− tail = new Aff(CONS, head, tail);
1463+ case CONTINUE:
1464+ switch (step.tag) {
1465+ case MAP:
1466+ if (head) {
1467+ tail = new Aff2(CONS, head, tail);
1468+ }
1469+ head = new Aff2(MAP, step._1, EMPTY, EMPTY);
1470+ step = step._2;
1471+ break;
1472+ case APPLY:
1473+ if (head) {
1474+ tail = new Aff2(CONS, head, tail);
1475+ }
1476+ head = new Aff2(APPLY, EMPTY, step._2, EMPTY);
1477+ step = step._1;
1478+ break;
1479+ case ALT:
1480+ if (head) {
1481+ tail = new Aff2(CONS, head, tail);
1482+ }
1483+ head = new Aff2(ALT, EMPTY, step._2, EMPTY);
1484+ step = step._1;
1485+ break;
1486+ default:
1487+ fid = fiberId++;
1488+ status = RETURN;
1489+ tmp = step;
1490+ step = new Aff2(FORKED, fid, new Aff2(CONS, head, tail), EMPTY);
1491+ tmp = Fiber(util, supervisor, tmp);
1492+ tmp.onComplete({
1493+ rethrow: false,
1494+ handler: resolve(step)
1495+ })();
1496+ fibers[fid] = tmp;
1497+ if (supervisor) {
1498+ supervisor.register(tmp);
1499+ }
12441500 }
1245− head = new Aff(ALT, EMPTY, step._2, EMPTY);
1246− step = step._1;
12471501 break;
1248− default:
1249− // When we hit a leaf value, we suspend the stack in the `FORKED`.
1250− // When the fiber resolves, it can bubble back up the tree.
1251− fid = fiberId++;
1252− status = RETURN;
1253− tmp = step;
1254− step = new Aff(FORKED, fid, new Aff(CONS, head, tail), EMPTY);
1255− tmp = Fiber(util, supervisor, tmp);
1256− tmp.onComplete({
1257− rethrow: false,
1258− handler: resolve(step)
1259− })();
1260− fibers[fid] = tmp;
1261− if (supervisor) {
1262− supervisor.register(tmp);
1502+ case RETURN:
1503+ if (head === null) {
1504+ break loop;
12631505 }
1264− }
1265− break;
1266− case RETURN:
1267− // Terminal case, we are back at the root.
1268− if (head === null) {
1269− break loop;
1270− }
1271− // If we are done with the right side, we need to continue down the
1272− // left. Otherwise we should continue up the stack.
1273− if (head._1 === EMPTY) {
1274− head._1 = step;
1275− status = CONTINUE;
1276− step = head._2;
1277− head._2 = EMPTY;
1278− } else {
1279− head._2 = step;
1280− step = head;
1281− if (tail === null) {
1282− head = null;
1506+ if (head._1 === EMPTY) {
1507+ head._1 = step;
1508+ status = CONTINUE;
1509+ step = head._2;
1510+ head._2 = EMPTY;
12831511 } else {
1284− head = tail._1;
1285− tail = tail._2;
1512+ head._2 = step;
1513+ step = head;
1514+ if (tail === null) {
1515+ head = null;
1516+ } else {
1517+ head = tail._1;
1518+ tail = tail._2;
1519+ }
12861520 }
1287− }
12881521 }
12891522 }
1290−
1291− // Keep a reference to the tree root so it can be cancelled.
12921523 root = step;
1293−
12941524 for (fid = 0; fid < fiberId; fid++) {
12951525 fibers[fid].run();
12961526 }
12971527 }
1298−
1299− // Cancels the entire tree. If there are already subtrees being canceled,
1300− // we need to first cancel those joins. We will then add fresh joins for
1301− // all pending branches including those that were in the process of being
1302− // canceled.
1303− function cancel(error, cb) {
1304− interrupt = util.left(error);
1528+ function cancel(error3, cb2) {
1529+ interrupt = util.left(error3);
13051530 var innerKills;
13061531 for (var kid in kills) {
13071532 if (kills.hasOwnProperty(kid)) {
@@ -1313,694 +1538,744 @@ var PS = {};
13131538 }
13141539 }
13151540 }
1316−
13171541 kills = null;
1318− var newKills = kill(error, root, cb);
1319−
1320− return function (killError) {
1321− return new Aff(ASYNC, function (killCb) {
1322− return function () {
1323− for (var kid in newKills) {
1324− if (newKills.hasOwnProperty(kid)) {
1325− newKills[kid]();
1542+ var newKills = kill(error3, root, cb2);
1543+ return function(killError) {
1544+ return new Aff2(ASYNC, function(killCb) {
1545+ return function() {
1546+ for (var kid2 in newKills) {
1547+ if (newKills.hasOwnProperty(kid2)) {
1548+ newKills[kid2]();
13261549 }
13271550 }
1328− return nonCanceler;
1551+ return nonCanceler2;
13291552 };
13301553 });
13311554 };
13321555 }
1333−
1334− run();
1335−
1336− return function (killError) {
1337− return new Aff(ASYNC, function (killCb) {
1338− return function () {
1556+ run2();
1557+ return function(killError) {
1558+ return new Aff2(ASYNC, function(killCb) {
1559+ return function() {
13391560 return cancel(killError, killCb);
13401561 };
13411562 });
13421563 };
13431564 }
1344−
1345− function sequential(util, supervisor, par) {
1346− return new Aff(ASYNC, function (cb) {
1347− return function () {
1565+ function sequential2(util, supervisor, par) {
1566+ return new Aff2(ASYNC, function(cb) {
1567+ return function() {
13481568 return runPar(util, supervisor, par, cb);
13491569 };
13501570 });
13511571 }
1352−
1353− Aff.EMPTY = EMPTY;
1354− Aff.Pure = AffCtr(PURE);
1355− Aff.Throw = AffCtr(THROW);
1356− Aff.Catch = AffCtr(CATCH);
1357− Aff.Sync = AffCtr(SYNC);
1358− Aff.Async = AffCtr(ASYNC);
1359− Aff.Bind = AffCtr(BIND);
1360− Aff.Bracket = AffCtr(BRACKET);
1361− Aff.Fork = AffCtr(FORK);
1362− Aff.Seq = AffCtr(SEQ);
1363− Aff.ParMap = AffCtr(MAP);
1364− Aff.ParApply = AffCtr(APPLY);
1365− Aff.ParAlt = AffCtr(ALT);
1366− Aff.Fiber = Fiber;
1367− Aff.Supervisor = Supervisor;
1368− Aff.Scheduler = Scheduler;
1369− Aff.nonCanceler = nonCanceler;
1370−
1371− return Aff;
1572+ Aff2.EMPTY = EMPTY;
1573+ Aff2.Pure = AffCtr(PURE);
1574+ Aff2.Throw = AffCtr(THROW);
1575+ Aff2.Catch = AffCtr(CATCH);
1576+ Aff2.Sync = AffCtr(SYNC);
1577+ Aff2.Async = AffCtr(ASYNC);
1578+ Aff2.Bind = AffCtr(BIND);
1579+ Aff2.Bracket = AffCtr(BRACKET);
1580+ Aff2.Fork = AffCtr(FORK);
1581+ Aff2.Seq = AffCtr(SEQ);
1582+ Aff2.ParMap = AffCtr(MAP);
1583+ Aff2.ParApply = AffCtr(APPLY);
1584+ Aff2.ParAlt = AffCtr(ALT);
1585+ Aff2.Fiber = Fiber;
1586+ Aff2.Supervisor = Supervisor;
1587+ Aff2.Scheduler = Scheduler;
1588+ Aff2.nonCanceler = nonCanceler2;
1589+ return Aff2;
13721590 }();
1373−
1374− exports._pure = Aff.Pure;
1375−
1376− exports._throwError = Aff.Throw;
1377−
1378− exports._catchError = function (aff) {
1379− return function (k) {
1591+ var _pure = Aff.Pure;
1592+ var _throwError = Aff.Throw;
1593+ function _catchError(aff) {
1594+ return function(k) {
13801595 return Aff.Catch(aff, k);
13811596 };
1382− };
1383−
1384− exports._map = function (f) {
1385− return function (aff) {
1597+ }
1598+ function _map(f) {
1599+ return function(aff) {
13861600 if (aff.tag === Aff.Pure.tag) {
13871601 return Aff.Pure(f(aff._1));
13881602 } else {
1389− return Aff.Bind(aff, function (value) {
1603+ return Aff.Bind(aff, function(value) {
13901604 return Aff.Pure(f(value));
13911605 });
13921606 }
13931607 };
1394− };
1395−
1396− exports._bind = function (aff) {
1397− return function (k) {
1608+ }
1609+ function _bind(aff) {
1610+ return function(k) {
13981611 return Aff.Bind(aff, k);
13991612 };
1400− };
1401−
1402− exports._liftEffect = Aff.Sync;
1403−
1404− exports.makeAff = Aff.Async;
1405−
1406− exports._makeFiber = function (util, aff) {
1407− return function () {
1613+ }
1614+ var _liftEffect = Aff.Sync;
1615+ function _parAffMap(f) {
1616+ return function(aff) {
1617+ return Aff.ParMap(f, aff);
1618+ };
1619+ }
1620+ function _parAffApply(aff1) {
1621+ return function(aff2) {
1622+ return Aff.ParApply(aff1, aff2);
1623+ };
1624+ }
1625+ var makeAff = Aff.Async;
1626+ function _makeFiber(util, aff) {
1627+ return function() {
14081628 return Aff.Fiber(util, null, aff);
14091629 };
1630+ }
1631+ var _sequential = Aff.Seq;
1632+
1633+ // output/Control.Parallel.Class/index.js
1634+ var sequential = function(dict) {
1635+ return dict.sequential;
1636+ };
1637+ var parallel = function(dict) {
1638+ return dict.parallel;
14101639 };
1411−})(PS["Effect.Aff"] = PS["Effect.Aff"] || {});
1412−(function($PS) {
1413− // Generated by purs version 0.13.6
1414− "use strict";
1415− $PS["Effect.Class"] = $PS["Effect.Class"] || {};
1416− var exports = $PS["Effect.Class"];
1417− var MonadEffect = function (Monad0, liftEffect) {
1418− this.Monad0 = Monad0;
1419− this.liftEffect = liftEffect;
1420− };
1421− var liftEffect = function (dict) {
1422− return dict.liftEffect;
1423− };
1424− exports["liftEffect"] = liftEffect;
1425− exports["MonadEffect"] = MonadEffect;
1426−})(PS);
1427−(function(exports) {
1428− "use strict";
14291640
1430− // module Partial.Unsafe
1641+ // output/Control.Parallel/index.js
1642+ var identity3 = /* @__PURE__ */ identity(categoryFn);
1643+ var parTraverse_ = function(dictParallel) {
1644+ var sequential2 = sequential(dictParallel);
1645+ var parallel3 = parallel(dictParallel);
1646+ return function(dictApplicative) {
1647+ var traverse_2 = traverse_(dictApplicative);
1648+ return function(dictFoldable) {
1649+ var traverse_1 = traverse_2(dictFoldable);
1650+ return function(f) {
1651+ var $51 = traverse_1(function($53) {
1652+ return parallel3(f($53));
1653+ });
1654+ return function($52) {
1655+ return sequential2($51($52));
1656+ };
1657+ };
1658+ };
1659+ };
1660+ };
1661+ var parSequence_ = function(dictParallel) {
1662+ var parTraverse_1 = parTraverse_(dictParallel);
1663+ return function(dictApplicative) {
1664+ var parTraverse_2 = parTraverse_1(dictApplicative);
1665+ return function(dictFoldable) {
1666+ return parTraverse_2(dictFoldable)(identity3);
1667+ };
1668+ };
1669+ };
14311670
1432− exports.unsafePartial = function (f) {
1671+ // output/Partial.Unsafe/foreign.js
1672+ var _unsafePartial = function(f) {
14331673 return f();
14341674 };
1435−})(PS["Partial.Unsafe"] = PS["Partial.Unsafe"] || {});
1436−(function(exports) {
1437− "use strict";
14381675
1439− // module Partial
1676+ // output/Partial/foreign.js
1677+ var _crashWith = function(msg) {
1678+ throw new Error(msg);
1679+ };
14401680
1441− exports.crashWith = function () {
1442− return function (msg) {
1443− throw new Error(msg);
1444− };
1445− };
1446−})(PS["Partial"] = PS["Partial"] || {});
1447−(function($PS) {
1448− // Generated by purs version 0.13.6
1449− "use strict";
1450− $PS["Partial"] = $PS["Partial"] || {};
1451− var exports = $PS["Partial"];
1452− var $foreign = $PS["Partial"];
1453− exports["crashWith"] = $foreign.crashWith;
1454−})(PS);
1455−(function($PS) {
1456− // Generated by purs version 0.13.6
1457− "use strict";
1458− $PS["Partial.Unsafe"] = $PS["Partial.Unsafe"] || {};
1459− var exports = $PS["Partial.Unsafe"];
1460− var $foreign = $PS["Partial.Unsafe"];
1461− var Partial = $PS["Partial"];
1462− var unsafeCrashWith = function (msg) {
1463− return $foreign.unsafePartial(function (dictPartial) {
1464− return Partial.crashWith()(msg);
1465− });
1681+ // output/Partial/index.js
1682+ var crashWith = function() {
1683+ return _crashWith;
14661684 };
1467− exports["unsafeCrashWith"] = unsafeCrashWith;
1468−})(PS);
1469−(function($PS) {
1470− // Generated by purs version 0.13.6
1471− "use strict";
1472− $PS["Effect.Aff"] = $PS["Effect.Aff"] || {};
1473− var exports = $PS["Effect.Aff"];
1474− var $foreign = $PS["Effect.Aff"];
1475− var Control_Applicative = $PS["Control.Applicative"];
1476− var Control_Apply = $PS["Control.Apply"];
1477− var Control_Bind = $PS["Control.Bind"];
1478− var Control_Monad = $PS["Control.Monad"];
1479− var Control_Monad_Error_Class = $PS["Control.Monad.Error.Class"];
1480− var Data_Either = $PS["Data.Either"];
1481− var Data_Function = $PS["Data.Function"];
1482− var Data_Functor = $PS["Data.Functor"];
1483− var Data_Unit = $PS["Data.Unit"];
1484− var Effect = $PS["Effect"];
1485− var Effect_Class = $PS["Effect.Class"];
1486− var Partial_Unsafe = $PS["Partial.Unsafe"];
1487− var functorAff = new Data_Functor.Functor($foreign["_map"]);
1488− var ffiUtil = (function () {
1489− var unsafeFromRight = function (v) {
1490− if (v instanceof Data_Either.Right) {
1491− return v.value0;
1492− };
1493− if (v instanceof Data_Either.Left) {
1494− return Partial_Unsafe.unsafeCrashWith("unsafeFromRight: Left");
1495− };
1496− throw new Error("Failed pattern match at Effect.Aff (line 400, column 21 - line 402, column 54): " + [ v.constructor.name ]);
1497− };
1498− var unsafeFromLeft = function (v) {
1499− if (v instanceof Data_Either.Left) {
1500− return v.value0;
1501− };
1502− if (v instanceof Data_Either.Right) {
1503− return Partial_Unsafe.unsafeCrashWith("unsafeFromLeft: Right");
1504− };
1505− throw new Error("Failed pattern match at Effect.Aff (line 395, column 20 - line 397, column 54): " + [ v.constructor.name ]);
1506− };
1507− var isLeft = function (v) {
1508− if (v instanceof Data_Either.Left) {
1509− return true;
1510− };
1511− if (v instanceof Data_Either.Right) {
1512− return false;
1513− };
1514− throw new Error("Failed pattern match at Effect.Aff (line 390, column 12 - line 392, column 20): " + [ v.constructor.name ]);
1515− };
1516− return {
1517− isLeft: isLeft,
1518− fromLeft: unsafeFromLeft,
1519− fromRight: unsafeFromRight,
1520− left: Data_Either.Left.create,
1521− right: Data_Either.Right.create
1522− };
1523− })();
1524− var makeFiber = function (aff) {
1525− return $foreign["_makeFiber"](ffiUtil, aff);
1526− };
1527− var launchAff = function (aff) {
1528− return function __do() {
1529− var fiber = makeFiber(aff)();
1530− fiber.run();
1531− return fiber;
1532− };
1685+
1686+ // output/Partial.Unsafe/index.js
1687+ var crashWith2 = /* @__PURE__ */ crashWith();
1688+ var unsafePartial = _unsafePartial;
1689+ var unsafeCrashWith = function(msg) {
1690+ return unsafePartial(function() {
1691+ return crashWith2(msg);
1692+ });
1693+ };
1694+
1695+ // output/Effect.Aff/index.js
1696+ var $runtime_lazy2 = function(name2, moduleName, init2) {
1697+ var state2 = 0;
1698+ var val;
1699+ return function(lineNumber) {
1700+ if (state2 === 2) return val;
1701+ if (state2 === 1) throw new ReferenceError(name2 + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);
1702+ state2 = 1;
1703+ val = init2();
1704+ state2 = 2;
1705+ return val;
1706+ };
1707+ };
1708+ var $$void2 = /* @__PURE__ */ $$void(functorEffect);
1709+ var functorParAff = {
1710+ map: _parAffMap
15331711 };
1534− var monadAff = new Control_Monad.Monad(function () {
1712+ var functorAff = {
1713+ map: _map
1714+ };
1715+ var ffiUtil = /* @__PURE__ */ function() {
1716+ var unsafeFromRight = function(v) {
1717+ if (v instanceof Right) {
1718+ return v.value0;
1719+ }
1720+ ;
1721+ if (v instanceof Left) {
1722+ return unsafeCrashWith("unsafeFromRight: Left");
1723+ }
1724+ ;
1725+ throw new Error("Failed pattern match at Effect.Aff (line 412, column 21 - line 414, column 54): " + [v.constructor.name]);
1726+ };
1727+ var unsafeFromLeft = function(v) {
1728+ if (v instanceof Left) {
1729+ return v.value0;
1730+ }
1731+ ;
1732+ if (v instanceof Right) {
1733+ return unsafeCrashWith("unsafeFromLeft: Right");
1734+ }
1735+ ;
1736+ throw new Error("Failed pattern match at Effect.Aff (line 407, column 20 - line 409, column 55): " + [v.constructor.name]);
1737+ };
1738+ var isLeft = function(v) {
1739+ if (v instanceof Left) {
1740+ return true;
1741+ }
1742+ ;
1743+ if (v instanceof Right) {
1744+ return false;
1745+ }
1746+ ;
1747+ throw new Error("Failed pattern match at Effect.Aff (line 402, column 12 - line 404, column 21): " + [v.constructor.name]);
1748+ };
1749+ return {
1750+ isLeft,
1751+ fromLeft: unsafeFromLeft,
1752+ fromRight: unsafeFromRight,
1753+ left: Left.create,
1754+ right: Right.create
1755+ };
1756+ }();
1757+ var makeFiber = function(aff) {
1758+ return _makeFiber(ffiUtil, aff);
1759+ };
1760+ var launchAff = function(aff) {
1761+ return function __do() {
1762+ var fiber = makeFiber(aff)();
1763+ fiber.run();
1764+ return fiber;
1765+ };
1766+ };
1767+ var applyParAff = {
1768+ apply: _parAffApply,
1769+ Functor0: function() {
1770+ return functorParAff;
1771+ }
1772+ };
1773+ var monadAff = {
1774+ Applicative0: function() {
15351775 return applicativeAff;
1536− }, function () {
1776+ },
1777+ Bind1: function() {
15371778 return bindAff;
1779+ }
1780+ };
1781+ var bindAff = {
1782+ bind: _bind,
1783+ Apply0: function() {
1784+ return $lazy_applyAff(0);
1785+ }
1786+ };
1787+ var applicativeAff = {
1788+ pure: _pure,
1789+ Apply0: function() {
1790+ return $lazy_applyAff(0);
1791+ }
1792+ };
1793+ var $lazy_applyAff = /* @__PURE__ */ $runtime_lazy2("applyAff", "Effect.Aff", function() {
1794+ return {
1795+ apply: ap(monadAff),
1796+ Functor0: function() {
1797+ return functorAff;
1798+ }
1799+ };
15381800 });
1539− var bindAff = new Control_Bind.Bind(function () {
1801+ var applyAff = /* @__PURE__ */ $lazy_applyAff(73);
1802+ var pure2 = /* @__PURE__ */ pure(applicativeAff);
1803+ var bindFlipped2 = /* @__PURE__ */ bindFlipped(bindAff);
1804+ var parallelAff = {
1805+ parallel: unsafeCoerce2,
1806+ sequential: _sequential,
1807+ Apply0: function() {
15401808 return applyAff;
1541− }, $foreign["_bind"]);
1542− var applyAff = new Control_Apply.Apply(function () {
1543− return functorAff;
1544− }, Control_Monad.ap(monadAff));
1545− var applicativeAff = new Control_Applicative.Applicative(function () {
1546− return applyAff;
1547− }, $foreign["_pure"]);
1548− var monadEffectAff = new Effect_Class.MonadEffect(function () {
1809+ },
1810+ Apply1: function() {
1811+ return applyParAff;
1812+ }
1813+ };
1814+ var parallel2 = /* @__PURE__ */ parallel(parallelAff);
1815+ var applicativeParAff = {
1816+ pure: function($76) {
1817+ return parallel2(pure2($76));
1818+ },
1819+ Apply0: function() {
1820+ return applyParAff;
1821+ }
1822+ };
1823+ var parSequence_2 = /* @__PURE__ */ parSequence_(parallelAff)(applicativeParAff)(foldableArray);
1824+ var semigroupCanceler = {
1825+ append: function(v) {
1826+ return function(v1) {
1827+ return function(err) {
1828+ return parSequence_2([v(err), v1(err)]);
1829+ };
1830+ };
1831+ }
1832+ };
1833+ var monadEffectAff = {
1834+ liftEffect: _liftEffect,
1835+ Monad0: function() {
15491836 return monadAff;
1550− }, $foreign["_liftEffect"]);
1551− var monadThrowAff = new Control_Monad_Error_Class.MonadThrow(function () {
1837+ }
1838+ };
1839+ var liftEffect2 = /* @__PURE__ */ liftEffect(monadEffectAff);
1840+ var monadThrowAff = {
1841+ throwError: _throwError,
1842+ Monad0: function() {
15521843 return monadAff;
1553− }, $foreign["_throwError"]);
1554− var monadErrorAff = new Control_Monad_Error_Class.MonadError(function () {
1844+ }
1845+ };
1846+ var monadErrorAff = {
1847+ catchError: _catchError,
1848+ MonadThrow0: function() {
15551849 return monadThrowAff;
1556− }, $foreign["_catchError"]);
1557− var runAff = function (k) {
1558− return function (aff) {
1559− return launchAff(Control_Bind.bindFlipped(bindAff)((function () {
1560− var $49 = Effect_Class.liftEffect(monadEffectAff);
1561− return function ($50) {
1562− return $49(k($50));
1563− };
1564− })())(Control_Monad_Error_Class["try"](monadErrorAff)(aff)));
1565− };
1850+ }
15661851 };
1567− var runAff_ = function (k) {
1568− return function (aff) {
1569− return Data_Functor["void"](Effect.functorEffect)(runAff(k)(aff));
1570− };
1852+ var $$try2 = /* @__PURE__ */ $$try(monadErrorAff);
1853+ var runAff = function(k) {
1854+ return function(aff) {
1855+ return launchAff(bindFlipped2(function($83) {
1856+ return liftEffect2(k($83));
1857+ })($$try2(aff)));
1858+ };
15711859 };
1572− var nonCanceler = Data_Function["const"](Control_Applicative.pure(applicativeAff)(Data_Unit.unit));
1573− exports["runAff_"] = runAff_;
1574− exports["nonCanceler"] = nonCanceler;
1575− exports["bindAff"] = bindAff;
1576− exports["monadEffectAff"] = monadEffectAff;
1577− exports["makeAff"] = $foreign.makeAff;
1578−})(PS);
1579−(function(exports) {
1580−
1581−
1582− exports.promiseToEffectImpl = function (promise, onFulfilled, onRejected) {
1583− return function () {
1584− return promise.then(function (a) {
1585− return onFulfilled(a)();
1586− }, function (err) {
1587− return onRejected(err)();
1588− });
1860+ var runAff_ = function(k) {
1861+ return function(aff) {
1862+ return $$void2(runAff(k)(aff));
15891863 };
15901864 };
1591−})(PS["Effect.Promise"] = PS["Effect.Promise"] || {});
1592−(function(exports) {
1593− exports.undefer = function (f) {
1594− return f();
1865+ var nonCanceler = /* @__PURE__ */ $$const(/* @__PURE__ */ pure2(unit));
1866+ var monoidCanceler = {
1867+ mempty: nonCanceler,
1868+ Semigroup0: function() {
1869+ return semigroupCanceler;
1870+ }
15951871 };
1596−})(PS["Effect.Promise.Unsafe"] = PS["Effect.Promise.Unsafe"] || {});
1597−(function($PS) {
1598− // Generated by purs version 0.13.6
1599− "use strict";
1600− $PS["Effect.Promise.Unsafe"] = $PS["Effect.Promise.Unsafe"] || {};
1601− var exports = $PS["Effect.Promise.Unsafe"];
1602− var $foreign = $PS["Effect.Promise.Unsafe"];
1603− exports["undefer"] = $foreign.undefer;
1604−})(PS);
1605−(function($PS) {
1606− // Generated by purs version 0.13.6
1607− "use strict";
1608− $PS["Effect.Promise"] = $PS["Effect.Promise"] || {};
1609− var exports = $PS["Effect.Promise"];
1610− var $foreign = $PS["Effect.Promise"];
1611− var Effect_Promise_Unsafe = $PS["Effect.Promise.Unsafe"];
1612− var runPromise = function (onSucc) {
1613− return function (onErr) {
1614− return function (p) {
1615− return $foreign.promiseToEffectImpl(Effect_Promise_Unsafe.undefer(function (dictDeferred) {
1616− return p();
1617− }), onSucc, onErr);
1618− };
1619− };
1872+
1873+ // output/Foreign/foreign.js
1874+ function typeOf(value) {
1875+ return typeof value;
1876+ }
1877+ function tagOf(value) {
1878+ return Object.prototype.toString.call(value).slice(8, -1);
1879+ }
1880+ var isArray = Array.isArray || function(value) {
1881+ return Object.prototype.toString.call(value) === "[object Array]";
16201882 };
1621− exports["runPromise"] = runPromise;
1622−})(PS);
1623−(function($PS) {
1624− // Generated by purs version 0.13.6
1625− "use strict";
1626− $PS["Crypto.Subtle.Key.Generate"] = $PS["Crypto.Subtle.Key.Generate"] || {};
1627− var exports = $PS["Crypto.Subtle.Key.Generate"];
1628− var $foreign = $PS["Crypto.Subtle.Key.Generate"];
1629− var Data_Either = $PS["Data.Either"];
1630− var Data_Functor = $PS["Data.Functor"];
1631− var Effect = $PS["Effect"];
1632− var Effect_Aff = $PS["Effect.Aff"];
1633− var Effect_Promise = $PS["Effect.Promise"];
1634− var rsa = function (r) {
1635− return function (l) {
1636− return function (e) {
1637− return function (h) {
1638− return {
1639− name: r,
1640− modulusLength: l,
1641− publicExponent: e,
1642− hash: h
1643− };
1644− };
1645− };
1883+
1884+ // output/Data.List.NonEmpty/index.js
1885+ var singleton3 = /* @__PURE__ */ function() {
1886+ var $200 = singleton2(plusList);
1887+ return function($201) {
1888+ return NonEmptyList($200($201));
1889+ };
1890+ }();
1891+
1892+ // output/Foreign/index.js
1893+ var TypeMismatch = /* @__PURE__ */ function() {
1894+ function TypeMismatch2(value0, value1) {
1895+ this.value0 = value0;
1896+ this.value1 = value1;
1897+ }
1898+ ;
1899+ TypeMismatch2.create = function(value0) {
1900+ return function(value1) {
1901+ return new TypeMismatch2(value0, value1);
16461902 };
1903+ };
1904+ return TypeMismatch2;
1905+ }();
1906+ var unsafeFromForeign = unsafeCoerce2;
1907+ var fail = function(dictMonad) {
1908+ var $153 = throwError(monadThrowExceptT(dictMonad));
1909+ return function($154) {
1910+ return $153(singleton3($154));
1911+ };
16471912 };
1648− var hmac = function (h) {
1649− return {
1650− name: "HMAC",
1651− hash: h
1913+ var unsafeReadTagged = function(dictMonad) {
1914+ var pure1 = pure(applicativeExceptT(dictMonad));
1915+ var fail1 = fail(dictMonad);
1916+ return function(tag) {
1917+ return function(value) {
1918+ if (tagOf(value) === tag) {
1919+ return pure1(unsafeFromForeign(value));
1920+ }
1921+ ;
1922+ if (otherwise) {
1923+ return fail1(new TypeMismatch(tag, tagOf(value)));
1924+ }
1925+ ;
1926+ throw new Error("Failed pattern match at Foreign (line 123, column 1 - line 123, column 104): " + [tag.constructor.name, value.constructor.name]);
16521927 };
1928+ };
16531929 };
1654− var generateKeyPair = function (a) {
1655− return function (e) {
1656− return function (u) {
1657− return Effect_Aff.makeAff(function (resolve) {
1658− return Data_Functor.voidRight(Effect.functorEffect)(Effect_Aff.nonCanceler)(Effect_Promise.runPromise(function ($2) {
1659− return resolve(Data_Either.Right.create($2));
1660− })(function ($3) {
1661− return resolve(Data_Either.Left.create($3));
1662− })(function (dictDeferred) {
1663− return $foreign.generateKeyImpl(a, e, u);
1664− }));
1665− });
1666− };
1667− };
1930+ var readString = function(dictMonad) {
1931+ return unsafeReadTagged(dictMonad)("String");
16681932 };
1669− var generateKey = function (a) {
1670− return function (e) {
1671− return function (u) {
1672− return Effect_Aff.makeAff(function (resolve) {
1673− return Data_Functor.voidRight(Effect.functorEffect)(Effect_Aff.nonCanceler)(Effect_Promise.runPromise(function ($4) {
1674− return resolve(Data_Either.Right.create($4));
1675− })(function ($5) {
1676− return resolve(Data_Either.Left.create($5));
1677− })(function (dictDeferred) {
1678− return $foreign.generateKeyImpl(a, e, u);
1679− }));
1680− });
1681− };
1682− };
1933+
1934+ // output/Control.Promise/index.js
1935+ var voidRight2 = /* @__PURE__ */ voidRight(functorEffect);
1936+ var mempty2 = /* @__PURE__ */ mempty(monoidCanceler);
1937+ var toAff$prime = function(customCoerce) {
1938+ return function(p) {
1939+ return makeAff(function(cb) {
1940+ return voidRight2(mempty2)(thenImpl(p)(function($14) {
1941+ return cb(Left.create(customCoerce($14)))();
1942+ })(function($15) {
1943+ return cb(Right.create($15))();
1944+ }));
1945+ });
1946+ };
16831947 };
1684− var ec = function (e) {
1685− return function (c) {
1686− return {
1687− name: e,
1688− namedCurve: c
1689− };
1948+
1949+ // output/Crypto.Subtle.Key.Types/foreign.js
1950+ function exportKeyImpl(f, x) {
1951+ return crypto.subtle.exportKey(f, x);
1952+ }
1953+
1954+ // output/Foreign.Index/foreign.js
1955+ function unsafeReadPropImpl(f, s, key, value) {
1956+ return value == null ? f : s(value[key]);
1957+ }
1958+
1959+ // output/Foreign.Index/index.js
1960+ var unsafeReadProp = function(dictMonad) {
1961+ var fail2 = fail(dictMonad);
1962+ var pure4 = pure(applicativeExceptT(dictMonad));
1963+ return function(k) {
1964+ return function(value) {
1965+ return unsafeReadPropImpl(fail2(new TypeMismatch("object", typeOf(value))), pure4, k, value);
16901966 };
1967+ };
16911968 };
1692− var aes = function (a) {
1693− return function (l) {
1694− return {
1695− name: a,
1696− length: l
1697− };
1698− };
1969+ var readProp = function(dictMonad) {
1970+ return unsafeReadProp(dictMonad);
16991971 };
1700− exports["generateKey"] = generateKey;
1701− exports["generateKeyPair"] = generateKeyPair;
1702− exports["rsa"] = rsa;
1703− exports["ec"] = ec;
1704− exports["hmac"] = hmac;
1705− exports["aes"] = aes;
1706− exports["exp65537"] = $foreign.exp65537;
1707−})(PS);
1708−(function(exports) {
1709− "use strict";
17101972
1711− exports.exportKeyImpl = function exportKeyImpl (f,x) {
1712− return crypto.subtle.exportKey(f,x);
1713− };
1714−})(PS["Crypto.Subtle.Key.Types"] = PS["Crypto.Subtle.Key.Types"] || {});
1715−(function($PS) {
1716− // Generated by purs version 0.13.6
1717− "use strict";
1718− $PS["Crypto.Subtle.Key.Types"] = $PS["Crypto.Subtle.Key.Types"] || {};
1719− var exports = $PS["Crypto.Subtle.Key.Types"];
1720− var $foreign = $PS["Crypto.Subtle.Key.Types"];
1721− var Data_Either = $PS["Data.Either"];
1722− var Data_Functor = $PS["Data.Functor"];
1723− var Effect = $PS["Effect"];
1724− var Effect_Aff = $PS["Effect.Aff"];
1725− var Effect_Promise = $PS["Effect.Promise"];
1973+ // output/Crypto.Subtle.Key.Types/index.js
1974+ var bind2 = /* @__PURE__ */ bind(/* @__PURE__ */ bindExceptT(monadIdentity));
1975+ var readProp2 = /* @__PURE__ */ readProp(monadIdentity);
1976+ var readString2 = /* @__PURE__ */ readString(monadIdentity);
17261977 var wrapKey = "wrapKey";
17271978 var verify = "verify";
17281979 var unwrapKey = "unwrapKey";
1729− var sign = "sign";
1980+ var sign2 = "sign";
17301981 var raw = "raw";
1731− var exportKey = function (f) {
1732− return function (x) {
1733− return Effect_Aff.makeAff(function (resolve) {
1734− return Data_Functor.voidRight(Effect.functorEffect)(Effect_Aff.nonCanceler)(Effect_Promise.runPromise(function ($1) {
1735− return resolve(Data_Either.Right.create($1));
1736− })(function ($2) {
1737− return resolve(Data_Either.Left.create($2));
1738− })(function (dictDeferred) {
1739− return $foreign.exportKeyImpl(f, x);
1740− }));
1741− });
1742− };
1743− };
1982+ var errorFromDOMException = function(x) {
1983+ var v = runExcept(bind2(readProp2("message")(x))(readString2));
1984+ if (v instanceof Left) {
1985+ return error("Not a DOMException");
1986+ }
1987+ ;
1988+ if (v instanceof Right) {
1989+ return error(v.value0);
1990+ }
1991+ ;
1992+ throw new Error("Failed pattern match at Crypto.Subtle.Key.Types (line 136, column 27 - line 138, column 21): " + [v.constructor.name]);
1993+ };
1994+ var exportKey = function(f) {
1995+ return function(x) {
1996+ return toAff$prime(errorFromDOMException)(exportKeyImpl(f, x));
1997+ };
1998+ };
17441999 var encrypt = "encrypt";
17452000 var deriveKey = "deriveKey";
17462001 var deriveBits = "deriveBits";
17472002 var decrypt = "decrypt";
1748− var allUsages = [ encrypt, decrypt, sign, verify, deriveKey, deriveBits, wrapKey, unwrapKey ];
1749− exports["allUsages"] = allUsages;
1750− exports["exportKey"] = exportKey;
1751− exports["raw"] = raw;
1752−})(PS);
1753−(function(exports) {
1754− "use strict";
2003+ var allUsages = [encrypt, decrypt, sign2, verify, deriveKey, deriveBits, wrapKey, unwrapKey];
17552004
1756− exports.log = function (s) {
1757− return function () {
1758− console.log(s);
1759− return {};
1760− };
1761− };
1762−})(PS["Effect.Console"] = PS["Effect.Console"] || {});
1763−(function($PS) {
1764− // Generated by purs version 0.13.6
1765− "use strict";
1766− $PS["Effect.Console"] = $PS["Effect.Console"] || {};
1767− var exports = $PS["Effect.Console"];
1768− var $foreign = $PS["Effect.Console"];
1769− exports["log"] = $foreign.log;
1770−})(PS);
1771−(function(exports) {
1772− "use strict";
2005+ // output/Crypto.Subtle.Hash/index.js
2006+ var sha512 = "SHA-512";
2007+ var sha384 = "SHA-384";
2008+ var sha256 = "SHA-256";
2009+ var sha1 = "SHA-1";
17732010
1774− exports.throwException = function (e) {
1775− return function () {
1776− throw e;
2011+ // output/Crypto.Subtle.Key.Generate/foreign.js
2012+ function generateKeyImpl(a, e, u) {
2013+ return crypto.subtle.generateKey(a, e, u);
2014+ }
2015+ var exp65537 = new Uint8Array([1, 0, 1]);
2016+
2017+ // output/Crypto.Subtle.Key.Generate/index.js
2018+ var rsa = function(r) {
2019+ return function(l) {
2020+ return function(e) {
2021+ return function(h) {
2022+ return {
2023+ name: r,
2024+ modulusLength: l,
2025+ publicExponent: e,
2026+ hash: h
2027+ };
2028+ };
2029+ };
2030+ };
2031+ };
2032+ var hmac = function(h) {
2033+ return {
2034+ name: "HMAC",
2035+ hash: h
17772036 };
17782037 };
1779−})(PS["Effect.Exception"] = PS["Effect.Exception"] || {});
1780−(function($PS) {
1781− // Generated by purs version 0.13.6
1782− "use strict";
1783− $PS["Effect.Exception"] = $PS["Effect.Exception"] || {};
1784− var exports = $PS["Effect.Exception"];
1785− var $foreign = $PS["Effect.Exception"];
1786− exports["throwException"] = $foreign.throwException;
1787−})(PS);
1788−(function($PS) {
1789− // Generated by purs version 0.13.6
1790− "use strict";
1791− $PS["Test.Main"] = $PS["Test.Main"] || {};
1792− var exports = $PS["Test.Main"];
1793− var Control_Applicative = $PS["Control.Applicative"];
1794− var Control_Bind = $PS["Control.Bind"];
1795− var Crypto_Subtle_Constants_AES = $PS["Crypto.Subtle.Constants.AES"];
1796− var Crypto_Subtle_Constants_EC = $PS["Crypto.Subtle.Constants.EC"];
1797− var Crypto_Subtle_Constants_RSA = $PS["Crypto.Subtle.Constants.RSA"];
1798− var Crypto_Subtle_Hash = $PS["Crypto.Subtle.Hash"];
1799− var Crypto_Subtle_Key_Generate = $PS["Crypto.Subtle.Key.Generate"];
1800− var Crypto_Subtle_Key_Types = $PS["Crypto.Subtle.Key.Types"];
1801− var Data_Either = $PS["Data.Either"];
1802− var Data_Unit = $PS["Data.Unit"];
1803− var Effect = $PS["Effect"];
1804− var Effect_Aff = $PS["Effect.Aff"];
1805− var Effect_Class = $PS["Effect.Class"];
1806− var Effect_Console = $PS["Effect.Console"];
1807− var Effect_Exception = $PS["Effect.Exception"];
1808− var log$prime = (function () {
1809− var $31 = Effect_Class.liftEffect(Effect_Aff.monadEffectAff);
1810− return function ($32) {
1811− return $31(Effect_Console.log($32));
2038+ var generateKeyPair = function(a) {
2039+ return function(e) {
2040+ return function(u) {
2041+ return toAff$prime(errorFromDOMException)(generateKeyImpl(a, e, u));
18122042 };
1813− })();
1814− var main = (function () {
1815− var resolve = function (eX) {
1816− if (eX instanceof Data_Either.Left) {
1817− return Effect_Exception.throwException(eX.value0);
1818− };
1819− if (eX instanceof Data_Either.Right) {
1820− return Control_Applicative.pure(Effect.applicativeEffect)(Data_Unit.unit);
1821− };
1822− throw new Error("Failed pattern match at Test.Main (line 24, column 20 - line 26, column 29): " + [ eX.constructor.name ]);
2043+ };
2044+ };
2045+ var generateKey = function(a) {
2046+ return function(e) {
2047+ return function(u) {
2048+ return toAff$prime(errorFromDOMException)(generateKeyImpl(a, e, u));
2049+ };
2050+ };
2051+ };
2052+ var ec = function(e) {
2053+ return function(c) {
2054+ return {
2055+ name: e,
2056+ namedCurve: c
18232057 };
1824− return Effect_Aff.runAff_(resolve)(Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime("Generating Keys..."))(function () {
1825− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)((function () {
1826− var genAES = function (mode) {
1827− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(Control_Bind.bind(Effect_Aff.bindAff)(Control_Bind.bindFlipped(Effect_Aff.bindAff)(Crypto_Subtle_Key_Types.exportKey(Crypto_Subtle_Key_Types.raw))(Crypto_Subtle_Key_Generate.generateKey(Crypto_Subtle_Key_Generate.aes(mode)(Crypto_Subtle_Constants_AES.l128))(true)(Crypto_Subtle_Key_Types.allUsages)))(function (k) {
1828− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - 128"))(function () {
1829− return log$prime(k);
2058+ };
2059+ };
2060+ var aes = function(a) {
2061+ return function(l) {
2062+ return {
2063+ name: a,
2064+ length: l
2065+ };
2066+ };
2067+ };
2068+
2069+ // output/Effect.Console/foreign.js
2070+ var log2 = function(s) {
2071+ return function() {
2072+ console.log(s);
2073+ };
2074+ };
2075+
2076+ // output/Test.Main/index.js
2077+ var pure3 = /* @__PURE__ */ pure(applicativeEffect);
2078+ var discard2 = /* @__PURE__ */ discard(discardUnit)(bindAff);
2079+ var bind3 = /* @__PURE__ */ bind(bindAff);
2080+ var bindFlipped3 = /* @__PURE__ */ bindFlipped(bindAff);
2081+ var log$prime = /* @__PURE__ */ function() {
2082+ var $38 = liftEffect(monadEffectAff);
2083+ return function($39) {
2084+ return $38(log2($39));
2085+ };
2086+ }();
2087+ var main = /* @__PURE__ */ function() {
2088+ var resolve = function(eX) {
2089+ if (eX instanceof Left) {
2090+ return throwException(eX.value0);
2091+ }
2092+ ;
2093+ if (eX instanceof Right) {
2094+ return pure3(unit);
2095+ }
2096+ ;
2097+ throw new Error("Failed pattern match at Test.Main (line 24, column 20 - line 26, column 29): " + [eX.constructor.name]);
2098+ };
2099+ return runAff_(resolve)(discard2(log$prime("Generating Keys..."))(function() {
2100+ return discard2(function() {
2101+ var genAES = function(mode) {
2102+ return discard2(bind3(bindFlipped3(exportKey(raw))(generateKey(aes(mode)(l128))(true)(allUsages)))(function(k) {
2103+ return discard2(log$prime(" - 128"))(function() {
2104+ return log$prime(k);
2105+ });
2106+ }))(function() {
2107+ return discard2(bind3(bindFlipped3(exportKey(raw))(generateKey(aes(mode)(l192))(true)(allUsages)))(function(k) {
2108+ return discard2(log$prime(" - 192"))(function() {
2109+ return log$prime(k);
2110+ });
2111+ }))(function() {
2112+ return bind3(bindFlipped3(exportKey(raw))(generateKey(aes(mode)(l256))(true)(allUsages)))(function(k) {
2113+ return discard2(log$prime(" - 256"))(function() {
2114+ return log$prime(k);
2115+ });
2116+ });
2117+ });
2118+ });
2119+ };
2120+ return discard2(log$prime("- AES-CTR"))(function() {
2121+ return discard2(genAES(aesCTR))(function() {
2122+ return discard2(log$prime("- AES-CBC"))(function() {
2123+ return discard2(genAES(aesCBC))(function() {
2124+ return discard2(log$prime("- AES-GCM"))(function() {
2125+ return discard2(genAES(aesGCM))(function() {
2126+ return discard2(log$prime("- AES-KW"))(function() {
2127+ return genAES(aesKW);
2128+ });
2129+ });
2130+ });
2131+ });
2132+ });
2133+ });
2134+ });
2135+ }())(function() {
2136+ return discard2(discard2(log$prime("HMAC"))(function() {
2137+ return discard2(bind3(bindFlipped3(exportKey(raw))(generateKey(hmac(sha1))(true)(allUsages)))(function(k) {
2138+ return discard2(log$prime(" - SHA-1"))(function() {
2139+ return log$prime(k);
2140+ });
2141+ }))(function() {
2142+ return discard2(bind3(bindFlipped3(exportKey(raw))(generateKey(hmac(sha256))(true)(allUsages)))(function(k) {
2143+ return discard2(log$prime(" - SHA-256"))(function() {
2144+ return log$prime(k);
2145+ });
2146+ }))(function() {
2147+ return discard2(bind3(bindFlipped3(exportKey(raw))(generateKey(hmac(sha384))(true)(allUsages)))(function(k) {
2148+ return discard2(log$prime(" - SHA-384"))(function() {
2149+ return log$prime(k);
2150+ });
2151+ }))(function() {
2152+ return bind3(bindFlipped3(exportKey(raw))(generateKey(hmac(sha512))(true)(allUsages)))(function(k) {
2153+ return discard2(log$prime(" - SHA-512"))(function() {
2154+ return log$prime(k);
2155+ });
2156+ });
2157+ });
2158+ });
2159+ });
2160+ }))(function() {
2161+ return discard2(function() {
2162+ var genEC = function(alg) {
2163+ return discard2(bind3(generateKeyPair(ec(alg)(p256))(true)(allUsages))(function(v) {
2164+ return discard2(log$prime(" - P-256"))(function() {
2165+ return discard2(log$prime(" - privateKey"))(function() {
2166+ return discard2(log$prime(v.privateKey))(function() {
2167+ return discard2(log$prime(" - publicKey"))(function() {
2168+ return bind3(exportKey(raw)(v.publicKey))(function(publicKey$prime) {
2169+ return log$prime(publicKey$prime);
2170+ });
18302171 });
1831− }))(function () {
1832− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(Control_Bind.bind(Effect_Aff.bindAff)(Control_Bind.bindFlipped(Effect_Aff.bindAff)(Crypto_Subtle_Key_Types.exportKey(Crypto_Subtle_Key_Types.raw))(Crypto_Subtle_Key_Generate.generateKey(Crypto_Subtle_Key_Generate.aes(mode)(Crypto_Subtle_Constants_AES.l192))(true)(Crypto_Subtle_Key_Types.allUsages)))(function (k) {
1833− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - 192"))(function () {
1834− return log$prime(k);
1835− });
1836− }))(function () {
1837− return Control_Bind.bind(Effect_Aff.bindAff)(Control_Bind.bindFlipped(Effect_Aff.bindAff)(Crypto_Subtle_Key_Types.exportKey(Crypto_Subtle_Key_Types.raw))(Crypto_Subtle_Key_Generate.generateKey(Crypto_Subtle_Key_Generate.aes(mode)(Crypto_Subtle_Constants_AES.l256))(true)(Crypto_Subtle_Key_Types.allUsages)))(function (k) {
1838− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - 256"))(function () {
1839− return log$prime(k);
1840− });
2172+ });
2173+ });
2174+ });
2175+ }))(function() {
2176+ return discard2(bind3(generateKeyPair(ec(alg)(p384))(true)(allUsages))(function(v) {
2177+ return discard2(log$prime(" - P-384"))(function() {
2178+ return discard2(log$prime(" - privateKey"))(function() {
2179+ return discard2(log$prime(v.privateKey))(function() {
2180+ return discard2(log$prime(" - publicKey"))(function() {
2181+ return bind3(exportKey(raw)(v.publicKey))(function(publicKey$prime) {
2182+ return log$prime(publicKey$prime);
18412183 });
2184+ });
18422185 });
2186+ });
18432187 });
1844− };
1845− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime("- AES-CTR"))(function () {
1846− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(genAES(Crypto_Subtle_Constants_AES.aesCTR))(function () {
1847− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime("- AES-CBC"))(function () {
1848− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(genAES(Crypto_Subtle_Constants_AES.aesCBC))(function () {
1849− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime("- AES-GCM"))(function () {
1850− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(genAES(Crypto_Subtle_Constants_AES.aesGCM))(function () {
1851− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime("- AES-KW"))(function () {
1852− return genAES(Crypto_Subtle_Constants_AES.aesKW);
1853− });
1854− });
1855− });
2188+ }))(function() {
2189+ return bind3(generateKeyPair(ec(alg)(p521))(true)(allUsages))(function(v) {
2190+ return discard2(log$prime(" - P-521"))(function() {
2191+ return discard2(log$prime(" - privateKey"))(function() {
2192+ return discard2(log$prime(v.privateKey))(function() {
2193+ return discard2(log$prime(" - publicKey"))(function() {
2194+ return bind3(exportKey(raw)(v.publicKey))(function(publicKey$prime) {
2195+ return log$prime(publicKey$prime);
2196+ });
18562197 });
2198+ });
18572199 });
2200+ });
18582201 });
2202+ });
18592203 });
1860− })())(function () {
1861− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime("HMAC"))(function () {
1862− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(Control_Bind.bind(Effect_Aff.bindAff)(Control_Bind.bindFlipped(Effect_Aff.bindAff)(Crypto_Subtle_Key_Types.exportKey(Crypto_Subtle_Key_Types.raw))(Crypto_Subtle_Key_Generate.generateKey(Crypto_Subtle_Key_Generate.hmac(Crypto_Subtle_Hash.sha1))(true)(Crypto_Subtle_Key_Types.allUsages)))(function (k) {
1863− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - SHA-1"))(function () {
1864− return log$prime(k);
2204+ };
2205+ return discard2(log$prime("- ECDSA"))(function() {
2206+ return discard2(genEC(ecdsa))(function() {
2207+ return discard2(log$prime("- ECDH"))(function() {
2208+ return genEC(ecdh);
2209+ });
2210+ });
2211+ });
2212+ }())(function() {
2213+ var genRSA = function(alg) {
2214+ return discard2(bind3(generateKeyPair(rsa(alg)(2048)(exp65537)(sha1))(true)(allUsages))(function(v) {
2215+ return discard2(log$prime(" - SHA-1"))(function() {
2216+ return discard2(log$prime(" - privateKey"))(function() {
2217+ return discard2(log$prime(v.privateKey))(function() {
2218+ return discard2(log$prime(" - publicKey"))(function() {
2219+ return log$prime(v.publicKey);
18652220 });
1866− }))(function () {
1867− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(Control_Bind.bind(Effect_Aff.bindAff)(Control_Bind.bindFlipped(Effect_Aff.bindAff)(Crypto_Subtle_Key_Types.exportKey(Crypto_Subtle_Key_Types.raw))(Crypto_Subtle_Key_Generate.generateKey(Crypto_Subtle_Key_Generate.hmac(Crypto_Subtle_Hash.sha256))(true)(Crypto_Subtle_Key_Types.allUsages)))(function (k) {
1868− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - SHA-256"))(function () {
1869− return log$prime(k);
1870− });
1871− }))(function () {
1872− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(Control_Bind.bind(Effect_Aff.bindAff)(Control_Bind.bindFlipped(Effect_Aff.bindAff)(Crypto_Subtle_Key_Types.exportKey(Crypto_Subtle_Key_Types.raw))(Crypto_Subtle_Key_Generate.generateKey(Crypto_Subtle_Key_Generate.hmac(Crypto_Subtle_Hash.sha384))(true)(Crypto_Subtle_Key_Types.allUsages)))(function (k) {
1873− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - SHA-384"))(function () {
1874− return log$prime(k);
1875− });
1876− }))(function () {
1877− return Control_Bind.bind(Effect_Aff.bindAff)(Control_Bind.bindFlipped(Effect_Aff.bindAff)(Crypto_Subtle_Key_Types.exportKey(Crypto_Subtle_Key_Types.raw))(Crypto_Subtle_Key_Generate.generateKey(Crypto_Subtle_Key_Generate.hmac(Crypto_Subtle_Hash.sha512))(true)(Crypto_Subtle_Key_Types.allUsages)))(function (k) {
1878− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - SHA-512"))(function () {
1879− return log$prime(k);
1880− });
1881− });
1882− });
2221+ });
2222+ });
2223+ });
2224+ }))(function() {
2225+ return discard2(bind3(generateKeyPair(rsa(alg)(2048)(exp65537)(sha256))(true)(allUsages))(function(v) {
2226+ return discard2(log$prime(" - SHA-256"))(function() {
2227+ return discard2(log$prime(" - privateKey"))(function() {
2228+ return discard2(log$prime(v.privateKey))(function() {
2229+ return discard2(log$prime(" - publicKey"))(function() {
2230+ return log$prime(v.publicKey);
2231+ });
18832232 });
2233+ });
18842234 });
1885− }))(function () {
1886− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)((function () {
1887− var genEC = function (alg) {
1888− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(Control_Bind.bind(Effect_Aff.bindAff)(Crypto_Subtle_Key_Generate.generateKeyPair(Crypto_Subtle_Key_Generate.ec(alg)(Crypto_Subtle_Constants_EC.p256))(true)(Crypto_Subtle_Key_Types.allUsages))(function (v) {
1889− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - P-256"))(function () {
1890− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - privateKey"))(function () {
1891− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(v.privateKey))(function () {
1892− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - publicKey"))(function () {
1893− return Control_Bind.bind(Effect_Aff.bindAff)(Crypto_Subtle_Key_Types.exportKey(Crypto_Subtle_Key_Types.raw)(v.publicKey))(function (publicKey$prime) {
1894− return log$prime(publicKey$prime);
1895− });
1896− });
1897− });
1898− });
1899− });
1900− }))(function () {
1901− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(Control_Bind.bind(Effect_Aff.bindAff)(Crypto_Subtle_Key_Generate.generateKeyPair(Crypto_Subtle_Key_Generate.ec(alg)(Crypto_Subtle_Constants_EC.p384))(true)(Crypto_Subtle_Key_Types.allUsages))(function (v) {
1902− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - P-384"))(function () {
1903− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - privateKey"))(function () {
1904− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(v.privateKey))(function () {
1905− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - publicKey"))(function () {
1906− return Control_Bind.bind(Effect_Aff.bindAff)(Crypto_Subtle_Key_Types.exportKey(Crypto_Subtle_Key_Types.raw)(v.publicKey))(function (publicKey$prime) {
1907− return log$prime(publicKey$prime);
1908− });
1909− });
1910− });
1911− });
1912− });
1913− }))(function () {
1914− return Control_Bind.bind(Effect_Aff.bindAff)(Crypto_Subtle_Key_Generate.generateKeyPair(Crypto_Subtle_Key_Generate.ec(alg)(Crypto_Subtle_Constants_EC.p521))(true)(Crypto_Subtle_Key_Types.allUsages))(function (v) {
1915− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - P-521"))(function () {
1916− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - privateKey"))(function () {
1917− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(v.privateKey))(function () {
1918− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - publicKey"))(function () {
1919− return Control_Bind.bind(Effect_Aff.bindAff)(Crypto_Subtle_Key_Types.exportKey(Crypto_Subtle_Key_Types.raw)(v.publicKey))(function (publicKey$prime) {
1920− return log$prime(publicKey$prime);
1921− });
1922− });
1923− });
1924− });
1925− });
1926− });
1927− });
1928− });
1929− };
1930− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime("- ECDSA"))(function () {
1931− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(genEC(Crypto_Subtle_Constants_EC.ecdsa))(function () {
1932− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime("- ECDH"))(function () {
1933− return genEC(Crypto_Subtle_Constants_EC.ecdh);
1934− });
2235+ }))(function() {
2236+ return discard2(bind3(generateKeyPair(rsa(alg)(2048)(exp65537)(sha384))(true)(allUsages))(function(v) {
2237+ return discard2(log$prime(" - SHA-384"))(function() {
2238+ return discard2(log$prime(" - privateKey"))(function() {
2239+ return discard2(log$prime(v.privateKey))(function() {
2240+ return discard2(log$prime(" - publicKey"))(function() {
2241+ return log$prime(v.publicKey);
19352242 });
2243+ });
19362244 });
1937− })())(function () {
1938− var genRSA = function (alg) {
1939− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(Control_Bind.bind(Effect_Aff.bindAff)(Crypto_Subtle_Key_Generate.generateKeyPair(Crypto_Subtle_Key_Generate.rsa(alg)(2048)(Crypto_Subtle_Key_Generate.exp65537)(Crypto_Subtle_Hash.sha1))(true)(Crypto_Subtle_Key_Types.allUsages))(function (v) {
1940− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - SHA-1"))(function () {
1941− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - privateKey"))(function () {
1942− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(v.privateKey))(function () {
1943− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - publicKey"))(function () {
1944− return log$prime(v.publicKey);
1945− });
1946− });
1947− });
1948− });
1949− }))(function () {
1950− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(Control_Bind.bind(Effect_Aff.bindAff)(Crypto_Subtle_Key_Generate.generateKeyPair(Crypto_Subtle_Key_Generate.rsa(alg)(2048)(Crypto_Subtle_Key_Generate.exp65537)(Crypto_Subtle_Hash.sha256))(true)(Crypto_Subtle_Key_Types.allUsages))(function (v) {
1951− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - SHA-256"))(function () {
1952− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - privateKey"))(function () {
1953− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(v.privateKey))(function () {
1954− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - publicKey"))(function () {
1955− return log$prime(v.publicKey);
1956− });
1957− });
1958− });
1959− });
1960− }))(function () {
1961− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(Control_Bind.bind(Effect_Aff.bindAff)(Crypto_Subtle_Key_Generate.generateKeyPair(Crypto_Subtle_Key_Generate.rsa(alg)(2048)(Crypto_Subtle_Key_Generate.exp65537)(Crypto_Subtle_Hash.sha384))(true)(Crypto_Subtle_Key_Types.allUsages))(function (v) {
1962− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - SHA-384"))(function () {
1963− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - privateKey"))(function () {
1964− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(v.privateKey))(function () {
1965− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - publicKey"))(function () {
1966− return log$prime(v.publicKey);
1967− });
1968− });
1969− });
1970− });
1971− }))(function () {
1972− return Control_Bind.bind(Effect_Aff.bindAff)(Crypto_Subtle_Key_Generate.generateKeyPair(Crypto_Subtle_Key_Generate.rsa(alg)(2048)(Crypto_Subtle_Key_Generate.exp65537)(Crypto_Subtle_Hash.sha512))(true)(Crypto_Subtle_Key_Types.allUsages))(function (v) {
1973− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - SHA-512"))(function () {
1974− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - privateKey"))(function () {
1975− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(v.privateKey))(function () {
1976− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime(" - publicKey"))(function () {
1977− return log$prime(v.publicKey);
1978− });
1979− });
1980− });
1981− });
1982− });
1983− });
1984− });
1985− });
1986− };
1987− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime("- RSASSA-PKCS1-v1_5"))(function () {
1988− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(genRSA(Crypto_Subtle_Constants_RSA.rsaPKCS1))(function () {
1989− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime("- RSA-PSS"))(function () {
1990− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(genRSA(Crypto_Subtle_Constants_RSA.rsaPSS))(function () {
1991− return Control_Bind.discard(Control_Bind.discardUnit)(Effect_Aff.bindAff)(log$prime("- RSA-OAEP"))(function () {
1992− return genRSA(Crypto_Subtle_Constants_RSA.rsaOAEP);
1993− });
1994− });
1995− });
2245+ });
2246+ }))(function() {
2247+ return bind3(generateKeyPair(rsa(alg)(2048)(exp65537)(sha512))(true)(allUsages))(function(v) {
2248+ return discard2(log$prime(" - SHA-512"))(function() {
2249+ return discard2(log$prime(" - privateKey"))(function() {
2250+ return discard2(log$prime(v.privateKey))(function() {
2251+ return discard2(log$prime(" - publicKey"))(function() {
2252+ return log$prime(v.publicKey);
2253+ });
19962254 });
2255+ });
19972256 });
2257+ });
19982258 });
2259+ });
19992260 });
2261+ };
2262+ return discard2(log$prime("- RSASSA-PKCS1-v1_5"))(function() {
2263+ return discard2(genRSA(rsaPKCS1))(function() {
2264+ return discard2(log$prime("- RSA-PSS"))(function() {
2265+ return discard2(genRSA(rsaPSS))(function() {
2266+ return discard2(log$prime("- RSA-OAEP"))(function() {
2267+ return genRSA(rsaOAEP);
2268+ });
2269+ });
2270+ });
2271+ });
2272+ });
20002273 });
2001− }));
2002− })();
2003− exports["main"] = main;
2004− exports["log'"] = log$prime;
2005−})(PS);
2006−PS["Test.Main"].main();
2274+ });
2275+ });
2276+ }));
2277+ }();
2278+
2279+ // <stdin>
2280+ main();
2281+})();