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