@@ -0,0 +1,3476 @@
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 _lookup(no, yes, k, m2) {
1987+ return k in m2 ? yes(m2[k]) : no;
1988+ }
1989+ function toArrayWithKey(f) {
1990+ return function(m2) {
1991+ var r = [];
1992+ for (var k in m2) {
1993+ if (hasOwnProperty.call(m2, k)) {
1994+ r.push(f(k)(m2[k]));
1995+ }
1996+ }
1997+ return r;
1998+ };
1999+ }
2000+ var keys = Object.keys || toArrayWithKey(function(k) {
2001+ return function() {
2002+ return k;
2003+ };
2004+ });
2005+
2006+ // output/Foreign.Object.ST/foreign.js
2007+ var newImpl = function() {
2008+ return {};
2009+ };
2010+ function poke2(k) {
2011+ return function(v) {
2012+ return function(m2) {
2013+ return function() {
2014+ m2[k] = v;
2015+ return m2;
2016+ };
2017+ };
2018+ };
2019+ }
2020+
2021+ // output/Foreign.Object/index.js
2022+ var bindFlipped2 = /* @__PURE__ */ bindFlipped(bindST);
2023+ var foldr2 = /* @__PURE__ */ foldr(foldableArray);
2024+ var identity4 = /* @__PURE__ */ identity(categoryFn);
2025+ var values = /* @__PURE__ */ toArrayWithKey(function(v) {
2026+ return function(v1) {
2027+ return v1;
2028+ };
2029+ });
2030+ var thawST = _copyST;
2031+ var singleton2 = function(k) {
2032+ return function(v) {
2033+ return runST(bindFlipped2(poke2(k)(v))(newImpl));
2034+ };
2035+ };
2036+ var mutate = function(f) {
2037+ return function(m2) {
2038+ return runST(function __do() {
2039+ var s = thawST(m2)();
2040+ f(s)();
2041+ return s;
2042+ });
2043+ };
2044+ };
2045+ var mapWithKey = function(f) {
2046+ return function(m2) {
2047+ return _mapWithKey(m2, f);
2048+ };
2049+ };
2050+ var insert = function(k) {
2051+ return function(v) {
2052+ return mutate(poke2(k)(v));
2053+ };
2054+ };
2055+ var functorObject = {
2056+ map: function(f) {
2057+ return function(m2) {
2058+ return _fmapObject(m2, f);
2059+ };
2060+ }
2061+ };
2062+ var functorWithIndexObject = {
2063+ mapWithIndex: mapWithKey,
2064+ Functor0: function() {
2065+ return functorObject;
2066+ }
2067+ };
2068+ var foldM = function(dictMonad) {
2069+ var bind1 = bind(dictMonad.Bind1());
2070+ var pure1 = pure(dictMonad.Applicative0());
2071+ return function(f) {
2072+ return function(z) {
2073+ return _foldM(bind1)(f)(pure1(z));
2074+ };
2075+ };
2076+ };
2077+ var foldM1 = /* @__PURE__ */ foldM(monadST);
2078+ var union = function(m2) {
2079+ return mutate(function(s) {
2080+ return foldM1(function(s$prime) {
2081+ return function(k) {
2082+ return function(v) {
2083+ return poke2(k)(v)(s$prime);
2084+ };
2085+ };
2086+ })(s)(m2);
2087+ });
2088+ };
2089+ var unionWith = function(f) {
2090+ return function(m1) {
2091+ return function(m2) {
2092+ return mutate(function(s1) {
2093+ return foldM1(function(s2) {
2094+ return function(k) {
2095+ return function(v1) {
2096+ return poke2(k)(_lookup(v1, function(v2) {
2097+ return f(v1)(v2);
2098+ }, k, m2))(s2);
2099+ };
2100+ };
2101+ })(s1)(m1);
2102+ })(m2);
2103+ };
2104+ };
2105+ };
2106+ var semigroupObject = function(dictSemigroup) {
2107+ return {
2108+ append: unionWith(append(dictSemigroup))
2109+ };
2110+ };
2111+ var monoidObject = function(dictSemigroup) {
2112+ var semigroupObject1 = semigroupObject(dictSemigroup);
2113+ return {
2114+ mempty: empty2,
2115+ Semigroup0: function() {
2116+ return semigroupObject1;
2117+ }
2118+ };
2119+ };
2120+ var fold2 = /* @__PURE__ */ _foldM(applyFlipped);
2121+ var foldMap2 = function(dictMonoid) {
2122+ var append1 = append(dictMonoid.Semigroup0());
2123+ var mempty6 = mempty(dictMonoid);
2124+ return function(f) {
2125+ return fold2(function(acc) {
2126+ return function(k) {
2127+ return function(v) {
2128+ return append1(acc)(f(k)(v));
2129+ };
2130+ };
2131+ })(mempty6);
2132+ };
2133+ };
2134+ var foldableObject = {
2135+ foldl: function(f) {
2136+ return fold2(function(z) {
2137+ return function(v) {
2138+ return f(z);
2139+ };
2140+ });
2141+ },
2142+ foldr: function(f) {
2143+ return function(z) {
2144+ return function(m2) {
2145+ return foldr2(f)(z)(values(m2));
2146+ };
2147+ };
2148+ },
2149+ foldMap: function(dictMonoid) {
2150+ var foldMap1 = foldMap2(dictMonoid);
2151+ return function(f) {
2152+ return foldMap1($$const(f));
2153+ };
2154+ }
2155+ };
2156+ var foldableWithIndexObject = {
2157+ foldlWithIndex: function(f) {
2158+ return fold2(flip(f));
2159+ },
2160+ foldrWithIndex: function(f) {
2161+ return function(z) {
2162+ return function(m2) {
2163+ return foldr2(uncurry(f))(z)(toArrayWithKey(Tuple.create)(m2));
2164+ };
2165+ };
2166+ },
2167+ foldMapWithIndex: function(dictMonoid) {
2168+ return foldMap2(dictMonoid);
2169+ },
2170+ Foldable0: function() {
2171+ return foldableObject;
2172+ }
2173+ };
2174+ var traversableWithIndexObject = {
2175+ traverseWithIndex: function(dictApplicative) {
2176+ var Apply0 = dictApplicative.Apply0();
2177+ var apply2 = apply(Apply0);
2178+ var map4 = map(Apply0.Functor0());
2179+ var pure1 = pure(dictApplicative);
2180+ return function(f) {
2181+ return function(ms) {
2182+ return fold2(function(acc) {
2183+ return function(k) {
2184+ return function(v) {
2185+ return apply2(map4(flip(insert(k)))(acc))(f(k)(v));
2186+ };
2187+ };
2188+ })(pure1(empty2))(ms);
2189+ };
2190+ };
2191+ },
2192+ FunctorWithIndex0: function() {
2193+ return functorWithIndexObject;
2194+ },
2195+ FoldableWithIndex1: function() {
2196+ return foldableWithIndexObject;
2197+ },
2198+ Traversable2: function() {
2199+ return traversableObject;
2200+ }
2201+ };
2202+ var traversableObject = {
2203+ traverse: function(dictApplicative) {
2204+ var $96 = traverseWithIndex(traversableWithIndexObject)(dictApplicative);
2205+ return function($97) {
2206+ return $96($$const($97));
2207+ };
2208+ },
2209+ sequence: function(dictApplicative) {
2210+ return traverse(traversableObject)(dictApplicative)(identity4);
2211+ },
2212+ Functor0: function() {
2213+ return functorObject;
2214+ },
2215+ Foldable1: function() {
2216+ return foldableObject;
2217+ }
2218+ };
2219+
2220+ // output/Record.Unsafe.Union/foreign.js
2221+ function unsafeUnionFn(r1, r2) {
2222+ var copy = {};
2223+ for (var k1 in r2) {
2224+ if ({}.hasOwnProperty.call(r2, k1)) {
2225+ copy[k1] = r2[k1];
2226+ }
2227+ }
2228+ for (var k2 in r1) {
2229+ if ({}.hasOwnProperty.call(r1, k2)) {
2230+ copy[k2] = r1[k2];
2231+ }
2232+ }
2233+ return copy;
2234+ }
2235+
2236+ // output/Record.Unsafe.Union/index.js
2237+ var unsafeUnion = /* @__PURE__ */ runFn2(unsafeUnionFn);
2238+
2239+ // output/Plum.View/index.js
2240+ var append2 = /* @__PURE__ */ append(semigroupArray);
2241+ var semigroupRecord3 = /* @__PURE__ */ semigroupRecord();
2242+ var childrenIsSymbol = {
2243+ reflectSymbol: function() {
2244+ return "children";
2245+ }
2246+ };
2247+ var downIsSymbol = {
2248+ reflectSymbol: function() {
2249+ return "down";
2250+ }
2251+ };
2252+ var hoverIsSymbol = {
2253+ reflectSymbol: function() {
2254+ return "hover";
2255+ }
2256+ };
2257+ var meatIsSymbol = {
2258+ reflectSymbol: function() {
2259+ return "meat";
2260+ }
2261+ };
2262+ var nervesIsSymbol = {
2263+ reflectSymbol: function() {
2264+ return "nerves";
2265+ }
2266+ };
2267+ var semigroupRecordCons2 = /* @__PURE__ */ semigroupRecordCons(childrenIsSymbol)()(/* @__PURE__ */ semigroupRecordCons(downIsSymbol)()(/* @__PURE__ */ semigroupRecordCons(hoverIsSymbol)()(/* @__PURE__ */ semigroupRecordCons(meatIsSymbol)()(/* @__PURE__ */ semigroupRecordCons(nervesIsSymbol)()(semigroupRecordNil)(semigroupArray))(semigroupArray))(semigroupArray))(semigroupArray));
2268+ var show2 = /* @__PURE__ */ show(showInt);
2269+ var monoidRecord2 = /* @__PURE__ */ monoidRecord();
2270+ var monoidRecordCons2 = /* @__PURE__ */ monoidRecordCons(downIsSymbol);
2271+ var monoidObject2 = /* @__PURE__ */ monoidObject(/* @__PURE__ */ semigroupRecord3(/* @__PURE__ */ semigroupRecordCons({
2272+ reflectSymbol: function() {
2273+ return "key";
2274+ }
2275+ })()(/* @__PURE__ */ semigroupRecordCons({
2276+ reflectSymbol: function() {
2277+ return "value";
2278+ }
2279+ })()(semigroupRecordNil)(semigroupString))(semigroupString)));
2280+ var monoidRecordCons1 = /* @__PURE__ */ monoidRecordCons(hoverIsSymbol);
2281+ var monoidRecordCons22 = /* @__PURE__ */ monoidRecordCons(meatIsSymbol);
2282+ var mempty2 = /* @__PURE__ */ mempty(monoidArray);
2283+ var monoidRecordCons3 = /* @__PURE__ */ monoidRecordCons(childrenIsSymbol);
2284+ var monoidRecordCons4 = /* @__PURE__ */ monoidRecordCons2(monoidArray)()(/* @__PURE__ */ monoidRecordCons1(monoidArray)()(/* @__PURE__ */ monoidRecordCons22(monoidArray)()(/* @__PURE__ */ monoidRecordCons(nervesIsSymbol)(monoidArray)()(monoidRecordNil))));
2285+ var mempty1 = /* @__PURE__ */ mempty(/* @__PURE__ */ monoidRecord2(/* @__PURE__ */ monoidRecordCons3(monoidArray)()(monoidRecordCons4)));
2286+ var foldMap3 = /* @__PURE__ */ foldMap2(monoidString);
2287+ var show1 = /* @__PURE__ */ show(showNumber);
2288+ var mempty22 = /* @__PURE__ */ mempty(monoidUnit);
2289+ var intercalate3 = /* @__PURE__ */ intercalate2(monoidString);
2290+ var map2 = /* @__PURE__ */ map(/* @__PURE__ */ functorWriterT(functorIdentity));
2291+ var map1 = /* @__PURE__ */ map(functorArray);
2292+ var Top = /* @__PURE__ */ function() {
2293+ function Top2() {
2294+ }
2295+ ;
2296+ Top2.value = new Top2();
2297+ return Top2;
2298+ }();
2299+ var Right2 = /* @__PURE__ */ function() {
2300+ function Right3() {
2301+ }
2302+ ;
2303+ Right3.value = new Right3();
2304+ return Right3;
2305+ }();
2306+ var Bottom = /* @__PURE__ */ function() {
2307+ function Bottom2() {
2308+ }
2309+ ;
2310+ Bottom2.value = new Bottom2();
2311+ return Bottom2;
2312+ }();
2313+ var Left2 = /* @__PURE__ */ function() {
2314+ function Left3() {
2315+ }
2316+ ;
2317+ Left3.value = new Left3();
2318+ return Left3;
2319+ }();
2320+ var Px = /* @__PURE__ */ function() {
2321+ function Px2(value0) {
2322+ this.value0 = value0;
2323+ }
2324+ ;
2325+ Px2.create = function(value0) {
2326+ return new Px2(value0);
2327+ };
2328+ return Px2;
2329+ }();
2330+ var Fill = /* @__PURE__ */ function() {
2331+ function Fill2() {
2332+ }
2333+ ;
2334+ Fill2.value = new Fill2();
2335+ return Fill2;
2336+ }();
2337+ var Fit = /* @__PURE__ */ function() {
2338+ function Fit2() {
2339+ }
2340+ ;
2341+ Fit2.value = new Fit2();
2342+ return Fit2;
2343+ }();
2344+ var Max2 = /* @__PURE__ */ function() {
2345+ function Max3(value0, value1) {
2346+ this.value0 = value0;
2347+ this.value1 = value1;
2348+ }
2349+ ;
2350+ Max3.create = function(value0) {
2351+ return function(value1) {
2352+ return new Max3(value0, value1);
2353+ };
2354+ };
2355+ return Max3;
2356+ }();
2357+ var Min2 = /* @__PURE__ */ function() {
2358+ function Min3(value0, value1) {
2359+ this.value0 = value0;
2360+ this.value1 = value1;
2361+ }
2362+ ;
2363+ Min3.create = function(value0) {
2364+ return function(value1) {
2365+ return new Min3(value0, value1);
2366+ };
2367+ };
2368+ return Min3;
2369+ }();
2370+ var X = /* @__PURE__ */ function() {
2371+ function X2() {
2372+ }
2373+ ;
2374+ X2.value = new X2();
2375+ return X2;
2376+ }();
2377+ var Y = /* @__PURE__ */ function() {
2378+ function Y2() {
2379+ }
2380+ ;
2381+ Y2.value = new Y2();
2382+ return Y2;
2383+ }();
2384+ var Grid = /* @__PURE__ */ function() {
2385+ function Grid2() {
2386+ }
2387+ ;
2388+ Grid2.value = new Grid2();
2389+ return Grid2;
2390+ }();
2391+ var Flexbox = /* @__PURE__ */ function() {
2392+ function Flexbox2(value0) {
2393+ this.value0 = value0;
2394+ }
2395+ ;
2396+ Flexbox2.create = function(value0) {
2397+ return new Flexbox2(value0);
2398+ };
2399+ return Flexbox2;
2400+ }();
2401+ var Generic = /* @__PURE__ */ function() {
2402+ function Generic2() {
2403+ }
2404+ ;
2405+ Generic2.value = new Generic2();
2406+ return Generic2;
2407+ }();
2408+ var Span = /* @__PURE__ */ function() {
2409+ function Span2() {
2410+ }
2411+ ;
2412+ Span2.value = new Span2();
2413+ return Span2;
2414+ }();
2415+ var Start = /* @__PURE__ */ function() {
2416+ function Start2() {
2417+ }
2418+ ;
2419+ Start2.value = new Start2();
2420+ return Start2;
2421+ }();
2422+ var Center = /* @__PURE__ */ function() {
2423+ function Center2() {
2424+ }
2425+ ;
2426+ Center2.value = new Center2();
2427+ return Center2;
2428+ }();
2429+ var End = /* @__PURE__ */ function() {
2430+ function End2() {
2431+ }
2432+ ;
2433+ End2.value = new End2();
2434+ return End2;
2435+ }();
2436+ var Spacing = /* @__PURE__ */ function() {
2437+ function Spacing2(value0, value1) {
2438+ this.value0 = value0;
2439+ this.value1 = value1;
2440+ }
2441+ ;
2442+ Spacing2.create = function(value0) {
2443+ return function(value1) {
2444+ return new Spacing2(value0, value1);
2445+ };
2446+ };
2447+ return Spacing2;
2448+ }();
2449+ var Explain = /* @__PURE__ */ function() {
2450+ function Explain2() {
2451+ }
2452+ ;
2453+ Explain2.value = new Explain2();
2454+ return Explain2;
2455+ }();
2456+ var Align = /* @__PURE__ */ function() {
2457+ function Align2(value0, value1) {
2458+ this.value0 = value0;
2459+ this.value1 = value1;
2460+ }
2461+ ;
2462+ Align2.create = function(value0) {
2463+ return function(value1) {
2464+ return new Align2(value0, value1);
2465+ };
2466+ };
2467+ return Align2;
2468+ }();
2469+ var Width = /* @__PURE__ */ function() {
2470+ function Width2(value0) {
2471+ this.value0 = value0;
2472+ }
2473+ ;
2474+ Width2.create = function(value0) {
2475+ return new Width2(value0);
2476+ };
2477+ return Width2;
2478+ }();
2479+ var Height = /* @__PURE__ */ function() {
2480+ function Height2(value0) {
2481+ this.value0 = value0;
2482+ }
2483+ ;
2484+ Height2.create = function(value0) {
2485+ return new Height2(value0);
2486+ };
2487+ return Height2;
2488+ }();
2489+ var Wrapped = /* @__PURE__ */ function() {
2490+ function Wrapped2() {
2491+ }
2492+ ;
2493+ Wrapped2.value = new Wrapped2();
2494+ return Wrapped2;
2495+ }();
2496+ var BackgroundColor = /* @__PURE__ */ function() {
2497+ function BackgroundColor2(value0) {
2498+ this.value0 = value0;
2499+ }
2500+ ;
2501+ BackgroundColor2.create = function(value0) {
2502+ return new BackgroundColor2(value0);
2503+ };
2504+ return BackgroundColor2;
2505+ }();
2506+ var Padding = /* @__PURE__ */ function() {
2507+ function Padding2(value0, value1) {
2508+ this.value0 = value0;
2509+ this.value1 = value1;
2510+ }
2511+ ;
2512+ Padding2.create = function(value0) {
2513+ return function(value1) {
2514+ return new Padding2(value0, value1);
2515+ };
2516+ };
2517+ return Padding2;
2518+ }();
2519+ var Spread = /* @__PURE__ */ function() {
2520+ function Spread2() {
2521+ }
2522+ ;
2523+ Spread2.value = new Spread2();
2524+ return Spread2;
2525+ }();
2526+ var Opacity = /* @__PURE__ */ function() {
2527+ function Opacity2(value0) {
2528+ this.value0 = value0;
2529+ }
2530+ ;
2531+ Opacity2.create = function(value0) {
2532+ return new Opacity2(value0);
2533+ };
2534+ return Opacity2;
2535+ }();
2536+ var Pointer = /* @__PURE__ */ function() {
2537+ function Pointer2() {
2538+ }
2539+ ;
2540+ Pointer2.value = new Pointer2();
2541+ return Pointer2;
2542+ }();
2543+ var Move = /* @__PURE__ */ function() {
2544+ function Move2(value0) {
2545+ this.value0 = value0;
2546+ }
2547+ ;
2548+ Move2.create = function(value0) {
2549+ return new Move2(value0);
2550+ };
2551+ return Move2;
2552+ }();
2553+ var Clip = /* @__PURE__ */ function() {
2554+ function Clip2(value0) {
2555+ this.value0 = value0;
2556+ }
2557+ ;
2558+ Clip2.create = function(value0) {
2559+ return new Clip2(value0);
2560+ };
2561+ return Clip2;
2562+ }();
2563+ var UI = /* @__PURE__ */ function() {
2564+ function UI2(value0, value1) {
2565+ this.value0 = value0;
2566+ this.value1 = value1;
2567+ }
2568+ ;
2569+ UI2.create = function(value0) {
2570+ return function(value1) {
2571+ return new UI2(value0, value1);
2572+ };
2573+ };
2574+ return UI2;
2575+ }();
2576+ var Column = /* @__PURE__ */ function() {
2577+ function Column2(value0) {
2578+ this.value0 = value0;
2579+ }
2580+ ;
2581+ Column2.create = function(value0) {
2582+ return new Column2(value0);
2583+ };
2584+ return Column2;
2585+ }();
2586+ var Row = /* @__PURE__ */ function() {
2587+ function Row2(value0) {
2588+ this.value0 = value0;
2589+ }
2590+ ;
2591+ Row2.create = function(value0) {
2592+ return new Row2(value0);
2593+ };
2594+ return Row2;
2595+ }();
2596+ var Stack = /* @__PURE__ */ function() {
2597+ function Stack2(value0) {
2598+ this.value0 = value0;
2599+ }
2600+ ;
2601+ Stack2.create = function(value0) {
2602+ return new Stack2(value0);
2603+ };
2604+ return Stack2;
2605+ }();
2606+ var Wrapper = /* @__PURE__ */ function() {
2607+ function Wrapper2(value0) {
2608+ this.value0 = value0;
2609+ }
2610+ ;
2611+ Wrapper2.create = function(value0) {
2612+ return new Wrapper2(value0);
2613+ };
2614+ return Wrapper2;
2615+ }();
2616+ var Text = /* @__PURE__ */ function() {
2617+ function Text2(value0) {
2618+ this.value0 = value0;
2619+ }
2620+ ;
2621+ Text2.create = function(value0) {
2622+ return new Text2(value0);
2623+ };
2624+ return Text2;
2625+ }();
2626+ var Link = /* @__PURE__ */ function() {
2627+ function Link2(value0, value1, value22) {
2628+ this.value0 = value0;
2629+ this.value1 = value1;
2630+ this.value2 = value22;
2631+ }
2632+ ;
2633+ Link2.create = function(value0) {
2634+ return function(value1) {
2635+ return function(value22) {
2636+ return new Link2(value0, value1, value22);
2637+ };
2638+ };
2639+ };
2640+ return Link2;
2641+ }();
2642+ var Download = /* @__PURE__ */ function() {
2643+ function Download2(value0, value1, value22) {
2644+ this.value0 = value0;
2645+ this.value1 = value1;
2646+ this.value2 = value22;
2647+ }
2648+ ;
2649+ Download2.create = function(value0) {
2650+ return function(value1) {
2651+ return function(value22) {
2652+ return new Download2(value0, value1, value22);
2653+ };
2654+ };
2655+ };
2656+ return Download2;
2657+ }();
2658+ var Image2 = /* @__PURE__ */ function() {
2659+ function Image3(value0, value1) {
2660+ this.value0 = value0;
2661+ this.value1 = value1;
2662+ }
2663+ ;
2664+ Image3.create = function(value0) {
2665+ return function(value1) {
2666+ return new Image3(value0, value1);
2667+ };
2668+ };
2669+ return Image3;
2670+ }();
2671+ var None = /* @__PURE__ */ function() {
2672+ function None3() {
2673+ }
2674+ ;
2675+ None3.value = new None3();
2676+ return None3;
2677+ }();
2678+ var semigroupSkinGrowth = {
2679+ append: function(v) {
2680+ return function(v1) {
2681+ return {
2682+ meat: union(v.meat)(v1.meat),
2683+ hover: union(v.hover)(v1.hover),
2684+ down: union(v.down)(v1.down)
2685+ };
2686+ };
2687+ }
2688+ };
2689+ var bindWriterT2 = /* @__PURE__ */ bindWriterT(semigroupSkinGrowth)(bindIdentity);
2690+ var discard2 = /* @__PURE__ */ discard(discardUnit)(bindWriterT2);
2691+ var bind2 = /* @__PURE__ */ bind(bindWriterT2);
2692+ var append22 = /* @__PURE__ */ append(/* @__PURE__ */ semigroupWriterT(applyIdentity)(semigroupSkinGrowth)(semigroupArray));
2693+ var semigroupMutation = {
2694+ append: function(v) {
2695+ return function(v1) {
2696+ return {
2697+ extraSkin: append2(v.extraSkin)(v1.extraSkin)
2698+ };
2699+ };
2700+ }
2701+ };
2702+ var semigroupGenericUI = function(dictSemigroup) {
2703+ var append3 = append(semigroupRecord3(semigroupRecordCons2(dictSemigroup)));
2704+ return function(dictSemigroup1) {
2705+ var append4 = append(dictSemigroup1);
2706+ return {
2707+ append: function(v) {
2708+ return function(v1) {
2709+ return new UI(append3(v.value0)(v1.value0), append4(v.value1)(v1.value1));
2710+ };
2711+ }
2712+ };
2713+ };
2714+ };
2715+ var renderableSide = {
2716+ render: function(v) {
2717+ if (v instanceof Top) {
2718+ return "top";
2719+ }
2720+ ;
2721+ if (v instanceof Right2) {
2722+ return "right";
2723+ }
2724+ ;
2725+ if (v instanceof Bottom) {
2726+ return "bottom";
2727+ }
2728+ ;
2729+ if (v instanceof Left2) {
2730+ return "left";
2731+ }
2732+ ;
2733+ throw new Error("Failed pattern match at Plum.View (line 263, column 12 - line 267, column 19): " + [v.constructor.name]);
2734+ },
2735+ renderKey: function(v) {
2736+ if (v instanceof Top) {
2737+ return "top";
2738+ }
2739+ ;
2740+ if (v instanceof Right2) {
2741+ return "right";
2742+ }
2743+ ;
2744+ if (v instanceof Bottom) {
2745+ return "bottom";
2746+ }
2747+ ;
2748+ if (v instanceof Left2) {
2749+ return "left";
2750+ }
2751+ ;
2752+ throw new Error("Failed pattern match at Plum.View (line 268, column 15 - line 272, column 19): " + [v.constructor.name]);
2753+ }
2754+ };
2755+ var renderableColor = {
2756+ render: function(v) {
2757+ return "rgb(" + (show2(v.r) + ("," + (show2(v.g) + ("," + (show2(v.b) + ("," + (show2(v.a) + "%)")))))));
2758+ },
2759+ renderKey: function(v) {
2760+ return show2(v.r) + ("-" + (show2(v.g) + ("-" + (show2(v.b) + ("-" + show2(v.a))))));
2761+ }
2762+ };
2763+ var monoidSkinGrowth = {
2764+ mempty: /* @__PURE__ */ mempty(/* @__PURE__ */ monoidRecord2(/* @__PURE__ */ monoidRecordCons2(monoidObject2)()(/* @__PURE__ */ monoidRecordCons1(monoidObject2)()(/* @__PURE__ */ monoidRecordCons22(monoidObject2)()(monoidRecordNil))))),
2765+ Semigroup0: function() {
2766+ return semigroupSkinGrowth;
2767+ }
2768+ };
2769+ var tell2 = /* @__PURE__ */ tell(/* @__PURE__ */ monadTellWriterT(monoidSkinGrowth)(monadIdentity));
2770+ var applicativeWriterT2 = /* @__PURE__ */ applicativeWriterT(monoidSkinGrowth)(applicativeIdentity);
2771+ var pure2 = /* @__PURE__ */ pure(applicativeWriterT2);
2772+ var mempty3 = /* @__PURE__ */ mempty(/* @__PURE__ */ monoidWriterT(applicativeIdentity)(monoidSkinGrowth)(monoidArray));
2773+ var traverse2 = /* @__PURE__ */ traverse(traversableArray)(applicativeWriterT2);
2774+ var traverseWithIndex2 = /* @__PURE__ */ traverseWithIndex(traversableWithIndexObject)(applicativeWriterT2);
2775+ var monoidMutation = {
2776+ mempty: {
2777+ extraSkin: mempty2
2778+ },
2779+ Semigroup0: function() {
2780+ return semigroupMutation;
2781+ }
2782+ };
2783+ var mempty4 = /* @__PURE__ */ mempty(monoidMutation);
2784+ var monoidGenericUI = function(dictMonoid) {
2785+ var mempty52 = mempty(monoidRecord2(monoidRecordCons3(dictMonoid)()(monoidRecordCons4)));
2786+ var semigroupGenericUI1 = semigroupGenericUI(dictMonoid.Semigroup0());
2787+ return function(dictMonoid1) {
2788+ var semigroupGenericUI2 = semigroupGenericUI1(dictMonoid1.Semigroup0());
2789+ return {
2790+ mempty: new UI(mempty52, mempty(dictMonoid1)),
2791+ Semigroup0: function() {
2792+ return semigroupGenericUI2;
2793+ }
2794+ };
2795+ };
2796+ };
2797+ var functorGenericUI = {
2798+ map: function(f) {
2799+ return function(v) {
2800+ return new UI(v.value0, f(v.value1));
2801+ };
2802+ }
2803+ };
2804+ var applyGenericUI = function(dictMonoid) {
2805+ var append3 = append(semigroupRecord3(semigroupRecordCons2(dictMonoid.Semigroup0())));
2806+ return {
2807+ apply: function(v) {
2808+ return function(v1) {
2809+ return new UI(append3(v.value0)(v1.value0), v.value1(v1.value1));
2810+ };
2811+ },
2812+ Functor0: function() {
2813+ return functorGenericUI;
2814+ }
2815+ };
2816+ };
2817+ var bindGenericUI = function(dictMonoid) {
2818+ var append3 = append(semigroupRecord3(semigroupRecordCons2(dictMonoid.Semigroup0())));
2819+ var applyGenericUI1 = applyGenericUI(dictMonoid);
2820+ return {
2821+ bind: function(v) {
2822+ return function(f) {
2823+ var v1 = f(v.value1);
2824+ return new UI(append3(v.value0)(v1.value0), v1.value1);
2825+ };
2826+ },
2827+ Apply0: function() {
2828+ return applyGenericUI1;
2829+ }
2830+ };
2831+ };
2832+ var text = function(s) {
2833+ return function(v) {
2834+ return new UI({
2835+ nerves: mempty1.nerves,
2836+ meat: mempty1.meat,
2837+ hover: mempty1.hover,
2838+ down: mempty1.down,
2839+ children: [new Tuple({
2840+ meat: v.value0.meat,
2841+ nerves: v.value0.nerves,
2842+ hover: v.value0.hover,
2843+ down: v.value0.down
2844+ }, new Text(s))]
2845+ }, v.value1);
2846+ };
2847+ };
2848+ var styleSkinGrowth = function(v) {
2849+ return foldMap3(function(className) {
2850+ return function(v1) {
2851+ return "." + (className + ("{" + (v1.key + (":" + (v1.value + ";}")))));
2852+ };
2853+ })(v.meat) + (foldMap3(function(className) {
2854+ return function(v1) {
2855+ return "." + (className + ("{" + (v1.key + (":" + (v1.value + ";}")))));
2856+ };
2857+ })(v.hover) + foldMap3(function(className) {
2858+ return function(v1) {
2859+ return "." + (className + ("{" + (v1.key + (":" + (v1.value + ";}")))));
2860+ };
2861+ })(v.down));
2862+ };
2863+ var sk = function(cName) {
2864+ return function(key) {
2865+ return function(value12) {
2866+ return discard2(tell2({
2867+ meat: singleton2(cName)({
2868+ key,
2869+ value: value12
2870+ }),
2871+ hover: empty2,
2872+ down: empty2
2873+ }))(function() {
2874+ return pure2([cName]);
2875+ });
2876+ };
2877+ };
2878+ };
2879+ var rgb = function(r) {
2880+ return function(g) {
2881+ return function(b) {
2882+ return {
2883+ r: round2(r * 255),
2884+ g: round2(g * 255),
2885+ b: round2(b * 255),
2886+ a: 100
2887+ };
2888+ };
2889+ };
2890+ };
2891+ var renderKey = function(dict) {
2892+ return dict.renderKey;
2893+ };
2894+ var renderKey1 = /* @__PURE__ */ renderKey(renderableColor);
2895+ var renderKey2 = /* @__PURE__ */ renderKey(renderableSide);
2896+ var render = function(dict) {
2897+ return dict.render;
2898+ };
2899+ var render1 = /* @__PURE__ */ render(renderableColor);
2900+ var render2 = /* @__PURE__ */ render(renderableSide);
2901+ var renderableLength = {
2902+ render: function(v) {
2903+ if (v instanceof Px) {
2904+ return show2(v.value0) + "px";
2905+ }
2906+ ;
2907+ if (v instanceof Fit) {
2908+ return "fit-content";
2909+ }
2910+ ;
2911+ if (v instanceof Fill) {
2912+ return "100%";
2913+ }
2914+ ;
2915+ if (v instanceof Max2) {
2916+ return "max(" + (show2(v.value0) + ("px," + (render(renderableLength)(v.value1) + ")")));
2917+ }
2918+ ;
2919+ if (v instanceof Min2) {
2920+ return "min(" + (show2(v.value0) + ("px," + (render(renderableLength)(v.value1) + ")")));
2921+ }
2922+ ;
2923+ throw new Error("Failed pattern match at Plum.View (line 362, column 12 - line 367, column 62): " + [v.constructor.name]);
2924+ },
2925+ renderKey: function(v) {
2926+ if (v instanceof Px) {
2927+ return show2(v.value0);
2928+ }
2929+ ;
2930+ if (v instanceof Fit) {
2931+ return "fit-content";
2932+ }
2933+ ;
2934+ if (v instanceof Fill) {
2935+ return "fill";
2936+ }
2937+ ;
2938+ if (v instanceof Max2) {
2939+ return "max-" + (show2(v.value0) + ("-" + renderKey(renderableLength)(v.value1)));
2940+ }
2941+ ;
2942+ if (v instanceof Min2) {
2943+ return "min-" + (show2(v.value0) + ("-" + renderKey(renderableLength)(v.value1)));
2944+ }
2945+ ;
2946+ throw new Error("Failed pattern match at Plum.View (line 368, column 15 - line 373, column 56): " + [v.constructor.name]);
2947+ }
2948+ };
2949+ var renderKey3 = /* @__PURE__ */ renderKey(renderableLength);
2950+ var render3 = /* @__PURE__ */ render(renderableLength);
2951+ var skin = function(ctx) {
2952+ return function(v) {
2953+ if (v instanceof Spacing) {
2954+ return sk("spacing-" + (show2(v.value0) + ("-" + show2(v.value1))))("gap")(show2(v.value0) + ("px " + (show2(v.value1) + "px")));
2955+ }
2956+ ;
2957+ if (v instanceof Explain) {
2958+ return sk("explain")("border")("dashed magenta");
2959+ }
2960+ ;
2961+ if (v instanceof Align) {
2962+ if (ctx instanceof Generic) {
2963+ return mempty3;
2964+ }
2965+ ;
2966+ if (ctx instanceof Span) {
2967+ return mempty3;
2968+ }
2969+ ;
2970+ if (ctx instanceof Grid) {
2971+ var v1 = function() {
2972+ if (v.value1 instanceof Start) {
2973+ return "start";
2974+ }
2975+ ;
2976+ if (v.value1 instanceof Center) {
2977+ return "center";
2978+ }
2979+ ;
2980+ if (v.value1 instanceof End) {
2981+ return "end";
2982+ }
2983+ ;
2984+ throw new Error("Failed pattern match at Plum.View (line 311, column 13 - line 314, column 27): " + [v.value1.constructor.name]);
2985+ }();
2986+ var k = function() {
2987+ if (v.value0 instanceof X) {
2988+ return "justify-items";
2989+ }
2990+ ;
2991+ if (v.value0 instanceof Y) {
2992+ return "align-items";
2993+ }
2994+ ;
2995+ throw new Error("Failed pattern match at Plum.View (line 306, column 13 - line 308, column 33): " + [v.value0.constructor.name]);
2996+ }();
2997+ return sk("align-grid-" + (k + ("-" + v1)))(k)(v1);
2998+ }
2999+ ;
3000+ if (ctx instanceof Flexbox) {
3001+ var v1 = function() {
3002+ if (v.value1 instanceof Start) {
3003+ return "flex-start";
3004+ }
3005+ ;
3006+ if (v.value1 instanceof Center) {
3007+ return "center";
3008+ }
3009+ ;
3010+ if (v.value1 instanceof End) {
3011+ return "flex-end";
3012+ }
3013+ ;
3014+ throw new Error("Failed pattern match at Plum.View (line 330, column 13 - line 333, column 32): " + [v.value1.constructor.name]);
3015+ }();
3016+ var k = function() {
3017+ var v2 = new Tuple(ctx.value0, v.value0);
3018+ if (v2.value0 instanceof X && v2.value1 instanceof X) {
3019+ return "justify-content";
3020+ }
3021+ ;
3022+ if (v2.value0 instanceof X && v2.value1 instanceof Y) {
3023+ return "align-items";
3024+ }
3025+ ;
3026+ if (v2.value0 instanceof Y && v2.value1 instanceof X) {
3027+ return "align-items";
3028+ }
3029+ ;
3030+ if (v2.value0 instanceof Y && v2.value1 instanceof Y) {
3031+ return "justify-content";
3032+ }
3033+ ;
3034+ throw new Error("Failed pattern match at Plum.View (line 322, column 13 - line 326, column 42): " + [v2.constructor.name]);
3035+ }();
3036+ return sk("align-flexbox-" + (k + ("-" + v1)))(k)(v1);
3037+ }
3038+ ;
3039+ throw new Error("Failed pattern match at Plum.View (line 300, column 26 - line 336, column 51): " + [ctx.constructor.name]);
3040+ }
3041+ ;
3042+ if (v instanceof Width) {
3043+ return sk("width-" + renderKey3(v.value0))("width")(render3(v.value0));
3044+ }
3045+ ;
3046+ if (v instanceof Height) {
3047+ return sk("height-" + renderKey3(v.value0))("height")(render3(v.value0));
3048+ }
3049+ ;
3050+ if (v instanceof Wrapped) {
3051+ if (ctx instanceof Flexbox) {
3052+ return sk("wrapped")("flex-wrap")("wrap");
3053+ }
3054+ ;
3055+ return pure2([]);
3056+ }
3057+ ;
3058+ if (v instanceof BackgroundColor) {
3059+ return sk("bg-color-" + renderKey1(v.value0))("background-color")(render1(v.value0));
3060+ }
3061+ ;
3062+ if (v instanceof Padding) {
3063+ return sk("padding-" + (renderKey2(v.value0) + ("-" + show2(v.value1))))("padding-" + render2(v.value0))(show2(v.value1) + "px");
3064+ }
3065+ ;
3066+ if (v instanceof Spread) {
3067+ if (ctx instanceof Flexbox) {
3068+ return sk("spread")("justify-content")("space-between");
3069+ }
3070+ ;
3071+ return pure2([]);
3072+ }
3073+ ;
3074+ if (v instanceof Opacity) {
3075+ return sk("opacity-" + show1(v.value0))("opacity")(show1(v.value0));
3076+ }
3077+ ;
3078+ if (v instanceof Pointer) {
3079+ return sk("pointer")("cursor")("pointer");
3080+ }
3081+ ;
3082+ if (v instanceof Move) {
3083+ return sk("move-" + (show2(v.value0.x) + ("-" + show2(v.value0.y))))("transform")("translate(" + (show2(v.value0.x) + ("px, " + (show2(v.value0.y) + "px)"))));
3084+ }
3085+ ;
3086+ if (v instanceof Clip && v.value0 instanceof X) {
3087+ return sk("clip-x")("overflow-x")("hidden");
3088+ }
3089+ ;
3090+ if (v instanceof Clip && v.value0 instanceof Y) {
3091+ return sk("clip-y")("overflow-y")("hidden");
3092+ }
3093+ ;
3094+ throw new Error("Failed pattern match at Plum.View (line 297, column 12 - line 355, column 46): " + [v.constructor.name]);
3095+ };
3096+ };
3097+ var onMouseDown = function(dictMonoid) {
3098+ var mempty52 = mempty(monoidRecord2(monoidRecordCons3(dictMonoid)()(monoidRecordCons4)));
3099+ return function(v) {
3100+ return new UI({
3101+ nerves: mempty52.nerves,
3102+ meat: mempty52.meat,
3103+ hover: mempty52.hover,
3104+ children: mempty52.children,
3105+ down: v.value0.meat
3106+ }, v.value1);
3107+ };
3108+ };
3109+ var onHover = function(dictMonoid) {
3110+ var mempty52 = mempty(monoidRecord2(monoidRecordCons3(dictMonoid)()(monoidRecordCons4)));
3111+ return function(v) {
3112+ return new UI({
3113+ nerves: mempty52.nerves,
3114+ meat: mempty52.meat,
3115+ down: mempty52.down,
3116+ children: mempty52.children,
3117+ hover: v.value0.meat
3118+ }, v.value1);
3119+ };
3120+ };
3121+ var m = function(dictMonoid) {
3122+ var mempty52 = mempty(monoidRecord2(monoidRecordCons3(dictMonoid)()(monoidRecordCons4)));
3123+ return function(meat) {
3124+ return new UI({
3125+ nerves: mempty52.nerves,
3126+ hover: mempty52.hover,
3127+ down: mempty52.down,
3128+ children: mempty52.children,
3129+ meat: [meat]
3130+ }, mempty22);
3131+ };
3132+ };
3133+ var hWith = function(elem2) {
3134+ return function(props) {
3135+ return function(classes) {
3136+ return function(children) {
3137+ return h2(elem2)(unsafeUnion(props)({
3138+ "class": intercalate3(" ")(classes)
3139+ }))(children);
3140+ };
3141+ };
3142+ };
3143+ };
3144+ var h3 = function(elem2) {
3145+ return function(classes) {
3146+ return function(children) {
3147+ return h2(elem2)({
3148+ "class": intercalate3(" ")(classes)
3149+ })(children);
3150+ };
3151+ };
3152+ };
3153+ var growSkin = function(fire) {
3154+ return function(v) {
3155+ return function(v1) {
3156+ var widthFill = [new Width(Fill.value), new Height(Fill.value)];
3157+ var alignCenter = [new Align(X.value, Center.value), new Align(Y.value, Center.value)];
3158+ var skn = function(ctx) {
3159+ return bind2(map2(function($513) {
3160+ return function(v2) {
3161+ return append2(v2)(v.extraSkin);
3162+ }(concat($513));
3163+ })(traverse2(skin(ctx))(append2(v1.value0.meat)(append2(function() {
3164+ if (ctx instanceof Span) {
3165+ return mempty2;
3166+ }
3167+ ;
3168+ if (ctx instanceof Grid) {
3169+ return widthFill;
3170+ }
3171+ ;
3172+ if (ctx instanceof Flexbox) {
3173+ return widthFill;
3174+ }
3175+ ;
3176+ if (ctx instanceof Generic) {
3177+ return widthFill;
3178+ }
3179+ ;
3180+ throw new Error("Failed pattern match at Plum.View (line 445, column 16 - line 449, column 35): " + [ctx.constructor.name]);
3181+ }())(function() {
3182+ if (ctx instanceof Grid) {
3183+ return alignCenter;
3184+ }
3185+ ;
3186+ if (ctx instanceof Flexbox) {
3187+ return alignCenter;
3188+ }
3189+ ;
3190+ if (ctx instanceof Span) {
3191+ return mempty2;
3192+ }
3193+ ;
3194+ if (ctx instanceof Generic) {
3195+ return alignCenter;
3196+ }
3197+ ;
3198+ throw new Error("Failed pattern match at Plum.View (line 450, column 16 - line 454, column 37): " + [ctx.constructor.name]);
3199+ }())))))(function(meatClasses) {
3200+ var v2 = runWriter(traverse2(skin(ctx))(v1.value0.hover));
3201+ return bind2(traverseWithIndex2(function(key) {
3202+ return function(val) {
3203+ return tell2({
3204+ meat: empty2,
3205+ hover: singleton2(key + "-hover:hover")(val),
3206+ down: empty2
3207+ });
3208+ };
3209+ })(v2.value1.meat))(function() {
3210+ var v3 = runWriter(traverse2(skin(ctx))(v1.value0.down));
3211+ return bind2(traverseWithIndex2(function(key) {
3212+ return function(val) {
3213+ return tell2({
3214+ meat: empty2,
3215+ hover: empty2,
3216+ down: singleton2(key + "-down:active")(val)
3217+ });
3218+ };
3219+ })(v3.value1.meat))(function() {
3220+ return pure2(append2(meatClasses)(append2(map1(function(v4) {
3221+ return v4 + "-hover";
3222+ })(concat(v2.value0)))(map1(function(v4) {
3223+ return v4 + "-down";
3224+ })(concat(v3.value0)))));
3225+ });
3226+ });
3227+ });
3228+ };
3229+ if (v1.value1 instanceof Text) {
3230+ return map2(function(c) {
3231+ return h3("span")(c)([string(v1.value1.value0)]);
3232+ })(skn(Span.value));
3233+ }
3234+ ;
3235+ if (v1.value1 instanceof Wrapper) {
3236+ return bind2(append22(skn(new Flexbox(X.value)))(append22(sk("display-flex")("display")("flex"))(sk("flex-direction-row")("flex-direction")("row"))))(function(classes) {
3237+ return bind2(growSkin(fire)(mempty4)(v1.value1.value0))(function(x$prime) {
3238+ return pure2(h3("div")(classes)([x$prime]));
3239+ });
3240+ });
3241+ }
3242+ ;
3243+ if (v1.value1 instanceof Stack) {
3244+ return bind2(append22(skn(Grid.value))(sk("display-grid")("display")("grid")))(function(classes) {
3245+ return bind2(append22(sk("grid-row-1")("grid-row")("1"))(sk("grid-column-1")("grid-column")("1")))(function(extraSkin) {
3246+ return bind2(traverse2(growSkin(fire)({
3247+ extraSkin
3248+ }))(v1.value1.value0))(function(children$prime) {
3249+ return pure2(h3("div")(classes)(children$prime));
3250+ });
3251+ });
3252+ });
3253+ }
3254+ ;
3255+ if (v1.value1 instanceof Row) {
3256+ return bind2(append22(skn(new Flexbox(X.value)))(append22(sk("display-flex")("display")("flex"))(sk("flex-direction-row")("flex-direction")("row"))))(function(classes) {
3257+ return bind2(traverse2(growSkin(fire)(mempty4))(v1.value1.value0))(function(children$prime) {
3258+ return pure2(h3("div")(classes)(children$prime));
3259+ });
3260+ });
3261+ }
3262+ ;
3263+ if (v1.value1 instanceof Column) {
3264+ return bind2(append22(skn(new Flexbox(Y.value)))(append22(sk("display-flex")("display")("flex"))(sk("flex-direction-column")("flex-direction")("column"))))(function(classes) {
3265+ return bind2(traverse2(growSkin(fire)(mempty4))(v1.value1.value0))(function(children$prime) {
3266+ return pure2(h3("div")(classes)(children$prime));
3267+ });
3268+ });
3269+ }
3270+ ;
3271+ if (v1.value1 instanceof Link) {
3272+ return bind2(append22(skn(new Flexbox(X.value)))(append22(sk("display-flex")("display")("flex"))(sk("flex-direction-row")("flex-direction")("row"))))(function(classes) {
3273+ return bind2(growSkin(fire)(mempty4)(v1.value1.value2))(function(child$prime) {
3274+ return pure2(hWith("a")({
3275+ href: v1.value1.value0,
3276+ rel: "noopener noreferrer",
3277+ target: function() {
3278+ if (v1.value1.value1.newTab) {
3279+ return "_blank";
3280+ }
3281+ ;
3282+ return "_self";
3283+ }()
3284+ })(classes)([child$prime]));
3285+ });
3286+ });
3287+ }
3288+ ;
3289+ if (v1.value1 instanceof Download) {
3290+ return bind2(append22(skn(new Flexbox(X.value)))(append22(sk("display-flex")("display")("flex"))(sk("flex-direction-row")("flex-direction")("row"))))(function(classes) {
3291+ return bind2(growSkin(fire)(mempty4)(v1.value1.value2))(function(child$prime) {
3292+ return pure2(hWith("a")({
3293+ href: v1.value1.value0,
3294+ download: fromMaybe("")(v1.value1.value1.filename)
3295+ })(classes)([child$prime]));
3296+ });
3297+ });
3298+ }
3299+ ;
3300+ if (v1.value1 instanceof Image2) {
3301+ return map2(function(c) {
3302+ return hWith("img")({
3303+ src: v1.value1.value0,
3304+ alt: v1.value1.value1.description
3305+ })(c)([]);
3306+ })(skn(Generic.value));
3307+ }
3308+ ;
3309+ if (v1.value1 instanceof None) {
3310+ return pure2(h3("div")(mempty2)([]));
3311+ }
3312+ ;
3313+ throw new Error("Failed pattern match at Plum.View (line 477, column 3 - line 518, column 37): " + [v1.value1.constructor.name]);
3314+ };
3315+ };
3316+ };
3317+ var grow = function(fire) {
3318+ return function(v) {
3319+ var v1 = runWriter(growSkin(fire)(mempty4)(v));
3320+ return {
3321+ node: v1.value0,
3322+ style: styleSkinGrowth(v1.value1)
3323+ };
3324+ };
3325+ };
3326+ var column = function(v) {
3327+ return new UI({
3328+ nerves: mempty1.nerves,
3329+ meat: mempty1.meat,
3330+ hover: mempty1.hover,
3331+ down: mempty1.down,
3332+ children: [new Tuple({
3333+ meat: v.value0.meat,
3334+ nerves: v.value0.nerves,
3335+ hover: v.value0.hover,
3336+ down: v.value0.down
3337+ }, new Column(v.value0.children))]
3338+ }, v.value1);
3339+ };
3340+ var bgColor = function(dictMonoid) {
3341+ var m1 = m(dictMonoid);
3342+ return function(c) {
3343+ return m1(new BackgroundColor(c));
3344+ };
3345+ };
3346+
3347+ // output/Web.DOM.NonElementParentNode/foreign.js
3348+ function _getElementById(id) {
3349+ return function(node) {
3350+ return function() {
3351+ return node.getElementById(id);
3352+ };
3353+ };
3354+ }
3355+
3356+ // output/Data.Nullable/foreign.js
3357+ function nullable(a, r, f) {
3358+ return a == null ? r : f(a);
3359+ }
3360+
3361+ // output/Data.Nullable/index.js
3362+ var toMaybe = function(n) {
3363+ return nullable(n, Nothing.value, Just.create);
3364+ };
3365+
3366+ // output/Web.DOM.NonElementParentNode/index.js
3367+ var map3 = /* @__PURE__ */ map(functorEffect);
3368+ var getElementById = function(eid) {
3369+ var $2 = map3(toMaybe);
3370+ var $3 = _getElementById(eid);
3371+ return function($4) {
3372+ return $2($3($4));
3373+ };
3374+ };
3375+
3376+ // output/Web.HTML/foreign.js
3377+ var windowImpl = function() {
3378+ return window;
3379+ };
3380+
3381+ // output/Web.HTML.HTMLDocument/index.js
3382+ var toNonElementParentNode = unsafeCoerce2;
3383+
3384+ // output/Web.HTML.Window/foreign.js
3385+ function document2(window2) {
3386+ return function() {
3387+ return window2.document;
3388+ };
3389+ }
3390+
3391+ // output/Plum/index.js
3392+ var bind3 = /* @__PURE__ */ bind(bindEffect);
3393+ var outerStyle = "html,body{height:100%;padding:0;margin:0;}";
3394+ var run3 = function(id) {
3395+ return function(plum2) {
3396+ return function __do() {
3397+ var modelRef = bind3(plum2.init)($$new)();
3398+ var v = bind3(bind3(windowImpl)(document2))(function() {
3399+ var $21 = getElementById(id);
3400+ return function($22) {
3401+ return $21(toNonElementParentNode($22));
3402+ };
3403+ }())();
3404+ if (v instanceof Just) {
3405+ var projector = createProjector();
3406+ return replace(projector)(v.value0)(function __do2() {
3407+ var model = read(modelRef)();
3408+ var v1 = plum2.view(model);
3409+ var v2 = head(v1.value0.children);
3410+ if (v2 instanceof Nothing) {
3411+ return h2("div")({})([]);
3412+ }
3413+ ;
3414+ if (v2 instanceof Just) {
3415+ var v3 = grow(function(msg) {
3416+ return function __do3() {
3417+ var m2 = read(modelRef)();
3418+ var m_ = plum2.update(msg)(m2)();
3419+ write(m_)(modelRef)();
3420+ return scheduleRender(projector)();
3421+ };
3422+ })(v2.value0);
3423+ return h2("div")({
3424+ styles: {
3425+ height: "100%",
3426+ width: "100%"
3427+ }
3428+ })([h2("style")({})([string(outerStyle + v3.style)]), v3.node]);
3429+ }
3430+ ;
3431+ throw new Error("Failed pattern match at Plum (line 35, column 20 - line 52, column 94): " + [v2.constructor.name]);
3432+ })();
3433+ }
3434+ ;
3435+ if (v instanceof Nothing) {
3436+ return unit;
3437+ }
3438+ ;
3439+ throw new Error("Failed pattern match at Plum (line 26, column 92 - line 54, column 25): " + [v.constructor.name]);
3440+ };
3441+ };
3442+ };
3443+
3444+ // output/Main/index.js
3445+ var pure3 = /* @__PURE__ */ pure(applicativeEffect);
3446+ var discard3 = /* @__PURE__ */ discard(discardUnit);
3447+ var discard1 = /* @__PURE__ */ discard3(/* @__PURE__ */ bindGenericUI(monoidArray));
3448+ var discard22 = /* @__PURE__ */ discard3(/* @__PURE__ */ bindGenericUI(monoidUnit));
3449+ var onHover2 = /* @__PURE__ */ onHover(monoidUnit);
3450+ var bgColor2 = /* @__PURE__ */ bgColor(monoidUnit);
3451+ var onMouseDown2 = /* @__PURE__ */ onMouseDown(monoidUnit);
3452+ var mempty5 = /* @__PURE__ */ mempty(/* @__PURE__ */ monoidGenericUI(monoidUnit)(monoidUnit));
3453+ var plum = {
3454+ init: /* @__PURE__ */ pure3({
3455+ text: "Test"
3456+ }),
3457+ view: function(model) {
3458+ return column(discard1(text("hi")(discard22(onHover2(bgColor2(rgb(1)(0)(0))))(function() {
3459+ return onMouseDown2(bgColor2(rgb(0)(1)(0)));
3460+ })))(function() {
3461+ return text("hello")(mempty5);
3462+ }));
3463+ },
3464+ update: function(msg) {
3465+ return function(model) {
3466+ return pure3({
3467+ text: "Button pressed"
3468+ });
3469+ };
3470+ }
3471+ };
3472+ var main = /* @__PURE__ */ run3("plum")(plum);
3473+
3474+ // <stdin>
3475+ main();
3476+})();