git.iko.soy/rowtype-yoga/purescript-yoga-subtlecrypto
on master help sign in
rowtype-yoga/purescript-yoga-subtlecrypto/test.browser.js
2281 lines 67 kB history raw
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 };
10 };
11 }
12 };
14 // output/Control.Category/index.js
15 var identity = function(dict) {
16 return dict.identity;
17 };
18 var categoryFn = {
19 identity: function(x) {
20 return x;
21 },
22 Semigroupoid0: function() {
23 return semigroupoidFn;
24 }
25 };
27 // output/Data.Boolean/index.js
28 var otherwise = true;
30 // output/Data.Function/index.js
31 var flip = function(f) {
32 return function(b) {
33 return function(a) {
34 return f(a)(b);
35 };
36 };
37 };
38 var $$const = function(a) {
39 return function(v) {
40 return a;
41 };
42 };
44 // output/Data.Unit/foreign.js
45 var unit = void 0;
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 };
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);
72 };
73 };
74 };
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);
86 };
87 };
88 };
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 }
104 };
106 // output/Crypto.Subtle.Constants.AES/index.js
107 var l256 = 256;
108 var l192 = 192;
109 var l128 = 128;
110 var aesKW = "AES-KW";
111 var aesGCM = "AES-GCM";
112 var aesCTR = "AES-CTR";
113 var aesCBC = "AES-CBC";
115 // output/Crypto.Subtle.Constants.EC/index.js
116 var p521 = "P-521";
117 var p384 = "P-384";
118 var p256 = "P-256";
119 var ecdsa = "ECDSA";
120 var ecdh = "ECDH";
122 // output/Crypto.Subtle.Constants.RSA/index.js
123 var rsaPSS = "RSA-PSS";
124 var rsaPKCS1 = "RSASSA-PKCS1-v1_5";
125 var rsaOAEP = "RSA-OAEP";
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 }
138 // output/Data.Semigroup/index.js
139 var append = function(dict) {
140 return dict.append;
141 };
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;
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 };
198 };
199 };
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() {
210 return f(a())();
211 };
212 };
213 };
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 };
230 // output/Data.Monoid/index.js
231 var mempty = function(dict) {
232 return dict.mempty;
233 };
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() {
250 return applicativeEffect;
251 },
252 Bind1: function() {
253 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 };
280 });
281 var functorEffect = /* @__PURE__ */ $lazy_functorEffect(20);
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 }
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 };
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 };
358 // output/Unsafe.Coerce/foreign.js
359 var unsafeCoerce2 = function(x) {
360 return x;
361 };
363 // output/Effect.Class/index.js
364 var liftEffect = function(dict) {
365 return dict.liftEffect;
366 };
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 };
455 // output/Safe.Coerce/index.js
456 var coerce = function() {
457 return unsafeCoerce2;
458 };
460 // output/Data.Newtype/index.js
461 var coerce2 = /* @__PURE__ */ coerce();
462 var unwrap = function() {
463 return coerce2;
464 };
466 // output/Control.Monad.Except/index.js
467 var unwrap2 = /* @__PURE__ */ unwrap();
468 var runExcept = function($3) {
469 return unwrap2(runExceptT($3));
470 };
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 };
498 // output/Control.Plus/index.js
499 var empty = function(dict) {
500 return dict.empty;
501 };
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 };
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 };
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 };
740 }
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 }();
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 }
787 function AffCtr(tag) {
788 var fn = function(_1, _2, _3) {
789 return new Aff2(tag, _1, _2, _3);
790 };
791 fn.tag = tag;
792 return fn;
793 }
794 function nonCanceler2(error3) {
795 return new Aff2(PURE, void 0);
796 }
797 function runEff(eff) {
798 try {
799 eff();
800 } catch (error3) {
801 setTimeout(function() {
802 throw error3;
803 }, 0);
804 }
805 }
806 function runSync(left, right, eff) {
807 try {
808 return right(eff());
809 } catch (error3) {
810 return left(error3);
811 }
812 }
813 function runAsync(left, eff, k) {
814 try {
815 return eff(k)();
816 } catch (error3) {
817 k(left(error3))();
818 return nonCanceler2;
819 }
820 }
821 var Scheduler = function() {
822 var limit = 1024;
823 var size = 0;
824 var ix = 0;
825 var queue = new Array(limit);
826 var draining = false;
827 function drain() {
828 var thunk;
829 draining = true;
830 while (size !== 0) {
831 size--;
832 thunk = queue[ix];
833 queue[ix] = void 0;
834 ix = (ix + 1) % limit;
835 thunk();
836 }
837 draining = false;
838 }
839 return {
840 isDraining: function() {
841 return draining;
842 },
843 enqueue: function(cb) {
844 var i, tmp;
845 if (size === limit) {
846 tmp = draining;
847 drain();
848 draining = tmp;
849 }
850 queue[(ix + size) % limit] = cb;
851 size++;
852 if (!draining) {
853 drain();
854 }
855 }
856 };
857 }();
858 function Supervisor(util) {
859 var fibers = {};
860 var fiberId = 0;
861 var count = 0;
862 return {
863 register: function(fiber) {
864 var fid = fiberId++;
865 fiber.onComplete({
866 rethrow: true,
867 handler: function(result) {
868 return function() {
869 count--;
870 delete fibers[fid];
871 };
872 }
873 })();
874 fibers[fid] = fiber;
875 count++;
876 },
877 isEmpty: function() {
878 return count === 0;
879 },
880 killAll: function(killError, cb) {
881 return function() {
882 if (count === 0) {
883 return cb();
884 }
885 var killCount = 0;
886 var kills = {};
887 function kill(fid) {
888 kills[fid] = fibers[fid].kill(killError, function(result) {
889 return function() {
890 delete kills[fid];
891 killCount--;
892 if (util.isLeft(result) && util.fromLeft(result)) {
893 setTimeout(function() {
894 throw util.fromLeft(result);
895 }, 0);
896 }
897 if (killCount === 0) {
898 cb();
899 }
900 };
901 })();
902 }
903 for (var k in fibers) {
904 if (fibers.hasOwnProperty(k)) {
905 killCount++;
906 kill(k);
907 }
908 }
909 fibers = {};
910 fiberId = 0;
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]();
917 }
918 }
919 });
920 };
921 };
922 }
923 };
924 }
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;
932 function Fiber(util, supervisor, aff) {
933 var runTick = 0;
934 var status = SUSPENDED;
935 var step = aff;
936 var fail2 = null;
937 var interrupt = null;
938 var bhead = null;
939 var btail = null;
940 var attempts = null;
941 var bracketCount = 0;
942 var joinId = 0;
943 var joins = null;
944 var rethrow = true;
945 function run2(localRunTick) {
946 var tmp, result, attempt;
947 while (true) {
948 tmp = null;
949 result = null;
950 attempt = null;
951 switch (status) {
952 case STEP_BIND:
953 status = CONTINUE;
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 }
967 break;
968 case STEP_RESULT:
969 if (util.isLeft(step)) {
970 status = RETURN;
971 fail2 = step;
972 step = null;
973 } else if (bhead === null) {
974 status = RETURN;
975 } else {
976 status = STEP_BIND;
977 step = util.fromRight(step);
978 }
979 break;
980 case CONTINUE:
981 switch (step.tag) {
982 case BIND:
983 if (bhead) {
984 btail = new Aff2(CONS, bhead, btail);
985 }
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;
1010 runTick++;
1011 Scheduler.enqueue(function() {
1012 if (runTick !== localRunTick + 1) {
1013 return;
1015 status = STEP_RESULT;
1016 step = result2;
1017 run2(runTick);
1018 });
1019 };
1020 });
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);
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);
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);
1060 if (step._1) {
1061 tmp.run();
1063 step = util.right(tmp);
1064 break;
1065 case SEQ:
1066 status = CONTINUE;
1067 step = sequential2(util, supervisor, step._1);
1068 break;
1070 break;
1071 case RETURN:
1072 bhead = null;
1073 btail = null;
1074 if (attempts === null) {
1075 status = COMPLETED;
1076 step = interrupt || fail2 || step;
1077 } else {
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;
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);
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);
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);
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;
1149 break;
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));
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);
1167 }, 0);
1169 return;
1170 case SUSPENDED:
1171 status = CONTINUE;
1172 break;
1173 case PENDING:
1174 return;
1178 function onComplete(join3) {
1179 return function() {
1180 if (status === COMPLETED) {
1181 rethrow = rethrow && join3.rethrow;
1182 join3.handler(step)();
1183 return function() {
1184 };
1186 var jid = joinId++;
1187 joins = joins || {};
1188 joins[jid] = join3;
1189 return function() {
1190 if (joins !== null) {
1191 delete joins[jid];
1193 };
1194 };
1196 function kill(error3, cb) {
1197 return function() {
1198 if (status === COMPLETED) {
1199 cb(util.right(void 0))();
1200 return function() {
1201 };
1203 var canceler = onComplete({
1204 rethrow: false,
1205 handler: function() {
1206 return cb(util.right(void 0));
1208 })();
1209 switch (status) {
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);
1220 if (bracketCount === 0) {
1221 if (status === PENDING) {
1222 attempts = new Aff2(CONS, new Aff2(FINALIZER, step(error3)), attempts, interrupt);
1224 status = RETURN;
1225 step = null;
1226 fail2 = null;
1227 run2(++runTick);
1229 break;
1230 default:
1231 if (interrupt === null) {
1232 interrupt = util.left(error3);
1234 if (bracketCount === 0) {
1235 status = RETURN;
1236 step = null;
1237 fail2 = null;
1240 return canceler;
1241 };
1243 function join2(cb) {
1244 return function() {
1245 var canceler = onComplete({
1246 rethrow: false,
1247 handler: cb
1248 })();
1249 if (status === SUSPENDED) {
1250 run2(runTick);
1252 return canceler;
1253 };
1255 return {
1256 kill,
1257 join: join2,
1258 onComplete,
1259 isSuspended: function() {
1260 return status === SUSPENDED;
1261 },
1262 run: function() {
1263 if (status === SUSPENDED) {
1264 if (!Scheduler.isDraining()) {
1265 Scheduler.enqueue(function() {
1266 run2(runTick);
1267 });
1268 } else {
1269 run2(runTick);
1273 };
1275 function runPar(util, supervisor, par, cb) {
1276 var fiberId = 0;
1277 var fibers = {};
1278 var killId = 0;
1279 var kills = {};
1280 var early = new Error("[ParAff] Early exit");
1281 var interrupt = null;
1282 var root = EMPTY;
1283 function kill(error3, par2, cb2) {
1284 var step = par2;
1285 var head = null;
1286 var tail = null;
1287 var count = 0;
1288 var kills2 = {};
1289 var tmp, kid;
1290 loop: while (true) {
1291 tmp = null;
1292 switch (step.tag) {
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)();
1302 };
1303 });
1305 if (head === null) {
1306 break loop;
1308 step = head._2;
1309 if (tail === null) {
1310 head = null;
1311 } else {
1312 head = tail._1;
1313 tail = tail._2;
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);
1324 head = step;
1325 step = step._1;
1326 break;
1329 if (count === 0) {
1330 cb2(util.right(void 0))();
1331 } else {
1332 kid = 0;
1333 tmp = count;
1334 for (; kid < tmp; kid++) {
1335 kills2[kid] = kills2[kid]();
1338 return kills2;
1340 function join2(result, head, tail) {
1341 var fail2, step, lhs, rhs, tmp, kid;
1342 if (util.isLeft(result)) {
1343 fail2 = result;
1344 step = null;
1345 } else {
1346 step = result;
1347 fail2 = null;
1349 loop: while (true) {
1350 lhs = null;
1351 rhs = null;
1352 tmp = null;
1353 kid = null;
1354 if (interrupt !== null) {
1355 return;
1357 if (head === null) {
1358 cb(fail2 || step)();
1359 return;
1361 if (head._3 !== EMPTY) {
1362 return;
1364 switch (head.tag) {
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;
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);
1390 };
1391 });
1392 if (tmp) {
1393 tmp = false;
1394 return;
1396 } else if (lhs === EMPTY || rhs === EMPTY) {
1397 return;
1398 } else {
1399 step = util.right(util.fromRight(lhs)(util.fromRight(rhs)));
1400 head._3 = step;
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)) {
1407 return;
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);
1427 };
1428 });
1429 if (tmp) {
1430 tmp = false;
1431 return;
1434 break;
1436 if (tail === null) {
1437 head = null;
1438 } else {
1439 head = tail._1;
1440 tail = tail._2;
1444 function resolve(fiber) {
1445 return function(result) {
1446 return function() {
1447 delete fibers[fiber._1];
1448 fiber._3 = result;
1449 join2(result, fiber._2._1, fiber._2._2);
1450 };
1451 };
1453 function run2() {
1454 var status = CONTINUE;
1455 var step = par;
1456 var head = null;
1457 var tail = null;
1458 var tmp, fid;
1459 loop: while (true) {
1460 tmp = null;
1461 fid = null;
1462 switch (status) {
1463 case CONTINUE:
1464 switch (step.tag) {
1465 case MAP:
1466 if (head) {
1467 tail = new Aff2(CONS, head, tail);
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);
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);
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);
1501 break;
1502 case RETURN:
1503 if (head === null) {
1504 break loop;
1506 if (head._1 === EMPTY) {
1507 head._1 = step;
1508 status = CONTINUE;
1509 step = head._2;
1510 head._2 = EMPTY;
1511 } else {
1512 head._2 = step;
1513 step = head;
1514 if (tail === null) {
1515 head = null;
1516 } else {
1517 head = tail._1;
1518 tail = tail._2;
1523 root = step;
1524 for (fid = 0; fid < fiberId; fid++) {
1525 fibers[fid].run();
1528 function cancel(error3, cb2) {
1529 interrupt = util.left(error3);
1530 var innerKills;
1531 for (var kid in kills) {
1532 if (kills.hasOwnProperty(kid)) {
1533 innerKills = kills[kid];
1534 for (kid in innerKills) {
1535 if (innerKills.hasOwnProperty(kid)) {
1536 innerKills[kid]();
1541 kills = null;
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]();
1551 return nonCanceler2;
1552 };
1553 });
1554 };
1556 run2();
1557 return function(killError) {
1558 return new Aff2(ASYNC, function(killCb) {
1559 return function() {
1560 return cancel(killError, killCb);
1561 };
1562 });
1563 };
1565 function sequential2(util, supervisor, par) {
1566 return new Aff2(ASYNC, function(cb) {
1567 return function() {
1568 return runPar(util, supervisor, par, cb);
1569 };
1570 });
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;
1590 }();
1591 var _pure = Aff.Pure;
1592 var _throwError = Aff.Throw;
1593 function _catchError(aff) {
1594 return function(k) {
1595 return Aff.Catch(aff, k);
1596 };
1598 function _map(f) {
1599 return function(aff) {
1600 if (aff.tag === Aff.Pure.tag) {
1601 return Aff.Pure(f(aff._1));
1602 } else {
1603 return Aff.Bind(aff, function(value) {
1604 return Aff.Pure(f(value));
1605 });
1607 };
1609 function _bind(aff) {
1610 return function(k) {
1611 return Aff.Bind(aff, k);
1612 };
1614 var _liftEffect = Aff.Sync;
1615 function _parAffMap(f) {
1616 return function(aff) {
1617 return Aff.ParMap(f, aff);
1618 };
1620 function _parAffApply(aff1) {
1621 return function(aff2) {
1622 return Aff.ParApply(aff1, aff2);
1623 };
1625 var makeAff = Aff.Async;
1626 function _makeFiber(util, aff) {
1627 return function() {
1628 return Aff.Fiber(util, null, aff);
1629 };
1631 var _sequential = Aff.Seq;
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;
1639 };
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 };
1671 // output/Partial.Unsafe/foreign.js
1672 var _unsafePartial = function(f) {
1673 return f();
1674 };
1676 // output/Partial/foreign.js
1677 var _crashWith = function(msg) {
1678 throw new Error(msg);
1679 };
1681 // output/Partial/index.js
1682 var crashWith = function() {
1683 return _crashWith;
1684 };
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 };
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
1711 };
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;
1721 if (v instanceof Left) {
1722 return unsafeCrashWith("unsafeFromRight: Left");
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;
1732 if (v instanceof Right) {
1733 return unsafeCrashWith("unsafeFromLeft: Right");
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;
1743 if (v instanceof Right) {
1744 return false;
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;
1772 };
1773 var monadAff = {
1774 Applicative0: function() {
1775 return applicativeAff;
1776 },
1777 Bind1: function() {
1778 return bindAff;
1780 };
1781 var bindAff = {
1782 bind: _bind,
1783 Apply0: function() {
1784 return $lazy_applyAff(0);
1786 };
1787 var applicativeAff = {
1788 pure: _pure,
1789 Apply0: function() {
1790 return $lazy_applyAff(0);
1792 };
1793 var $lazy_applyAff = /* @__PURE__ */ $runtime_lazy2("applyAff", "Effect.Aff", function() {
1794 return {
1795 apply: ap(monadAff),
1796 Functor0: function() {
1797 return functorAff;
1799 };
1800 });
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() {
1808 return applyAff;
1809 },
1810 Apply1: function() {
1811 return applyParAff;
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;
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 };
1832 };
1833 var monadEffectAff = {
1834 liftEffect: _liftEffect,
1835 Monad0: function() {
1836 return monadAff;
1838 };
1839 var liftEffect2 = /* @__PURE__ */ liftEffect(monadEffectAff);
1840 var monadThrowAff = {
1841 throwError: _throwError,
1842 Monad0: function() {
1843 return monadAff;
1845 };
1846 var monadErrorAff = {
1847 catchError: _catchError,
1848 MonadThrow0: function() {
1849 return monadThrowAff;
1851 };
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 };
1859 };
1860 var runAff_ = function(k) {
1861 return function(aff) {
1862 return $$void2(runAff(k)(aff));
1863 };
1864 };
1865 var nonCanceler = /* @__PURE__ */ $$const(/* @__PURE__ */ pure2(unit));
1866 var monoidCanceler = {
1867 mempty: nonCanceler,
1868 Semigroup0: function() {
1869 return semigroupCanceler;
1871 };
1873 // output/Foreign/foreign.js
1874 function typeOf(value) {
1875 return typeof value;
1877 function tagOf(value) {
1878 return Object.prototype.toString.call(value).slice(8, -1);
1880 var isArray = Array.isArray || function(value) {
1881 return Object.prototype.toString.call(value) === "[object Array]";
1882 };
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 }();
1892 // output/Foreign/index.js
1893 var TypeMismatch = /* @__PURE__ */ function() {
1894 function TypeMismatch2(value0, value1) {
1895 this.value0 = value0;
1896 this.value1 = value1;
1899 TypeMismatch2.create = function(value0) {
1900 return function(value1) {
1901 return new TypeMismatch2(value0, value1);
1902 };
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 };
1912 };
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));
1922 if (otherwise) {
1923 return fail1(new TypeMismatch(tag, tagOf(value)));
1926 throw new Error("Failed pattern match at Foreign (line 123, column 1 - line 123, column 104): " + [tag.constructor.name, value.constructor.name]);
1927 };
1928 };
1929 };
1930 var readString = function(dictMonad) {
1931 return unsafeReadTagged(dictMonad)("String");
1932 };
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 };
1947 };
1949 // output/Crypto.Subtle.Key.Types/foreign.js
1950 function exportKeyImpl(f, x) {
1951 return crypto.subtle.exportKey(f, x);
1954 // output/Foreign.Index/foreign.js
1955 function unsafeReadPropImpl(f, s, key, value) {
1956 return value == null ? f : s(value[key]);
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);
1966 };
1967 };
1968 };
1969 var readProp = function(dictMonad) {
1970 return unsafeReadProp(dictMonad);
1971 };
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);
1977 var wrapKey = "wrapKey";
1978 var verify = "verify";
1979 var unwrapKey = "unwrapKey";
1980 var sign2 = "sign";
1981 var raw = "raw";
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");
1988 if (v instanceof Right) {
1989 return error(v.value0);
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 };
1999 var encrypt = "encrypt";
2000 var deriveKey = "deriveKey";
2001 var deriveBits = "deriveBits";
2002 var decrypt = "decrypt";
2003 var allUsages = [encrypt, decrypt, sign2, verify, deriveKey, deriveBits, wrapKey, unwrapKey];
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";
2011 // output/Crypto.Subtle.Key.Generate/foreign.js
2012 function generateKeyImpl(a, e, u) {
2013 return crypto.subtle.generateKey(a, e, u);
2015 var exp65537 = new Uint8Array([1, 0, 1]);
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
2036 };
2037 };
2038 var generateKeyPair = function(a) {
2039 return function(e) {
2040 return function(u) {
2041 return toAff$prime(errorFromDOMException)(generateKeyImpl(a, e, u));
2042 };
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
2057 };
2058 };
2059 };
2060 var aes = function(a) {
2061 return function(l) {
2062 return {
2063 name: a,
2064 length: l
2065 };
2066 };
2067 };
2069 // output/Effect.Console/foreign.js
2070 var log2 = function(s) {
2071 return function() {
2072 console.log(s);
2073 };
2074 };
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);
2093 if (eX instanceof Right) {
2094 return pure3(unit);
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 });
2171 });
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);
2183 });
2184 });
2185 });
2186 });
2187 });
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 });
2197 });
2198 });
2199 });
2200 });
2201 });
2202 });
2203 });
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);
2220 });
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 });
2232 });
2233 });
2234 });
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);
2242 });
2243 });
2244 });
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 });
2254 });
2255 });
2256 });
2257 });
2258 });
2259 });
2260 });
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 });
2273 });
2274 });
2275 });
2276 }));
2277 }();
2279 // <stdin>
2280 main();
2281})();