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