@@ -1,1633 +0,0 @@
1−(() => {
2− // output/Bun.Server/foreign.js
3− function serve(f) {
4− return function() {
5− return Bun.serve({
6− fetch(req) {
7− return f(req)();
8− }
9− });
10− };
11− }
12−
13− // output/Control.Apply/foreign.js
14− var arrayApply = function(fs) {
15− return function(xs) {
16− var l = fs.length;
17− var k = xs.length;
18− var result = new Array(l * k);
19− var n = 0;
20− for (var i = 0; i < l; i++) {
21− var f = fs[i];
22− for (var j = 0; j < k; j++) {
23− result[n++] = f(xs[j]);
24− }
25− }
26− return result;
27− };
28− };
29−
30− // output/Control.Semigroupoid/index.js
31− var semigroupoidFn = {
32− compose: function(f) {
33− return function(g) {
34− return function(x) {
35− return f(g(x));
36− };
37− };
38− }
39− };
40−
41− // output/Control.Category/index.js
42− var identity = function(dict) {
43− return dict.identity;
44− };
45− var categoryFn = {
46− identity: function(x) {
47− return x;
48− },
49− Semigroupoid0: function() {
50− return semigroupoidFn;
51− }
52− };
53−
54− // output/Data.Function/index.js
55− var flip = function(f) {
56− return function(b) {
57− return function(a) {
58− return f(a)(b);
59− };
60− };
61− };
62− var $$const = function(a) {
63− return function(v) {
64− return a;
65− };
66− };
67−
68− // output/Data.Functor/foreign.js
69− var arrayMap = function(f) {
70− return function(arr) {
71− var l = arr.length;
72− var result = new Array(l);
73− for (var i = 0; i < l; i++) {
74− result[i] = f(arr[i]);
75− }
76− return result;
77− };
78− };
79−
80− // output/Data.Unit/foreign.js
81− var unit = void 0;
82−
83− // output/Type.Proxy/index.js
84− var $$Proxy = /* @__PURE__ */ function() {
85− function $$Proxy2() {
86− }
87− ;
88− $$Proxy2.value = new $$Proxy2();
89− return $$Proxy2;
90− }();
91−
92− // output/Data.Functor/index.js
93− var map = function(dict) {
94− return dict.map;
95− };
96− var $$void = function(dictFunctor) {
97− return map(dictFunctor)($$const(unit));
98− };
99− var functorArray = {
100− map: arrayMap
101− };
102−
103− // output/Control.Apply/index.js
104− var applyArray = {
105− apply: arrayApply,
106− Functor0: function() {
107− return functorArray;
108− }
109− };
110− var apply = function(dict) {
111− return dict.apply;
112− };
113−
114− // output/Control.Applicative/index.js
115− var pure = function(dict) {
116− return dict.pure;
117− };
118− var liftA1 = function(dictApplicative) {
119− var apply3 = apply(dictApplicative.Apply0());
120− var pure13 = pure(dictApplicative);
121− return function(f) {
122− return function(a) {
123− return apply3(pure13(f))(a);
124− };
125− };
126− };
127−
128− // output/Data.Argonaut.Core/foreign.js
129− function id(x) {
130− return x;
131− }
132−
133− // output/Data.Eq/foreign.js
134− var refEq = function(r1) {
135− return function(r2) {
136− return r1 === r2;
137− };
138− };
139− var eqStringImpl = refEq;
140− var eqArrayImpl = function(f) {
141− return function(xs) {
142− return function(ys) {
143− if (xs.length !== ys.length) return false;
144− for (var i = 0; i < xs.length; i++) {
145− if (!f(xs[i])(ys[i])) return false;
146− }
147− return true;
148− };
149− };
150− };
151−
152− // output/Data.Symbol/index.js
153− var reflectSymbol = function(dict) {
154− return dict.reflectSymbol;
155− };
156−
157− // output/Record.Unsafe/foreign.js
158− var unsafeGet = function(label) {
159− return function(rec) {
160− return rec[label];
161− };
162− };
163− var unsafeDelete = function(label) {
164− return function(rec) {
165− var copy = {};
166− for (var key in rec) {
167− if (key !== label && {}.hasOwnProperty.call(rec, key)) {
168− copy[key] = rec[key];
169− }
170− }
171− return copy;
172− };
173− };
174−
175− // output/Data.Eq/index.js
176− var eqString = {
177− eq: eqStringImpl
178− };
179− var eq = function(dict) {
180− return dict.eq;
181− };
182− var eqArray = function(dictEq) {
183− return {
184− eq: eqArrayImpl(eq(dictEq))
185− };
186− };
187−
188− // output/Data.Semigroup/foreign.js
189− var concatArray = function(xs) {
190− return function(ys) {
191− if (xs.length === 0) return ys;
192− if (ys.length === 0) return xs;
193− return xs.concat(ys);
194− };
195− };
196−
197− // output/Data.Semigroup/index.js
198− var semigroupArray = {
199− append: concatArray
200− };
201− var append = function(dict) {
202− return dict.append;
203− };
204−
205− // output/Data.Bounded/foreign.js
206− var topChar = String.fromCharCode(65535);
207− var bottomChar = String.fromCharCode(0);
208− var topNumber = Number.POSITIVE_INFINITY;
209− var bottomNumber = Number.NEGATIVE_INFINITY;
210−
211− // output/Data.Maybe/index.js
212− var Nothing = /* @__PURE__ */ function() {
213− function Nothing2() {
214− }
215− ;
216− Nothing2.value = new Nothing2();
217− return Nothing2;
218− }();
219− var Just = /* @__PURE__ */ function() {
220− function Just2(value0) {
221− this.value0 = value0;
222− }
223− ;
224− Just2.create = function(value0) {
225− return new Just2(value0);
226− };
227− return Just2;
228− }();
229− var maybe = function(v) {
230− return function(v1) {
231− return function(v2) {
232− if (v2 instanceof Nothing) {
233− return v;
234− }
235− ;
236− if (v2 instanceof Just) {
237− return v1(v2.value0);
238− }
239− ;
240− throw new Error("Failed pattern match at Data.Maybe (line 237, column 1 - line 237, column 51): " + [v.constructor.name, v1.constructor.name, v2.constructor.name]);
241− };
242− };
243− };
244− var functorMaybe = {
245− map: function(v) {
246− return function(v1) {
247− if (v1 instanceof Just) {
248− return new Just(v(v1.value0));
249− }
250− ;
251− return Nothing.value;
252− };
253− }
254− };
255− var map2 = /* @__PURE__ */ map(functorMaybe);
256− var applyMaybe = {
257− apply: function(v) {
258− return function(v1) {
259− if (v instanceof Just) {
260− return map2(v.value0)(v1);
261− }
262− ;
263− if (v instanceof Nothing) {
264− return Nothing.value;
265− }
266− ;
267− throw new Error("Failed pattern match at Data.Maybe (line 67, column 1 - line 69, column 30): " + [v.constructor.name, v1.constructor.name]);
268− };
269− },
270− Functor0: function() {
271− return functorMaybe;
272− }
273− };
274− var bindMaybe = {
275− bind: function(v) {
276− return function(v1) {
277− if (v instanceof Just) {
278− return v1(v.value0);
279− }
280− ;
281− if (v instanceof Nothing) {
282− return Nothing.value;
283− }
284− ;
285− throw new Error("Failed pattern match at Data.Maybe (line 125, column 1 - line 127, column 28): " + [v.constructor.name, v1.constructor.name]);
286− };
287− },
288− Apply0: function() {
289− return applyMaybe;
290− }
291− };
292− var applicativeMaybe = /* @__PURE__ */ function() {
293− return {
294− pure: Just.create,
295− Apply0: function() {
296− return applyMaybe;
297− }
298− };
299− }();
300− var altMaybe = {
301− alt: function(v) {
302− return function(v1) {
303− if (v instanceof Nothing) {
304− return v1;
305− }
306− ;
307− return v;
308− };
309− },
310− Functor0: function() {
311− return functorMaybe;
312− }
313− };
314− var plusMaybe = /* @__PURE__ */ function() {
315− return {
316− empty: Nothing.value,
317− Alt0: function() {
318− return altMaybe;
319− }
320− };
321− }();
322−
323− // output/Foreign.Object/foreign.js
324− function _copyST(m) {
325− return function() {
326− var r = {};
327− for (var k in m) {
328− if (hasOwnProperty.call(m, k)) {
329− r[k] = m[k];
330− }
331− }
332− return r;
333− };
334− }
335− var empty = {};
336− function runST(f) {
337− return f();
338− }
339− function toArrayWithKey(f) {
340− return function(m) {
341− var r = [];
342− for (var k in m) {
343− if (hasOwnProperty.call(m, k)) {
344− r.push(f(k)(m[k]));
345− }
346− }
347− return r;
348− };
349− }
350− var keys = Object.keys || toArrayWithKey(function(k) {
351− return function() {
352− return k;
353− };
354− });
355−
356− // output/Control.Bind/foreign.js
357− var arrayBind = typeof Array.prototype.flatMap === "function" ? function(arr) {
358− return function(f) {
359− return arr.flatMap(f);
360− };
361− } : function(arr) {
362− return function(f) {
363− var result = [];
364− var l = arr.length;
365− for (var i = 0; i < l; i++) {
366− var xs = f(arr[i]);
367− var k = xs.length;
368− for (var j = 0; j < k; j++) {
369− result.push(xs[j]);
370− }
371− }
372− return result;
373− };
374− };
375−
376− // output/Control.Bind/index.js
377− var identity2 = /* @__PURE__ */ identity(categoryFn);
378− var discard = function(dict) {
379− return dict.discard;
380− };
381− var bindArray = {
382− bind: arrayBind,
383− Apply0: function() {
384− return applyArray;
385− }
386− };
387− var bind = function(dict) {
388− return dict.bind;
389− };
390− var bindFlipped = function(dictBind) {
391− return flip(bind(dictBind));
392− };
393− var discardUnit = {
394− discard: function(dictBind) {
395− return bind(dictBind);
396− }
397− };
398− var join = function(dictBind) {
399− var bind1 = bind(dictBind);
400− return function(m) {
401− return bind1(m)(identity2);
402− };
403− };
404−
405− // output/Control.Monad.ST.Internal/foreign.js
406− var map_ = function(f) {
407− return function(a) {
408− return function() {
409− return f(a());
410− };
411− };
412− };
413− var pure_ = function(a) {
414− return function() {
415− return a;
416− };
417− };
418− var bind_ = function(a) {
419− return function(f) {
420− return function() {
421− return f(a())();
422− };
423− };
424− };
425− function newSTRef(val) {
426− return function() {
427− return { value: val };
428− };
429− }
430− var read = function(ref) {
431− return function() {
432− return ref.value;
433− };
434− };
435− var modifyImpl = function(f) {
436− return function(ref) {
437− return function() {
438− var t = f(ref.value);
439− ref.value = t.state;
440− return t.value;
441− };
442− };
443− };
444− var write = function(a) {
445− return function(ref) {
446− return function() {
447− return ref.value = a;
448− };
449− };
450− };
451−
452− // output/Control.Monad/index.js
453− var ap = function(dictMonad) {
454− var bind3 = bind(dictMonad.Bind1());
455− var pure4 = pure(dictMonad.Applicative0());
456− return function(f) {
457− return function(a) {
458− return bind3(f)(function(f$prime) {
459− return bind3(a)(function(a$prime) {
460− return pure4(f$prime(a$prime));
461− });
462− });
463− };
464− };
465− };
466−
467− // output/Data.Either/index.js
468− var Left = /* @__PURE__ */ function() {
469− function Left2(value0) {
470− this.value0 = value0;
471− }
472− ;
473− Left2.create = function(value0) {
474− return new Left2(value0);
475− };
476− return Left2;
477− }();
478− var Right = /* @__PURE__ */ function() {
479− function Right2(value0) {
480− this.value0 = value0;
481− }
482− ;
483− Right2.create = function(value0) {
484− return new Right2(value0);
485− };
486− return Right2;
487− }();
488−
489− // output/Data.Monoid/index.js
490− var mempty = function(dict) {
491− return dict.mempty;
492− };
493−
494− // output/Effect/foreign.js
495− var pureE = function(a) {
496− return function() {
497− return a;
498− };
499− };
500− var bindE = function(a) {
501− return function(f) {
502− return function() {
503− return f(a())();
504− };
505− };
506− };
507−
508− // output/Effect/index.js
509− var $runtime_lazy = function(name2, moduleName, init3) {
510− var state2 = 0;
511− var val;
512− return function(lineNumber) {
513− if (state2 === 2) return val;
514− if (state2 === 1) throw new ReferenceError(name2 + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);
515− state2 = 1;
516− val = init3();
517− state2 = 2;
518− return val;
519− };
520− };
521− var monadEffect = {
522− Applicative0: function() {
523− return applicativeEffect;
524− },
525− Bind1: function() {
526− return bindEffect;
527− }
528− };
529− var bindEffect = {
530− bind: bindE,
531− Apply0: function() {
532− return $lazy_applyEffect(0);
533− }
534− };
535− var applicativeEffect = {
536− pure: pureE,
537− Apply0: function() {
538− return $lazy_applyEffect(0);
539− }
540− };
541− var $lazy_functorEffect = /* @__PURE__ */ $runtime_lazy("functorEffect", "Effect", function() {
542− return {
543− map: liftA1(applicativeEffect)
544− };
545− });
546− var $lazy_applyEffect = /* @__PURE__ */ $runtime_lazy("applyEffect", "Effect", function() {
547− return {
548− apply: ap(monadEffect),
549− Functor0: function() {
550− return $lazy_functorEffect(0);
551− }
552− };
553− });
554−
555− // output/Control.Monad.ST.Internal/index.js
556− var $runtime_lazy2 = function(name2, moduleName, init3) {
557− var state2 = 0;
558− var val;
559− return function(lineNumber) {
560− if (state2 === 2) return val;
561− if (state2 === 1) throw new ReferenceError(name2 + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);
562− state2 = 1;
563− val = init3();
564− state2 = 2;
565− return val;
566− };
567− };
568− var modify$prime = modifyImpl;
569− var modify = function(f) {
570− return modify$prime(function(s) {
571− var s$prime = f(s);
572− return {
573− state: s$prime,
574− value: s$prime
575− };
576− });
577− };
578− var functorST = {
579− map: map_
580− };
581− var monadST = {
582− Applicative0: function() {
583− return applicativeST;
584− },
585− Bind1: function() {
586− return bindST;
587− }
588− };
589− var bindST = {
590− bind: bind_,
591− Apply0: function() {
592− return $lazy_applyST(0);
593− }
594− };
595− var applicativeST = {
596− pure: pure_,
597− Apply0: function() {
598− return $lazy_applyST(0);
599− }
600− };
601− var $lazy_applyST = /* @__PURE__ */ $runtime_lazy2("applyST", "Control.Monad.ST.Internal", function() {
602− return {
603− apply: ap(monadST),
604− Functor0: function() {
605− return functorST;
606− }
607− };
608− });
609− var applyST = /* @__PURE__ */ $lazy_applyST(47);
610−
611− // output/Data.Array/foreign.js
612− var replicateFill = function(count, value) {
613− if (count < 1) {
614− return [];
615− }
616− var result = new Array(count);
617− return result.fill(value);
618− };
619− var replicatePolyfill = function(count, value) {
620− var result = [];
621− var n = 0;
622− for (var i = 0; i < count; i++) {
623− result[n++] = value;
624− }
625− return result;
626− };
627− var replicateImpl = typeof Array.prototype.fill === "function" ? replicateFill : replicatePolyfill;
628− var length = function(xs) {
629− return xs.length;
630− };
631− var unconsImpl = function(empty4, next2, xs) {
632− return xs.length === 0 ? empty4({}) : next2(xs[0])(xs.slice(1));
633− };
634− var indexImpl = function(just, nothing, xs, i) {
635− return i < 0 || i >= xs.length ? nothing : just(xs[i]);
636− };
637− var filterImpl = function(f, xs) {
638− return xs.filter(f);
639− };
640− var partitionImpl = function(f, xs) {
641− var yes = [];
642− var no = [];
643− for (var i = 0; i < xs.length; i++) {
644− var x = xs[i];
645− if (f(x))
646− yes.push(x);
647− else
648− no.push(x);
649− }
650− return { yes, no };
651− };
652−
653− // output/Data.Array.ST/foreign.js
654− function newSTArray() {
655− return [];
656− }
657− function unsafeFreezeThawImpl(xs) {
658− return xs;
659− }
660− var unsafeFreezeImpl = unsafeFreezeThawImpl;
661− var pushImpl = function(a, xs) {
662− return xs.push(a);
663− };
664−
665− // output/Control.Monad.ST.Uncurried/foreign.js
666− var runSTFn1 = function runSTFn12(fn) {
667− return function(a) {
668− return function() {
669− return fn(a);
670− };
671− };
672− };
673− var runSTFn2 = function runSTFn22(fn) {
674− return function(a) {
675− return function(b) {
676− return function() {
677− return fn(a, b);
678− };
679− };
680− };
681− };
682−
683− // output/Data.Array.ST/index.js
684− var unsafeFreeze = /* @__PURE__ */ runSTFn1(unsafeFreezeImpl);
685− var push = /* @__PURE__ */ runSTFn2(pushImpl);
686−
687− // output/Data.HeytingAlgebra/foreign.js
688− var boolConj = function(b1) {
689− return function(b2) {
690− return b1 && b2;
691− };
692− };
693− var boolDisj = function(b1) {
694− return function(b2) {
695− return b1 || b2;
696− };
697− };
698− var boolNot = function(b) {
699− return !b;
700− };
701−
702− // output/Data.HeytingAlgebra/index.js
703− var not = function(dict) {
704− return dict.not;
705− };
706− var disj = function(dict) {
707− return dict.disj;
708− };
709− var heytingAlgebraBoolean = {
710− ff: false,
711− tt: true,
712− implies: function(a) {
713− return function(b) {
714− return disj(heytingAlgebraBoolean)(not(heytingAlgebraBoolean)(a))(b);
715− };
716− },
717− conj: boolConj,
718− disj: boolDisj,
719− not: boolNot
720− };
721−
722− // output/Data.Array.ST.Iterator/index.js
723− var map3 = /* @__PURE__ */ map(functorST);
724− var not2 = /* @__PURE__ */ not(heytingAlgebraBoolean);
725− var $$void2 = /* @__PURE__ */ $$void(functorST);
726− var Iterator = /* @__PURE__ */ function() {
727− function Iterator2(value0, value1) {
728− this.value0 = value0;
729− this.value1 = value1;
730− }
731− ;
732− Iterator2.create = function(value0) {
733− return function(value1) {
734− return new Iterator2(value0, value1);
735− };
736− };
737− return Iterator2;
738− }();
739− var next = function(v) {
740− return function __do2() {
741− var i = read(v.value1)();
742− modify(function(v1) {
743− return v1 + 1 | 0;
744− })(v.value1)();
745− return v.value0(i);
746− };
747− };
748− var iterator = function(f) {
749− return map3(Iterator.create(f))(newSTRef(0));
750− };
751− var iterate = function(iter) {
752− return function(f) {
753− return function __do2() {
754− var $$break = newSTRef(false)();
755− while (map3(not2)(read($$break))()) {
756− (function __do3() {
757− var mx = next(iter)();
758− if (mx instanceof Just) {
759− return f(mx.value0)();
760− }
761− ;
762− if (mx instanceof Nothing) {
763− return $$void2(write(true)($$break))();
764− }
765− ;
766− throw new Error("Failed pattern match at Data.Array.ST.Iterator (line 42, column 5 - line 44, column 47): " + [mx.constructor.name]);
767− })();
768− }
769− ;
770− return {};
771− };
772− };
773− };
774−
775− // output/Data.Foldable/foreign.js
776− var foldrArray = function(f) {
777− return function(init3) {
778− return function(xs) {
779− var acc = init3;
780− var len = xs.length;
781− for (var i = len - 1; i >= 0; i--) {
782− acc = f(xs[i])(acc);
783− }
784− return acc;
785− };
786− };
787− };
788− var foldlArray = function(f) {
789− return function(init3) {
790− return function(xs) {
791− var acc = init3;
792− var len = xs.length;
793− for (var i = 0; i < len; i++) {
794− acc = f(acc)(xs[i]);
795− }
796− return acc;
797− };
798− };
799− };
800−
801− // output/Control.Plus/index.js
802− var empty2 = function(dict) {
803− return dict.empty;
804− };
805−
806− // output/Unsafe.Coerce/foreign.js
807− var unsafeCoerce2 = function(x) {
808− return x;
809− };
810−
811− // output/Safe.Coerce/index.js
812− var coerce = function() {
813− return unsafeCoerce2;
814− };
815−
816− // output/Data.Newtype/index.js
817− var coerce2 = /* @__PURE__ */ coerce();
818− var wrap = function() {
819− return coerce2;
820− };
821−
822− // output/Data.Foldable/index.js
823− var foldr = function(dict) {
824− return dict.foldr;
825− };
826− var foldl = function(dict) {
827− return dict.foldl;
828− };
829− var foldMapDefaultR = function(dictFoldable) {
830− var foldr2 = foldr(dictFoldable);
831− return function(dictMonoid) {
832− var append3 = append(dictMonoid.Semigroup0());
833− var mempty2 = mempty(dictMonoid);
834− return function(f) {
835− return foldr2(function(x) {
836− return function(acc) {
837− return append3(f(x))(acc);
838− };
839− })(mempty2);
840− };
841− };
842− };
843− var foldableArray = {
844− foldr: foldrArray,
845− foldl: foldlArray,
846− foldMap: function(dictMonoid) {
847− return foldMapDefaultR(foldableArray)(dictMonoid);
848− }
849− };
850−
851− // output/Data.Function.Uncurried/foreign.js
852− var runFn2 = function(fn) {
853− return function(a) {
854− return function(b) {
855− return fn(a, b);
856− };
857− };
858− };
859− var runFn3 = function(fn) {
860− return function(a) {
861− return function(b) {
862− return function(c) {
863− return fn(a, b, c);
864− };
865− };
866− };
867− };
868− var runFn4 = function(fn) {
869− return function(a) {
870− return function(b) {
871− return function(c) {
872− return function(d) {
873− return fn(a, b, c, d);
874− };
875− };
876− };
877− };
878− };
879−
880− // output/Data.Array/index.js
881− var uncons = /* @__PURE__ */ function() {
882− return runFn3(unconsImpl)($$const(Nothing.value))(function(x) {
883− return function(xs) {
884− return new Just({
885− head: x,
886− tail: xs
887− });
888− };
889− });
890− }();
891− var singleton2 = function(a) {
892− return [a];
893− };
894− var partition = /* @__PURE__ */ runFn2(partitionImpl);
895− var $$null = function(xs) {
896− return length(xs) === 0;
897− };
898− var index = /* @__PURE__ */ function() {
899− return runFn4(indexImpl)(Just.create)(Nothing.value);
900− }();
901− var filter = /* @__PURE__ */ runFn2(filterImpl);
902− var concatMap = /* @__PURE__ */ flip(/* @__PURE__ */ bind(bindArray));
903− var mapMaybe = function(f) {
904− return concatMap(function() {
905− var $189 = maybe([])(singleton2);
906− return function($190) {
907− return $189(f($190));
908− };
909− }());
910− };
911−
912− // output/Foreign.Object.ST/foreign.js
913− function poke2(k) {
914− return function(v) {
915− return function(m) {
916− return function() {
917− m[k] = v;
918− return m;
919− };
920− };
921− };
922− }
923−
924− // output/Foreign.Object/index.js
925− var thawST = _copyST;
926− var mutate = function(f) {
927− return function(m) {
928− return runST(function __do2() {
929− var s = thawST(m)();
930− f(s)();
931− return s;
932− });
933− };
934− };
935− var insert = function(k) {
936− return function(v) {
937− return mutate(poke2(k)(v));
938− };
939− };
940−
941− // output/Data.Int/foreign.js
942− var toNumber = function(n) {
943− return n;
944− };
945−
946− // output/Data.String.CodePoints/foreign.js
947− var hasArrayFrom = typeof Array.from === "function";
948− var hasStringIterator = typeof Symbol !== "undefined" && Symbol != null && typeof Symbol.iterator !== "undefined" && typeof String.prototype[Symbol.iterator] === "function";
949− var hasFromCodePoint = typeof String.prototype.fromCodePoint === "function";
950− var hasCodePointAt = typeof String.prototype.codePointAt === "function";
951−
952− // output/Data.String.Common/foreign.js
953− var split = function(sep) {
954− return function(s) {
955− return s.split(sep);
956− };
957− };
958−
959− // output/Data.String.Common/index.js
960− var $$null2 = function(s) {
961− return s === "";
962− };
963−
964− // output/Data.Argonaut.Encode.Encoders/index.js
965− var encodeNumber = id;
966− var encodeInt = function($53) {
967− return id(toNumber($53));
968− };
969−
970− // output/Record/index.js
971− var get = function(dictIsSymbol) {
972− var reflectSymbol2 = reflectSymbol(dictIsSymbol);
973− return function() {
974− return function(l) {
975− return function(r) {
976− return unsafeGet(reflectSymbol2(l))(r);
977− };
978− };
979− };
980− };
981− var $$delete3 = function(dictIsSymbol) {
982− var reflectSymbol2 = reflectSymbol(dictIsSymbol);
983− return function() {
984− return function() {
985− return function(l) {
986− return function(r) {
987− return unsafeDelete(reflectSymbol2(l))(r);
988− };
989− };
990− };
991− };
992− };
993−
994− // output/Data.Argonaut.Encode.Class/index.js
995− var gEncodeJsonNil = {
996− gEncodeJson: function(v) {
997− return function(v1) {
998− return empty;
999− };
1000− }
1001− };
1002− var gEncodeJson = function(dict) {
1003− return dict.gEncodeJson;
1004− };
1005− var encodeRecord = function(dictGEncodeJson) {
1006− var gEncodeJson1 = gEncodeJson(dictGEncodeJson);
1007− return function() {
1008− return {
1009− encodeJson: function(rec) {
1010− return id(gEncodeJson1(rec)($$Proxy.value));
1011− }
1012− };
1013− };
1014− };
1015− var encodeJsonJNumber = {
1016− encodeJson: encodeNumber
1017− };
1018− var encodeJsonInt = {
1019− encodeJson: encodeInt
1020− };
1021− var encodeJson = function(dict) {
1022− return dict.encodeJson;
1023− };
1024− var gEncodeJsonCons = function(dictEncodeJson) {
1025− var encodeJson1 = encodeJson(dictEncodeJson);
1026− return function(dictGEncodeJson) {
1027− var gEncodeJson1 = gEncodeJson(dictGEncodeJson);
1028− return function(dictIsSymbol) {
1029− var reflectSymbol2 = reflectSymbol(dictIsSymbol);
1030− var get2 = get(dictIsSymbol)();
1031− return function() {
1032− return {
1033− gEncodeJson: function(row) {
1034− return function(v) {
1035− return insert(reflectSymbol2($$Proxy.value))(encodeJson1(get2($$Proxy.value)(row)))(gEncodeJson1(row)($$Proxy.value));
1036− };
1037− }
1038− };
1039− };
1040− };
1041− };
1042− };
1043−
1044− // output/Effect.Console/foreign.js
1045− var log2 = function(s) {
1046− return function() {
1047− console.log(s);
1048− };
1049− };
1050−
1051− // output/Bun.Request/foreign.js
1052− function method(req) {
1053− return req.method;
1054− }
1055− function url(req) {
1056− return req.url;
1057− }
1058−
1059− // output/Bun.Response/foreign.js
1060− function json2(j) {
1061− return function(options) {
1062− return Response.json(j, options);
1063− };
1064− }
1065− function string(s) {
1066− return function(options) {
1067− return new Response(s, options);
1068− };
1069− }
1070−
1071− // output/Data.URL/foreign.js
1072− var fromStringImpl2 = (s) => {
1073− try {
1074− return new URL(s);
1075− } catch {
1076− return null;
1077− }
1078− };
1079− var pathnameImpl = (u) => u.pathname;
1080−
1081− // output/Data.Compactable/index.js
1082− var $$void3 = /* @__PURE__ */ $$void(functorST);
1083− var pure1 = /* @__PURE__ */ pure(applicativeST);
1084− var apply2 = /* @__PURE__ */ apply(applyST);
1085− var map4 = /* @__PURE__ */ map(functorST);
1086− var compactableMaybe = {
1087− compact: /* @__PURE__ */ join(bindMaybe),
1088− separate: function(v) {
1089− if (v instanceof Nothing) {
1090− return {
1091− left: Nothing.value,
1092− right: Nothing.value
1093− };
1094− }
1095− ;
1096− if (v instanceof Just) {
1097− if (v.value0 instanceof Left) {
1098− return {
1099− left: new Just(v.value0.value0),
1100− right: Nothing.value
1101− };
1102− }
1103− ;
1104− if (v.value0 instanceof Right) {
1105− return {
1106− left: Nothing.value,
1107− right: new Just(v.value0.value0)
1108− };
1109− }
1110− ;
1111− throw new Error("Failed pattern match at Data.Compactable (line 91, column 23 - line 93, column 48): " + [v.value0.constructor.name]);
1112− }
1113− ;
1114− throw new Error("Failed pattern match at Data.Compactable (line 87, column 1 - line 93, column 48): " + [v.constructor.name]);
1115− }
1116− };
1117− var compactableArray = {
1118− compact: function(xs) {
1119− return function __do2() {
1120− var result = newSTArray();
1121− var iter = iterator(function(v) {
1122− return index(xs)(v);
1123− })();
1124− iterate(iter)(function($108) {
1125− return $$void3(function(v) {
1126− if (v instanceof Nothing) {
1127− return pure1(0);
1128− }
1129− ;
1130− if (v instanceof Just) {
1131− return push(v.value0)(result);
1132− }
1133− ;
1134− throw new Error("Failed pattern match at Data.Compactable (line 111, column 34 - line 113, column 35): " + [v.constructor.name]);
1135− }($108));
1136− })();
1137− return unsafeFreeze(result)();
1138− }();
1139− },
1140− separate: function(xs) {
1141− return function __do2() {
1142− var ls = newSTArray();
1143− var rs = newSTArray();
1144− var iter = iterator(function(v) {
1145− return index(xs)(v);
1146− })();
1147− iterate(iter)(function($109) {
1148− return $$void3(function(v) {
1149− if (v instanceof Left) {
1150− return push(v.value0)(ls);
1151− }
1152− ;
1153− if (v instanceof Right) {
1154− return push(v.value0)(rs);
1155− }
1156− ;
1157− throw new Error("Failed pattern match at Data.Compactable (line 122, column 34 - line 124, column 31): " + [v.constructor.name]);
1158− }($109));
1159− })();
1160− return apply2(map4(function(v) {
1161− return function(v1) {
1162− return {
1163− left: v,
1164− right: v1
1165− };
1166− };
1167− })(unsafeFreeze(ls)))(unsafeFreeze(rs))();
1168− }();
1169− }
1170− };
1171−
1172− // output/Data.Filterable/index.js
1173− var append2 = /* @__PURE__ */ append(semigroupArray);
1174− var foldl2 = /* @__PURE__ */ foldl(foldableArray);
1175− var partitionMap = function(dict) {
1176− return dict.partitionMap;
1177− };
1178− var maybeBool = function(p) {
1179− return function(x) {
1180− var $66 = p(x);
1181− if ($66) {
1182− return new Just(x);
1183− }
1184− ;
1185− return Nothing.value;
1186− };
1187− };
1188− var filterableArray = {
1189− partitionMap: function(p) {
1190− var go = function(acc) {
1191− return function(x) {
1192− var v = p(x);
1193− if (v instanceof Left) {
1194− return {
1195− right: acc.right,
1196− left: append2(acc.left)([v.value0])
1197− };
1198− }
1199− ;
1200− if (v instanceof Right) {
1201− return {
1202− left: acc.left,
1203− right: append2(acc.right)([v.value0])
1204− };
1205− }
1206− ;
1207− throw new Error("Failed pattern match at Data.Filterable (line 149, column 16 - line 151, column 50): " + [v.constructor.name]);
1208− };
1209− };
1210− return foldl2(go)({
1211− left: [],
1212− right: []
1213− });
1214− },
1215− partition,
1216− filterMap: mapMaybe,
1217− filter,
1218− Compactable0: function() {
1219− return compactableArray;
1220− },
1221− Functor1: function() {
1222− return functorArray;
1223− }
1224− };
1225− var filterMap = function(dict) {
1226− return dict.filterMap;
1227− };
1228− var filterDefault = function(dictFilterable) {
1229− var $121 = filterMap(dictFilterable);
1230− return function($122) {
1231− return $121(maybeBool($122));
1232− };
1233− };
1234− var filter3 = function(dict) {
1235− return dict.filter;
1236− };
1237− var eitherBool = function(p) {
1238− return function(x) {
1239− var $84 = p(x);
1240− if ($84) {
1241− return new Right(x);
1242− }
1243− ;
1244− return new Left(x);
1245− };
1246− };
1247− var partitionDefault = function(dictFilterable) {
1248− var partitionMap1 = partitionMap(dictFilterable);
1249− return function(p) {
1250− return function(xs) {
1251− var o = partitionMap1(eitherBool(p))(xs);
1252− return {
1253− no: o.left,
1254− yes: o.right
1255− };
1256− };
1257− };
1258− };
1259− var filterableMaybe = {
1260− partitionMap: function(v) {
1261− return function(v1) {
1262− if (v1 instanceof Nothing) {
1263− return {
1264− left: Nothing.value,
1265− right: Nothing.value
1266− };
1267− }
1268− ;
1269− if (v1 instanceof Just) {
1270− var v2 = v(v1.value0);
1271− if (v2 instanceof Left) {
1272− return {
1273− left: new Just(v2.value0),
1274− right: Nothing.value
1275− };
1276− }
1277− ;
1278− if (v2 instanceof Right) {
1279− return {
1280− left: Nothing.value,
1281− right: new Just(v2.value0)
1282− };
1283− }
1284− ;
1285− throw new Error("Failed pattern match at Data.Filterable (line 161, column 29 - line 163, column 48): " + [v2.constructor.name]);
1286− }
1287− ;
1288− throw new Error("Failed pattern match at Data.Filterable (line 159, column 1 - line 169, column 29): " + [v.constructor.name, v1.constructor.name]);
1289− };
1290− },
1291− partition: function(p) {
1292− return partitionDefault(filterableMaybe)(p);
1293− },
1294− filterMap: /* @__PURE__ */ bindFlipped(bindMaybe),
1295− filter: function(p) {
1296− return filterDefault(filterableMaybe)(p);
1297− },
1298− Compactable0: function() {
1299− return compactableMaybe;
1300− },
1301− Functor1: function() {
1302− return functorMaybe;
1303− }
1304− };
1305−
1306− // output/Data.Nullable/foreign.js
1307− function nullable(a, r, f) {
1308− return a == null ? r : f(a);
1309− }
1310−
1311− // output/Data.Nullable/index.js
1312− var toMaybe = function(n) {
1313− return nullable(n, Nothing.value, Just.create);
1314− };
1315−
1316− // output/Data.String.Utils/foreign.js
1317− function startsWithImpl(searchString, s) {
1318− return s.startsWith(searchString);
1319− }
1320−
1321− // output/Data.String.Utils/index.js
1322− var startsWith = function(searchString) {
1323− return function(s) {
1324− return startsWithImpl(searchString, s);
1325− };
1326− };
1327−
1328− // output/Foreign/foreign.js
1329− var isArray = Array.isArray || function(value) {
1330− return Object.prototype.toString.call(value) === "[object Array]";
1331− };
1332−
1333− // output/Data.URL/index.js
1334− var filter4 = /* @__PURE__ */ filter3(filterableMaybe);
1335− var wrap2 = /* @__PURE__ */ wrap();
1336− var filter1 = /* @__PURE__ */ filter3(filterableArray);
1337− var PathEmpty = /* @__PURE__ */ function() {
1338− function PathEmpty2() {
1339− }
1340− ;
1341− PathEmpty2.value = new PathEmpty2();
1342− return PathEmpty2;
1343− }();
1344− var PathAbsolute = /* @__PURE__ */ function() {
1345− function PathAbsolute2(value0) {
1346− this.value0 = value0;
1347− }
1348− ;
1349− PathAbsolute2.create = function(value0) {
1350− return new PathAbsolute2(value0);
1351− };
1352− return PathAbsolute2;
1353− }();
1354− var PathRelative = /* @__PURE__ */ function() {
1355− function PathRelative2(value0) {
1356− this.value0 = value0;
1357− }
1358− ;
1359− PathRelative2.create = function(value0) {
1360− return new PathRelative2(value0);
1361− };
1362− return PathRelative2;
1363− }();
1364− var pathFromString = function(s) {
1365− var segments = function() {
1366− var $235 = filter1(function($238) {
1367− return !$$null2($238);
1368− });
1369− var $236 = split(wrap2("/"));
1370− return function($237) {
1371− return $235($236($237));
1372− };
1373− }();
1374− return maybe(PathEmpty.value)(function() {
1375− var $203 = startsWith("/")(s);
1376− if ($203) {
1377− return PathAbsolute.create;
1378− }
1379− ;
1380− return PathRelative.create;
1381− }())(filter4(function($239) {
1382− return !$$null($239);
1383− })(new Just(segments(s))));
1384− };
1385− var path = function($240) {
1386− return pathFromString(pathnameImpl($240));
1387− };
1388− var fromString2 = function($255) {
1389− return toMaybe(fromStringImpl2($255));
1390− };
1391−
1392− // output/PureStack.Router/index.js
1393− var bind2 = /* @__PURE__ */ bind(bindMaybe);
1394− var pure2 = /* @__PURE__ */ pure(applicativeEffect);
1395− var discard2 = /* @__PURE__ */ discard(discardUnit)(bindMaybe);
1396− var eq12 = /* @__PURE__ */ eq(/* @__PURE__ */ eqArray(eqString));
1397− var pure12 = /* @__PURE__ */ pure(applicativeMaybe);
1398− var toResponseRecord = function(dictEncodeJson) {
1399− var encodeJson2 = encodeJson(dictEncodeJson);
1400− return {
1401− toResponse: function(rec) {
1402− return function(opts) {
1403− return json2(encodeJson2(rec))(opts);
1404− };
1405− }
1406− };
1407− };
1408− var toResponse = function(dict) {
1409− return dict.toResponse;
1410− };
1411− var runAPI = function(dict) {
1412− return dict.runAPI;
1413− };
1414− var routeFromRequest = function(req) {
1415− return {
1416− verb: method(req),
1417− path: function() {
1418− var v = fromString2(url(req));
1419− if (v instanceof Nothing) {
1420− return [];
1421− }
1422− ;
1423− if (v instanceof Just) {
1424− var v1 = path(v.value0);
1425− if (v1 instanceof PathEmpty) {
1426− return [];
1427− }
1428− ;
1429− if (v1 instanceof PathAbsolute) {
1430− return v1.value0;
1431− }
1432− ;
1433− if (v1 instanceof PathRelative) {
1434− return v1.value0;
1435− }
1436− ;
1437− throw new Error("Failed pattern match at PureStack.Router (line 68, column 19 - line 71, column 32): " + [v1.constructor.name]);
1438− }
1439− ;
1440− throw new Error("Failed pattern match at PureStack.Router (line 66, column 11 - line 71, column 32): " + [v.constructor.name]);
1441− }()
1442− };
1443− };
1444− var run3 = function() {
1445− return function(dictRunAPI) {
1446− var runAPI1 = runAPI(dictRunAPI);
1447− return function(handlers) {
1448− return function(req) {
1449− return runAPI1(handlers)(routeFromRequest(req))(req);
1450− };
1451− };
1452− };
1453− };
1454− var parseRoute = function(dict) {
1455− return dict.parseRoute;
1456− };
1457− var runAPICons = function(dictParseRoute) {
1458− var parseRoute1 = parseRoute(dictParseRoute);
1459− return function() {
1460− return function(dictRunAPI) {
1461− var runAPI1 = runAPI(dictRunAPI);
1462− return function(dictIsSymbol) {
1463− var $$delete4 = $$delete3(dictIsSymbol)()();
1464− var get2 = get(dictIsSymbol)();
1465− return function() {
1466− return function() {
1467− return {
1468− runAPI: function(handlers) {
1469− return function(v) {
1470− return function(req) {
1471− var v1 = parseRoute1({
1472− path: v.path,
1473− verb: v.verb
1474− });
1475− if (v1 instanceof Nothing) {
1476− return runAPI1($$delete4($$Proxy.value)(handlers))(v)(req);
1477− }
1478− ;
1479− if (v1 instanceof Just) {
1480− return v1.value0(get2($$Proxy.value)(handlers))(req);
1481− }
1482− ;
1483− throw new Error("Failed pattern match at PureStack.Router (line 150, column 5 - line 152, column 59): " + [v1.constructor.name]);
1484− };
1485− };
1486− }
1487− };
1488− };
1489− };
1490− };
1491− };
1492− };
1493− };
1494− var notFound = /* @__PURE__ */ string("")({
1495− status: 404,
1496− statusText: "Not Found",
1497− headers: []
1498− });
1499− var runAPINilRow = {
1500− runAPI: function(v) {
1501− return function(v1) {
1502− return function(v2) {
1503− return pure2(notFound);
1504− };
1505− };
1506− }
1507− };
1508− var assert = function(dictApplicative) {
1509− var pure22 = pure(dictApplicative);
1510− return function(dictPlus) {
1511− var empty4 = empty2(dictPlus);
1512− return function(v) {
1513− if (v) {
1514− return pure22(unit);
1515− }
1516− ;
1517− if (!v) {
1518− return empty4;
1519− }
1520− ;
1521− throw new Error("Failed pattern match at PureStack.Router (line 130, column 1 - line 130, column 65): " + [v.constructor.name]);
1522− };
1523− };
1524− };
1525− var assert1 = /* @__PURE__ */ assert(applicativeMaybe)(plusMaybe);
1526− var parseRoute$div = function(dictParseRoute) {
1527− var parseRoute1 = parseRoute(dictParseRoute);
1528− return function(dictIsSymbol) {
1529− var reflectSymbol2 = reflectSymbol(dictIsSymbol);
1530− return {
1531− parseRoute: function(v) {
1532− return bind2(uncons(v.path))(function(v1) {
1533− return discard2(assert1(v1.head === reflectSymbol2($$Proxy.value)))(function() {
1534− return parseRoute1({
1535− path: v1.tail,
1536− verb: v.verb
1537− });
1538− });
1539− });
1540− }
1541− };
1542− };
1543− };
1544− var parseRouteGETEffect = function(dictToResponse) {
1545− var toResponse1 = toResponse(dictToResponse);
1546− return {
1547− parseRoute: function(v) {
1548− return discard2(assert1(v.verb === "GET"))(function() {
1549− return discard2(assert1(eq12(v.path)([])))(function() {
1550− return pure12(function(handler) {
1551− return function(_req) {
1552− return function __do2() {
1553− var resp = handler();
1554− return toResponse1(resp)({
1555− status: 200,
1556− statusText: "OK",
1557− headers: []
1558− });
1559− };
1560− };
1561− });
1562− });
1563− });
1564− }
1565− };
1566− };
1567− var parseRoutePOSTUnitEffect = function(dictToResponse) {
1568− var toResponse1 = toResponse(dictToResponse);
1569− return {
1570− parseRoute: function(v) {
1571− return discard2(assert1(eq12(v.path)([])))(function() {
1572− return discard2(assert1(v.verb === "POST"))(function() {
1573− return pure12(function(handler) {
1574− return function(req) {
1575− return function __do2() {
1576− var resp = handler();
1577− return toResponse1(resp)({
1578− status: 200,
1579− statusText: "OK",
1580− headers: []
1581− });
1582− };
1583− };
1584− });
1585− });
1586− });
1587− }
1588− };
1589− };
1590−
1591− // output/Main/index.js
1592− var gEncodeJsonCons2 = /* @__PURE__ */ gEncodeJsonCons(encodeJsonInt);
1593− var aIsSymbol = {
1594− reflectSymbol: function() {
1595− return "a";
1596− }
1597− };
1598− var fooIsSymbol = {
1599− reflectSymbol: function() {
1600− return "foo";
1601− }
1602− };
1603− var barIsSymbol = {
1604− reflectSymbol: function() {
1605− return "bar";
1606− }
1607− };
1608− var run4 = /* @__PURE__ */ run3()(/* @__PURE__ */ runAPICons(/* @__PURE__ */ parseRoute$div(/* @__PURE__ */ parseRoute$div(/* @__PURE__ */ parseRoutePOSTUnitEffect(/* @__PURE__ */ toResponseRecord(/* @__PURE__ */ encodeRecord(/* @__PURE__ */ gEncodeJsonCons2(gEncodeJsonNil)(aIsSymbol)())())))({
1609− reflectSymbol: function() {
1610− return "qux";
1611− }
1612− }))(fooIsSymbol))()(/* @__PURE__ */ runAPICons(/* @__PURE__ */ parseRoute$div(/* @__PURE__ */ parseRoute$div(/* @__PURE__ */ parseRoute$div(/* @__PURE__ */ parseRouteGETEffect(/* @__PURE__ */ toResponseRecord(/* @__PURE__ */ encodeRecord(/* @__PURE__ */ gEncodeJsonCons2(/* @__PURE__ */ gEncodeJsonCons(encodeJsonJNumber)(gEncodeJsonNil)({
1613− reflectSymbol: function() {
1614− return "b";
1615− }
1616− })())(aIsSymbol)())())))(fooIsSymbol))(barIsSymbol))(fooIsSymbol))()(runAPINilRow)(fooIsSymbol)()())(barIsSymbol)()());
1617− var pure3 = /* @__PURE__ */ pure(applicativeEffect);
1618− var main = function __do() {
1619− log2("\u{1F35D}")();
1620− return serve(run4({
1621− foo: pure3({
1622− a: 1,
1623− b: 1
1624− }),
1625− bar: pure3({
1626− a: 8
1627− })
1628− }))();
1629− };
1630−
1631− // <stdin>
1632− main();
1633−})();