git.iko.soy/purestack-dev/purescript-purestack-server
on master help sign in
Got initial version working
30b25dbiko
.gitignorenew file+11
compare with master
unifiedsplit
@@ -0,0 +1,11 @@
1+/bower_components/
2+/node_modules/
3+/.pulp-cache/
4+/output/
5+/generated-docs/
6+/.psc-package/
7+/.psc*
8+/.purs*
9+/.psa*
10+/.spago
11+index.js
index.jsnew file+1625
@@ -0,0 +1,1625 @@
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 run3 = function() {
1415+ return function(dictRunAPI) {
1416+ return runAPI(dictRunAPI);
1417+ };
1418+ };
1419+ var parseRoute = function(dict) {
1420+ return dict.parseRoute;
1421+ };
1422+ var notFound = /* @__PURE__ */ string("")({
1423+ status: 404,
1424+ statusText: "Not Found",
1425+ headers: []
1426+ });
1427+ var runAPINilRow = {
1428+ runAPI: function(v) {
1429+ return function(v1) {
1430+ return pure2(notFound);
1431+ };
1432+ }
1433+ };
1434+ var internalServerError = /* @__PURE__ */ string("")({
1435+ status: 500,
1436+ statusText: "Internal Server Error",
1437+ headers: []
1438+ });
1439+ var runAPICons = function(dictParseRoute) {
1440+ var parseRoute1 = parseRoute(dictParseRoute);
1441+ return function() {
1442+ return function(dictRunAPI) {
1443+ var runAPI1 = runAPI(dictRunAPI);
1444+ return function(dictIsSymbol) {
1445+ var $$delete4 = $$delete3(dictIsSymbol)()();
1446+ var get2 = get(dictIsSymbol)();
1447+ return function() {
1448+ return function() {
1449+ return {
1450+ runAPI: function(handlers) {
1451+ return function(req) {
1452+ var v = fromString2(url(req));
1453+ if (v instanceof Nothing) {
1454+ return pure2(internalServerError);
1455+ }
1456+ ;
1457+ if (v instanceof Just) {
1458+ var verb1 = method(req);
1459+ var path2 = function() {
1460+ var v12 = path(v.value0);
1461+ if (v12 instanceof PathEmpty) {
1462+ return [];
1463+ }
1464+ ;
1465+ if (v12 instanceof PathAbsolute) {
1466+ return v12.value0;
1467+ }
1468+ ;
1469+ if (v12 instanceof PathRelative) {
1470+ return v12.value0;
1471+ }
1472+ ;
1473+ throw new Error("Failed pattern match at PureStack.Router (line 161, column 18 - line 164, column 36): " + [v12.constructor.name]);
1474+ }();
1475+ var v1 = parseRoute1({
1476+ path: path2,
1477+ verb: verb1
1478+ });
1479+ if (v1 instanceof Nothing) {
1480+ return runAPI1($$delete4($$Proxy.value)(handlers))(req);
1481+ }
1482+ ;
1483+ if (v1 instanceof Just) {
1484+ return v1.value0(get2($$Proxy.value)(handlers))(req);
1485+ }
1486+ ;
1487+ throw new Error("Failed pattern match at PureStack.Router (line 166, column 9 - line 168, column 63): " + [v1.constructor.name]);
1488+ }
1489+ ;
1490+ throw new Error("Failed pattern match at PureStack.Router (line 157, column 5 - line 168, column 63): " + [v.constructor.name]);
1491+ };
1492+ }
1493+ };
1494+ };
1495+ };
1496+ };
1497+ };
1498+ };
1499+ };
1500+ var assert = function(dictApplicative) {
1501+ var pure22 = pure(dictApplicative);
1502+ return function(dictPlus) {
1503+ var empty4 = empty2(dictPlus);
1504+ return function(v) {
1505+ if (v) {
1506+ return pure22(unit);
1507+ }
1508+ ;
1509+ if (!v) {
1510+ return empty4;
1511+ }
1512+ ;
1513+ throw new Error("Failed pattern match at PureStack.Router (line 137, column 1 - line 137, column 65): " + [v.constructor.name]);
1514+ };
1515+ };
1516+ };
1517+ var assert1 = /* @__PURE__ */ assert(applicativeMaybe)(plusMaybe);
1518+ var parseRoute$div = function(dictParseRoute) {
1519+ var parseRoute1 = parseRoute(dictParseRoute);
1520+ return function(dictIsSymbol) {
1521+ var reflectSymbol2 = reflectSymbol(dictIsSymbol);
1522+ return {
1523+ parseRoute: function(v) {
1524+ return bind2(uncons(v.path))(function(v1) {
1525+ return discard2(assert1(v1.head === reflectSymbol2($$Proxy.value)))(function() {
1526+ return parseRoute1({
1527+ path: v1.tail,
1528+ verb: v.verb
1529+ });
1530+ });
1531+ });
1532+ }
1533+ };
1534+ };
1535+ };
1536+ var parseRouteGETEffect = function(dictToResponse) {
1537+ var toResponse1 = toResponse(dictToResponse);
1538+ return {
1539+ parseRoute: function(v) {
1540+ return discard2(assert1(v.verb === "GET"))(function() {
1541+ return discard2(assert1(eq12(v.path)([])))(function() {
1542+ return pure12(function(handler) {
1543+ return function(_req) {
1544+ return function __do2() {
1545+ var resp = handler();
1546+ return toResponse1(resp)({
1547+ status: 200,
1548+ statusText: "OK",
1549+ headers: []
1550+ });
1551+ };
1552+ };
1553+ });
1554+ });
1555+ });
1556+ }
1557+ };
1558+ };
1559+ var parseRoutePOSTUnitEffect = function(dictToResponse) {
1560+ var toResponse1 = toResponse(dictToResponse);
1561+ return {
1562+ parseRoute: function(v) {
1563+ return discard2(assert1(eq12(v.path)([])))(function() {
1564+ return discard2(assert1(v.verb === "POST"))(function() {
1565+ return pure12(function(handler) {
1566+ return function(req) {
1567+ return function __do2() {
1568+ var resp = handler();
1569+ return toResponse1(resp)({
1570+ status: 200,
1571+ statusText: "OK",
1572+ headers: []
1573+ });
1574+ };
1575+ };
1576+ });
1577+ });
1578+ });
1579+ }
1580+ };
1581+ };
1582+
1583+ // output/Main/index.js
1584+ var gEncodeJsonCons2 = /* @__PURE__ */ gEncodeJsonCons(encodeJsonInt);
1585+ var aIsSymbol = {
1586+ reflectSymbol: function() {
1587+ return "a";
1588+ }
1589+ };
1590+ var fooIsSymbol = {
1591+ reflectSymbol: function() {
1592+ return "foo";
1593+ }
1594+ };
1595+ var barIsSymbol = {
1596+ reflectSymbol: function() {
1597+ return "bar";
1598+ }
1599+ };
1600+ var run4 = /* @__PURE__ */ run3()(/* @__PURE__ */ runAPICons(/* @__PURE__ */ parseRoute$div(/* @__PURE__ */ parseRoute$div(/* @__PURE__ */ parseRoutePOSTUnitEffect(/* @__PURE__ */ toResponseRecord(/* @__PURE__ */ encodeRecord(/* @__PURE__ */ gEncodeJsonCons2(gEncodeJsonNil)(aIsSymbol)())())))({
1601+ reflectSymbol: function() {
1602+ return "qux";
1603+ }
1604+ }))(fooIsSymbol))()(/* @__PURE__ */ runAPICons(/* @__PURE__ */ parseRoute$div(/* @__PURE__ */ parseRoute$div(/* @__PURE__ */ parseRoute$div(/* @__PURE__ */ parseRouteGETEffect(/* @__PURE__ */ toResponseRecord(/* @__PURE__ */ encodeRecord(/* @__PURE__ */ gEncodeJsonCons2(/* @__PURE__ */ gEncodeJsonCons(encodeJsonJNumber)(gEncodeJsonNil)({
1605+ reflectSymbol: function() {
1606+ return "b";
1607+ }
1608+ })())(aIsSymbol)())())))(fooIsSymbol))(barIsSymbol))(fooIsSymbol))()(runAPINilRow)(fooIsSymbol)()())(barIsSymbol)()());
1609+ var pure3 = /* @__PURE__ */ pure(applicativeEffect);
1610+ var main = function __do() {
1611+ log2("\u{1F35D}")();
1612+ return serve(run4({
1613+ foo: pure3({
1614+ a: 1,
1615+ b: 1
1616+ }),
1617+ bar: pure3({
1618+ a: 8
1619+ })
1620+ }))();
1621+ };
1622+
1623+ // <stdin>
1624+ main();
1625+})();
packages.dhallnew file+5
@@ -0,0 +1,5 @@
1+let upstream =
2+ https://github.com/purescript/package-sets/releases/download/psc-0.15.15-20250523/packages.dhall
3+ sha256:1274f34a6328069aabf8a149e395c414d80999a73073330c436ba0739615c536
4+
5+in upstream
spago.dhallnew file+19
@@ -0,0 +1,19 @@
1+{ name = "my-project"
2+, dependencies =
3+ [ "aff-promise"
4+ , "argonaut"
5+ , "arrays"
6+ , "console"
7+ , "control"
8+ , "effect"
9+ , "maybe"
10+ , "prelude"
11+ , "record"
12+ , "tuples"
13+ , "typelevel-prelude"
14+ , "unsafe-coerce"
15+ , "url-immutable"
16+ ]
17+, packages = ./packages.dhall
18+, sources = [ "src/**/*.purs", "test/**/*.purs" ]
19+}
src/Bun/Request.jsnew file+11
@@ -0,0 +1,11 @@
1+export function json(req) {
2+ return req.json
3+}
4+
5+export function method(req) {
6+ return req.method
7+}
8+
9+export function url(req) {
10+ return req.url
11+}
src/Bun/Request.pursnew file+12
@@ -0,0 +1,12 @@
1+module Bun.Request where
2+
3+import Control.Promise (Promise)
4+import Data.Argonaut (Json)
5+
6+foreign import data Request :: Type
7+
8+foreign import json :: Request -> Promise Json
9+
10+foreign import method :: Request -> String
11+
12+foreign import url :: Request -> String
src/Bun/Response.jsnew file+12
@@ -0,0 +1,12 @@
1+export function json(j) {
2+ return function(options) {
3+ return Response.json(j, options)
4+ }
5+}
6+
7+
8+export function string(s) {
9+ return function(options) {
10+ return new Response(s, options)
11+ }
12+}
src/Bun/Response.pursnew file+12
@@ -0,0 +1,12 @@
1+module Bun.Response where
2+
3+import Data.Argonaut (Json)
4+import Data.Tuple.Nested (type (/\))
5+import Effect (Effect)
6+
7+foreign import data Response :: Type
8+
9+type Options = { status :: Int, statusText :: String, headers :: Array (String /\ String) }
10+
11+foreign import json :: Json -> Options -> Response
12+foreign import string :: String -> Options -> Response
src/Bun/Server.jsnew file+9
@@ -0,0 +1,9 @@
1+export function serve(f) {
2+ return function() {
3+ return Bun.serve({
4+ fetch(req) {
5+ return f(req)()
6+ }
7+ })
8+ }
9+}
src/Bun/Server.pursnew file+9
@@ -0,0 +1,9 @@
1+module Bun.Server (serve) where
2+
3+import Prelude
4+
5+import Bun.Request (Request)
6+import Bun.Response (Response)
7+import Effect (Effect)
8+
9+foreign import serve :: (Request -> Effect Response) -> Effect Unit
src/Main.pursnew file+19
@@ -0,0 +1,19 @@
1+module Main where
2+
3+import Prelude
4+
5+import Bun.Server as Bun
6+import Effect (Effect)
7+import Effect.Console (log)
8+import PureStack.Router (type (/), GET, POST)
9+import PureStack.Router as Router
10+
11+type API =
12+ ( foo :: "foo" / "bar" / "foo" / GET { a :: Int, b :: Number }
13+ , bar :: "foo" / "qux" / POST Unit { a :: Int }
14+ )
15+
16+main :: Effect Unit
17+main = do
18+ log "🍝"
19+ Bun.serve $ Router.run @API { foo: pure { a: 1, b: 1.0 }, bar: pure { a: 8 } }
src/PureStack/Router.pursnew file+180
@@ -0,0 +1,180 @@
1+module PureStack.Router
2+ ( run
3+ , type (/)
4+ , class RunAPI
5+ , runAPI
6+ , Slash
7+ , GET
8+ , POST
9+ , PUT
10+ , DELETE
11+ , PATCH
12+ , class ParseRoute
13+ , parseRoute
14+ , class ToResponse
15+ , toResponse
16+ ) where
17+
18+import Prelude
19+import Record
20+
21+import Bun.Request (Request)
22+import Bun.Request as Request
23+import Bun.Response (Response)
24+import Bun.Response as Response
25+import Control.Alternative (class Plus, empty)
26+import Data.Argonaut (class EncodeJson, Json, encodeJson)
27+import Data.Array as Array
28+import Data.Maybe (Maybe(..))
29+import Data.Symbol (class IsSymbol, reflectSymbol)
30+import Data.URL as URL
31+import Data.Unit (Unit)
32+import Effect (Effect)
33+import Effect.Class (liftEffect)
34+import Prim.Row as Row
35+import Prim.RowList (class RowToList)
36+import Prim.RowList as RowList
37+import Record as Record
38+import Type.Prelude (Proxy(..))
39+import Unsafe.Coerce (unsafeCoerce)
40+
41+class Verb :: Type -> Type -> Constraint
42+class Verb t resp | t -> resp where
43+ verb :: String
44+
45+data GET :: Type -> Type
46+data GET resp
47+
48+instance Verb (GET resp) resp where
49+ verb = "GET"
50+
51+data POST :: Type -> Type -> Type
52+data POST req resp
53+
54+instance Verb (POST req resp) resp where
55+ verb = "POST"
56+
57+data PUT :: Type -> Type -> Type
58+data PUT req resp
59+
60+instance Verb (PUT req resp) resp where
61+ verb = "PUT"
62+
63+data DELETE :: Type -> Type -> Type
64+data DELETE req resp
65+
66+instance Verb (DELETE req resp) (req -> Effect resp) where
67+ verb = "DELETE"
68+
69+data PATCH :: Type -> Type -> Type
70+data PATCH req resp
71+
72+instance Verb (PATCH req resp) (req -> Effect resp) where
73+ verb = "PATCH"
74+
75+data Slash :: forall k1 k2. k1 -> k2 -> Type
76+data Slash x y
77+
78+infixr 6 type Slash as /
79+
80+type Route = { path :: Array String, verb :: String }
81+
82+class ParseRoute :: forall k. k -> Type -> Constraint
83+class ParseRoute route handler | route -> handler where
84+ parseRoute :: Route -> Maybe (handler -> Request -> Effect Response)
85+
86+instance (ParseRoute rest handler, IsSymbol path) => ParseRoute (path / rest) handler where
87+ parseRoute { path, verb } = do
88+ { head: h, tail } <- Array.uncons path
89+ assert $ h == (reflectSymbol @path Proxy)
90+ parseRoute @rest { path: tail, verb: verb }
91+
92+else instance (ParseRoute rest handler, ParsePathPiece t) => ParseRoute (t / rest) (t -> handler) where
93+ parseRoute { path, verb } = do
94+ { head: h, tail } <- Array.uncons path
95+ t <- parsePathPiece @t h
96+ parseRoute @rest { path: tail, verb } <#> (\f handler req -> f (handler t) req)
97+
98+else instance ToResponse resp => ParseRoute (GET resp) (Effect resp) where
99+ parseRoute { path, verb } = do
100+ assert $ verb == "GET"
101+ assert $ path == []
102+ pure $ \handler _req -> do
103+ resp <- handler
104+ pure $ toResponse resp { status: 200, statusText: "OK", headers: [] }
105+
106+else instance (ToResponse resp) => ParseRoute (POST Unit resp) (Effect resp) where
107+ parseRoute { path, verb } = do
108+ assert $ path == []
109+ assert $ verb == "POST"
110+ pure $ \handler req -> do
111+ resp <- handler
112+ pure $ toResponse resp { status: 200, statusText: "OK", headers: [] }
113+
114+else instance (FromRequestBody req, ToResponse resp) => ParseRoute (POST req resp) (req -> Effect resp) where
115+ parseRoute { path, verb } = do
116+ assert $ path == []
117+ assert $ verb == "POST"
118+ pure $ \handler req -> do
119+ fromRequestBody req >>= case _ of
120+ Nothing -> pure $ Response.string "" { status: 400, statusText: "Bad Request", headers: [] }
121+ Just r -> do
122+ resp <- handler r
123+ pure $ toResponse resp { status: 200, statusText: "OK", headers: [] }
124+
125+class ToResponse r where
126+ toResponse :: r -> Response.Options -> Response
127+
128+instance EncodeJson (Record row) => ToResponse (Record row) where
129+ toResponse rec opts = Response.json (encodeJson rec) opts
130+
131+class FromRequestBody r where
132+ fromRequestBody :: Request -> Effect (Maybe r)
133+
134+class ParsePathPiece t where
135+ parsePathPiece :: String -> Maybe t
136+
137+assert :: forall m. Applicative m => Plus m => Boolean -> m Unit
138+assert true = pure unit
139+assert false = empty
140+
141+class RunAPI row list handlers | row -> handlers where
142+ runAPI :: Record handlers -> Request -> Effect Response
143+
144+instance RunAPI row RowList.Nil () where
145+ runAPI _ _ = pure notFound
146+
147+instance
148+ ( ParseRoute t handler
149+ , Row.Cons field t tail row
150+ , RunAPI row rest restHandlers
151+ , IsSymbol field
152+ , Row.Cons field handler restHandlers handlers
153+ , Row.Lacks field restHandlers
154+ ) =>
155+ RunAPI row (RowList.Cons field t rest) handlers where
156+ runAPI handlers req = do
157+ case URL.fromString (Request.url req) of
158+ Nothing -> pure internalServerError
159+ Just url -> do
160+ let
161+ path = case URL.path url of
162+ URL.PathEmpty -> []
163+ URL.PathAbsolute p -> p
164+ URL.PathRelative p -> p
165+ verb = Request.method req
166+ case parseRoute @t { path, verb } of
167+ Nothing -> runAPI @row @rest @restHandlers (Record.delete (Proxy @field) handlers) req
168+ Just f -> f (Record.get (Proxy @field) handlers) req
169+
170+notFound :: Response
171+notFound = Response.string "" { status: 404, statusText: "Not Found", headers: [] }
172+
173+internalServerError :: Response
174+internalServerError = Response.string "" { status: 500, statusText: "Internal Server Error", headers: [] }
175+
176+run :: forall @row list handlers. RowToList row list => RunAPI row list handlers => Record handlers -> Request -> Effect Response
177+run = runAPI @row @list @handlers
178+
179+---------------------------------------------------------------------------------------------------
180+
test/Main.pursnew file+11
@@ -0,0 +1,11 @@
1+module Test.Main where
2+
3+import Prelude
4+
5+import Effect (Effect)
6+import Effect.Class.Console (log)
7+
8+main :: Effect Unit
9+main = do
10+ log "🍝"
11+ log "You should add some tests."