@@ -0,0 +1,2281 @@
1+/* Generated by Spago v0.93.40 */
3+ // output/Control.Semigroupoid/index.js
4+ var semigroupoidFn = {
5+ compose: function(f) {
14+ // output/Control.Category/index.js
15+ var identity = function(dict) {
16+ return dict.identity;
19+ identity: function(x) {
22+ Semigroupoid0: function() {
23+ return semigroupoidFn;
27+ // output/Data.Boolean/index.js
28+ var otherwise = true;
30+ // output/Data.Function/index.js
31+ var flip = function(f) {
38+ var $$const = function(a) {
44+ // output/Data.Unit/foreign.js
47+ // output/Data.Functor/index.js
48+ var map = function(dict) {
51+ var $$void = function(dictFunctor) {
52+ return map(dictFunctor)($$const(unit));
54+ var voidRight = function(dictFunctor) {
55+ var map1 = map(dictFunctor);
57+ return map1($$const(x));
61+ // output/Control.Apply/index.js
62+ var identity2 = /* @__PURE__ */ identity(categoryFn);
63+ var apply = function(dict) {
66+ var applySecond = function(dictApply) {
67+ var apply1 = apply(dictApply);
68+ var map3 = map(dictApply.Functor0());
71+ return apply1(map3($$const(identity2))(a))(b);
76+ // output/Control.Applicative/index.js
77+ var pure = function(dict) {
80+ var liftA1 = function(dictApplicative) {
81+ var apply2 = apply(dictApplicative.Apply0());
82+ var pure1 = pure(dictApplicative);
85+ return apply2(pure1(f))(a);
90+ // output/Control.Bind/index.js
91+ var discard = function(dict) {
94+ var bind = function(dict) {
97+ var bindFlipped = function(dictBind) {
98+ return flip(bind(dictBind));
101+ discard: function(dictBind) {
102+ return bind(dictBind);
106+ // output/Crypto.Subtle.Constants.AES/index.js
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
119+ var ecdsa = "ECDSA";
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) {
132+ promise2.then(succCB, errCB);
138+ // output/Data.Semigroup/index.js
139+ var append = function(dict) {
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;
155+ Left2.create = function(value0) {
156+ return new Left2(value0);
160+ var Right = /* @__PURE__ */ function() {
161+ function Right2(value0) {
162+ this.value0 = value0;
165+ Right2.create = function(value0) {
166+ return new Right2(value0);
170+ var functorEither = {
172+ return function(m) {
173+ if (m instanceof Left) {
174+ return new Left(m.value0);
177+ if (m instanceof Right) {
178+ return new Right(f(m.value0));
181+ throw new Error("Failed pattern match at Data.Either (line 0, column 0 - line 0, column 0): " + [m.constructor.name]);
185+ var either = function(v) {
186+ return function(v1) {
187+ return function(v2) {
188+ if (v2 instanceof Left) {
189+ return v(v2.value0);
192+ if (v2 instanceof Right) {
193+ return v1(v2.value0);
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]);
201+ // output/Effect/foreign.js
202+ var pureE = function(a) {
207+ var bindE = function(a) {
208+ return function(f) {
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));
230+ // output/Data.Monoid/index.js
231+ var mempty = function(dict) {
235+ // output/Effect/index.js
236+ var $runtime_lazy = function(name2, moduleName, init2) {
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);
249+ Applicative0: function() {
250+ return applicativeEffect;
258+ Apply0: function() {
259+ return $lazy_applyEffect(0);
262+ var applicativeEffect = {
264+ Apply0: function() {
265+ return $lazy_applyEffect(0);
268+ var $lazy_functorEffect = /* @__PURE__ */ $runtime_lazy("functorEffect", "Effect", function() {
270+ map: liftA1(applicativeEffect)
273+ var $lazy_applyEffect = /* @__PURE__ */ $runtime_lazy("applyEffect", "Effect", function() {
275+ apply: ap(monadEffect),
276+ Functor0: function() {
277+ return $lazy_functorEffect(0);
281+ var functorEffect = /* @__PURE__ */ $lazy_functorEffect(20);
283+ // output/Effect.Exception/foreign.js
284+ function error(msg) {
285+ return new Error(msg);
287+ function throwException(e) {
293+ // output/Control.Monad.Error.Class/index.js
294+ var throwError = function(dict) {
295+ return dict.throwError;
297+ var catchError = function(dict) {
298+ return dict.catchError;
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));
312+ // output/Data.Identity/index.js
313+ var Identity = function(x) {
316+ var functorIdentity = {
318+ return function(m) {
323+ var applyIdentity = {
324+ apply: function(v) {
325+ return function(v1) {
329+ Functor0: function() {
330+ return functorIdentity;
333+ var bindIdentity = {
335+ return function(f) {
339+ Apply0: function() {
340+ return applyIdentity;
343+ var applicativeIdentity = {
345+ Apply0: function() {
346+ return applyIdentity;
349+ var monadIdentity = {
350+ Applicative0: function() {
351+ return applicativeIdentity;
354+ return bindIdentity;
358+ // output/Unsafe.Coerce/foreign.js
359+ var unsafeCoerce2 = function(x) {
363+ // output/Effect.Class/index.js
364+ var liftEffect = function(dict) {
365+ return dict.liftEffect;
368+ // output/Control.Monad.Except.Trans/index.js
369+ var map2 = /* @__PURE__ */ map(functorEither);
370+ var ExceptT = function(x) {
373+ var runExceptT = function(v) {
376+ var mapExceptT = function(f) {
377+ return function(v) {
381+ var functorExceptT = function(dictFunctor) {
382+ var map1 = map(dictFunctor);
385+ return mapExceptT(map1(map2(f)));
389+ var monadExceptT = function(dictMonad) {
391+ Applicative0: function() {
392+ return applicativeExceptT(dictMonad);
395+ return bindExceptT(dictMonad);
399+ var bindExceptT = function(dictMonad) {
400+ var bind4 = bind(dictMonad.Bind1());
401+ var pure4 = pure(dictMonad.Applicative0());
404+ return function(k) {
405+ return bind4(v)(either(function($193) {
406+ return pure4(Left.create($193));
413+ Apply0: function() {
414+ return applyExceptT(dictMonad);
418+ var applyExceptT = function(dictMonad) {
419+ var functorExceptT1 = functorExceptT(dictMonad.Bind1().Apply0().Functor0());
421+ apply: ap(monadExceptT(dictMonad)),
422+ Functor0: function() {
423+ return functorExceptT1;
427+ var applicativeExceptT = function(dictMonad) {
430+ var $194 = pure(dictMonad.Applicative0());
431+ return function($195) {
432+ return ExceptT($194(Right.create($195)));
435+ Apply0: function() {
436+ return applyExceptT(dictMonad);
440+ var monadThrowExceptT = function(dictMonad) {
441+ var monadExceptT1 = monadExceptT(dictMonad);
443+ throwError: function() {
444+ var $204 = pure(dictMonad.Applicative0());
445+ return function($205) {
446+ return ExceptT($204(Left.create($205)));
449+ Monad0: function() {
450+ return monadExceptT1;
455+ // output/Safe.Coerce/index.js
456+ var coerce = function() {
457+ return unsafeCoerce2;
460+ // output/Data.Newtype/index.js
461+ var coerce2 = /* @__PURE__ */ coerce();
462+ var unwrap = function() {
466+ // output/Control.Monad.Except/index.js
467+ var unwrap2 = /* @__PURE__ */ unwrap();
468+ var runExcept = function($3) {
469+ return unwrap2(runExceptT($3));
472+ // output/Data.Foldable/foreign.js
473+ var foldrArray = function(f) {
474+ return function(init2) {
475+ return function(xs) {
477+ var len = xs.length;
478+ for (var i = len - 1; i >= 0; i--) {
479+ acc = f(xs[i])(acc);
485+ var foldlArray = function(f) {
486+ return function(init2) {
487+ return function(xs) {
489+ var len = xs.length;
490+ for (var i = 0; i < len; i++) {
491+ acc = f(acc)(xs[i]);
498+ // output/Control.Plus/index.js
499+ var empty = function(dict) {
503+ // output/Data.Foldable/index.js
504+ var foldr = function(dict) {
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));
519+ var foldl = function(dict) {
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);
536+ var foldableArray = {
539+ foldMap: function(dictMonoid) {
540+ return foldMapDefaultR(foldableArray)(dictMonoid);
544+ // output/Data.NonEmpty/index.js
545+ var NonEmpty = /* @__PURE__ */ function() {
546+ function NonEmpty2(value0, value1) {
547+ this.value0 = value0;
548+ this.value1 = value1;
551+ NonEmpty2.create = function(value0) {
552+ return function(value1) {
553+ return new NonEmpty2(value0, value1);
558+ var singleton2 = function(dictPlus) {
559+ var empty2 = empty(dictPlus);
560+ return function(a) {
561+ return new NonEmpty(a, empty2);
565+ // output/Data.List.Types/index.js
566+ var Nil = /* @__PURE__ */ function() {
570+ Nil2.value = new Nil2();
573+ var Cons = /* @__PURE__ */ function() {
574+ function Cons2(value0, value1) {
575+ this.value0 = value0;
576+ this.value1 = value1;
579+ Cons2.create = function(value0) {
580+ return function(value1) {
581+ return new Cons2(value0, value1);
586+ var NonEmptyList = function(x) {
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;
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;
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));
607+ if (v2 instanceof Cons && v2.value1 instanceof Nil) {
608+ return new Cons(f(v2.value0), Nil.value);
613+ var reverseUnrolledMap = function($copy_v2) {
614+ return function($copy_v3) {
615+ var $tco_var_v2 = $copy_v2;
616+ var $tco_done1 = false;
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)));
629+ while (!$tco_done1) {
630+ $tco_result2 = $tco_loop2($tco_var_v2, $copy_v3);
633+ return $tco_result2;
637+ return reverseUnrolledMap(v)(unrolledMap(v1));
640+ while (!$tco_done) {
641+ $tco_result = $tco_loop($tco_var_v, $copy_v1);
647+ return chunkedRevMap(Nil.value);
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;
661+ function $tco_loop(v, v1) {
662+ if (v1 instanceof Nil) {
667+ if (v1 instanceof Cons) {
668+ $tco_var_v = new Cons(v1.value0, v);
669+ $copy_v1 = v1.value1;
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]);
676+ while (!$tco_done) {
677+ $tco_result = $tco_loop($tco_var_v, $copy_v1);
683+ return go(Nil.value);
685+ var $284 = foldl(foldableList)(flip(f))(b);
686+ return function($285) {
687+ return $284(rev($285));
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;
697+ function $tco_loop(b, v) {
698+ if (v instanceof Nil) {
703+ if (v instanceof Cons) {
704+ $tco_var_b = f(b)(v.value0);
709+ throw new Error("Failed pattern match at Data.List.Types (line 111, column 12 - line 113, column 30): " + [v.constructor.name]);
712+ while (!$tco_done1) {
713+ $tco_result = $tco_loop($tco_var_b, $copy_v);
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));
734+ var foldr2 = /* @__PURE__ */ foldr(foldableList);
735+ var semigroupList = {
736+ append: function(xs) {
737+ return function(ys) {
738+ return foldr2(Cons.create)(ys)(xs);
742+ var append1 = /* @__PURE__ */ append(semigroupList);
745+ Functor0: function() {
749+ var plusList = /* @__PURE__ */ function() {
758+ // output/Effect.Aff/foreign.js
759+ var Aff = function() {
762+ var THROW = "Throw";
763+ var CATCH = "Catch";
765+ var ASYNC = "Async";
767+ var BRACKET = "Bracket";
769+ var SEQ = "Sequential";
771+ var APPLY = "Apply";
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) {
787+ function AffCtr(tag) {
788+ var fn = function(_1, _2, _3) {
789+ return new Aff2(tag, _1, _2, _3);
794+ function nonCanceler2(error3) {
795+ return new Aff2(PURE, void 0);
797+ function runEff(eff) {
801+ setTimeout(function() {
806+ function runSync(left, right, eff) {
808+ return right(eff());
810+ return left(error3);
813+ function runAsync(left, eff, k) {
818+ return nonCanceler2;
821+ var Scheduler = function() {
825+ var queue = new Array(limit);
826+ var draining = false;
830+ while (size !== 0) {
834+ ix = (ix + 1) % limit;
840+ isDraining: function() {
843+ enqueue: function(cb) {
845+ if (size === limit) {
850+ queue[(ix + size) % limit] = cb;
858+ function Supervisor(util) {
863+ register: function(fiber) {
864+ var fid = fiberId++;
867+ handler: function(result) {
874+ fibers[fid] = fiber;
877+ isEmpty: function() {
880+ killAll: function(killError, cb) {
887+ function kill(fid) {
888+ kills[fid] = fibers[fid].kill(killError, function(result) {
892+ if (util.isLeft(result) && util.fromLeft(result)) {
893+ setTimeout(function() {
894+ throw util.fromLeft(result);
897+ if (killCount === 0) {
903+ for (var k in fibers) {
904+ if (fibers.hasOwnProperty(k)) {
912+ return function(error3) {
913+ return new Aff2(SYNC, function() {
914+ for (var k2 in kills) {
915+ if (kills.hasOwnProperty(k2)) {
928+ var STEP_RESULT = 3;
932+ function Fiber(util, supervisor, aff) {
934+ var status = SUSPENDED;
937+ var interrupt = null;
940+ var attempts = null;
941+ var bracketCount = 0;
945+ function run2(localRunTick) {
946+ var tmp, result, attempt;
956+ if (btail === null) {
964+ fail2 = util.left(e);
969+ if (util.isLeft(step)) {
973+ } else if (bhead === null) {
977+ step = util.fromRight(step);
984+ btail = new Aff2(CONS, bhead, btail);
991+ if (bhead === null) {
993+ step = util.right(step._1);
1000+ status = STEP_RESULT;
1001+ step = runSync(util.left, util.right, step._1);
1005+ step = runAsync(util.left, step._1, function(result2) {
1006+ return function() {
1007+ if (runTick !== localRunTick) {
1011+ Scheduler.enqueue(function() {
1012+ if (runTick !== localRunTick + 1) {
1015+ status = STEP_RESULT;
1024+ fail2 = util.left(step._1);
1027+ // Enqueue the Catch so that we can call the error handler later on
1028+ // in case of an exception.
1030+ if (bhead === null) {
1031+ attempts = new Aff2(CONS, step, attempts, interrupt);
1033+ attempts = new Aff2(CONS, step, new Aff2(CONS, new Aff2(RESUME, bhead, btail), attempts, interrupt), interrupt);
1040+ // Enqueue the Bracket so that we can call the appropriate handlers
1041+ // after resource acquisition.
1044+ if (bhead === null) {
1045+ attempts = new Aff2(CONS, step, attempts, interrupt);
1047+ attempts = new Aff2(CONS, step, new Aff2(CONS, new Aff2(RESUME, bhead, btail), attempts, interrupt), interrupt);
1055+ status = STEP_RESULT;
1056+ tmp = Fiber(util, supervisor, step._2);
1058+ supervisor.register(tmp);
1063+ step = util.right(tmp);
1067+ step = sequential2(util, supervisor, step._1);
1074+ if (attempts === null) {
1075+ status = COMPLETED;
1076+ step = interrupt || fail2 || step;
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
1086+ if (interrupt && interrupt !== tmp && bracketCount === 0) {
1088+ } else if (fail2) {
1090+ step = attempt._2(util.fromLeft(fail2));
1094+ // We cannot resume from an unmasked interrupt or exception.
1096+ if (interrupt && interrupt !== tmp && bracketCount === 0 || fail2) {
1099+ bhead = attempt._1;
1100+ btail = attempt._2;
1101+ status = STEP_BIND;
1102+ step = util.fromRight(step);
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.
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) {
1116+ step = attempt._3(result);
1120+ // Enqueue the appropriate handler. We increase the bracket count
1121+ // because it should not be cancelled.
1123+ attempts = new Aff2(CONS, new Aff2(FINALIZED, step, fail2), attempts, interrupt);
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);
1130+ step = attempt._1.completed(util.fromRight(step))(attempt._2);
1137+ attempts = new Aff2(CONS, new Aff2(FINALIZED, step, fail2), attempts, interrupt);
1145+ fail2 = attempt._2;
1151+ for (var k in joins) {
1152+ if (joins.hasOwnProperty(k)) {
1153+ rethrow = rethrow && joins[k].rethrow;
1154+ runEff(joins[k].handler(step));
1158+ if (interrupt && fail2) {
1159+ setTimeout(function() {
1160+ throw util.fromLeft(fail2);
1162+ } else if (util.isLeft(step) && rethrow) {
1163+ setTimeout(function() {
1165+ throw util.fromLeft(step);
1178+ function onComplete(join3) {
1179+ return function() {
1180+ if (status === COMPLETED) {
1181+ rethrow = rethrow && join3.rethrow;
1182+ join3.handler(step)();
1183+ return function() {
1186+ var jid = joinId++;
1187+ joins = joins || {};
1188+ joins[jid] = join3;
1189+ return function() {
1190+ if (joins !== null) {
1196+ function kill(error3, cb) {
1197+ return function() {
1198+ if (status === COMPLETED) {
1199+ cb(util.right(void 0))();
1200+ return function() {
1203+ var canceler = onComplete({
1205+ handler: function() {
1206+ return cb(util.right(void 0));
1211+ interrupt = util.left(error3);
1212+ status = COMPLETED;
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);
1231+ if (interrupt === null) {
1232+ interrupt = util.left(error3);
1234+ if (bracketCount === 0) {
1243+ function join2(cb) {
1244+ return function() {
1245+ var canceler = onComplete({
1249+ if (status === SUSPENDED) {
1259+ isSuspended: function() {
1260+ return status === SUSPENDED;
1263+ if (status === SUSPENDED) {
1264+ if (!Scheduler.isDraining()) {
1265+ Scheduler.enqueue(function() {
1275+ function runPar(util, supervisor, par, cb) {
1280+ var early = new Error("[ParAff] Early exit");
1281+ var interrupt = null;
1283+ function kill(error3, par2, cb2) {
1290+ loop: while (true) {
1292+ switch (step.tag) {
1294+ if (step._3 === EMPTY) {
1295+ tmp = fibers[step._1];
1296+ kills2[count++] = tmp.kill(error3, function(result) {
1297+ return function() {
1305+ if (head === null) {
1309+ if (tail === null) {
1322+ tail = new Aff2(CONS, head, tail);
1330+ cb2(util.right(void 0))();
1334+ for (; kid < tmp; kid++) {
1335+ kills2[kid] = kills2[kid]();
1340+ function join2(result, head, tail) {
1341+ var fail2, step, lhs, rhs, tmp, kid;
1342+ if (util.isLeft(result)) {
1349+ loop: while (true) {
1354+ if (interrupt !== null) {
1357+ if (head === null) {
1358+ cb(fail2 || step)();
1361+ if (head._3 !== EMPTY) {
1364+ switch (head.tag) {
1366+ if (fail2 === null) {
1367+ head._3 = util.right(head._1(util.fromRight(step)));
1380+ kills[kid] = kill(early, fail2 === lhs ? head._2 : head._1, function() {
1381+ return function() {
1385+ } else if (tail === null) {
1386+ join2(fail2, null, null);
1388+ join2(fail2, tail._1, tail._2);
1396+ } else if (lhs === EMPTY || rhs === EMPTY) {
1399+ step = util.right(util.fromRight(lhs)(util.fromRight(rhs)));
1406+ if (lhs === EMPTY && util.isLeft(rhs) || rhs === EMPTY && util.isLeft(lhs)) {
1409+ if (lhs !== EMPTY && util.isLeft(lhs) && rhs !== EMPTY && util.isLeft(rhs)) {
1410+ fail2 = step === lhs ? rhs : lhs;
1417+ kills[kid] = kill(early, step === lhs ? head._2 : head._1, function() {
1418+ return function() {
1422+ } else if (tail === null) {
1423+ join2(step, null, null);
1425+ join2(step, tail._1, tail._2);
1436+ if (tail === null) {
1444+ function resolve(fiber) {
1445+ return function(result) {
1446+ return function() {
1447+ delete fibers[fiber._1];
1449+ join2(result, fiber._2._1, fiber._2._2);
1454+ var status = CONTINUE;
1459+ loop: while (true) {
1464+ switch (step.tag) {
1467+ tail = new Aff2(CONS, head, tail);
1469+ head = new Aff2(MAP, step._1, EMPTY, EMPTY);
1474+ tail = new Aff2(CONS, head, tail);
1476+ head = new Aff2(APPLY, EMPTY, step._2, EMPTY);
1481+ tail = new Aff2(CONS, head, tail);
1483+ head = new Aff2(ALT, EMPTY, step._2, EMPTY);
1490+ step = new Aff2(FORKED, fid, new Aff2(CONS, head, tail), EMPTY);
1491+ tmp = Fiber(util, supervisor, tmp);
1494+ handler: resolve(step)
1498+ supervisor.register(tmp);
1503+ if (head === null) {
1506+ if (head._1 === EMPTY) {
1514+ if (tail === null) {
1524+ for (fid = 0; fid < fiberId; fid++) {
1528+ function cancel(error3, cb2) {
1529+ interrupt = util.left(error3);
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)) {
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)) {
1551+ return nonCanceler2;
1557+ return function(killError) {
1558+ return new Aff2(ASYNC, function(killCb) {
1559+ return function() {
1560+ return cancel(killError, killCb);
1565+ function sequential2(util, supervisor, par) {
1566+ return new Aff2(ASYNC, function(cb) {
1567+ return function() {
1568+ return runPar(util, supervisor, par, cb);
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;
1591+ var _pure = Aff.Pure;
1592+ var _throwError = Aff.Throw;
1593+ function _catchError(aff) {
1594+ return function(k) {
1595+ return Aff.Catch(aff, k);
1599+ return function(aff) {
1600+ if (aff.tag === Aff.Pure.tag) {
1601+ return Aff.Pure(f(aff._1));
1603+ return Aff.Bind(aff, function(value) {
1604+ return Aff.Pure(f(value));
1609+ function _bind(aff) {
1610+ return function(k) {
1611+ return Aff.Bind(aff, k);
1614+ var _liftEffect = Aff.Sync;
1615+ function _parAffMap(f) {
1616+ return function(aff) {
1617+ return Aff.ParMap(f, aff);
1620+ function _parAffApply(aff1) {
1621+ return function(aff2) {
1622+ return Aff.ParApply(aff1, aff2);
1625+ var makeAff = Aff.Async;
1626+ function _makeFiber(util, aff) {
1627+ return function() {
1628+ return Aff.Fiber(util, null, aff);
1631+ var _sequential = Aff.Seq;
1633+ // output/Control.Parallel.Class/index.js
1634+ var sequential = function(dict) {
1635+ return dict.sequential;
1637+ var parallel = function(dict) {
1638+ return dict.parallel;
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));
1654+ return function($52) {
1655+ return sequential2($51($52));
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);
1671+ // output/Partial.Unsafe/foreign.js
1672+ var _unsafePartial = function(f) {
1676+ // output/Partial/foreign.js
1677+ var _crashWith = function(msg) {
1678+ throw new Error(msg);
1681+ // output/Partial/index.js
1682+ var crashWith = function() {
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);
1695+ // output/Effect.Aff/index.js
1696+ var $runtime_lazy2 = function(name2, moduleName, init2) {
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);
1708+ var $$void2 = /* @__PURE__ */ $$void(functorEffect);
1709+ var functorParAff = {
1715+ var ffiUtil = /* @__PURE__ */ function() {
1716+ var unsafeFromRight = function(v) {
1717+ if (v instanceof Right) {
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]);
1727+ var unsafeFromLeft = function(v) {
1728+ if (v instanceof Left) {
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]);
1738+ var isLeft = function(v) {
1739+ if (v instanceof Left) {
1743+ if (v instanceof Right) {
1747+ throw new Error("Failed pattern match at Effect.Aff (line 402, column 12 - line 404, column 21): " + [v.constructor.name]);
1751+ fromLeft: unsafeFromLeft,
1752+ fromRight: unsafeFromRight,
1754+ right: Right.create
1757+ var makeFiber = function(aff) {
1758+ return _makeFiber(ffiUtil, aff);
1760+ var launchAff = function(aff) {
1761+ return function __do() {
1762+ var fiber = makeFiber(aff)();
1767+ var applyParAff = {
1768+ apply: _parAffApply,
1769+ Functor0: function() {
1770+ return functorParAff;
1774+ Applicative0: function() {
1775+ return applicativeAff;
1777+ Bind1: function() {
1783+ Apply0: function() {
1784+ return $lazy_applyAff(0);
1787+ var applicativeAff = {
1789+ Apply0: function() {
1790+ return $lazy_applyAff(0);
1793+ var $lazy_applyAff = /* @__PURE__ */ $runtime_lazy2("applyAff", "Effect.Aff", function() {
1795+ apply: ap(monadAff),
1796+ Functor0: 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() {
1810+ Apply1: function() {
1811+ return applyParAff;
1814+ var parallel2 = /* @__PURE__ */ parallel(parallelAff);
1815+ var applicativeParAff = {
1816+ pure: function($76) {
1817+ return parallel2(pure2($76));
1819+ Apply0: function() {
1820+ return applyParAff;
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)]);
1833+ var monadEffectAff = {
1834+ liftEffect: _liftEffect,
1835+ Monad0: function() {
1839+ var liftEffect2 = /* @__PURE__ */ liftEffect(monadEffectAff);
1840+ var monadThrowAff = {
1841+ throwError: _throwError,
1842+ Monad0: function() {
1846+ var monadErrorAff = {
1847+ catchError: _catchError,
1848+ MonadThrow0: function() {
1849+ return monadThrowAff;
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));
1860+ var runAff_ = function(k) {
1861+ return function(aff) {
1862+ return $$void2(runAff(k)(aff));
1865+ var nonCanceler = /* @__PURE__ */ $$const(/* @__PURE__ */ pure2(unit));
1866+ var monoidCanceler = {
1867+ mempty: nonCanceler,
1868+ Semigroup0: function() {
1869+ return semigroupCanceler;
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]";
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));
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);
1904+ return TypeMismatch2;
1906+ var unsafeFromForeign = unsafeCoerce2;
1907+ var fail = function(dictMonad) {
1908+ var $153 = throwError(monadThrowExceptT(dictMonad));
1909+ return function($154) {
1910+ return $153(singleton3($154));
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));
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]);
1930+ var readString = function(dictMonad) {
1931+ return unsafeReadTagged(dictMonad)("String");
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)))();
1943+ return cb(Right.create($15))();
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);
1969+ var readProp = function(dictMonad) {
1970+ return unsafeReadProp(dictMonad);
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";
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]);
1994+ var exportKey = function(f) {
1995+ return function(x) {
1996+ return toAff$prime(errorFromDOMException)(exportKeyImpl(f, x));
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) {
2032+ var hmac = function(h) {
2038+ var generateKeyPair = function(a) {
2039+ return function(e) {
2040+ return function(u) {
2041+ return toAff$prime(errorFromDOMException)(generateKeyImpl(a, e, u));
2045+ var generateKey = function(a) {
2046+ return function(e) {
2047+ return function(u) {
2048+ return toAff$prime(errorFromDOMException)(generateKeyImpl(a, e, u));
2052+ var ec = function(e) {
2053+ return function(c) {
2060+ var aes = function(a) {
2061+ return function(l) {
2069+ // output/Effect.Console/foreign.js
2070+ var log2 = function(s) {
2071+ return function() {
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));
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]);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
2205+ return discard2(log$prime("- ECDSA"))(function() {
2206+ return discard2(genEC(ecdsa))(function() {
2207+ return discard2(log$prime("- ECDH"))(function() {
2208+ return genEC(ecdh);
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);
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);
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);
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);
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);