@@ -0,0 +1,3484 @@
1+(() => {
2+ // output/Control.Semigroupoid/index.js
3+ var semigroupoidFn = {
4+ compose: function(f) {
5+ return function(g2) {
6+ return function(x2) {
7+ return f(g2(x2));
8+ };
9+ };
10+ }
11+ };
12+
13+ // output/Control.Category/index.js
14+ var identity = function(dict) {
15+ return dict.identity;
16+ };
17+ var categoryFn = {
18+ identity: function(x2) {
19+ return x2;
20+ },
21+ Semigroupoid0: function() {
22+ return semigroupoidFn;
23+ }
24+ };
25+
26+ // output/Data.Boolean/index.js
27+ var otherwise = true;
28+
29+ // output/Data.Function/index.js
30+ var flip = function(f) {
31+ return function(b2) {
32+ return function(a2) {
33+ return f(a2)(b2);
34+ };
35+ };
36+ };
37+ var $$const = function(a2) {
38+ return function(v2) {
39+ return a2;
40+ };
41+ };
42+ var applyFlipped = function(x2) {
43+ return function(f) {
44+ return f(x2);
45+ };
46+ };
47+
48+ // output/Data.Functor/foreign.js
49+ var arrayMap = function(f) {
50+ return function(arr) {
51+ var l2 = arr.length;
52+ var result = new Array(l2);
53+ for (var i2 = 0; i2 < l2; i2++) {
54+ result[i2] = f(arr[i2]);
55+ }
56+ return result;
57+ };
58+ };
59+
60+ // output/Data.Unit/foreign.js
61+ var unit = void 0;
62+
63+ // output/Type.Proxy/index.js
64+ var $$Proxy = /* @__PURE__ */ function() {
65+ function $$Proxy2() {
66+ }
67+ ;
68+ $$Proxy2.value = new $$Proxy2();
69+ return $$Proxy2;
70+ }();
71+
72+ // output/Data.Functor/index.js
73+ var map = function(dict) {
74+ return dict.map;
75+ };
76+ var mapFlipped = function(dictFunctor) {
77+ var map12 = map(dictFunctor);
78+ return function(fa) {
79+ return function(f) {
80+ return map12(f)(fa);
81+ };
82+ };
83+ };
84+ var functorArray = {
85+ map: arrayMap
86+ };
87+
88+ // output/Control.Apply/index.js
89+ var apply = function(dict) {
90+ return dict.apply;
91+ };
92+ var lift2 = function(dictApply) {
93+ var apply1 = apply(dictApply);
94+ var map4 = map(dictApply.Functor0());
95+ return function(f) {
96+ return function(a2) {
97+ return function(b2) {
98+ return apply1(map4(f)(a2))(b2);
99+ };
100+ };
101+ };
102+ };
103+
104+ // output/Control.Applicative/index.js
105+ var pure = function(dict) {
106+ return dict.pure;
107+ };
108+ var liftA1 = function(dictApplicative) {
109+ var apply3 = apply(dictApplicative.Apply0());
110+ var pure12 = pure(dictApplicative);
111+ return function(f) {
112+ return function(a2) {
113+ return apply3(pure12(f))(a2);
114+ };
115+ };
116+ };
117+
118+ // output/Control.Bind/foreign.js
119+ var arrayBind = typeof Array.prototype.flatMap === "function" ? function(arr) {
120+ return function(f) {
121+ return arr.flatMap(f);
122+ };
123+ } : function(arr) {
124+ return function(f) {
125+ var result = [];
126+ var l2 = arr.length;
127+ for (var i2 = 0; i2 < l2; i2++) {
128+ var xs = f(arr[i2]);
129+ var k = xs.length;
130+ for (var j = 0; j < k; j++) {
131+ result.push(xs[j]);
132+ }
133+ }
134+ return result;
135+ };
136+ };
137+
138+ // output/Control.Bind/index.js
139+ var discard = function(dict) {
140+ return dict.discard;
141+ };
142+ var bind = function(dict) {
143+ return dict.bind;
144+ };
145+ var bindFlipped = function(dictBind) {
146+ return flip(bind(dictBind));
147+ };
148+ var discardUnit = {
149+ discard: function(dictBind) {
150+ return bind(dictBind);
151+ }
152+ };
153+
154+ // output/Data.Symbol/index.js
155+ var reflectSymbol = function(dict) {
156+ return dict.reflectSymbol;
157+ };
158+
159+ // output/Record.Unsafe/foreign.js
160+ var unsafeGet = function(label4) {
161+ return function(rec) {
162+ return rec[label4];
163+ };
164+ };
165+ var unsafeSet = function(label4) {
166+ return function(value12) {
167+ return function(rec) {
168+ var copy = {};
169+ for (var key in rec) {
170+ if ({}.hasOwnProperty.call(rec, key)) {
171+ copy[key] = rec[key];
172+ }
173+ }
174+ copy[label4] = value12;
175+ return copy;
176+ };
177+ };
178+ };
179+
180+ // output/Data.Eq/foreign.js
181+ var refEq = function(r1) {
182+ return function(r2) {
183+ return r1 === r2;
184+ };
185+ };
186+ var eqIntImpl = refEq;
187+
188+ // output/Data.Eq/index.js
189+ var eqInt = {
190+ eq: eqIntImpl
191+ };
192+
193+ // output/Data.Ordering/index.js
194+ var LT = /* @__PURE__ */ function() {
195+ function LT2() {
196+ }
197+ ;
198+ LT2.value = new LT2();
199+ return LT2;
200+ }();
201+ var GT = /* @__PURE__ */ function() {
202+ function GT2() {
203+ }
204+ ;
205+ GT2.value = new GT2();
206+ return GT2;
207+ }();
208+ var EQ = /* @__PURE__ */ function() {
209+ function EQ2() {
210+ }
211+ ;
212+ EQ2.value = new EQ2();
213+ return EQ2;
214+ }();
215+
216+ // output/Data.Semigroup/foreign.js
217+ var concatString = function(s1) {
218+ return function(s2) {
219+ return s1 + s2;
220+ };
221+ };
222+ var concatArray = function(xs) {
223+ return function(ys) {
224+ if (xs.length === 0) return ys;
225+ if (ys.length === 0) return xs;
226+ return xs.concat(ys);
227+ };
228+ };
229+
230+ // output/Data.Semigroup/index.js
231+ var semigroupUnit = {
232+ append: function(v2) {
233+ return function(v1) {
234+ return unit;
235+ };
236+ }
237+ };
238+ var semigroupString = {
239+ append: concatString
240+ };
241+ var semigroupRecordNil = {
242+ appendRecord: function(v2) {
243+ return function(v1) {
244+ return function(v22) {
245+ return {};
246+ };
247+ };
248+ }
249+ };
250+ var semigroupArray = {
251+ append: concatArray
252+ };
253+ var appendRecord = function(dict) {
254+ return dict.appendRecord;
255+ };
256+ var semigroupRecord = function() {
257+ return function(dictSemigroupRecord) {
258+ return {
259+ append: appendRecord(dictSemigroupRecord)($$Proxy.value)
260+ };
261+ };
262+ };
263+ var append = function(dict) {
264+ return dict.append;
265+ };
266+ var semigroupRecordCons = function(dictIsSymbol) {
267+ var reflectSymbol2 = reflectSymbol(dictIsSymbol);
268+ return function() {
269+ return function(dictSemigroupRecord) {
270+ var appendRecord1 = appendRecord(dictSemigroupRecord);
271+ return function(dictSemigroup) {
272+ var append1 = append(dictSemigroup);
273+ return {
274+ appendRecord: function(v2) {
275+ return function(ra) {
276+ return function(rb) {
277+ var tail = appendRecord1($$Proxy.value)(ra)(rb);
278+ var key = reflectSymbol2($$Proxy.value);
279+ var insert2 = unsafeSet(key);
280+ var get = unsafeGet(key);
281+ return insert2(append1(get(ra))(get(rb)))(tail);
282+ };
283+ };
284+ }
285+ };
286+ };
287+ };
288+ };
289+ };
290+
291+ // output/Data.Monoid/index.js
292+ var semigroupRecord2 = /* @__PURE__ */ semigroupRecord();
293+ var monoidUnit = {
294+ mempty: unit,
295+ Semigroup0: function() {
296+ return semigroupUnit;
297+ }
298+ };
299+ var monoidString = {
300+ mempty: "",
301+ Semigroup0: function() {
302+ return semigroupString;
303+ }
304+ };
305+ var monoidRecordNil = {
306+ memptyRecord: function(v2) {
307+ return {};
308+ },
309+ SemigroupRecord0: function() {
310+ return semigroupRecordNil;
311+ }
312+ };
313+ var monoidArray = {
314+ mempty: [],
315+ Semigroup0: function() {
316+ return semigroupArray;
317+ }
318+ };
319+ var memptyRecord = function(dict) {
320+ return dict.memptyRecord;
321+ };
322+ var monoidRecord = function() {
323+ return function(dictMonoidRecord) {
324+ var semigroupRecord1 = semigroupRecord2(dictMonoidRecord.SemigroupRecord0());
325+ return {
326+ mempty: memptyRecord(dictMonoidRecord)($$Proxy.value),
327+ Semigroup0: function() {
328+ return semigroupRecord1;
329+ }
330+ };
331+ };
332+ };
333+ var mempty = function(dict) {
334+ return dict.mempty;
335+ };
336+ var monoidRecordCons = function(dictIsSymbol) {
337+ var reflectSymbol2 = reflectSymbol(dictIsSymbol);
338+ var semigroupRecordCons3 = semigroupRecordCons(dictIsSymbol)();
339+ return function(dictMonoid) {
340+ var mempty12 = mempty(dictMonoid);
341+ var Semigroup0 = dictMonoid.Semigroup0();
342+ return function() {
343+ return function(dictMonoidRecord) {
344+ var memptyRecord1 = memptyRecord(dictMonoidRecord);
345+ var semigroupRecordCons1 = semigroupRecordCons3(dictMonoidRecord.SemigroupRecord0())(Semigroup0);
346+ return {
347+ memptyRecord: function(v2) {
348+ var tail = memptyRecord1($$Proxy.value);
349+ var key = reflectSymbol2($$Proxy.value);
350+ var insert2 = unsafeSet(key);
351+ return insert2(mempty12)(tail);
352+ },
353+ SemigroupRecord0: function() {
354+ return semigroupRecordCons1;
355+ }
356+ };
357+ };
358+ };
359+ };
360+ };
361+
362+ // output/Effect/foreign.js
363+ var pureE = function(a2) {
364+ return function() {
365+ return a2;
366+ };
367+ };
368+ var bindE = function(a2) {
369+ return function(f) {
370+ return function() {
371+ return f(a2())();
372+ };
373+ };
374+ };
375+
376+ // output/Control.Monad/index.js
377+ var ap = function(dictMonad) {
378+ var bind4 = bind(dictMonad.Bind1());
379+ var pure5 = pure(dictMonad.Applicative0());
380+ return function(f) {
381+ return function(a2) {
382+ return bind4(f)(function(f$prime) {
383+ return bind4(a2)(function(a$prime) {
384+ return pure5(f$prime(a$prime));
385+ });
386+ });
387+ };
388+ };
389+ };
390+
391+ // output/Effect/index.js
392+ var $runtime_lazy = function(name15, moduleName, init3) {
393+ var state3 = 0;
394+ var val;
395+ return function(lineNumber) {
396+ if (state3 === 2) return val;
397+ if (state3 === 1) throw new ReferenceError(name15 + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);
398+ state3 = 1;
399+ val = init3();
400+ state3 = 2;
401+ return val;
402+ };
403+ };
404+ var monadEffect = {
405+ Applicative0: function() {
406+ return applicativeEffect;
407+ },
408+ Bind1: function() {
409+ return bindEffect;
410+ }
411+ };
412+ var bindEffect = {
413+ bind: bindE,
414+ Apply0: function() {
415+ return $lazy_applyEffect(0);
416+ }
417+ };
418+ var applicativeEffect = {
419+ pure: pureE,
420+ Apply0: function() {
421+ return $lazy_applyEffect(0);
422+ }
423+ };
424+ var $lazy_functorEffect = /* @__PURE__ */ $runtime_lazy("functorEffect", "Effect", function() {
425+ return {
426+ map: liftA1(applicativeEffect)
427+ };
428+ });
429+ var $lazy_applyEffect = /* @__PURE__ */ $runtime_lazy("applyEffect", "Effect", function() {
430+ return {
431+ apply: ap(monadEffect),
432+ Functor0: function() {
433+ return $lazy_functorEffect(0);
434+ }
435+ };
436+ });
437+ var functorEffect = /* @__PURE__ */ $lazy_functorEffect(20);
438+
439+ // output/Data.Array/foreign.js
440+ var replicateFill = function(count, value12) {
441+ if (count < 1) {
442+ return [];
443+ }
444+ var result = new Array(count);
445+ return result.fill(value12);
446+ };
447+ var replicatePolyfill = function(count, value12) {
448+ var result = [];
449+ var n2 = 0;
450+ for (var i2 = 0; i2 < count; i2++) {
451+ result[n2++] = value12;
452+ }
453+ return result;
454+ };
455+ var replicateImpl = typeof Array.prototype.fill === "function" ? replicateFill : replicatePolyfill;
456+ var unconsImpl = function(empty3, next, xs) {
457+ return xs.length === 0 ? empty3({}) : next(xs[0])(xs.slice(1));
458+ };
459+ var concat = function(xss) {
460+ if (xss.length <= 1e4) {
461+ return Array.prototype.concat.apply([], xss);
462+ }
463+ var result = [];
464+ for (var i2 = 0, l2 = xss.length; i2 < l2; i2++) {
465+ var xs = xss[i2];
466+ for (var j = 0, m3 = xs.length; j < m3; j++) {
467+ result.push(xs[j]);
468+ }
469+ }
470+ return result;
471+ };
472+
473+ // output/Data.Bounded/foreign.js
474+ var topInt = 2147483647;
475+ var bottomInt = -2147483648;
476+ var topChar = String.fromCharCode(65535);
477+ var bottomChar = String.fromCharCode(0);
478+ var topNumber = Number.POSITIVE_INFINITY;
479+ var bottomNumber = Number.NEGATIVE_INFINITY;
480+
481+ // output/Data.Ord/foreign.js
482+ var unsafeCompareImpl = function(lt) {
483+ return function(eq2) {
484+ return function(gt) {
485+ return function(x2) {
486+ return function(y) {
487+ return x2 < y ? lt : x2 === y ? eq2 : gt;
488+ };
489+ };
490+ };
491+ };
492+ };
493+ var ordIntImpl = unsafeCompareImpl;
494+
495+ // output/Data.Ord/index.js
496+ var ordInt = /* @__PURE__ */ function() {
497+ return {
498+ compare: ordIntImpl(LT.value)(EQ.value)(GT.value),
499+ Eq0: function() {
500+ return eqInt;
501+ }
502+ };
503+ }();
504+
505+ // output/Data.Bounded/index.js
506+ var top = function(dict) {
507+ return dict.top;
508+ };
509+ var boundedInt = {
510+ top: topInt,
511+ bottom: bottomInt,
512+ Ord0: function() {
513+ return ordInt;
514+ }
515+ };
516+ var bottom = function(dict) {
517+ return dict.bottom;
518+ };
519+
520+ // output/Data.Show/foreign.js
521+ var showIntImpl = function(n2) {
522+ return n2.toString();
523+ };
524+ var showNumberImpl = function(n2) {
525+ var str = n2.toString();
526+ return isNaN(str + ".0") ? str : str + ".0";
527+ };
528+
529+ // output/Data.Show/index.js
530+ var showNumber = {
531+ show: showNumberImpl
532+ };
533+ var showInt = {
534+ show: showIntImpl
535+ };
536+ var show = function(dict) {
537+ return dict.show;
538+ };
539+
540+ // output/Data.Maybe/index.js
541+ var identity2 = /* @__PURE__ */ identity(categoryFn);
542+ var Nothing = /* @__PURE__ */ function() {
543+ function Nothing2() {
544+ }
545+ ;
546+ Nothing2.value = new Nothing2();
547+ return Nothing2;
548+ }();
549+ var Just = /* @__PURE__ */ function() {
550+ function Just2(value0) {
551+ this.value0 = value0;
552+ }
553+ ;
554+ Just2.create = function(value0) {
555+ return new Just2(value0);
556+ };
557+ return Just2;
558+ }();
559+ var maybe = function(v2) {
560+ return function(v1) {
561+ return function(v22) {
562+ if (v22 instanceof Nothing) {
563+ return v2;
564+ }
565+ ;
566+ if (v22 instanceof Just) {
567+ return v1(v22.value0);
568+ }
569+ ;
570+ throw new Error("Failed pattern match at Data.Maybe (line 237, column 1 - line 237, column 51): " + [v2.constructor.name, v1.constructor.name, v22.constructor.name]);
571+ };
572+ };
573+ };
574+ var fromMaybe = function(a2) {
575+ return maybe(a2)(identity2);
576+ };
577+
578+ // output/Data.Identity/index.js
579+ var Identity = function(x2) {
580+ return x2;
581+ };
582+ var functorIdentity = {
583+ map: function(f) {
584+ return function(m3) {
585+ return f(m3);
586+ };
587+ }
588+ };
589+ var applyIdentity = {
590+ apply: function(v2) {
591+ return function(v1) {
592+ return v2(v1);
593+ };
594+ },
595+ Functor0: function() {
596+ return functorIdentity;
597+ }
598+ };
599+ var bindIdentity = {
600+ bind: function(v2) {
601+ return function(f) {
602+ return f(v2);
603+ };
604+ },
605+ Apply0: function() {
606+ return applyIdentity;
607+ }
608+ };
609+ var applicativeIdentity = {
610+ pure: Identity,
611+ Apply0: function() {
612+ return applyIdentity;
613+ }
614+ };
615+ var monadIdentity = {
616+ Applicative0: function() {
617+ return applicativeIdentity;
618+ },
619+ Bind1: function() {
620+ return bindIdentity;
621+ }
622+ };
623+
624+ // output/Effect.Ref/foreign.js
625+ var _new = function(val) {
626+ return function() {
627+ return { value: val };
628+ };
629+ };
630+ var read = function(ref) {
631+ return function() {
632+ return ref.value;
633+ };
634+ };
635+ var write = function(val) {
636+ return function(ref) {
637+ return function() {
638+ ref.value = val;
639+ };
640+ };
641+ };
642+
643+ // output/Effect.Ref/index.js
644+ var $$new = _new;
645+
646+ // output/Control.Monad.ST.Internal/foreign.js
647+ var map_ = function(f) {
648+ return function(a2) {
649+ return function() {
650+ return f(a2());
651+ };
652+ };
653+ };
654+ var pure_ = function(a2) {
655+ return function() {
656+ return a2;
657+ };
658+ };
659+ var bind_ = function(a2) {
660+ return function(f) {
661+ return function() {
662+ return f(a2())();
663+ };
664+ };
665+ };
666+
667+ // output/Control.Monad.ST.Internal/index.js
668+ var $runtime_lazy2 = function(name15, moduleName, init3) {
669+ var state3 = 0;
670+ var val;
671+ return function(lineNumber) {
672+ if (state3 === 2) return val;
673+ if (state3 === 1) throw new ReferenceError(name15 + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);
674+ state3 = 1;
675+ val = init3();
676+ state3 = 2;
677+ return val;
678+ };
679+ };
680+ var functorST = {
681+ map: map_
682+ };
683+ var monadST = {
684+ Applicative0: function() {
685+ return applicativeST;
686+ },
687+ Bind1: function() {
688+ return bindST;
689+ }
690+ };
691+ var bindST = {
692+ bind: bind_,
693+ Apply0: function() {
694+ return $lazy_applyST(0);
695+ }
696+ };
697+ var applicativeST = {
698+ pure: pure_,
699+ Apply0: function() {
700+ return $lazy_applyST(0);
701+ }
702+ };
703+ var $lazy_applyST = /* @__PURE__ */ $runtime_lazy2("applyST", "Control.Monad.ST.Internal", function() {
704+ return {
705+ apply: ap(monadST),
706+ Functor0: function() {
707+ return functorST;
708+ }
709+ };
710+ });
711+
712+ // output/Data.Foldable/foreign.js
713+ var foldrArray = function(f) {
714+ return function(init3) {
715+ return function(xs) {
716+ var acc = init3;
717+ var len = xs.length;
718+ for (var i2 = len - 1; i2 >= 0; i2--) {
719+ acc = f(xs[i2])(acc);
720+ }
721+ return acc;
722+ };
723+ };
724+ };
725+ var foldlArray = function(f) {
726+ return function(init3) {
727+ return function(xs) {
728+ var acc = init3;
729+ var len = xs.length;
730+ for (var i2 = 0; i2 < len; i2++) {
731+ acc = f(acc)(xs[i2]);
732+ }
733+ return acc;
734+ };
735+ };
736+ };
737+
738+ // output/Data.Tuple/index.js
739+ var Tuple = /* @__PURE__ */ function() {
740+ function Tuple2(value0, value1) {
741+ this.value0 = value0;
742+ this.value1 = value1;
743+ }
744+ ;
745+ Tuple2.create = function(value0) {
746+ return function(value1) {
747+ return new Tuple2(value0, value1);
748+ };
749+ };
750+ return Tuple2;
751+ }();
752+ var uncurry = function(f) {
753+ return function(v2) {
754+ return f(v2.value0)(v2.value1);
755+ };
756+ };
757+
758+ // output/Unsafe.Coerce/foreign.js
759+ var unsafeCoerce2 = function(x2) {
760+ return x2;
761+ };
762+
763+ // output/Safe.Coerce/index.js
764+ var coerce = function() {
765+ return unsafeCoerce2;
766+ };
767+
768+ // output/Data.Newtype/index.js
769+ var coerce2 = /* @__PURE__ */ coerce();
770+ var unwrap = function() {
771+ return coerce2;
772+ };
773+
774+ // output/Data.Foldable/index.js
775+ var foldr = function(dict) {
776+ return dict.foldr;
777+ };
778+ var foldl = function(dict) {
779+ return dict.foldl;
780+ };
781+ var intercalate = function(dictFoldable) {
782+ var foldl2 = foldl(dictFoldable);
783+ return function(dictMonoid) {
784+ var append3 = append(dictMonoid.Semigroup0());
785+ var mempty6 = mempty(dictMonoid);
786+ return function(sep) {
787+ return function(xs) {
788+ var go2 = function(v2) {
789+ return function(v1) {
790+ if (v2.init) {
791+ return {
792+ init: false,
793+ acc: v1
794+ };
795+ }
796+ ;
797+ return {
798+ init: false,
799+ acc: append3(v2.acc)(append3(sep)(v1))
800+ };
801+ };
802+ };
803+ return foldl2(go2)({
804+ init: true,
805+ acc: mempty6
806+ })(xs).acc;
807+ };
808+ };
809+ };
810+ };
811+ var foldMapDefaultR = function(dictFoldable) {
812+ var foldr22 = foldr(dictFoldable);
813+ return function(dictMonoid) {
814+ var append3 = append(dictMonoid.Semigroup0());
815+ var mempty6 = mempty(dictMonoid);
816+ return function(f) {
817+ return foldr22(function(x2) {
818+ return function(acc) {
819+ return append3(f(x2))(acc);
820+ };
821+ })(mempty6);
822+ };
823+ };
824+ };
825+ var foldableArray = {
826+ foldr: foldrArray,
827+ foldl: foldlArray,
828+ foldMap: function(dictMonoid) {
829+ return foldMapDefaultR(foldableArray)(dictMonoid);
830+ }
831+ };
832+
833+ // output/Data.Function.Uncurried/foreign.js
834+ var runFn3 = function(fn) {
835+ return function(a2) {
836+ return function(b2) {
837+ return function(c) {
838+ return fn(a2, b2, c);
839+ };
840+ };
841+ };
842+ };
843+ var runFn4 = function(fn) {
844+ return function(a2) {
845+ return function(b2) {
846+ return function(c) {
847+ return function(d) {
848+ return fn(a2, b2, c, d);
849+ };
850+ };
851+ };
852+ };
853+ };
854+
855+ // output/Data.Traversable/foreign.js
856+ var traverseArrayImpl = /* @__PURE__ */ function() {
857+ function array1(a2) {
858+ return [a2];
859+ }
860+ function array2(a2) {
861+ return function(b2) {
862+ return [a2, b2];
863+ };
864+ }
865+ function array3(a2) {
866+ return function(b2) {
867+ return function(c) {
868+ return [a2, b2, c];
869+ };
870+ };
871+ }
872+ function concat2(xs) {
873+ return function(ys) {
874+ return xs.concat(ys);
875+ };
876+ }
877+ return function(apply3) {
878+ return function(map4) {
879+ return function(pure5) {
880+ return function(f) {
881+ return function(array) {
882+ function go2(bot, top3) {
883+ switch (top3 - bot) {
884+ case 0:
885+ return pure5([]);
886+ case 1:
887+ return map4(array1)(f(array[bot]));
888+ case 2:
889+ return apply3(map4(array2)(f(array[bot])))(f(array[bot + 1]));
890+ case 3:
891+ return apply3(apply3(map4(array3)(f(array[bot])))(f(array[bot + 1])))(f(array[bot + 2]));
892+ default:
893+ var pivot = bot + Math.floor((top3 - bot) / 4) * 2;
894+ return apply3(map4(concat2)(go2(bot, pivot)))(go2(pivot, top3));
895+ }
896+ }
897+ return go2(0, array.length);
898+ };
899+ };
900+ };
901+ };
902+ };
903+ }();
904+
905+ // output/Data.Traversable/index.js
906+ var identity3 = /* @__PURE__ */ identity(categoryFn);
907+ var traverse = function(dict) {
908+ return dict.traverse;
909+ };
910+ var sequenceDefault = function(dictTraversable) {
911+ var traverse22 = traverse(dictTraversable);
912+ return function(dictApplicative) {
913+ return traverse22(dictApplicative)(identity3);
914+ };
915+ };
916+ var traversableArray = {
917+ traverse: function(dictApplicative) {
918+ var Apply0 = dictApplicative.Apply0();
919+ return traverseArrayImpl(apply(Apply0))(map(Apply0.Functor0()))(pure(dictApplicative));
920+ },
921+ sequence: function(dictApplicative) {
922+ return sequenceDefault(traversableArray)(dictApplicative);
923+ },
924+ Functor0: function() {
925+ return functorArray;
926+ },
927+ Foldable1: function() {
928+ return foldableArray;
929+ }
930+ };
931+
932+ // output/Data.Array/index.js
933+ var intercalate1 = /* @__PURE__ */ intercalate(foldableArray);
934+ var uncons = /* @__PURE__ */ function() {
935+ return runFn3(unconsImpl)($$const(Nothing.value))(function(x2) {
936+ return function(xs) {
937+ return new Just({
938+ head: x2,
939+ tail: xs
940+ });
941+ };
942+ });
943+ }();
944+ var intercalate2 = function(dictMonoid) {
945+ return intercalate1(dictMonoid);
946+ };
947+
948+ // output/Foreign.Object/foreign.js
949+ function _copyST(m3) {
950+ return function() {
951+ var r2 = {};
952+ for (var k in m3) {
953+ if (hasOwnProperty.call(m3, k)) {
954+ r2[k] = m3[k];
955+ }
956+ }
957+ return r2;
958+ };
959+ }
960+ var empty2 = {};
961+ function runST(f) {
962+ return f();
963+ }
964+ function _fmapObject(m0, f) {
965+ var m3 = {};
966+ for (var k in m0) {
967+ if (hasOwnProperty.call(m0, k)) {
968+ m3[k] = f(m0[k]);
969+ }
970+ }
971+ return m3;
972+ }
973+ function _mapWithKey(m0, f) {
974+ var m3 = {};
975+ for (var k in m0) {
976+ if (hasOwnProperty.call(m0, k)) {
977+ m3[k] = f(k)(m0[k]);
978+ }
979+ }
980+ return m3;
981+ }
982+ function _foldM(bind4) {
983+ return function(f) {
984+ return function(mz) {
985+ return function(m3) {
986+ var acc = mz;
987+ function g2(k2) {
988+ return function(z) {
989+ return f(z)(k2)(m3[k2]);
990+ };
991+ }
992+ for (var k in m3) {
993+ if (hasOwnProperty.call(m3, k)) {
994+ acc = bind4(acc)(g2(k));
995+ }
996+ }
997+ return acc;
998+ };
999+ };
1000+ };
1001+ }
1002+ function _lookup(no, yes, k, m3) {
1003+ return k in m3 ? yes(m3[k]) : no;
1004+ }
1005+ function toArrayWithKey(f) {
1006+ return function(m3) {
1007+ var r2 = [];
1008+ for (var k in m3) {
1009+ if (hasOwnProperty.call(m3, k)) {
1010+ r2.push(f(k)(m3[k]));
1011+ }
1012+ }
1013+ return r2;
1014+ };
1015+ }
1016+ var keys = Object.keys || toArrayWithKey(function(k) {
1017+ return function() {
1018+ return k;
1019+ };
1020+ });
1021+
1022+ // output/Data.TraversableWithIndex/index.js
1023+ var traverseWithIndex = function(dict) {
1024+ return dict.traverseWithIndex;
1025+ };
1026+
1027+ // output/Foreign.Object.ST/foreign.js
1028+ var newImpl = function() {
1029+ return {};
1030+ };
1031+ function poke2(k) {
1032+ return function(v2) {
1033+ return function(m3) {
1034+ return function() {
1035+ m3[k] = v2;
1036+ return m3;
1037+ };
1038+ };
1039+ };
1040+ }
1041+
1042+ // output/Foreign.Object/index.js
1043+ var bindFlipped2 = /* @__PURE__ */ bindFlipped(bindST);
1044+ var foldr2 = /* @__PURE__ */ foldr(foldableArray);
1045+ var identity4 = /* @__PURE__ */ identity(categoryFn);
1046+ var values = /* @__PURE__ */ toArrayWithKey(function(v2) {
1047+ return function(v1) {
1048+ return v1;
1049+ };
1050+ });
1051+ var thawST = _copyST;
1052+ var singleton2 = function(k) {
1053+ return function(v2) {
1054+ return runST(bindFlipped2(poke2(k)(v2))(newImpl));
1055+ };
1056+ };
1057+ var mutate = function(f) {
1058+ return function(m3) {
1059+ return runST(function __do() {
1060+ var s2 = thawST(m3)();
1061+ f(s2)();
1062+ return s2;
1063+ });
1064+ };
1065+ };
1066+ var mapWithKey = function(f) {
1067+ return function(m3) {
1068+ return _mapWithKey(m3, f);
1069+ };
1070+ };
1071+ var insert = function(k) {
1072+ return function(v2) {
1073+ return mutate(poke2(k)(v2));
1074+ };
1075+ };
1076+ var functorObject = {
1077+ map: function(f) {
1078+ return function(m3) {
1079+ return _fmapObject(m3, f);
1080+ };
1081+ }
1082+ };
1083+ var functorWithIndexObject = {
1084+ mapWithIndex: mapWithKey,
1085+ Functor0: function() {
1086+ return functorObject;
1087+ }
1088+ };
1089+ var fromHomogeneous = function() {
1090+ return unsafeCoerce2;
1091+ };
1092+ var foldM = function(dictMonad) {
1093+ var bind1 = bind(dictMonad.Bind1());
1094+ var pure12 = pure(dictMonad.Applicative0());
1095+ return function(f) {
1096+ return function(z) {
1097+ return _foldM(bind1)(f)(pure12(z));
1098+ };
1099+ };
1100+ };
1101+ var foldM1 = /* @__PURE__ */ foldM(monadST);
1102+ var union = function(m3) {
1103+ return mutate(function(s2) {
1104+ return foldM1(function(s$prime) {
1105+ return function(k) {
1106+ return function(v2) {
1107+ return poke2(k)(v2)(s$prime);
1108+ };
1109+ };
1110+ })(s2)(m3);
1111+ });
1112+ };
1113+ var unionWith = function(f) {
1114+ return function(m1) {
1115+ return function(m22) {
1116+ return mutate(function(s1) {
1117+ return foldM1(function(s2) {
1118+ return function(k) {
1119+ return function(v1) {
1120+ return poke2(k)(_lookup(v1, function(v2) {
1121+ return f(v1)(v2);
1122+ }, k, m22))(s2);
1123+ };
1124+ };
1125+ })(s1)(m1);
1126+ })(m22);
1127+ };
1128+ };
1129+ };
1130+ var semigroupObject = function(dictSemigroup) {
1131+ return {
1132+ append: unionWith(append(dictSemigroup))
1133+ };
1134+ };
1135+ var monoidObject = function(dictSemigroup) {
1136+ var semigroupObject1 = semigroupObject(dictSemigroup);
1137+ return {
1138+ mempty: empty2,
1139+ Semigroup0: function() {
1140+ return semigroupObject1;
1141+ }
1142+ };
1143+ };
1144+ var fold2 = /* @__PURE__ */ _foldM(applyFlipped);
1145+ var foldMap2 = function(dictMonoid) {
1146+ var append1 = append(dictMonoid.Semigroup0());
1147+ var mempty6 = mempty(dictMonoid);
1148+ return function(f) {
1149+ return fold2(function(acc) {
1150+ return function(k) {
1151+ return function(v2) {
1152+ return append1(acc)(f(k)(v2));
1153+ };
1154+ };
1155+ })(mempty6);
1156+ };
1157+ };
1158+ var foldableObject = {
1159+ foldl: function(f) {
1160+ return fold2(function(z) {
1161+ return function(v2) {
1162+ return f(z);
1163+ };
1164+ });
1165+ },
1166+ foldr: function(f) {
1167+ return function(z) {
1168+ return function(m3) {
1169+ return foldr2(f)(z)(values(m3));
1170+ };
1171+ };
1172+ },
1173+ foldMap: function(dictMonoid) {
1174+ var foldMap12 = foldMap2(dictMonoid);
1175+ return function(f) {
1176+ return foldMap12($$const(f));
1177+ };
1178+ }
1179+ };
1180+ var foldableWithIndexObject = {
1181+ foldlWithIndex: function(f) {
1182+ return fold2(flip(f));
1183+ },
1184+ foldrWithIndex: function(f) {
1185+ return function(z) {
1186+ return function(m3) {
1187+ return foldr2(uncurry(f))(z)(toArrayWithKey(Tuple.create)(m3));
1188+ };
1189+ };
1190+ },
1191+ foldMapWithIndex: function(dictMonoid) {
1192+ return foldMap2(dictMonoid);
1193+ },
1194+ Foldable0: function() {
1195+ return foldableObject;
1196+ }
1197+ };
1198+ var traversableWithIndexObject = {
1199+ traverseWithIndex: function(dictApplicative) {
1200+ var Apply0 = dictApplicative.Apply0();
1201+ var apply3 = apply(Apply0);
1202+ var map4 = map(Apply0.Functor0());
1203+ var pure12 = pure(dictApplicative);
1204+ return function(f) {
1205+ return function(ms) {
1206+ return fold2(function(acc) {
1207+ return function(k) {
1208+ return function(v2) {
1209+ return apply3(map4(flip(insert(k)))(acc))(f(k)(v2));
1210+ };
1211+ };
1212+ })(pure12(empty2))(ms);
1213+ };
1214+ };
1215+ },
1216+ FunctorWithIndex0: function() {
1217+ return functorWithIndexObject;
1218+ },
1219+ FoldableWithIndex1: function() {
1220+ return foldableWithIndexObject;
1221+ },
1222+ Traversable2: function() {
1223+ return traversableObject;
1224+ }
1225+ };
1226+ var traversableObject = {
1227+ traverse: function(dictApplicative) {
1228+ var $96 = traverseWithIndex(traversableWithIndexObject)(dictApplicative);
1229+ return function($97) {
1230+ return $96($$const($97));
1231+ };
1232+ },
1233+ sequence: function(dictApplicative) {
1234+ return traverse(traversableObject)(dictApplicative)(identity4);
1235+ },
1236+ Functor0: function() {
1237+ return functorObject;
1238+ },
1239+ Foldable1: function() {
1240+ return foldableObject;
1241+ }
1242+ };
1243+
1244+ // output/Literals.Undefined/foreign.js
1245+ var _undefined = void 0;
1246+
1247+ // output/Literals.Undefined/index.js
1248+ var $$undefined = _undefined;
1249+
1250+ // output/Control.Monad.Writer.Class/index.js
1251+ var tell = function(dict) {
1252+ return dict.tell;
1253+ };
1254+
1255+ // output/Control.Monad.Writer.Trans/index.js
1256+ var WriterT = function(x2) {
1257+ return x2;
1258+ };
1259+ var runWriterT = function(v2) {
1260+ return v2;
1261+ };
1262+ var mapWriterT = function(f) {
1263+ return function(v2) {
1264+ return f(v2);
1265+ };
1266+ };
1267+ var functorWriterT = function(dictFunctor) {
1268+ var map4 = map(dictFunctor);
1269+ return {
1270+ map: function(f) {
1271+ return mapWriterT(map4(function(v2) {
1272+ return new Tuple(f(v2.value0), v2.value1);
1273+ }));
1274+ }
1275+ };
1276+ };
1277+ var applyWriterT = function(dictSemigroup) {
1278+ var append3 = append(dictSemigroup);
1279+ return function(dictApply) {
1280+ var apply3 = apply(dictApply);
1281+ var Functor0 = dictApply.Functor0();
1282+ var map4 = map(Functor0);
1283+ var functorWriterT1 = functorWriterT(Functor0);
1284+ return {
1285+ apply: function(v2) {
1286+ return function(v1) {
1287+ var k = function(v3) {
1288+ return function(v4) {
1289+ return new Tuple(v3.value0(v4.value0), append3(v3.value1)(v4.value1));
1290+ };
1291+ };
1292+ return apply3(map4(k)(v2))(v1);
1293+ };
1294+ },
1295+ Functor0: function() {
1296+ return functorWriterT1;
1297+ }
1298+ };
1299+ };
1300+ };
1301+ var bindWriterT = function(dictSemigroup) {
1302+ var append3 = append(dictSemigroup);
1303+ var applyWriterT1 = applyWriterT(dictSemigroup);
1304+ return function(dictBind) {
1305+ var bind4 = bind(dictBind);
1306+ var Apply0 = dictBind.Apply0();
1307+ var map4 = map(Apply0.Functor0());
1308+ var applyWriterT2 = applyWriterT1(Apply0);
1309+ return {
1310+ bind: function(v2) {
1311+ return function(k) {
1312+ return bind4(v2)(function(v1) {
1313+ var v22 = k(v1.value0);
1314+ return map4(function(v3) {
1315+ return new Tuple(v3.value0, append3(v1.value1)(v3.value1));
1316+ })(v22);
1317+ });
1318+ };
1319+ },
1320+ Apply0: function() {
1321+ return applyWriterT2;
1322+ }
1323+ };
1324+ };
1325+ };
1326+ var semigroupWriterT = function(dictApply) {
1327+ return function(dictSemigroup) {
1328+ var lift22 = lift2(applyWriterT(dictSemigroup)(dictApply));
1329+ return function(dictSemigroup1) {
1330+ return {
1331+ append: lift22(append(dictSemigroup1))
1332+ };
1333+ };
1334+ };
1335+ };
1336+ var applicativeWriterT = function(dictMonoid) {
1337+ var mempty6 = mempty(dictMonoid);
1338+ var applyWriterT1 = applyWriterT(dictMonoid.Semigroup0());
1339+ return function(dictApplicative) {
1340+ var pure5 = pure(dictApplicative);
1341+ var applyWriterT2 = applyWriterT1(dictApplicative.Apply0());
1342+ return {
1343+ pure: function(a2) {
1344+ return pure5(new Tuple(a2, mempty6));
1345+ },
1346+ Apply0: function() {
1347+ return applyWriterT2;
1348+ }
1349+ };
1350+ };
1351+ };
1352+ var monadWriterT = function(dictMonoid) {
1353+ var applicativeWriterT1 = applicativeWriterT(dictMonoid);
1354+ var bindWriterT1 = bindWriterT(dictMonoid.Semigroup0());
1355+ return function(dictMonad) {
1356+ var applicativeWriterT22 = applicativeWriterT1(dictMonad.Applicative0());
1357+ var bindWriterT22 = bindWriterT1(dictMonad.Bind1());
1358+ return {
1359+ Applicative0: function() {
1360+ return applicativeWriterT22;
1361+ },
1362+ Bind1: function() {
1363+ return bindWriterT22;
1364+ }
1365+ };
1366+ };
1367+ };
1368+ var monadTellWriterT = function(dictMonoid) {
1369+ var Semigroup0 = dictMonoid.Semigroup0();
1370+ var monadWriterT1 = monadWriterT(dictMonoid);
1371+ return function(dictMonad) {
1372+ var monadWriterT2 = monadWriterT1(dictMonad);
1373+ return {
1374+ tell: function() {
1375+ var $262 = pure(dictMonad.Applicative0());
1376+ var $263 = Tuple.create(unit);
1377+ return function($264) {
1378+ return WriterT($262($263($264)));
1379+ };
1380+ }(),
1381+ Semigroup0: function() {
1382+ return Semigroup0;
1383+ },
1384+ Monad1: function() {
1385+ return monadWriterT2;
1386+ }
1387+ };
1388+ };
1389+ };
1390+ var monoidWriterT = function(dictApplicative) {
1391+ var semigroupWriterT1 = semigroupWriterT(dictApplicative.Apply0());
1392+ return function(dictMonoid) {
1393+ var pure5 = pure(applicativeWriterT(dictMonoid)(dictApplicative));
1394+ var semigroupWriterT2 = semigroupWriterT1(dictMonoid.Semigroup0());
1395+ return function(dictMonoid1) {
1396+ var semigroupWriterT3 = semigroupWriterT2(dictMonoid1.Semigroup0());
1397+ return {
1398+ mempty: pure5(mempty(dictMonoid1)),
1399+ Semigroup0: function() {
1400+ return semigroupWriterT3;
1401+ }
1402+ };
1403+ };
1404+ };
1405+ };
1406+
1407+ // output/Control.Monad.Writer/index.js
1408+ var unwrap2 = /* @__PURE__ */ unwrap();
1409+ var runWriter = function($5) {
1410+ return unwrap2(runWriterT($5));
1411+ };
1412+
1413+ // output/Data.Int/foreign.js
1414+ var fromNumberImpl = function(just) {
1415+ return function(nothing) {
1416+ return function(n2) {
1417+ return (n2 | 0) === n2 ? just(n2) : nothing;
1418+ };
1419+ };
1420+ };
1421+ var toNumber = function(n2) {
1422+ return n2;
1423+ };
1424+
1425+ // output/Data.Number/foreign.js
1426+ var isFiniteImpl = isFinite;
1427+ var round = Math.round;
1428+
1429+ // output/Data.Int/index.js
1430+ var top2 = /* @__PURE__ */ top(boundedInt);
1431+ var bottom2 = /* @__PURE__ */ bottom(boundedInt);
1432+ var fromNumber = /* @__PURE__ */ function() {
1433+ return fromNumberImpl(Just.create)(Nothing.value);
1434+ }();
1435+ var unsafeClamp = function(x2) {
1436+ if (!isFiniteImpl(x2)) {
1437+ return 0;
1438+ }
1439+ ;
1440+ if (x2 >= toNumber(top2)) {
1441+ return top2;
1442+ }
1443+ ;
1444+ if (x2 <= toNumber(bottom2)) {
1445+ return bottom2;
1446+ }
1447+ ;
1448+ if (otherwise) {
1449+ return fromMaybe(0)(fromNumber(x2));
1450+ }
1451+ ;
1452+ throw new Error("Failed pattern match at Data.Int (line 72, column 1 - line 72, column 29): " + [x2.constructor.name]);
1453+ };
1454+ var round2 = function($37) {
1455+ return unsafeClamp(round($37));
1456+ };
1457+
1458+ // output/Data.String.Common/foreign.js
1459+ var replaceAll = function(s1) {
1460+ return function(s2) {
1461+ return function(s3) {
1462+ return s3.replace(new RegExp(s1.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"), "g"), s2);
1463+ };
1464+ };
1465+ };
1466+
1467+ // output/Snabbdom/foreign.js
1468+ function h(z, J) {
1469+ let P, G = J.elm, X2 = z.data.attrs, $ = J.data.attrs;
1470+ if (!X2 && !$) return;
1471+ if (X2 === $) return;
1472+ X2 = X2 || {}, $ = $ || {};
1473+ for (P in $) {
1474+ let U = $[P];
1475+ if (X2[P] !== U) if (U === true) G.setAttribute(P, "");
1476+ else if (U === false) G.removeAttribute(P);
1477+ else if (P.charCodeAt(0) !== 120) G.setAttribute(P, U);
1478+ else if (P.charCodeAt(3) === 58) G.setAttributeNS("http://www.w3.org/XML/1998/namespace", P, U);
1479+ else if (P.charCodeAt(5) === 58) P.charCodeAt(1) === 109 ? G.setAttributeNS("http://www.w3.org/2000/xmlns/", P, U) : G.setAttributeNS("http://www.w3.org/1999/xlink", P, U);
1480+ else G.setAttribute(P, U);
1481+ }
1482+ for (P in X2) if (!(P in $)) G.removeAttribute(P);
1483+ }
1484+ var v = { create: h, update: h };
1485+ function i(z, J, P) {
1486+ if (typeof z === "function") z.call(J, P, J);
1487+ else if (typeof z === "object") for (let G = 0; G < z.length; G++) i(z[G], J, P);
1488+ }
1489+ function e(z, J) {
1490+ let P = z.type, G = J.data.on;
1491+ if (G && G[P]) i(G[P], J, z);
1492+ }
1493+ function zz() {
1494+ return function z(J) {
1495+ e(J, z.vnode);
1496+ };
1497+ }
1498+ function E(z, J) {
1499+ let P = z.data.on, G = z.listener, X2 = z.elm, $ = J && J.data.on, U = J && J.elm, L;
1500+ if (P === $) return;
1501+ if (P && G) {
1502+ if (!$) for (L in P) X2.removeEventListener(L, G, false);
1503+ else for (L in P) if (!$[L]) X2.removeEventListener(L, G, false);
1504+ }
1505+ if ($) {
1506+ let F = J.listener = z.listener || zz();
1507+ if (F.vnode = J, !P) for (L in $) U.addEventListener(L, F, false);
1508+ else for (L in $) if (!P[L]) U.addEventListener(L, F, false);
1509+ }
1510+ }
1511+ var m = { create: E, update: E, destroy: E };
1512+ function C(z, J, P, G, X2) {
1513+ let $ = J === void 0 ? void 0 : J.key;
1514+ return { sel: z, data: J, children: P, text: G, elm: X2, key: $ };
1515+ }
1516+ var w = Array.isArray;
1517+ function s(z) {
1518+ return typeof z === "string" || typeof z === "number" || z instanceof String || z instanceof Number;
1519+ }
1520+ function Jz(z, J) {
1521+ return document.createElement(z, J);
1522+ }
1523+ function Pz(z, J, P) {
1524+ return document.createElementNS(z, J, P);
1525+ }
1526+ function Wz() {
1527+ return g(document.createDocumentFragment());
1528+ }
1529+ function Xz(z) {
1530+ return document.createTextNode(z);
1531+ }
1532+ function Yz(z) {
1533+ return document.createComment(z);
1534+ }
1535+ function Zz(z, J, P) {
1536+ if (b(z)) {
1537+ let G = z;
1538+ while (G && b(G)) G = g(G).parent;
1539+ z = G !== null && G !== void 0 ? G : z;
1540+ }
1541+ if (b(J)) J = g(J, z);
1542+ if (P && b(P)) P = g(P).firstChildNode;
1543+ z.insertBefore(J, P);
1544+ }
1545+ function $z(z, J) {
1546+ z.removeChild(J);
1547+ }
1548+ function Bz(z, J) {
1549+ if (b(J)) J = g(J, z);
1550+ z.appendChild(J);
1551+ }
1552+ function r(z) {
1553+ if (b(z)) {
1554+ while (z && b(z)) z = g(z).parent;
1555+ return z !== null && z !== void 0 ? z : null;
1556+ }
1557+ return z.parentNode;
1558+ }
1559+ function qz(z) {
1560+ var J;
1561+ if (b(z)) {
1562+ let P = g(z), G = r(P);
1563+ if (G && P.lastChildNode) {
1564+ let X2 = Array.from(G.childNodes), $ = X2.indexOf(P.lastChildNode);
1565+ return (J = X2[$ + 1]) !== null && J !== void 0 ? J : null;
1566+ }
1567+ return null;
1568+ }
1569+ return z.nextSibling;
1570+ }
1571+ function Kz(z) {
1572+ return z.tagName;
1573+ }
1574+ function Uz(z, J) {
1575+ z.textContent = J;
1576+ }
1577+ function Hz(z) {
1578+ return z.textContent;
1579+ }
1580+ function Oz(z) {
1581+ return z.nodeType === 1;
1582+ }
1583+ function Rz(z) {
1584+ return z.nodeType === 3;
1585+ }
1586+ function Az(z) {
1587+ return z.nodeType === 8;
1588+ }
1589+ function b(z) {
1590+ return z.nodeType === 11;
1591+ }
1592+ function g(z, J) {
1593+ var P, G, X2;
1594+ let $ = z;
1595+ return (P = $.parent) !== null && P !== void 0 || ($.parent = J !== null && J !== void 0 ? J : null), (G = $.firstChildNode) !== null && G !== void 0 || ($.firstChildNode = z.firstChild), (X2 = $.lastChildNode) !== null && X2 !== void 0 || ($.lastChildNode = z.lastChild), $;
1596+ }
1597+ var l = { createElement: Jz, createElementNS: Pz, createTextNode: Xz, createDocumentFragment: Wz, createComment: Yz, insertBefore: Zz, removeChild: $z, appendChild: Bz, parentNode: r, nextSibling: qz, tagName: Kz, setTextContent: Uz, getTextContent: Hz, isElement: Oz, isText: Rz, isComment: Az, isDocumentFragment: b };
1598+ var x = C("", {}, [], void 0, void 0);
1599+ function I(z, J) {
1600+ var P, G;
1601+ let X2 = z.key === J.key, $ = ((P = z.data) === null || P === void 0 ? void 0 : P.is) === ((G = J.data) === null || G === void 0 ? void 0 : G.is), U = z.sel === J.sel, L = !z.sel && z.sel === J.sel ? typeof z.text === typeof J.text : true;
1602+ return U && X2 && $ && L;
1603+ }
1604+ function Mz() {
1605+ throw new Error("The document fragment is not supported on this platform.");
1606+ }
1607+ function Tz(z, J) {
1608+ return z.isElement(J);
1609+ }
1610+ function Lz(z, J) {
1611+ return z.isDocumentFragment(J);
1612+ }
1613+ function Dz(z, J, P) {
1614+ var G;
1615+ let X2 = {};
1616+ for (let $ = J; $ <= P; ++$) {
1617+ let U = (G = z[$]) === null || G === void 0 ? void 0 : G.key;
1618+ if (U !== void 0) X2[U] = $;
1619+ }
1620+ return X2;
1621+ }
1622+ var jz = ["create", "update", "remove", "destroy", "pre", "post"];
1623+ function a(z, J, P) {
1624+ let G = { create: [], update: [], remove: [], destroy: [], pre: [], post: [] }, X2 = J !== void 0 ? J : l;
1625+ for (let W of jz) for (let Y2 of z) {
1626+ let q = Y2[W];
1627+ if (q !== void 0) G[W].push(q);
1628+ }
1629+ function $(W) {
1630+ let Y2 = W.id ? "#" + W.id : "", q = W.getAttribute("class"), B = q ? "." + q.split(" ").join(".") : "";
1631+ return C(X2.tagName(W).toLowerCase() + Y2 + B, {}, [], void 0, W);
1632+ }
1633+ function U(W) {
1634+ return C(void 0, {}, [], void 0, W);
1635+ }
1636+ function L(W, Y2) {
1637+ return function q() {
1638+ if (--Y2 === 0) {
1639+ let B = X2.parentNode(W);
1640+ if (B !== null) X2.removeChild(B, W);
1641+ }
1642+ };
1643+ }
1644+ function F(W, Y2) {
1645+ var q, B, K, O, M;
1646+ let Z, R = W.data, T = R === null || R === void 0 ? void 0 : R.hook;
1647+ (q = T === null || T === void 0 ? void 0 : T.init) === null || q === void 0 || q.call(T, W);
1648+ let { children: A, sel: H } = W;
1649+ if (H === "!") (B = W.text) !== null && B !== void 0 || (W.text = ""), W.elm = X2.createComment(W.text);
1650+ else if (H === "") W.elm = X2.createTextNode(W.text);
1651+ else if (H !== void 0) {
1652+ let D = H.indexOf("#"), j = H.indexOf(".", D), Q = D > 0 ? D : H.length, f = j > 0 ? j : H.length, c = D !== -1 || j !== -1 ? H.slice(0, Math.min(Q, f)) : H, V = R === null || R === void 0 ? void 0 : R.ns, S = V === void 0 ? X2.createElement(c, R) : X2.createElementNS(V, c, R);
1653+ if (W.elm = S, Q < f) S.setAttribute("id", H.slice(Q + 1, f));
1654+ if (j > 0) S.setAttribute("class", H.slice(f + 1).replace(/\./g, " "));
1655+ for (Z = 0; Z < G.create.length; ++Z) G.create[Z](x, W);
1656+ if (s(W.text) && (!w(A) || A.length === 0)) X2.appendChild(S, X2.createTextNode(W.text));
1657+ if (w(A)) for (Z = 0; Z < A.length; ++Z) {
1658+ let p = A[Z];
1659+ if (p != null) X2.appendChild(S, F(p, Y2));
1660+ }
1661+ if (T !== void 0) {
1662+ if ((K = T.create) === null || K === void 0 || K.call(T, x, W), T.insert !== void 0) Y2.push(W);
1663+ }
1664+ } else if (((O = P === null || P === void 0 ? void 0 : P.experimental) === null || O === void 0 ? void 0 : O.fragments) && W.children) {
1665+ W.elm = ((M = X2.createDocumentFragment) !== null && M !== void 0 ? M : Mz)();
1666+ for (Z = 0; Z < G.create.length; ++Z) G.create[Z](x, W);
1667+ for (Z = 0; Z < W.children.length; ++Z) {
1668+ let D = W.children[Z];
1669+ if (D != null) X2.appendChild(W.elm, F(D, Y2));
1670+ }
1671+ } else W.elm = X2.createTextNode(W.text);
1672+ return W.elm;
1673+ }
1674+ function _(W, Y2, q, B, K, O) {
1675+ for (; B <= K; ++B) {
1676+ let M = q[B];
1677+ if (M != null) X2.insertBefore(W, F(M, O), Y2);
1678+ }
1679+ }
1680+ function N(W) {
1681+ var Y2, q;
1682+ let B = W.data;
1683+ if (B !== void 0) {
1684+ (q = (Y2 = B === null || B === void 0 ? void 0 : B.hook) === null || Y2 === void 0 ? void 0 : Y2.destroy) === null || q === void 0 || q.call(Y2, W);
1685+ for (let K = 0; K < G.destroy.length; ++K) G.destroy[K](W);
1686+ if (W.children !== void 0) for (let K = 0; K < W.children.length; ++K) {
1687+ let O = W.children[K];
1688+ if (O != null && typeof O !== "string") N(O);
1689+ }
1690+ }
1691+ }
1692+ function k(W, Y2, q, B) {
1693+ var K, O;
1694+ for (; q <= B; ++q) {
1695+ let M, Z = Y2[q];
1696+ if (Z != null) if (Z.sel !== void 0) {
1697+ N(Z), M = G.remove.length + 1;
1698+ let R = L(Z.elm, M);
1699+ for (let A = 0; A < G.remove.length; ++A) G.remove[A](Z, R);
1700+ let T = (O = (K = Z === null || Z === void 0 ? void 0 : Z.data) === null || K === void 0 ? void 0 : K.hook) === null || O === void 0 ? void 0 : O.remove;
1701+ if (T !== void 0) T(Z, R);
1702+ else R();
1703+ } else if (Z.children) N(Z), k(W, Z.children, 0, Z.children.length - 1);
1704+ else X2.removeChild(W, Z.elm);
1705+ }
1706+ }
1707+ function d(W, Y2, q, B) {
1708+ let K = 0, O = 0, M = Y2.length - 1, Z = Y2[0], R = Y2[M], T = q.length - 1, A = q[0], H = q[T], D, j, Q, f;
1709+ while (K <= M && O <= T) if (Z == null) Z = Y2[++K];
1710+ else if (R == null) R = Y2[--M];
1711+ else if (A == null) A = q[++O];
1712+ else if (H == null) H = q[--T];
1713+ else if (I(Z, A)) y(Z, A, B), Z = Y2[++K], A = q[++O];
1714+ else if (I(R, H)) y(R, H, B), R = Y2[--M], H = q[--T];
1715+ else if (I(Z, H)) y(Z, H, B), X2.insertBefore(W, Z.elm, X2.nextSibling(R.elm)), Z = Y2[++K], H = q[--T];
1716+ else if (I(R, A)) y(R, A, B), X2.insertBefore(W, R.elm, Z.elm), R = Y2[--M], A = q[++O];
1717+ else {
1718+ if (D === void 0) D = Dz(Y2, K, M);
1719+ if (j = D[A.key], j === void 0) X2.insertBefore(W, F(A, B), Z.elm), A = q[++O];
1720+ else if (D[H.key] === void 0) X2.insertBefore(W, F(H, B), X2.nextSibling(R.elm)), H = q[--T];
1721+ else {
1722+ if (Q = Y2[j], Q.sel !== A.sel) X2.insertBefore(W, F(A, B), Z.elm);
1723+ else y(Q, A, B), Y2[j] = void 0, X2.insertBefore(W, Q.elm, Z.elm);
1724+ A = q[++O];
1725+ }
1726+ }
1727+ if (O <= T) f = q[T + 1] == null ? null : q[T + 1].elm, _(W, f, q, O, T, B);
1728+ if (K <= M) k(W, Y2, K, M);
1729+ }
1730+ function y(W, Y2, q) {
1731+ var B, K, O, M, Z, R, T, A;
1732+ let H = (B = Y2.data) === null || B === void 0 ? void 0 : B.hook;
1733+ (K = H === null || H === void 0 ? void 0 : H.prepatch) === null || K === void 0 || K.call(H, W, Y2);
1734+ let D = Y2.elm = W.elm;
1735+ if (W === Y2) return;
1736+ if (Y2.data !== void 0 || Y2.text !== void 0 && Y2.text !== W.text) {
1737+ (O = Y2.data) !== null && O !== void 0 || (Y2.data = {}), (M = W.data) !== null && M !== void 0 || (W.data = {});
1738+ for (let f = 0; f < G.update.length; ++f) G.update[f](W, Y2);
1739+ (T = (R = (Z = Y2.data) === null || Z === void 0 ? void 0 : Z.hook) === null || R === void 0 ? void 0 : R.update) === null || T === void 0 || T.call(R, W, Y2);
1740+ }
1741+ let j = W.children, Q = Y2.children;
1742+ if (Y2.text === void 0) {
1743+ if (j !== void 0 && Q !== void 0) {
1744+ if (j !== Q) d(D, j, Q, q);
1745+ } else if (Q !== void 0) {
1746+ if (W.text !== void 0) X2.setTextContent(D, "");
1747+ _(D, null, Q, 0, Q.length - 1, q);
1748+ } else if (j !== void 0) k(D, j, 0, j.length - 1);
1749+ else if (W.text !== void 0) X2.setTextContent(D, "");
1750+ } else if (W.text !== Y2.text) {
1751+ if (j !== void 0) k(D, j, 0, j.length - 1);
1752+ X2.setTextContent(D, Y2.text);
1753+ }
1754+ (A = H === null || H === void 0 ? void 0 : H.postpatch) === null || A === void 0 || A.call(H, W, Y2);
1755+ }
1756+ return function W(Y2, q) {
1757+ let B, K, O, M = [];
1758+ for (B = 0; B < G.pre.length; ++B) G.pre[B]();
1759+ if (Tz(X2, Y2)) Y2 = $(Y2);
1760+ else if (Lz(X2, Y2)) Y2 = U(Y2);
1761+ if (I(Y2, q)) y(Y2, q, M);
1762+ else if (K = Y2.elm, O = X2.parentNode(K), F(q, M), O !== null) X2.insertBefore(O, q.elm, X2.nextSibling(K)), k(O, [Y2], 0, 0);
1763+ for (B = 0; B < M.length; ++B) M[B].data.hook.insert(M[B]);
1764+ for (B = 0; B < G.post.length; ++B) G.post[B]();
1765+ return q;
1766+ };
1767+ }
1768+ var t = typeof (window === null || window === void 0 ? void 0 : window.requestAnimationFrame) === "function" ? window.requestAnimationFrame.bind(window) : setTimeout;
1769+ var Fz = (z) => {
1770+ t(() => {
1771+ t(z);
1772+ });
1773+ };
1774+ var u = false;
1775+ function Qz(z, J, P) {
1776+ Fz(() => {
1777+ z[J] = P;
1778+ });
1779+ }
1780+ function o(z, J) {
1781+ let P, G, X2 = J.elm, $ = z.data.style, U = J.data.style;
1782+ if (!$ && !U) return;
1783+ if ($ === U) return;
1784+ $ = $ || {}, U = U || {};
1785+ let L = "delayed" in $;
1786+ for (G in $) if (!(G in U)) if (G[0] === "-" && G[1] === "-") X2.style.removeProperty(G);
1787+ else X2.style[G] = "";
1788+ for (G in U) if (P = U[G], G === "delayed" && U.delayed) {
1789+ for (let F in U.delayed) if (P = U.delayed[F], !L || P !== $.delayed[F]) Qz(X2.style, F, P);
1790+ } else if (G !== "remove" && P !== $[G]) if (G[0] === "-" && G[1] === "-") X2.style.setProperty(G, P);
1791+ else X2.style[G] = P;
1792+ }
1793+ function fz(z) {
1794+ let J, P, G = z.elm, X2 = z.data.style;
1795+ if (!X2 || !(J = X2.destroy)) return;
1796+ for (P in J) G.style[P] = J[P];
1797+ }
1798+ function bz(z, J) {
1799+ let P = z.data.style;
1800+ if (!P || !P.remove) {
1801+ J();
1802+ return;
1803+ }
1804+ if (!u) z.elm.offsetLeft, u = true;
1805+ let G, X2 = z.elm, $ = 0, U = P.remove, L = 0, F = [];
1806+ for (G in U) F.push(G), X2.style[G] = U[G];
1807+ let N = getComputedStyle(X2)["transition-property"].split(", ");
1808+ for (; $ < N.length; ++$) if (F.indexOf(N[$]) !== -1) L++;
1809+ X2.addEventListener("transitionend", (k) => {
1810+ if (k.target === X2) --L;
1811+ if (L === 0) J();
1812+ });
1813+ }
1814+ function kz() {
1815+ u = false;
1816+ }
1817+ var n = { pre: kz, create: o, update: o, destroy: fz, remove: bz };
1818+ function Vz() {
1819+ return a([v, m, n]);
1820+ }
1821+
1822+ // output/Effect.Uncurried/foreign.js
1823+ var runEffectFn2 = function runEffectFn22(fn) {
1824+ return function(a2) {
1825+ return function(b2) {
1826+ return function() {
1827+ return fn(a2, b2);
1828+ };
1829+ };
1830+ };
1831+ };
1832+
1833+ // output/Snabbdom/index.js
1834+ var init = /* @__PURE__ */ mapFlipped(functorEffect)(Vz)(runEffectFn2);
1835+ var h2 = /* @__PURE__ */ runFn4(C);
1836+
1837+ // output/Foreign/foreign.js
1838+ var isArray = Array.isArray || function(value12) {
1839+ return Object.prototype.toString.call(value12) === "[object Array]";
1840+ };
1841+
1842+ // output/Untagged.Castable/index.js
1843+ var cast = function() {
1844+ return unsafeCoerce2;
1845+ };
1846+
1847+ // output/Untagged.Union/index.js
1848+ var cast2 = /* @__PURE__ */ cast();
1849+ var asOneOf = function() {
1850+ return cast2;
1851+ };
1852+
1853+ // output/Plum.View/index.js
1854+ var append2 = /* @__PURE__ */ append(semigroupArray);
1855+ var semigroupRecord3 = /* @__PURE__ */ semigroupRecord();
1856+ var childrenIsSymbol = {
1857+ reflectSymbol: function() {
1858+ return "children";
1859+ }
1860+ };
1861+ var downIsSymbol = {
1862+ reflectSymbol: function() {
1863+ return "down";
1864+ }
1865+ };
1866+ var hoverIsSymbol = {
1867+ reflectSymbol: function() {
1868+ return "hover";
1869+ }
1870+ };
1871+ var meatIsSymbol = {
1872+ reflectSymbol: function() {
1873+ return "meat";
1874+ }
1875+ };
1876+ var nervesIsSymbol = {
1877+ reflectSymbol: function() {
1878+ return "nerves";
1879+ }
1880+ };
1881+ var semigroupRecordCons2 = /* @__PURE__ */ semigroupRecordCons(childrenIsSymbol)()(/* @__PURE__ */ semigroupRecordCons(downIsSymbol)()(/* @__PURE__ */ semigroupRecordCons(hoverIsSymbol)()(/* @__PURE__ */ semigroupRecordCons(meatIsSymbol)()(/* @__PURE__ */ semigroupRecordCons(nervesIsSymbol)()(semigroupRecordNil)(semigroupArray))(semigroupArray))(semigroupArray))(semigroupArray));
1882+ var show2 = /* @__PURE__ */ show(showInt);
1883+ var monoidRecord2 = /* @__PURE__ */ monoidRecord();
1884+ var monoidRecordCons2 = /* @__PURE__ */ monoidRecordCons(downIsSymbol);
1885+ var monoidObject2 = /* @__PURE__ */ monoidObject(/* @__PURE__ */ semigroupRecord3(/* @__PURE__ */ semigroupRecordCons({
1886+ reflectSymbol: function() {
1887+ return "key";
1888+ }
1889+ })()(/* @__PURE__ */ semigroupRecordCons({
1890+ reflectSymbol: function() {
1891+ return "value";
1892+ }
1893+ })()(semigroupRecordNil)(semigroupString))(semigroupString)));
1894+ var monoidRecordCons1 = /* @__PURE__ */ monoidRecordCons(hoverIsSymbol);
1895+ var monoidRecordCons22 = /* @__PURE__ */ monoidRecordCons(meatIsSymbol);
1896+ var mempty2 = /* @__PURE__ */ mempty(monoidArray);
1897+ var monoidRecordCons3 = /* @__PURE__ */ monoidRecordCons(childrenIsSymbol);
1898+ var monoidRecordCons4 = /* @__PURE__ */ monoidRecordCons2(monoidArray)()(/* @__PURE__ */ monoidRecordCons1(monoidArray)()(/* @__PURE__ */ monoidRecordCons22(monoidArray)()(/* @__PURE__ */ monoidRecordCons(nervesIsSymbol)(monoidArray)()(monoidRecordNil))));
1899+ var mempty1 = /* @__PURE__ */ mempty(/* @__PURE__ */ monoidRecord2(/* @__PURE__ */ monoidRecordCons3(monoidArray)()(monoidRecordCons4)));
1900+ var foldMap4 = /* @__PURE__ */ foldMap2(monoidString);
1901+ var intercalate3 = /* @__PURE__ */ intercalate2(monoidString);
1902+ var asOneOf2 = /* @__PURE__ */ asOneOf();
1903+ var show1 = /* @__PURE__ */ show(showNumber);
1904+ var mempty22 = /* @__PURE__ */ mempty(monoidUnit);
1905+ var fromHomogeneous2 = /* @__PURE__ */ fromHomogeneous();
1906+ var map2 = /* @__PURE__ */ map(/* @__PURE__ */ functorWriterT(functorIdentity));
1907+ var map1 = /* @__PURE__ */ map(functorArray);
1908+ var Top = /* @__PURE__ */ function() {
1909+ function Top2() {
1910+ }
1911+ ;
1912+ Top2.value = new Top2();
1913+ return Top2;
1914+ }();
1915+ var Right2 = /* @__PURE__ */ function() {
1916+ function Right3() {
1917+ }
1918+ ;
1919+ Right3.value = new Right3();
1920+ return Right3;
1921+ }();
1922+ var Bottom = /* @__PURE__ */ function() {
1923+ function Bottom2() {
1924+ }
1925+ ;
1926+ Bottom2.value = new Bottom2();
1927+ return Bottom2;
1928+ }();
1929+ var Left2 = /* @__PURE__ */ function() {
1930+ function Left3() {
1931+ }
1932+ ;
1933+ Left3.value = new Left3();
1934+ return Left3;
1935+ }();
1936+ var Px = /* @__PURE__ */ function() {
1937+ function Px2(value0) {
1938+ this.value0 = value0;
1939+ }
1940+ ;
1941+ Px2.create = function(value0) {
1942+ return new Px2(value0);
1943+ };
1944+ return Px2;
1945+ }();
1946+ var Fill = /* @__PURE__ */ function() {
1947+ function Fill2() {
1948+ }
1949+ ;
1950+ Fill2.value = new Fill2();
1951+ return Fill2;
1952+ }();
1953+ var Fit = /* @__PURE__ */ function() {
1954+ function Fit2() {
1955+ }
1956+ ;
1957+ Fit2.value = new Fit2();
1958+ return Fit2;
1959+ }();
1960+ var Max2 = /* @__PURE__ */ function() {
1961+ function Max3(value0, value1) {
1962+ this.value0 = value0;
1963+ this.value1 = value1;
1964+ }
1965+ ;
1966+ Max3.create = function(value0) {
1967+ return function(value1) {
1968+ return new Max3(value0, value1);
1969+ };
1970+ };
1971+ return Max3;
1972+ }();
1973+ var Min2 = /* @__PURE__ */ function() {
1974+ function Min3(value0, value1) {
1975+ this.value0 = value0;
1976+ this.value1 = value1;
1977+ }
1978+ ;
1979+ Min3.create = function(value0) {
1980+ return function(value1) {
1981+ return new Min3(value0, value1);
1982+ };
1983+ };
1984+ return Min3;
1985+ }();
1986+ var X = /* @__PURE__ */ function() {
1987+ function X2() {
1988+ }
1989+ ;
1990+ X2.value = new X2();
1991+ return X2;
1992+ }();
1993+ var Y = /* @__PURE__ */ function() {
1994+ function Y2() {
1995+ }
1996+ ;
1997+ Y2.value = new Y2();
1998+ return Y2;
1999+ }();
2000+ var TopLeft = /* @__PURE__ */ function() {
2001+ function TopLeft2() {
2002+ }
2003+ ;
2004+ TopLeft2.value = new TopLeft2();
2005+ return TopLeft2;
2006+ }();
2007+ var TopRight = /* @__PURE__ */ function() {
2008+ function TopRight2() {
2009+ }
2010+ ;
2011+ TopRight2.value = new TopRight2();
2012+ return TopRight2;
2013+ }();
2014+ var BottomRight = /* @__PURE__ */ function() {
2015+ function BottomRight2() {
2016+ }
2017+ ;
2018+ BottomRight2.value = new BottomRight2();
2019+ return BottomRight2;
2020+ }();
2021+ var BottomLeft = /* @__PURE__ */ function() {
2022+ function BottomLeft2() {
2023+ }
2024+ ;
2025+ BottomLeft2.value = new BottomLeft2();
2026+ return BottomLeft2;
2027+ }();
2028+ var Grid = /* @__PURE__ */ function() {
2029+ function Grid2() {
2030+ }
2031+ ;
2032+ Grid2.value = new Grid2();
2033+ return Grid2;
2034+ }();
2035+ var Flexbox = /* @__PURE__ */ function() {
2036+ function Flexbox2(value0) {
2037+ this.value0 = value0;
2038+ }
2039+ ;
2040+ Flexbox2.create = function(value0) {
2041+ return new Flexbox2(value0);
2042+ };
2043+ return Flexbox2;
2044+ }();
2045+ var Generic = /* @__PURE__ */ function() {
2046+ function Generic2() {
2047+ }
2048+ ;
2049+ Generic2.value = new Generic2();
2050+ return Generic2;
2051+ }();
2052+ var Span = /* @__PURE__ */ function() {
2053+ function Span2() {
2054+ }
2055+ ;
2056+ Span2.value = new Span2();
2057+ return Span2;
2058+ }();
2059+ var Solid = /* @__PURE__ */ function() {
2060+ function Solid2() {
2061+ }
2062+ ;
2063+ Solid2.value = new Solid2();
2064+ return Solid2;
2065+ }();
2066+ var Dashed = /* @__PURE__ */ function() {
2067+ function Dashed2() {
2068+ }
2069+ ;
2070+ Dashed2.value = new Dashed2();
2071+ return Dashed2;
2072+ }();
2073+ var Dotted = /* @__PURE__ */ function() {
2074+ function Dotted2() {
2075+ }
2076+ ;
2077+ Dotted2.value = new Dotted2();
2078+ return Dotted2;
2079+ }();
2080+ var Start = /* @__PURE__ */ function() {
2081+ function Start2() {
2082+ }
2083+ ;
2084+ Start2.value = new Start2();
2085+ return Start2;
2086+ }();
2087+ var Center = /* @__PURE__ */ function() {
2088+ function Center2() {
2089+ }
2090+ ;
2091+ Center2.value = new Center2();
2092+ return Center2;
2093+ }();
2094+ var End = /* @__PURE__ */ function() {
2095+ function End2() {
2096+ }
2097+ ;
2098+ End2.value = new End2();
2099+ return End2;
2100+ }();
2101+ var Spacing = /* @__PURE__ */ function() {
2102+ function Spacing2(value0, value1) {
2103+ this.value0 = value0;
2104+ this.value1 = value1;
2105+ }
2106+ ;
2107+ Spacing2.create = function(value0) {
2108+ return function(value1) {
2109+ return new Spacing2(value0, value1);
2110+ };
2111+ };
2112+ return Spacing2;
2113+ }();
2114+ var Explain = /* @__PURE__ */ function() {
2115+ function Explain2() {
2116+ }
2117+ ;
2118+ Explain2.value = new Explain2();
2119+ return Explain2;
2120+ }();
2121+ var Align = /* @__PURE__ */ function() {
2122+ function Align2(value0, value1) {
2123+ this.value0 = value0;
2124+ this.value1 = value1;
2125+ }
2126+ ;
2127+ Align2.create = function(value0) {
2128+ return function(value1) {
2129+ return new Align2(value0, value1);
2130+ };
2131+ };
2132+ return Align2;
2133+ }();
2134+ var Width = /* @__PURE__ */ function() {
2135+ function Width2(value0) {
2136+ this.value0 = value0;
2137+ }
2138+ ;
2139+ Width2.create = function(value0) {
2140+ return new Width2(value0);
2141+ };
2142+ return Width2;
2143+ }();
2144+ var Height = /* @__PURE__ */ function() {
2145+ function Height2(value0) {
2146+ this.value0 = value0;
2147+ }
2148+ ;
2149+ Height2.create = function(value0) {
2150+ return new Height2(value0);
2151+ };
2152+ return Height2;
2153+ }();
2154+ var Wrapped = /* @__PURE__ */ function() {
2155+ function Wrapped2() {
2156+ }
2157+ ;
2158+ Wrapped2.value = new Wrapped2();
2159+ return Wrapped2;
2160+ }();
2161+ var BackgroundColor = /* @__PURE__ */ function() {
2162+ function BackgroundColor2(value0) {
2163+ this.value0 = value0;
2164+ }
2165+ ;
2166+ BackgroundColor2.create = function(value0) {
2167+ return new BackgroundColor2(value0);
2168+ };
2169+ return BackgroundColor2;
2170+ }();
2171+ var Padding = /* @__PURE__ */ function() {
2172+ function Padding2(value0, value1) {
2173+ this.value0 = value0;
2174+ this.value1 = value1;
2175+ }
2176+ ;
2177+ Padding2.create = function(value0) {
2178+ return function(value1) {
2179+ return new Padding2(value0, value1);
2180+ };
2181+ };
2182+ return Padding2;
2183+ }();
2184+ var Spread = /* @__PURE__ */ function() {
2185+ function Spread2() {
2186+ }
2187+ ;
2188+ Spread2.value = new Spread2();
2189+ return Spread2;
2190+ }();
2191+ var Opacity = /* @__PURE__ */ function() {
2192+ function Opacity2(value0) {
2193+ this.value0 = value0;
2194+ }
2195+ ;
2196+ Opacity2.create = function(value0) {
2197+ return new Opacity2(value0);
2198+ };
2199+ return Opacity2;
2200+ }();
2201+ var Pointer = /* @__PURE__ */ function() {
2202+ function Pointer2() {
2203+ }
2204+ ;
2205+ Pointer2.value = new Pointer2();
2206+ return Pointer2;
2207+ }();
2208+ var Move = /* @__PURE__ */ function() {
2209+ function Move2(value0) {
2210+ this.value0 = value0;
2211+ }
2212+ ;
2213+ Move2.create = function(value0) {
2214+ return new Move2(value0);
2215+ };
2216+ return Move2;
2217+ }();
2218+ var Clip = /* @__PURE__ */ function() {
2219+ function Clip2(value0) {
2220+ this.value0 = value0;
2221+ }
2222+ ;
2223+ Clip2.create = function(value0) {
2224+ return new Clip2(value0);
2225+ };
2226+ return Clip2;
2227+ }();
2228+ var BorderWidth = /* @__PURE__ */ function() {
2229+ function BorderWidth2(value0, value1) {
2230+ this.value0 = value0;
2231+ this.value1 = value1;
2232+ }
2233+ ;
2234+ BorderWidth2.create = function(value0) {
2235+ return function(value1) {
2236+ return new BorderWidth2(value0, value1);
2237+ };
2238+ };
2239+ return BorderWidth2;
2240+ }();
2241+ var BorderStyle = /* @__PURE__ */ function() {
2242+ function BorderStyle2(value0) {
2243+ this.value0 = value0;
2244+ }
2245+ ;
2246+ BorderStyle2.create = function(value0) {
2247+ return new BorderStyle2(value0);
2248+ };
2249+ return BorderStyle2;
2250+ }();
2251+ var Round = /* @__PURE__ */ function() {
2252+ function Round2(value0, value1) {
2253+ this.value0 = value0;
2254+ this.value1 = value1;
2255+ }
2256+ ;
2257+ Round2.create = function(value0) {
2258+ return function(value1) {
2259+ return new Round2(value0, value1);
2260+ };
2261+ };
2262+ return Round2;
2263+ }();
2264+ var Shadow = /* @__PURE__ */ function() {
2265+ function Shadow2(value0) {
2266+ this.value0 = value0;
2267+ }
2268+ ;
2269+ Shadow2.create = function(value0) {
2270+ return new Shadow2(value0);
2271+ };
2272+ return Shadow2;
2273+ }();
2274+ var InnerShadow = /* @__PURE__ */ function() {
2275+ function InnerShadow2(value0) {
2276+ this.value0 = value0;
2277+ }
2278+ ;
2279+ InnerShadow2.create = function(value0) {
2280+ return new InnerShadow2(value0);
2281+ };
2282+ return InnerShadow2;
2283+ }();
2284+ var FontColor = /* @__PURE__ */ function() {
2285+ function FontColor2(value0) {
2286+ this.value0 = value0;
2287+ }
2288+ ;
2289+ FontColor2.create = function(value0) {
2290+ return new FontColor2(value0);
2291+ };
2292+ return FontColor2;
2293+ }();
2294+ var FontWeight = /* @__PURE__ */ function() {
2295+ function FontWeight2(value0) {
2296+ this.value0 = value0;
2297+ }
2298+ ;
2299+ FontWeight2.create = function(value0) {
2300+ return new FontWeight2(value0);
2301+ };
2302+ return FontWeight2;
2303+ }();
2304+ var FontSize = /* @__PURE__ */ function() {
2305+ function FontSize2(value0) {
2306+ this.value0 = value0;
2307+ }
2308+ ;
2309+ FontSize2.create = function(value0) {
2310+ return new FontSize2(value0);
2311+ };
2312+ return FontSize2;
2313+ }();
2314+ var Font = /* @__PURE__ */ function() {
2315+ function Font2(value0) {
2316+ this.value0 = value0;
2317+ }
2318+ ;
2319+ Font2.create = function(value0) {
2320+ return new Font2(value0);
2321+ };
2322+ return Font2;
2323+ }();
2324+ var UI = /* @__PURE__ */ function() {
2325+ function UI2(value0, value1) {
2326+ this.value0 = value0;
2327+ this.value1 = value1;
2328+ }
2329+ ;
2330+ UI2.create = function(value0) {
2331+ return function(value1) {
2332+ return new UI2(value0, value1);
2333+ };
2334+ };
2335+ return UI2;
2336+ }();
2337+ var Column = /* @__PURE__ */ function() {
2338+ function Column2(value0) {
2339+ this.value0 = value0;
2340+ }
2341+ ;
2342+ Column2.create = function(value0) {
2343+ return new Column2(value0);
2344+ };
2345+ return Column2;
2346+ }();
2347+ var Row = /* @__PURE__ */ function() {
2348+ function Row2(value0) {
2349+ this.value0 = value0;
2350+ }
2351+ ;
2352+ Row2.create = function(value0) {
2353+ return new Row2(value0);
2354+ };
2355+ return Row2;
2356+ }();
2357+ var Stack = /* @__PURE__ */ function() {
2358+ function Stack2(value0) {
2359+ this.value0 = value0;
2360+ }
2361+ ;
2362+ Stack2.create = function(value0) {
2363+ return new Stack2(value0);
2364+ };
2365+ return Stack2;
2366+ }();
2367+ var Wrapper = /* @__PURE__ */ function() {
2368+ function Wrapper2(value0) {
2369+ this.value0 = value0;
2370+ }
2371+ ;
2372+ Wrapper2.create = function(value0) {
2373+ return new Wrapper2(value0);
2374+ };
2375+ return Wrapper2;
2376+ }();
2377+ var Text = /* @__PURE__ */ function() {
2378+ function Text2(value0) {
2379+ this.value0 = value0;
2380+ }
2381+ ;
2382+ Text2.create = function(value0) {
2383+ return new Text2(value0);
2384+ };
2385+ return Text2;
2386+ }();
2387+ var Link = /* @__PURE__ */ function() {
2388+ function Link2(value0, value1, value22) {
2389+ this.value0 = value0;
2390+ this.value1 = value1;
2391+ this.value2 = value22;
2392+ }
2393+ ;
2394+ Link2.create = function(value0) {
2395+ return function(value1) {
2396+ return function(value22) {
2397+ return new Link2(value0, value1, value22);
2398+ };
2399+ };
2400+ };
2401+ return Link2;
2402+ }();
2403+ var Download = /* @__PURE__ */ function() {
2404+ function Download2(value0, value1, value22) {
2405+ this.value0 = value0;
2406+ this.value1 = value1;
2407+ this.value2 = value22;
2408+ }
2409+ ;
2410+ Download2.create = function(value0) {
2411+ return function(value1) {
2412+ return function(value22) {
2413+ return new Download2(value0, value1, value22);
2414+ };
2415+ };
2416+ };
2417+ return Download2;
2418+ }();
2419+ var Image2 = /* @__PURE__ */ function() {
2420+ function Image3(value0, value1) {
2421+ this.value0 = value0;
2422+ this.value1 = value1;
2423+ }
2424+ ;
2425+ Image3.create = function(value0) {
2426+ return function(value1) {
2427+ return new Image3(value0, value1);
2428+ };
2429+ };
2430+ return Image3;
2431+ }();
2432+ var None = /* @__PURE__ */ function() {
2433+ function None3() {
2434+ }
2435+ ;
2436+ None3.value = new None3();
2437+ return None3;
2438+ }();
2439+ var semigroupSkinGrowth = {
2440+ append: function(v2) {
2441+ return function(v1) {
2442+ return {
2443+ meat: union(v2.meat)(v1.meat),
2444+ hover: union(v2.hover)(v1.hover),
2445+ down: union(v2.down)(v1.down)
2446+ };
2447+ };
2448+ }
2449+ };
2450+ var bindWriterT2 = /* @__PURE__ */ bindWriterT(semigroupSkinGrowth)(bindIdentity);
2451+ var discard2 = /* @__PURE__ */ discard(discardUnit)(bindWriterT2);
2452+ var bind2 = /* @__PURE__ */ bind(bindWriterT2);
2453+ var append22 = /* @__PURE__ */ append(/* @__PURE__ */ semigroupWriterT(applyIdentity)(semigroupSkinGrowth)(semigroupArray));
2454+ var semigroupMutation = {
2455+ append: function(v2) {
2456+ return function(v1) {
2457+ return {
2458+ extraSkin: append2(v2.extraSkin)(v1.extraSkin)
2459+ };
2460+ };
2461+ }
2462+ };
2463+ var semigroupGenericUI = function(dictSemigroup) {
2464+ var append3 = append(semigroupRecord3(semigroupRecordCons2(dictSemigroup)));
2465+ return function(dictSemigroup1) {
2466+ var append4 = append(dictSemigroup1);
2467+ return {
2468+ append: function(v2) {
2469+ return function(v1) {
2470+ return new UI(append3(v2.value0)(v1.value0), append4(v2.value1)(v1.value1));
2471+ };
2472+ }
2473+ };
2474+ };
2475+ };
2476+ var renderableSide = {
2477+ render: function(v2) {
2478+ if (v2 instanceof Top) {
2479+ return "top";
2480+ }
2481+ ;
2482+ if (v2 instanceof Right2) {
2483+ return "right";
2484+ }
2485+ ;
2486+ if (v2 instanceof Bottom) {
2487+ return "bottom";
2488+ }
2489+ ;
2490+ if (v2 instanceof Left2) {
2491+ return "left";
2492+ }
2493+ ;
2494+ throw new Error("Failed pattern match at Plum.View (line 383, column 12 - line 387, column 19): " + [v2.constructor.name]);
2495+ },
2496+ renderKey: function(v2) {
2497+ if (v2 instanceof Top) {
2498+ return "top";
2499+ }
2500+ ;
2501+ if (v2 instanceof Right2) {
2502+ return "right";
2503+ }
2504+ ;
2505+ if (v2 instanceof Bottom) {
2506+ return "bottom";
2507+ }
2508+ ;
2509+ if (v2 instanceof Left2) {
2510+ return "left";
2511+ }
2512+ ;
2513+ throw new Error("Failed pattern match at Plum.View (line 388, column 15 - line 392, column 19): " + [v2.constructor.name]);
2514+ }
2515+ };
2516+ var renderableCorner = {
2517+ render: function(v2) {
2518+ if (v2 instanceof TopLeft) {
2519+ return "top-left";
2520+ }
2521+ ;
2522+ if (v2 instanceof TopRight) {
2523+ return "top-right";
2524+ }
2525+ ;
2526+ if (v2 instanceof BottomRight) {
2527+ return "bottom-right";
2528+ }
2529+ ;
2530+ if (v2 instanceof BottomLeft) {
2531+ return "bottom-left";
2532+ }
2533+ ;
2534+ throw new Error("Failed pattern match at Plum.View (line 357, column 12 - line 361, column 32): " + [v2.constructor.name]);
2535+ },
2536+ renderKey: function(v2) {
2537+ if (v2 instanceof TopLeft) {
2538+ return "top-left";
2539+ }
2540+ ;
2541+ if (v2 instanceof TopRight) {
2542+ return "top-right";
2543+ }
2544+ ;
2545+ if (v2 instanceof BottomRight) {
2546+ return "bottom-right";
2547+ }
2548+ ;
2549+ if (v2 instanceof BottomLeft) {
2550+ return "bottom-left";
2551+ }
2552+ ;
2553+ throw new Error("Failed pattern match at Plum.View (line 362, column 15 - line 366, column 32): " + [v2.constructor.name]);
2554+ }
2555+ };
2556+ var renderableColor = {
2557+ render: function(v2) {
2558+ return "rgb(" + (show2(v2.r) + ("," + (show2(v2.g) + ("," + (show2(v2.b) + ("," + (show2(v2.a) + "%)")))))));
2559+ },
2560+ renderKey: function(v2) {
2561+ return show2(v2.r) + ("-" + (show2(v2.g) + ("-" + (show2(v2.b) + ("-" + show2(v2.a))))));
2562+ }
2563+ };
2564+ var renderableBorderStyle = {
2565+ render: function(v2) {
2566+ if (v2 instanceof Solid) {
2567+ return "solid";
2568+ }
2569+ ;
2570+ if (v2 instanceof Dashed) {
2571+ return "dashed";
2572+ }
2573+ ;
2574+ if (v2 instanceof Dotted) {
2575+ return "dotted";
2576+ }
2577+ ;
2578+ throw new Error("Failed pattern match at Plum.View (line 371, column 12 - line 374, column 23): " + [v2.constructor.name]);
2579+ },
2580+ renderKey: function(v2) {
2581+ if (v2 instanceof Solid) {
2582+ return "solid";
2583+ }
2584+ ;
2585+ if (v2 instanceof Dashed) {
2586+ return "dashed";
2587+ }
2588+ ;
2589+ if (v2 instanceof Dotted) {
2590+ return "dotted";
2591+ }
2592+ ;
2593+ throw new Error("Failed pattern match at Plum.View (line 375, column 15 - line 378, column 23): " + [v2.constructor.name]);
2594+ }
2595+ };
2596+ var monoidSkinGrowth = {
2597+ mempty: /* @__PURE__ */ mempty(/* @__PURE__ */ monoidRecord2(/* @__PURE__ */ monoidRecordCons2(monoidObject2)()(/* @__PURE__ */ monoidRecordCons1(monoidObject2)()(/* @__PURE__ */ monoidRecordCons22(monoidObject2)()(monoidRecordNil))))),
2598+ Semigroup0: function() {
2599+ return semigroupSkinGrowth;
2600+ }
2601+ };
2602+ var tell2 = /* @__PURE__ */ tell(/* @__PURE__ */ monadTellWriterT(monoidSkinGrowth)(monadIdentity));
2603+ var applicativeWriterT2 = /* @__PURE__ */ applicativeWriterT(monoidSkinGrowth)(applicativeIdentity);
2604+ var pure2 = /* @__PURE__ */ pure(applicativeWriterT2);
2605+ var mempty3 = /* @__PURE__ */ mempty(/* @__PURE__ */ monoidWriterT(applicativeIdentity)(monoidSkinGrowth)(monoidArray));
2606+ var traverse2 = /* @__PURE__ */ traverse(traversableArray)(applicativeWriterT2);
2607+ var traverseWithIndex2 = /* @__PURE__ */ traverseWithIndex(traversableWithIndexObject)(applicativeWriterT2);
2608+ var monoidMutation = {
2609+ mempty: {
2610+ extraSkin: mempty2
2611+ },
2612+ Semigroup0: function() {
2613+ return semigroupMutation;
2614+ }
2615+ };
2616+ var mempty4 = /* @__PURE__ */ mempty(monoidMutation);
2617+ var monoidGenericUI = function(dictMonoid) {
2618+ var mempty52 = mempty(monoidRecord2(monoidRecordCons3(dictMonoid)()(monoidRecordCons4)));
2619+ var semigroupGenericUI1 = semigroupGenericUI(dictMonoid.Semigroup0());
2620+ return function(dictMonoid1) {
2621+ var semigroupGenericUI2 = semigroupGenericUI1(dictMonoid1.Semigroup0());
2622+ return {
2623+ mempty: new UI(mempty52, mempty(dictMonoid1)),
2624+ Semigroup0: function() {
2625+ return semigroupGenericUI2;
2626+ }
2627+ };
2628+ };
2629+ };
2630+ var functorGenericUI = {
2631+ map: function(f) {
2632+ return function(v2) {
2633+ return new UI(v2.value0, f(v2.value1));
2634+ };
2635+ }
2636+ };
2637+ var applyGenericUI = function(dictMonoid) {
2638+ var append3 = append(semigroupRecord3(semigroupRecordCons2(dictMonoid.Semigroup0())));
2639+ return {
2640+ apply: function(v2) {
2641+ return function(v1) {
2642+ return new UI(append3(v2.value0)(v1.value0), v2.value1(v1.value1));
2643+ };
2644+ },
2645+ Functor0: function() {
2646+ return functorGenericUI;
2647+ }
2648+ };
2649+ };
2650+ var bindGenericUI = function(dictMonoid) {
2651+ var append3 = append(semigroupRecord3(semigroupRecordCons2(dictMonoid.Semigroup0())));
2652+ var applyGenericUI1 = applyGenericUI(dictMonoid);
2653+ return {
2654+ bind: function(v2) {
2655+ return function(f) {
2656+ var v1 = f(v2.value1);
2657+ return new UI(append3(v2.value0)(v1.value0), v1.value1);
2658+ };
2659+ },
2660+ Apply0: function() {
2661+ return applyGenericUI1;
2662+ }
2663+ };
2664+ };
2665+ var applicativeGenericUI = function(dictMonoid) {
2666+ var applyGenericUI1 = applyGenericUI(dictMonoid);
2667+ return {
2668+ pure: UI.create(mempty(monoidRecord2(monoidRecordCons3(dictMonoid)()(monoidRecordCons4)))),
2669+ Apply0: function() {
2670+ return applyGenericUI1;
2671+ }
2672+ };
2673+ };
2674+ var text = function(s2) {
2675+ return function(v2) {
2676+ return new UI({
2677+ nerves: mempty1.nerves,
2678+ meat: mempty1.meat,
2679+ hover: mempty1.hover,
2680+ down: mempty1.down,
2681+ children: [new Tuple({
2682+ meat: v2.value0.meat,
2683+ nerves: v2.value0.nerves,
2684+ hover: v2.value0.hover,
2685+ down: v2.value0.down
2686+ }, new Text(s2))]
2687+ }, v2.value1);
2688+ };
2689+ };
2690+ var styleSkinGrowth = function(v2) {
2691+ return foldMap4(function(className) {
2692+ return function(v1) {
2693+ return "." + (className + ("{" + (v1.key + (":" + (v1.value + ";}")))));
2694+ };
2695+ })(v2.meat) + (foldMap4(function(className) {
2696+ return function(v1) {
2697+ return "." + (className + ("{" + (v1.key + (":" + (v1.value + ";}")))));
2698+ };
2699+ })(v2.hover) + foldMap4(function(className) {
2700+ return function(v1) {
2701+ return "." + (className + ("{" + (v1.key + (":" + (v1.value + ";}")))));
2702+ };
2703+ })(v2.down));
2704+ };
2705+ var string = function(elem2) {
2706+ return function(classes) {
2707+ return function(string1) {
2708+ return h2(elem2)({
2709+ attrs: singleton2("class")(intercalate3(" ")(classes)),
2710+ on: empty2,
2711+ style: empty2
2712+ })([])(asOneOf2(string1));
2713+ };
2714+ };
2715+ };
2716+ var stack = function(v2) {
2717+ return new UI({
2718+ nerves: mempty1.nerves,
2719+ meat: mempty1.meat,
2720+ hover: mempty1.hover,
2721+ down: mempty1.down,
2722+ children: [new Tuple({
2723+ meat: v2.value0.meat,
2724+ nerves: v2.value0.nerves,
2725+ hover: v2.value0.hover,
2726+ down: v2.value0.down
2727+ }, new Stack(v2.value0.children))]
2728+ }, v2.value1);
2729+ };
2730+ var sk = function(cName) {
2731+ return function(key) {
2732+ return function(value12) {
2733+ return discard2(tell2({
2734+ meat: singleton2(cName)({
2735+ key,
2736+ value: value12
2737+ }),
2738+ hover: empty2,
2739+ down: empty2
2740+ }))(function() {
2741+ return pure2([cName]);
2742+ });
2743+ };
2744+ };
2745+ };
2746+ var row = function(v2) {
2747+ return new UI({
2748+ nerves: mempty1.nerves,
2749+ meat: mempty1.meat,
2750+ hover: mempty1.hover,
2751+ down: mempty1.down,
2752+ children: [new Tuple({
2753+ meat: v2.value0.meat,
2754+ nerves: v2.value0.nerves,
2755+ hover: v2.value0.hover,
2756+ down: v2.value0.down
2757+ }, new Row(v2.value0.children))]
2758+ }, v2.value1);
2759+ };
2760+ var rgb = function(r2) {
2761+ return function(g2) {
2762+ return function(b2) {
2763+ return {
2764+ r: round2(r2 * 255),
2765+ g: round2(g2 * 255),
2766+ b: round2(b2 * 255),
2767+ a: 100
2768+ };
2769+ };
2770+ };
2771+ };
2772+ var renderKey = function(dict) {
2773+ return dict.renderKey;
2774+ };
2775+ var renderKey1 = /* @__PURE__ */ renderKey(renderableColor);
2776+ var renderKey2 = /* @__PURE__ */ renderKey(renderableSide);
2777+ var renderKey3 = /* @__PURE__ */ renderKey(renderableBorderStyle);
2778+ var renderKey4 = /* @__PURE__ */ renderKey(renderableCorner);
2779+ var render = function(dict) {
2780+ return dict.render;
2781+ };
2782+ var render1 = /* @__PURE__ */ render(renderableColor);
2783+ var render2 = /* @__PURE__ */ render(renderableSide);
2784+ var render3 = /* @__PURE__ */ render(renderableBorderStyle);
2785+ var render4 = /* @__PURE__ */ render(renderableCorner);
2786+ var renderableLength = {
2787+ render: function(v2) {
2788+ if (v2 instanceof Px) {
2789+ return show2(v2.value0) + "px";
2790+ }
2791+ ;
2792+ if (v2 instanceof Fit) {
2793+ return "fit-content";
2794+ }
2795+ ;
2796+ if (v2 instanceof Fill) {
2797+ return "100%";
2798+ }
2799+ ;
2800+ if (v2 instanceof Max2) {
2801+ return "max(" + (show2(v2.value0) + ("px," + (render(renderableLength)(v2.value1) + ")")));
2802+ }
2803+ ;
2804+ if (v2 instanceof Min2) {
2805+ return "min(" + (show2(v2.value0) + ("px," + (render(renderableLength)(v2.value1) + ")")));
2806+ }
2807+ ;
2808+ throw new Error("Failed pattern match at Plum.View (line 494, column 12 - line 499, column 62): " + [v2.constructor.name]);
2809+ },
2810+ renderKey: function(v2) {
2811+ if (v2 instanceof Px) {
2812+ return show2(v2.value0);
2813+ }
2814+ ;
2815+ if (v2 instanceof Fit) {
2816+ return "fit-content";
2817+ }
2818+ ;
2819+ if (v2 instanceof Fill) {
2820+ return "fill";
2821+ }
2822+ ;
2823+ if (v2 instanceof Max2) {
2824+ return "max-" + (show2(v2.value0) + ("-" + renderKey(renderableLength)(v2.value1)));
2825+ }
2826+ ;
2827+ if (v2 instanceof Min2) {
2828+ return "min-" + (show2(v2.value0) + ("-" + renderKey(renderableLength)(v2.value1)));
2829+ }
2830+ ;
2831+ throw new Error("Failed pattern match at Plum.View (line 500, column 15 - line 505, column 56): " + [v2.constructor.name]);
2832+ }
2833+ };
2834+ var renderKey5 = /* @__PURE__ */ renderKey(renderableLength);
2835+ var render5 = /* @__PURE__ */ render(renderableLength);
2836+ var renderableShadow = {
2837+ render: function(v2) {
2838+ return show2(v2.offset.x) + ("px " + (show2(v2.offset.y) + ("px " + (show1(v2.blur) + ("px " + (show1(v2.size) + ("px " + render1(v2.color))))))));
2839+ },
2840+ renderKey: function(v2) {
2841+ return show2(v2.offset.x) + ("-" + (show2(v2.offset.y) + ("-" + (show1(v2.blur) + ("-" + (show1(v2.size) + ("-" + renderKey1(v2.color))))))));
2842+ }
2843+ };
2844+ var renderKey6 = /* @__PURE__ */ renderKey(renderableShadow);
2845+ var render6 = /* @__PURE__ */ render(renderableShadow);
2846+ var removeSpaces = /* @__PURE__ */ replaceAll(" ")("-");
2847+ var skin = function(ctx) {
2848+ return function(v2) {
2849+ if (v2 instanceof Spacing) {
2850+ return sk("spacing-" + (show2(v2.value0) + ("-" + show2(v2.value1))))("gap")(show2(v2.value0) + ("px " + (show2(v2.value1) + "px")));
2851+ }
2852+ ;
2853+ if (v2 instanceof Explain) {
2854+ return sk("explain")("border")("dashed magenta");
2855+ }
2856+ ;
2857+ if (v2 instanceof Align) {
2858+ if (ctx instanceof Generic) {
2859+ return mempty3;
2860+ }
2861+ ;
2862+ if (ctx instanceof Span) {
2863+ return mempty3;
2864+ }
2865+ ;
2866+ if (ctx instanceof Grid) {
2867+ var v1 = function() {
2868+ if (v2.value1 instanceof Start) {
2869+ return "start";
2870+ }
2871+ ;
2872+ if (v2.value1 instanceof Center) {
2873+ return "center";
2874+ }
2875+ ;
2876+ if (v2.value1 instanceof End) {
2877+ return "end";
2878+ }
2879+ ;
2880+ throw new Error("Failed pattern match at Plum.View (line 431, column 13 - line 434, column 27): " + [v2.value1.constructor.name]);
2881+ }();
2882+ var k = function() {
2883+ if (v2.value0 instanceof X) {
2884+ return "justify-items";
2885+ }
2886+ ;
2887+ if (v2.value0 instanceof Y) {
2888+ return "align-items";
2889+ }
2890+ ;
2891+ throw new Error("Failed pattern match at Plum.View (line 426, column 13 - line 428, column 33): " + [v2.value0.constructor.name]);
2892+ }();
2893+ return sk("align-grid-" + (k + ("-" + v1)))(k)(v1);
2894+ }
2895+ ;
2896+ if (ctx instanceof Flexbox) {
2897+ var v1 = function() {
2898+ if (v2.value1 instanceof Start) {
2899+ return "flex-start";
2900+ }
2901+ ;
2902+ if (v2.value1 instanceof Center) {
2903+ return "center";
2904+ }
2905+ ;
2906+ if (v2.value1 instanceof End) {
2907+ return "flex-end";
2908+ }
2909+ ;
2910+ throw new Error("Failed pattern match at Plum.View (line 450, column 13 - line 453, column 32): " + [v2.value1.constructor.name]);
2911+ }();
2912+ var k = function() {
2913+ var v22 = new Tuple(ctx.value0, v2.value0);
2914+ if (v22.value0 instanceof X && v22.value1 instanceof X) {
2915+ return "justify-content";
2916+ }
2917+ ;
2918+ if (v22.value0 instanceof X && v22.value1 instanceof Y) {
2919+ return "align-items";
2920+ }
2921+ ;
2922+ if (v22.value0 instanceof Y && v22.value1 instanceof X) {
2923+ return "align-items";
2924+ }
2925+ ;
2926+ if (v22.value0 instanceof Y && v22.value1 instanceof Y) {
2927+ return "justify-content";
2928+ }
2929+ ;
2930+ throw new Error("Failed pattern match at Plum.View (line 442, column 13 - line 446, column 42): " + [v22.constructor.name]);
2931+ }();
2932+ return sk("align-flexbox-" + (k + ("-" + v1)))(k)(v1);
2933+ }
2934+ ;
2935+ throw new Error("Failed pattern match at Plum.View (line 420, column 26 - line 456, column 51): " + [ctx.constructor.name]);
2936+ }
2937+ ;
2938+ if (v2 instanceof Width) {
2939+ return sk("width-" + renderKey5(v2.value0))("width")(render5(v2.value0));
2940+ }
2941+ ;
2942+ if (v2 instanceof Height) {
2943+ return sk("height-" + renderKey5(v2.value0))("height")(render5(v2.value0));
2944+ }
2945+ ;
2946+ if (v2 instanceof Wrapped) {
2947+ if (ctx instanceof Flexbox) {
2948+ return sk("wrapped")("flex-wrap")("wrap");
2949+ }
2950+ ;
2951+ return pure2([]);
2952+ }
2953+ ;
2954+ if (v2 instanceof BackgroundColor) {
2955+ return sk("bg-color-" + renderKey1(v2.value0))("background-color")(render1(v2.value0));
2956+ }
2957+ ;
2958+ if (v2 instanceof Padding) {
2959+ return sk("padding-" + (renderKey2(v2.value0) + ("-" + show2(v2.value1))))("padding-" + render2(v2.value0))(show2(v2.value1) + "px");
2960+ }
2961+ ;
2962+ if (v2 instanceof Spread) {
2963+ if (ctx instanceof Flexbox) {
2964+ return sk("spread")("justify-content")("space-between");
2965+ }
2966+ ;
2967+ return pure2([]);
2968+ }
2969+ ;
2970+ if (v2 instanceof Opacity) {
2971+ return sk("opacity-" + show1(v2.value0))("opacity")(show1(v2.value0));
2972+ }
2973+ ;
2974+ if (v2 instanceof Pointer) {
2975+ return sk("pointer")("cursor")("pointer");
2976+ }
2977+ ;
2978+ if (v2 instanceof Move) {
2979+ return sk("move-" + (show2(v2.value0.x) + ("-" + show2(v2.value0.y))))("transform")("translate(" + (show2(v2.value0.x) + ("px, " + (show2(v2.value0.y) + "px)"))));
2980+ }
2981+ ;
2982+ if (v2 instanceof Clip && v2.value0 instanceof X) {
2983+ return sk("clip-x")("overflow-x")("hidden");
2984+ }
2985+ ;
2986+ if (v2 instanceof Clip && v2.value0 instanceof Y) {
2987+ return sk("clip-y")("overflow-y")("hidden");
2988+ }
2989+ ;
2990+ if (v2 instanceof BorderWidth) {
2991+ return sk("border-width-" + (renderKey2(v2.value0) + ("-" + show2(v2.value1))))("border-" + (render2(v2.value0) + "-width"))(show2(v2.value1) + "px");
2992+ }
2993+ ;
2994+ if (v2 instanceof BorderStyle) {
2995+ return sk("border-style-" + renderKey3(v2.value0))("border-style")(render3(v2.value0));
2996+ }
2997+ ;
2998+ if (v2 instanceof Round) {
2999+ return sk("round-" + (renderKey4(v2.value0) + ("-" + show2(v2.value1))))("border-" + (render4(v2.value0) + "-radius"))(show2(v2.value1) + "px");
3000+ }
3001+ ;
3002+ if (v2 instanceof Shadow) {
3003+ return sk("shadow-" + renderKey6(v2.value0))("box-shadow")(render6(v2.value0));
3004+ }
3005+ ;
3006+ if (v2 instanceof InnerShadow) {
3007+ return sk("inner-shadow-" + renderKey6(v2.value0))("box-shadow")(render6(v2.value0) + " inset");
3008+ }
3009+ ;
3010+ if (v2 instanceof FontColor) {
3011+ return sk("font-color-" + renderKey1(v2.value0))("color")(render1(v2.value0));
3012+ }
3013+ ;
3014+ if (v2 instanceof FontSize) {
3015+ return sk("font-size-" + show2(v2.value0))("font-size")(show2(v2.value0) + "px");
3016+ }
3017+ ;
3018+ if (v2 instanceof Font) {
3019+ return sk("font-" + removeSpaces(v2.value0))("font-family")(v2.value0);
3020+ }
3021+ ;
3022+ if (v2 instanceof FontWeight) {
3023+ return sk("font-weight-" + show2(v2.value0))("font-weight")(show2(v2.value0));
3024+ }
3025+ ;
3026+ throw new Error("Failed pattern match at Plum.View (line 417, column 12 - line 484, column 71): " + [v2.constructor.name]);
3027+ };
3028+ };
3029+ var m2 = function(dictMonoid) {
3030+ var mempty52 = mempty(monoidRecord2(monoidRecordCons3(dictMonoid)()(monoidRecordCons4)));
3031+ return function(meat) {
3032+ return new UI({
3033+ nerves: mempty52.nerves,
3034+ hover: mempty52.hover,
3035+ down: mempty52.down,
3036+ children: mempty52.children,
3037+ meat: [meat]
3038+ }, mempty22);
3039+ };
3040+ };
3041+ var width = function(dictMonoid) {
3042+ var m1 = m2(dictMonoid);
3043+ return function(l2) {
3044+ return m1(new Width(l2));
3045+ };
3046+ };
3047+ var height = function(dictMonoid) {
3048+ var m1 = m2(dictMonoid);
3049+ return function(l2) {
3050+ return m1(new Height(l2));
3051+ };
3052+ };
3053+ var hWith = function() {
3054+ return function(elem2) {
3055+ return function(props) {
3056+ return function(classes) {
3057+ return function(children) {
3058+ return h2(elem2)({
3059+ attrs: union(fromHomogeneous2(props))(singleton2("class")(intercalate3(" ")(classes))),
3060+ on: empty2,
3061+ style: empty2
3062+ })(children)(asOneOf2($$undefined));
3063+ };
3064+ };
3065+ };
3066+ };
3067+ };
3068+ var hWith1 = /* @__PURE__ */ hWith();
3069+ var h3 = function(elem2) {
3070+ return function(classes) {
3071+ return function(children) {
3072+ return h2(elem2)({
3073+ attrs: singleton2("class")(intercalate3(" ")(classes)),
3074+ on: empty2,
3075+ style: empty2
3076+ })(children)(asOneOf2($$undefined));
3077+ };
3078+ };
3079+ };
3080+ var growSkin = function(fire) {
3081+ return function(v2) {
3082+ return function(v1) {
3083+ var widthFill = [new Width(Fill.value), new Height(Fill.value)];
3084+ var alignCenter = [new Align(X.value, Center.value), new Align(Y.value, Center.value)];
3085+ var skn = function(ctx) {
3086+ return bind2(map2(function($574) {
3087+ return function(v22) {
3088+ return append2(v22)(v2.extraSkin);
3089+ }(concat($574));
3090+ })(traverse2(skin(ctx))(append2(v1.value0.meat)(append2(function() {
3091+ if (ctx instanceof Span) {
3092+ return mempty2;
3093+ }
3094+ ;
3095+ if (ctx instanceof Grid) {
3096+ return widthFill;
3097+ }
3098+ ;
3099+ if (ctx instanceof Flexbox) {
3100+ return widthFill;
3101+ }
3102+ ;
3103+ if (ctx instanceof Generic) {
3104+ return widthFill;
3105+ }
3106+ ;
3107+ throw new Error("Failed pattern match at Plum.View (line 577, column 16 - line 581, column 35): " + [ctx.constructor.name]);
3108+ }())(function() {
3109+ if (ctx instanceof Grid) {
3110+ return alignCenter;
3111+ }
3112+ ;
3113+ if (ctx instanceof Flexbox) {
3114+ return alignCenter;
3115+ }
3116+ ;
3117+ if (ctx instanceof Span) {
3118+ return mempty2;
3119+ }
3120+ ;
3121+ if (ctx instanceof Generic) {
3122+ return alignCenter;
3123+ }
3124+ ;
3125+ throw new Error("Failed pattern match at Plum.View (line 582, column 16 - line 586, column 37): " + [ctx.constructor.name]);
3126+ }())))))(function(meatClasses) {
3127+ var v22 = runWriter(traverse2(skin(ctx))(v1.value0.hover));
3128+ return bind2(traverseWithIndex2(function(key) {
3129+ return function(val) {
3130+ return tell2({
3131+ meat: empty2,
3132+ hover: singleton2(key + "-hover:hover")(val),
3133+ down: empty2
3134+ });
3135+ };
3136+ })(v22.value1.meat))(function() {
3137+ var v3 = runWriter(traverse2(skin(ctx))(v1.value0.down));
3138+ return bind2(traverseWithIndex2(function(key) {
3139+ return function(val) {
3140+ return tell2({
3141+ meat: empty2,
3142+ hover: empty2,
3143+ down: singleton2(key + "-down:active")(val)
3144+ });
3145+ };
3146+ })(v3.value1.meat))(function() {
3147+ return pure2(append2(meatClasses)(append2(map1(function(v4) {
3148+ return v4 + "-hover";
3149+ })(concat(v22.value0)))(map1(function(v4) {
3150+ return v4 + "-down";
3151+ })(concat(v3.value0)))));
3152+ });
3153+ });
3154+ });
3155+ };
3156+ if (v1.value1 instanceof Text) {
3157+ return map2(function(c) {
3158+ return string("span")(c)(v1.value1.value0);
3159+ })(skn(Span.value));
3160+ }
3161+ ;
3162+ if (v1.value1 instanceof Wrapper) {
3163+ return bind2(append22(skn(new Flexbox(X.value)))(append22(sk("display-flex")("display")("flex"))(sk("flex-direction-row")("flex-direction")("row"))))(function(classes) {
3164+ return bind2(growSkin(fire)(mempty4)(v1.value1.value0))(function(x$prime) {
3165+ return pure2(h3("div")(classes)([x$prime]));
3166+ });
3167+ });
3168+ }
3169+ ;
3170+ if (v1.value1 instanceof Stack) {
3171+ return bind2(append22(skn(Grid.value))(sk("display-grid")("display")("grid")))(function(classes) {
3172+ return bind2(append22(sk("grid-row-1")("grid-row")("1"))(sk("grid-column-1")("grid-column")("1")))(function(extraSkin) {
3173+ return bind2(traverse2(growSkin(fire)({
3174+ extraSkin
3175+ }))(v1.value1.value0))(function(children$prime) {
3176+ return pure2(h3("div")(classes)(children$prime));
3177+ });
3178+ });
3179+ });
3180+ }
3181+ ;
3182+ if (v1.value1 instanceof Row) {
3183+ return bind2(append22(skn(new Flexbox(X.value)))(append22(sk("display-flex")("display")("flex"))(sk("flex-direction-row")("flex-direction")("row"))))(function(classes) {
3184+ return bind2(traverse2(growSkin(fire)(mempty4))(v1.value1.value0))(function(children$prime) {
3185+ return pure2(h3("div")(classes)(children$prime));
3186+ });
3187+ });
3188+ }
3189+ ;
3190+ if (v1.value1 instanceof Column) {
3191+ return bind2(append22(skn(new Flexbox(Y.value)))(append22(sk("display-flex")("display")("flex"))(sk("flex-direction-column")("flex-direction")("column"))))(function(classes) {
3192+ return bind2(traverse2(growSkin(fire)(mempty4))(v1.value1.value0))(function(children$prime) {
3193+ return pure2(h3("div")(classes)(children$prime));
3194+ });
3195+ });
3196+ }
3197+ ;
3198+ if (v1.value1 instanceof Link) {
3199+ return bind2(append22(skn(new Flexbox(X.value)))(append22(sk("display-flex")("display")("flex"))(sk("flex-direction-row")("flex-direction")("row"))))(function(classes) {
3200+ return bind2(growSkin(fire)(mempty4)(v1.value1.value2))(function(child$prime) {
3201+ return pure2(hWith1("a")({
3202+ href: v1.value1.value0,
3203+ rel: "noopener noreferrer",
3204+ target: function() {
3205+ if (v1.value1.value1.newTab) {
3206+ return "_blank";
3207+ }
3208+ ;
3209+ return "_self";
3210+ }()
3211+ })(classes)([child$prime]));
3212+ });
3213+ });
3214+ }
3215+ ;
3216+ if (v1.value1 instanceof Download) {
3217+ return bind2(append22(skn(new Flexbox(X.value)))(append22(sk("display-flex")("display")("flex"))(sk("flex-direction-row")("flex-direction")("row"))))(function(classes) {
3218+ return bind2(growSkin(fire)(mempty4)(v1.value1.value2))(function(child$prime) {
3219+ return pure2(hWith1("a")({
3220+ href: v1.value1.value0,
3221+ download: fromMaybe("")(v1.value1.value1.filename)
3222+ })(classes)([child$prime]));
3223+ });
3224+ });
3225+ }
3226+ ;
3227+ if (v1.value1 instanceof Image2) {
3228+ return map2(function(c) {
3229+ return hWith1("img")({
3230+ src: v1.value1.value0,
3231+ alt: v1.value1.value1.description
3232+ })(c)([]);
3233+ })(skn(Generic.value));
3234+ }
3235+ ;
3236+ if (v1.value1 instanceof None) {
3237+ return pure2(h3("div")(mempty2)([]));
3238+ }
3239+ ;
3240+ throw new Error("Failed pattern match at Plum.View (line 609, column 3 - line 650, column 37): " + [v1.value1.constructor.name]);
3241+ };
3242+ };
3243+ };
3244+ var grow = function(fire) {
3245+ return function(v2) {
3246+ var v1 = runWriter(growSkin(fire)(mempty4)(v2));
3247+ return {
3248+ node: v1.value0,
3249+ style: styleSkinGrowth(v1.value1)
3250+ };
3251+ };
3252+ };
3253+ var fontWeight = function(dictMonoid) {
3254+ var m1 = m2(dictMonoid);
3255+ return function(f) {
3256+ return m1(new FontWeight(f));
3257+ };
3258+ };
3259+ var fontSize = function(dictMonoid) {
3260+ var m1 = m2(dictMonoid);
3261+ return function(f) {
3262+ return m1(new FontSize(f));
3263+ };
3264+ };
3265+ var font = function(dictMonoid) {
3266+ var m1 = m2(dictMonoid);
3267+ return function(f) {
3268+ return m1(new Font(f));
3269+ };
3270+ };
3271+ var column = function(v2) {
3272+ return new UI({
3273+ nerves: mempty1.nerves,
3274+ meat: mempty1.meat,
3275+ hover: mempty1.hover,
3276+ down: mempty1.down,
3277+ children: [new Tuple({
3278+ meat: v2.value0.meat,
3279+ nerves: v2.value0.nerves,
3280+ hover: v2.value0.hover,
3281+ down: v2.value0.down
3282+ }, new Column(v2.value0.children))]
3283+ }, unit);
3284+ };
3285+ var bgColor = function(dictMonoid) {
3286+ var m1 = m2(dictMonoid);
3287+ return function(c) {
3288+ return m1(new BackgroundColor(c));
3289+ };
3290+ };
3291+ var align = function(dictMonoid) {
3292+ var m1 = m2(dictMonoid);
3293+ return function(dir2) {
3294+ return function(al) {
3295+ return m1(new Align(dir2, al));
3296+ };
3297+ };
3298+ };
3299+
3300+ // output/Web.DOM.NonElementParentNode/foreign.js
3301+ function _getElementById(id) {
3302+ return function(node) {
3303+ return function() {
3304+ return node.getElementById(id);
3305+ };
3306+ };
3307+ }
3308+
3309+ // output/Data.Nullable/foreign.js
3310+ function nullable(a2, r2, f) {
3311+ return a2 == null ? r2 : f(a2);
3312+ }
3313+
3314+ // output/Data.Nullable/index.js
3315+ var toMaybe = function(n2) {
3316+ return nullable(n2, Nothing.value, Just.create);
3317+ };
3318+
3319+ // output/Web.DOM.NonElementParentNode/index.js
3320+ var map3 = /* @__PURE__ */ map(functorEffect);
3321+ var getElementById = function(eid) {
3322+ var $2 = map3(toMaybe);
3323+ var $3 = _getElementById(eid);
3324+ return function($4) {
3325+ return $2($3($4));
3326+ };
3327+ };
3328+
3329+ // output/Web.HTML/foreign.js
3330+ var windowImpl = function() {
3331+ return window;
3332+ };
3333+
3334+ // output/Web.HTML.HTMLDocument/index.js
3335+ var toNonElementParentNode = unsafeCoerce2;
3336+
3337+ // output/Web.HTML.Window/foreign.js
3338+ function document2(window2) {
3339+ return function() {
3340+ return window2.document;
3341+ };
3342+ }
3343+
3344+ // output/Plum/index.js
3345+ var bind3 = /* @__PURE__ */ bind(bindEffect);
3346+ var pure3 = /* @__PURE__ */ pure(applicativeEffect);
3347+ var asOneOf3 = /* @__PURE__ */ asOneOf();
3348+ var outerStyle = "html,body{height:100%;padding:0;margin:0;}";
3349+ var run3 = function(id) {
3350+ return function(plum2) {
3351+ return function __do() {
3352+ var initModel = plum2.init();
3353+ var modelRef = $$new(initModel)();
3354+ var v2 = bind3(bind3(windowImpl)(document2))(function() {
3355+ var $23 = getElementById(id);
3356+ return function($24) {
3357+ return $23(toNonElementParentNode($24));
3358+ };
3359+ }())();
3360+ if (v2 instanceof Just) {
3361+ var patch = init();
3362+ var view = function(model) {
3363+ var v1 = plum2.view(model);
3364+ var v22 = uncons(v1.value0.children);
3365+ if (v22 instanceof Just) {
3366+ var v3 = grow(function(msg) {
3367+ return function __do2() {
3368+ var m3 = read(modelRef)();
3369+ var m_ = plum2.update(msg)(m3)();
3370+ write(m_)(modelRef)();
3371+ var node2 = view(m_)();
3372+ patch(v2.value0)(node2)();
3373+ return unit;
3374+ };
3375+ })(v22.value0.head);
3376+ return pure3(h2("div")({
3377+ attrs: empty2,
3378+ on: empty2,
3379+ style: empty2
3380+ })([h2("style")({
3381+ attrs: empty2,
3382+ on: empty2,
3383+ style: empty2
3384+ })([])(asOneOf3(outerStyle + v3.style)), v3.node])(asOneOf3($$undefined)));
3385+ }
3386+ ;
3387+ if (v22 instanceof Nothing) {
3388+ return pure3(h2("div")({
3389+ attrs: empty2,
3390+ on: empty2,
3391+ style: empty2
3392+ })([])(asOneOf3($$undefined)));
3393+ }
3394+ ;
3395+ throw new Error("Failed pattern match at Plum (line 38, column 11 - line 74, column 36): " + [v22.constructor.name]);
3396+ };
3397+ var node = view(initModel)();
3398+ patch(v2.value0)(node)();
3399+ return unit;
3400+ }
3401+ ;
3402+ if (v2 instanceof Nothing) {
3403+ return unit;
3404+ }
3405+ ;
3406+ throw new Error("Failed pattern match at Plum (line 32, column 92 - line 79, column 25): " + [v2.constructor.name]);
3407+ };
3408+ };
3409+ };
3410+
3411+ // output/Main/index.js
3412+ var pure4 = /* @__PURE__ */ pure(applicativeEffect);
3413+ var discard3 = /* @__PURE__ */ discard(discardUnit);
3414+ var discard1 = /* @__PURE__ */ discard3(/* @__PURE__ */ bindGenericUI(monoidArray));
3415+ var align2 = /* @__PURE__ */ align(monoidArray);
3416+ var height9 = /* @__PURE__ */ height(monoidArray);
3417+ var bgColor2 = /* @__PURE__ */ bgColor(monoidArray);
3418+ var mempty5 = /* @__PURE__ */ mempty(/* @__PURE__ */ monoidGenericUI(monoidArray)(monoidUnit));
3419+ var pure1 = /* @__PURE__ */ pure(/* @__PURE__ */ applicativeGenericUI(monoidArray));
3420+ var font2 = /* @__PURE__ */ font(monoidArray);
3421+ var width9 = /* @__PURE__ */ width(monoidArray);
3422+ var discard22 = /* @__PURE__ */ discard3(/* @__PURE__ */ bindGenericUI(monoidUnit));
3423+ var fontSize2 = /* @__PURE__ */ fontSize(monoidUnit);
3424+ var fontWeight2 = /* @__PURE__ */ fontWeight(monoidUnit);
3425+ var plum = {
3426+ init: /* @__PURE__ */ pure4({
3427+ text: "Test"
3428+ }),
3429+ view: function(model) {
3430+ return stack(discard1(align2(Y.value)(End.value))(function() {
3431+ return discard1(height9(Fit.value))(function() {
3432+ return discard1(row(discard1(align2(Y.value)(End.value))(function() {
3433+ return discard1(column(discard1(bgColor2(rgb(0)(0)(0)))(function() {
3434+ return height9(new Px(10));
3435+ })))(function() {
3436+ return discard1(column(mempty5))(function() {
3437+ return pure1(unit);
3438+ });
3439+ });
3440+ })))(function() {
3441+ return discard1(column(discard1(font2("sans-serif"))(function() {
3442+ return discard1(column(discard1(height9(new Px(100)))(function() {
3443+ return width9(Fit.value);
3444+ })))(function() {
3445+ return discard1(align2(Y.value)(Start.value))(function() {
3446+ return discard1(width9(Fill.value))(function() {
3447+ return column(discard1(width9(Fill.value))(function() {
3448+ return discard1(width9(Fit.value))(function() {
3449+ return discard1(height9(Fit.value))(function() {
3450+ return discard1(text("PureStack")(discard22(fontSize2(72))(function() {
3451+ return fontWeight2(1e3);
3452+ })))(function() {
3453+ return column(discard1(bgColor2(rgb(0)(0)(0)))(function() {
3454+ return discard1(height9(new Px(10)))(function() {
3455+ return width9(Fill.value);
3456+ });
3457+ }));
3458+ });
3459+ });
3460+ });
3461+ }));
3462+ });
3463+ });
3464+ });
3465+ })))(function() {
3466+ return column(width9(Fill.value));
3467+ });
3468+ });
3469+ });
3470+ }));
3471+ },
3472+ update: function(msg) {
3473+ return function(model) {
3474+ return pure4({
3475+ text: "Button pressed"
3476+ });
3477+ };
3478+ }
3479+ };
3480+ var main = /* @__PURE__ */ run3("plum")(plum);
3481+
3482+ // <stdin>
3483+ main();
3484+})();