@@ -0,0 +1,2312 @@
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+
43+ // output/Data.Functor/foreign.js
44+ var arrayMap = function(f) {
45+ return function(arr) {
46+ var l = arr.length;
47+ var result = new Array(l);
48+ for (var i = 0; i < l; i++) {
49+ result[i] = f(arr[i]);
50+ }
51+ return result;
52+ };
53+ };
54+
55+ // output/Data.Unit/foreign.js
56+ var unit = void 0;
57+
58+ // output/Data.Functor/index.js
59+ var map = function(dict) {
60+ return dict.map;
61+ };
62+ var functorArray = {
63+ map: arrayMap
64+ };
65+
66+ // output/Control.Apply/index.js
67+ var apply = function(dict) {
68+ return dict.apply;
69+ };
70+
71+ // output/Control.Applicative/index.js
72+ var pure = function(dict) {
73+ return dict.pure;
74+ };
75+ var liftA1 = function(dictApplicative) {
76+ var apply2 = apply(dictApplicative.Apply0());
77+ var pure1 = pure(dictApplicative);
78+ return function(f) {
79+ return function(a) {
80+ return apply2(pure1(f))(a);
81+ };
82+ };
83+ };
84+
85+ // output/Data.Array/foreign.js
86+ var rangeImpl = function(start2, end) {
87+ var step2 = start2 > end ? -1 : 1;
88+ var result = new Array(step2 * (end - start2) + 1);
89+ var i = start2, n = 0;
90+ while (i !== end) {
91+ result[n++] = i;
92+ i += step2;
93+ }
94+ result[n] = i;
95+ return result;
96+ };
97+ var replicateFill = function(count, value12) {
98+ if (count < 1) {
99+ return [];
100+ }
101+ var result = new Array(count);
102+ return result.fill(value12);
103+ };
104+ var replicatePolyfill = function(count, value12) {
105+ var result = [];
106+ var n = 0;
107+ for (var i = 0; i < count; i++) {
108+ result[n++] = value12;
109+ }
110+ return result;
111+ };
112+ var replicateImpl = typeof Array.prototype.fill === "function" ? replicateFill : replicatePolyfill;
113+
114+ // output/Data.Semigroup/foreign.js
115+ var concatArray = function(xs) {
116+ return function(ys) {
117+ if (xs.length === 0) return ys;
118+ if (ys.length === 0) return xs;
119+ return xs.concat(ys);
120+ };
121+ };
122+
123+ // output/Data.Semigroup/index.js
124+ var semigroupArray = {
125+ append: concatArray
126+ };
127+ var append = function(dict) {
128+ return dict.append;
129+ };
130+
131+ // output/Control.Bind/foreign.js
132+ var arrayBind = typeof Array.prototype.flatMap === "function" ? function(arr) {
133+ return function(f) {
134+ return arr.flatMap(f);
135+ };
136+ } : function(arr) {
137+ return function(f) {
138+ var result = [];
139+ var l = arr.length;
140+ for (var i = 0; i < l; i++) {
141+ var xs = f(arr[i]);
142+ var k = xs.length;
143+ for (var j = 0; j < k; j++) {
144+ result.push(xs[j]);
145+ }
146+ }
147+ return result;
148+ };
149+ };
150+
151+ // output/Control.Bind/index.js
152+ var bind = function(dict) {
153+ return dict.bind;
154+ };
155+ var bindFlipped = function(dictBind) {
156+ return flip(bind(dictBind));
157+ };
158+
159+ // output/Control.Monad/index.js
160+ var ap = function(dictMonad) {
161+ var bind3 = bind(dictMonad.Bind1());
162+ var pure3 = pure(dictMonad.Applicative0());
163+ return function(f) {
164+ return function(a) {
165+ return bind3(f)(function(f$prime) {
166+ return bind3(a)(function(a$prime) {
167+ return pure3(f$prime(a$prime));
168+ });
169+ });
170+ };
171+ };
172+ };
173+
174+ // output/Data.Bounded/foreign.js
175+ var topInt = 2147483647;
176+ var bottomInt = -2147483648;
177+ var topChar = String.fromCharCode(65535);
178+ var bottomChar = String.fromCharCode(0);
179+ var topNumber = Number.POSITIVE_INFINITY;
180+ var bottomNumber = Number.NEGATIVE_INFINITY;
181+
182+ // output/Data.Ord/foreign.js
183+ var unsafeCompareImpl = function(lt) {
184+ return function(eq2) {
185+ return function(gt) {
186+ return function(x) {
187+ return function(y) {
188+ return x < y ? lt : x === y ? eq2 : gt;
189+ };
190+ };
191+ };
192+ };
193+ };
194+ var ordIntImpl = unsafeCompareImpl;
195+
196+ // output/Data.Eq/foreign.js
197+ var refEq = function(r1) {
198+ return function(r2) {
199+ return r1 === r2;
200+ };
201+ };
202+ var eqIntImpl = refEq;
203+
204+ // output/Data.Eq/index.js
205+ var eqInt = {
206+ eq: eqIntImpl
207+ };
208+
209+ // output/Data.Ordering/index.js
210+ var LT = /* @__PURE__ */ function() {
211+ function LT2() {
212+ }
213+ ;
214+ LT2.value = new LT2();
215+ return LT2;
216+ }();
217+ var GT = /* @__PURE__ */ function() {
218+ function GT2() {
219+ }
220+ ;
221+ GT2.value = new GT2();
222+ return GT2;
223+ }();
224+ var EQ = /* @__PURE__ */ function() {
225+ function EQ2() {
226+ }
227+ ;
228+ EQ2.value = new EQ2();
229+ return EQ2;
230+ }();
231+
232+ // output/Data.Ord/index.js
233+ var ordInt = /* @__PURE__ */ function() {
234+ return {
235+ compare: ordIntImpl(LT.value)(EQ.value)(GT.value),
236+ Eq0: function() {
237+ return eqInt;
238+ }
239+ };
240+ }();
241+
242+ // output/Data.Bounded/index.js
243+ var top = function(dict) {
244+ return dict.top;
245+ };
246+ var boundedInt = {
247+ top: topInt,
248+ bottom: bottomInt,
249+ Ord0: function() {
250+ return ordInt;
251+ }
252+ };
253+ var bottom = function(dict) {
254+ return dict.bottom;
255+ };
256+
257+ // output/Data.Show/foreign.js
258+ var showIntImpl = function(n) {
259+ return n.toString();
260+ };
261+ var showNumberImpl = function(n) {
262+ var str = n.toString();
263+ return isNaN(str + ".0") ? str : str + ".0";
264+ };
265+
266+ // output/Data.Show/index.js
267+ var showNumber = {
268+ show: showNumberImpl
269+ };
270+ var showInt = {
271+ show: showIntImpl
272+ };
273+ var show = function(dict) {
274+ return dict.show;
275+ };
276+
277+ // output/Data.Maybe/index.js
278+ var identity2 = /* @__PURE__ */ identity(categoryFn);
279+ var Nothing = /* @__PURE__ */ function() {
280+ function Nothing2() {
281+ }
282+ ;
283+ Nothing2.value = new Nothing2();
284+ return Nothing2;
285+ }();
286+ var Just = /* @__PURE__ */ function() {
287+ function Just2(value0) {
288+ this.value0 = value0;
289+ }
290+ ;
291+ Just2.create = function(value0) {
292+ return new Just2(value0);
293+ };
294+ return Just2;
295+ }();
296+ var maybe = function(v) {
297+ return function(v1) {
298+ return function(v2) {
299+ if (v2 instanceof Nothing) {
300+ return v;
301+ }
302+ ;
303+ if (v2 instanceof Just) {
304+ return v1(v2.value0);
305+ }
306+ ;
307+ 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]);
308+ };
309+ };
310+ };
311+ var fromMaybe = function(a) {
312+ return maybe(a)(identity2);
313+ };
314+
315+ // output/Data.Monoid/index.js
316+ var monoidArray = {
317+ mempty: [],
318+ Semigroup0: function() {
319+ return semigroupArray;
320+ }
321+ };
322+ var mempty = function(dict) {
323+ return dict.mempty;
324+ };
325+
326+ // output/Effect/foreign.js
327+ var pureE = function(a) {
328+ return function() {
329+ return a;
330+ };
331+ };
332+ var bindE = function(a) {
333+ return function(f) {
334+ return function() {
335+ return f(a())();
336+ };
337+ };
338+ };
339+
340+ // output/Effect/index.js
341+ var $runtime_lazy = function(name14, moduleName, init) {
342+ var state2 = 0;
343+ var val;
344+ return function(lineNumber) {
345+ if (state2 === 2) return val;
346+ if (state2 === 1) throw new ReferenceError(name14 + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);
347+ state2 = 1;
348+ val = init();
349+ state2 = 2;
350+ return val;
351+ };
352+ };
353+ var monadEffect = {
354+ Applicative0: function() {
355+ return applicativeEffect;
356+ },
357+ Bind1: function() {
358+ return bindEffect;
359+ }
360+ };
361+ var bindEffect = {
362+ bind: bindE,
363+ Apply0: function() {
364+ return $lazy_applyEffect(0);
365+ }
366+ };
367+ var applicativeEffect = {
368+ pure: pureE,
369+ Apply0: function() {
370+ return $lazy_applyEffect(0);
371+ }
372+ };
373+ var $lazy_functorEffect = /* @__PURE__ */ $runtime_lazy("functorEffect", "Effect", function() {
374+ return {
375+ map: liftA1(applicativeEffect)
376+ };
377+ });
378+ var $lazy_applyEffect = /* @__PURE__ */ $runtime_lazy("applyEffect", "Effect", function() {
379+ return {
380+ apply: ap(monadEffect),
381+ Functor0: function() {
382+ return $lazy_functorEffect(0);
383+ }
384+ };
385+ });
386+ var functorEffect = /* @__PURE__ */ $lazy_functorEffect(20);
387+
388+ // output/Effect.Ref/foreign.js
389+ var _new = function(val) {
390+ return function() {
391+ return { value: val };
392+ };
393+ };
394+ var read = function(ref) {
395+ return function() {
396+ return ref.value;
397+ };
398+ };
399+ var write = function(val) {
400+ return function(ref) {
401+ return function() {
402+ ref.value = val;
403+ };
404+ };
405+ };
406+
407+ // output/Effect.Ref/index.js
408+ var $$new = _new;
409+
410+ // output/Control.Monad.ST.Internal/foreign.js
411+ var map_ = function(f) {
412+ return function(a) {
413+ return function() {
414+ return f(a());
415+ };
416+ };
417+ };
418+ var pure_ = function(a) {
419+ return function() {
420+ return a;
421+ };
422+ };
423+ var bind_ = function(a) {
424+ return function(f) {
425+ return function() {
426+ return f(a())();
427+ };
428+ };
429+ };
430+
431+ // output/Control.Monad.ST.Internal/index.js
432+ var $runtime_lazy2 = function(name14, moduleName, init) {
433+ var state2 = 0;
434+ var val;
435+ return function(lineNumber) {
436+ if (state2 === 2) return val;
437+ if (state2 === 1) throw new ReferenceError(name14 + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);
438+ state2 = 1;
439+ val = init();
440+ state2 = 2;
441+ return val;
442+ };
443+ };
444+ var functorST = {
445+ map: map_
446+ };
447+ var monadST = {
448+ Applicative0: function() {
449+ return applicativeST;
450+ },
451+ Bind1: function() {
452+ return bindST;
453+ }
454+ };
455+ var bindST = {
456+ bind: bind_,
457+ Apply0: function() {
458+ return $lazy_applyST(0);
459+ }
460+ };
461+ var applicativeST = {
462+ pure: pure_,
463+ Apply0: function() {
464+ return $lazy_applyST(0);
465+ }
466+ };
467+ var $lazy_applyST = /* @__PURE__ */ $runtime_lazy2("applyST", "Control.Monad.ST.Internal", function() {
468+ return {
469+ apply: ap(monadST),
470+ Functor0: function() {
471+ return functorST;
472+ }
473+ };
474+ });
475+
476+ // output/Data.Foldable/foreign.js
477+ var foldrArray = function(f) {
478+ return function(init) {
479+ return function(xs) {
480+ var acc = init;
481+ var len = xs.length;
482+ for (var i = len - 1; i >= 0; i--) {
483+ acc = f(xs[i])(acc);
484+ }
485+ return acc;
486+ };
487+ };
488+ };
489+ var foldlArray = function(f) {
490+ return function(init) {
491+ return function(xs) {
492+ var acc = init;
493+ var len = xs.length;
494+ for (var i = 0; i < len; i++) {
495+ acc = f(acc)(xs[i]);
496+ }
497+ return acc;
498+ };
499+ };
500+ };
501+
502+ // output/Data.Tuple/index.js
503+ var Tuple = /* @__PURE__ */ function() {
504+ function Tuple2(value0, value1) {
505+ this.value0 = value0;
506+ this.value1 = value1;
507+ }
508+ ;
509+ Tuple2.create = function(value0) {
510+ return function(value1) {
511+ return new Tuple2(value0, value1);
512+ };
513+ };
514+ return Tuple2;
515+ }();
516+
517+ // output/Unsafe.Coerce/foreign.js
518+ var unsafeCoerce2 = function(x) {
519+ return x;
520+ };
521+
522+ // output/Data.Foldable/index.js
523+ var foldr = function(dict) {
524+ return dict.foldr;
525+ };
526+ var foldMapDefaultR = function(dictFoldable) {
527+ var foldr2 = foldr(dictFoldable);
528+ return function(dictMonoid) {
529+ var append3 = append(dictMonoid.Semigroup0());
530+ var mempty3 = mempty(dictMonoid);
531+ return function(f) {
532+ return foldr2(function(x) {
533+ return function(acc) {
534+ return append3(f(x))(acc);
535+ };
536+ })(mempty3);
537+ };
538+ };
539+ };
540+ var foldableArray = {
541+ foldr: foldrArray,
542+ foldl: foldlArray,
543+ foldMap: function(dictMonoid) {
544+ return foldMapDefaultR(foldableArray)(dictMonoid);
545+ }
546+ };
547+ var foldMap = function(dict) {
548+ return dict.foldMap;
549+ };
550+
551+ // output/Data.Function.Uncurried/foreign.js
552+ var runFn2 = function(fn) {
553+ return function(a) {
554+ return function(b) {
555+ return fn(a, b);
556+ };
557+ };
558+ };
559+
560+ // output/Data.Array/index.js
561+ var foldMap1 = /* @__PURE__ */ foldMap(foldableArray);
562+ var range2 = /* @__PURE__ */ runFn2(rangeImpl);
563+ var foldMap2 = function(dictMonoid) {
564+ return foldMap1(dictMonoid);
565+ };
566+
567+ // output/Maquette/foreign.js
568+ var NAMESPACE_W3 = "http://www.w3.org/";
569+ var NAMESPACE_SVG = NAMESPACE_W3 + "2000/svg";
570+ var NAMESPACE_XLINK = NAMESPACE_W3 + "1999/xlink";
571+ var emptyArray = [];
572+ var extend2 = function(base, overrides) {
573+ var result = {};
574+ Object.keys(base).forEach(function(key) {
575+ result[key] = base[key];
576+ });
577+ if (overrides) {
578+ Object.keys(overrides).forEach(function(key) {
579+ result[key] = overrides[key];
580+ });
581+ }
582+ return result;
583+ };
584+ var same = function(vnode1, vnode2) {
585+ if (vnode1.vnodeSelector !== vnode2.vnodeSelector) {
586+ return false;
587+ }
588+ if (vnode1.properties && vnode2.properties) {
589+ if (vnode1.properties.key !== vnode2.properties.key) {
590+ return false;
591+ }
592+ return vnode1.properties.bind === vnode2.properties.bind;
593+ }
594+ return !vnode1.properties && !vnode2.properties;
595+ };
596+ var checkStyleValue = function(styleValue) {
597+ if (typeof styleValue !== "string") {
598+ throw new Error("Style values must be strings");
599+ }
600+ };
601+ var findIndexOfChild = function(children, sameAs, start2) {
602+ if (sameAs.vnodeSelector !== "") {
603+ for (var i = start2; i < children.length; i++) {
604+ if (same(children[i], sameAs)) {
605+ return i;
606+ }
607+ }
608+ }
609+ return -1;
610+ };
611+ var checkDistinguishable = function(childNodes, indexToCheck, parentVNode, operation) {
612+ var childNode = childNodes[indexToCheck];
613+ if (childNode.vnodeSelector === "") {
614+ return;
615+ }
616+ var properties = childNode.properties;
617+ var key = properties ? properties.key === void 0 ? properties.bind : properties.key : void 0;
618+ if (!key) {
619+ for (var i = 0; i < childNodes.length; i++) {
620+ if (i !== indexToCheck) {
621+ var node = childNodes[i];
622+ if (same(node, childNode)) {
623+ throw {
624+ 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."),
625+ parentNode: parentVNode,
626+ childNode
627+ };
628+ }
629+ }
630+ }
631+ }
632+ };
633+ var nodeAdded = function(vNode) {
634+ if (vNode.properties) {
635+ var enterAnimation = vNode.properties.enterAnimation;
636+ if (enterAnimation) {
637+ enterAnimation(vNode.domNode, vNode.properties);
638+ }
639+ }
640+ };
641+ var removedNodes = [];
642+ var requestedIdleCallback = false;
643+ var visitRemovedNode = function(node) {
644+ (node.children || []).forEach(visitRemovedNode);
645+ if (node.properties && node.properties.afterRemoved) {
646+ node.properties.afterRemoved.apply(node.properties.bind || node.properties, [
647+ node.domNode
648+ ]);
649+ }
650+ };
651+ var processPendingNodeRemovals = function() {
652+ requestedIdleCallback = false;
653+ removedNodes.forEach(visitRemovedNode);
654+ removedNodes.length = 0;
655+ };
656+ var scheduleNodeRemoval = function(vNode) {
657+ removedNodes.push(vNode);
658+ if (!requestedIdleCallback) {
659+ requestedIdleCallback = true;
660+ if (typeof window !== "undefined" && "requestIdleCallback" in window) {
661+ window.requestIdleCallback(processPendingNodeRemovals, { timeout: 16 });
662+ } else {
663+ setTimeout(processPendingNodeRemovals, 16);
664+ }
665+ }
666+ };
667+ var nodeToRemove = function(vNode) {
668+ var domNode = vNode.domNode;
669+ if (vNode.properties) {
670+ var exitAnimation = vNode.properties.exitAnimation;
671+ if (exitAnimation) {
672+ domNode.style.pointerEvents = "none";
673+ var removeDomNode = function() {
674+ if (domNode.parentNode) {
675+ domNode.parentNode.removeChild(domNode);
676+ scheduleNodeRemoval(vNode);
677+ }
678+ };
679+ exitAnimation(domNode, removeDomNode, vNode.properties);
680+ return;
681+ }
682+ }
683+ if (domNode.parentNode) {
684+ domNode.parentNode.removeChild(domNode);
685+ scheduleNodeRemoval(vNode);
686+ }
687+ };
688+ var vnodeOnlyProps = [
689+ "afterCreate",
690+ "afterUpdate",
691+ "afterRemoved",
692+ "enterAnimation",
693+ "exitAnimation",
694+ "updateAnimation"
695+ ];
696+ function filterVNodeOnlyProps(name14) {
697+ return !vnodeOnlyProps.includes(name14);
698+ }
699+ var setProperties = function(domNode, properties, projectionOptions) {
700+ if (!properties) {
701+ return;
702+ }
703+ var eventHandlerInterceptor = projectionOptions.eventHandlerInterceptor;
704+ var propNames = Object.keys(properties).filter(filterVNodeOnlyProps);
705+ var propCount = propNames.length;
706+ for (var i = 0; i < propCount; i++) {
707+ var propName = propNames[i];
708+ var propValue = properties[propName];
709+ if (propName === "className") {
710+ throw new Error('Property "className" is not supported, use "class".');
711+ } else if (propName === "class") {
712+ toggleClasses(domNode, propValue, true);
713+ } else if (propName === "classes") {
714+ var classNames = Object.keys(propValue);
715+ var classNameCount = classNames.length;
716+ for (var j = 0; j < classNameCount; j++) {
717+ var className = classNames[j];
718+ if (propValue[className]) {
719+ domNode.classList.add(className);
720+ }
721+ }
722+ } else if (propName === "styles") {
723+ var styleNames = Object.keys(propValue);
724+ var styleCount = styleNames.length;
725+ for (var j = 0; j < styleCount; j++) {
726+ var styleName = styleNames[j];
727+ var styleValue = propValue[styleName];
728+ if (styleValue) {
729+ checkStyleValue(styleValue);
730+ projectionOptions.styleApplyer(domNode, styleName, styleValue);
731+ }
732+ }
733+ } else if (propName === "on" && propValue) {
734+ for (var _i = 0, _a = Object.entries(properties.on); _i < _a.length; _i++) {
735+ var _b = _a[_i], key = _b[0], handler = _b[1];
736+ var listener = typeof handler === "function" ? handler : handler.listener;
737+ if (eventHandlerInterceptor) {
738+ listener = eventHandlerInterceptor(key, listener, domNode, properties);
739+ }
740+ if (listener) {
741+ domNode.addEventListener(key, listener, typeof handler === "function" ? void 0 : handler.options);
742+ }
743+ }
744+ } else if (propName !== "key" && propValue !== null && propValue !== void 0) {
745+ var type = typeof propValue;
746+ if (type === "function") {
747+ if (propName.lastIndexOf("on", 0) === 0) {
748+ if (eventHandlerInterceptor) {
749+ propValue = eventHandlerInterceptor(propName, propValue, domNode, properties);
750+ }
751+ }
752+ domNode[propName] = propValue;
753+ } else if (projectionOptions.namespace === NAMESPACE_SVG) {
754+ if (propName === "href") {
755+ domNode.setAttributeNS(NAMESPACE_XLINK, propName, propValue);
756+ } else {
757+ domNode.setAttribute(propName, propValue);
758+ }
759+ } else if (type === "string" && propName !== "value" && propName !== "innerHTML") {
760+ domNode.setAttribute(propName, propValue);
761+ } else {
762+ domNode[propName] = propValue;
763+ }
764+ }
765+ }
766+ };
767+ var addChildren = function(domNode, children, projectionOptions) {
768+ if (!children) {
769+ return;
770+ }
771+ for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
772+ var child = children_1[_i];
773+ createDom(child, domNode, void 0, projectionOptions);
774+ }
775+ };
776+ var initPropertiesAndChildren = function(domNode, vnode, projectionOptions) {
777+ addChildren(domNode, vnode.children, projectionOptions);
778+ if (vnode.text) {
779+ domNode.textContent = vnode.text;
780+ }
781+ setProperties(domNode, vnode.properties, projectionOptions);
782+ if (vnode.properties && vnode.properties.afterCreate) {
783+ vnode.properties.afterCreate.apply(vnode.properties.bind || vnode.properties, [
784+ domNode,
785+ projectionOptions,
786+ vnode.vnodeSelector,
787+ vnode.properties,
788+ vnode.children
789+ ]);
790+ }
791+ };
792+ var createDom = function(vnode, parentNode, insertBefore, projectionOptions) {
793+ var _a;
794+ var domNode;
795+ var start2 = 0;
796+ var vnodeSelector = vnode.vnodeSelector;
797+ var doc = parentNode.ownerDocument;
798+ if (vnodeSelector === "") {
799+ if (vnode.domNode) {
800+ vnode.domNode.nodeValue = vnode.text;
801+ } else {
802+ domNode = vnode.domNode = doc.createTextNode(vnode.text);
803+ if (insertBefore !== void 0) {
804+ parentNode.insertBefore(domNode, insertBefore);
805+ } else {
806+ parentNode.appendChild(domNode);
807+ }
808+ }
809+ } else {
810+ for (var i = 0; i <= vnodeSelector.length; ++i) {
811+ var c = vnodeSelector.charAt(i);
812+ if (i === vnodeSelector.length || c === "." || c === "#") {
813+ var type = vnodeSelector.charAt(start2 - 1);
814+ var found = vnodeSelector.slice(start2, i);
815+ if (type === ".") {
816+ domNode.classList.add(found);
817+ } else if (type === "#") {
818+ domNode.id = found;
819+ } else {
820+ if (found === "svg") {
821+ projectionOptions = extend2(projectionOptions, {
822+ namespace: NAMESPACE_SVG
823+ });
824+ }
825+ if (projectionOptions.namespace !== void 0) {
826+ domNode = vnode.domNode = doc.createElementNS(projectionOptions.namespace, found);
827+ } else {
828+ 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));
829+ if (found === "input" && vnode.properties && vnode.properties.type !== void 0) {
830+ domNode.setAttribute("type", vnode.properties.type);
831+ }
832+ }
833+ if (insertBefore !== void 0) {
834+ parentNode.insertBefore(domNode, insertBefore);
835+ } else if (domNode.parentNode !== parentNode) {
836+ parentNode.appendChild(domNode);
837+ }
838+ }
839+ start2 = i + 1;
840+ }
841+ }
842+ initPropertiesAndChildren(domNode, vnode, projectionOptions);
843+ }
844+ };
845+ var updateDom;
846+ var toggleClasses = function(domNode, classes, on2) {
847+ if (!classes) {
848+ return;
849+ }
850+ classes.split(" ").forEach(function(classToToggle) {
851+ if (classToToggle) {
852+ domNode.classList.toggle(classToToggle, on2);
853+ }
854+ });
855+ };
856+ var updateProperties = function(domNode, previousProperties, properties, projectionOptions) {
857+ if (!properties) {
858+ return;
859+ }
860+ var propertiesUpdated = false;
861+ var propNames = Object.keys(properties).filter(filterVNodeOnlyProps);
862+ var propCount = propNames.length;
863+ for (var i = 0; i < propCount; i++) {
864+ var propName = propNames[i];
865+ var propValue = properties[propName];
866+ var previousValue = previousProperties[propName];
867+ if (propName === "class") {
868+ if (previousValue !== propValue) {
869+ toggleClasses(domNode, previousValue, false);
870+ toggleClasses(domNode, propValue, true);
871+ }
872+ } else if (propName === "classes") {
873+ var classList = domNode.classList;
874+ var classNames = Object.keys(propValue);
875+ var classNameCount = classNames.length;
876+ for (var j = 0; j < classNameCount; j++) {
877+ var className = classNames[j];
878+ var on2 = !!propValue[className];
879+ var previousOn = !!previousValue[className];
880+ if (on2 === previousOn) {
881+ continue;
882+ }
883+ propertiesUpdated = true;
884+ if (on2) {
885+ classList.add(className);
886+ } else {
887+ classList.remove(className);
888+ }
889+ }
890+ } else if (propName === "styles") {
891+ var styleNames = Object.keys(propValue);
892+ var styleCount = styleNames.length;
893+ for (var j = 0; j < styleCount; j++) {
894+ var styleName = styleNames[j];
895+ var newStyleValue = propValue[styleName];
896+ var oldStyleValue = previousValue[styleName];
897+ if (newStyleValue === oldStyleValue) {
898+ continue;
899+ }
900+ propertiesUpdated = true;
901+ if (newStyleValue) {
902+ checkStyleValue(newStyleValue);
903+ projectionOptions.styleApplyer(domNode, styleName, newStyleValue);
904+ } else {
905+ projectionOptions.styleApplyer(domNode, styleName, "");
906+ }
907+ }
908+ } else {
909+ if (!propValue && typeof previousValue === "string") {
910+ propValue = "";
911+ }
912+ if (propName === "value") {
913+ var domValue = domNode[propName];
914+ if (domValue !== propValue && // The 'value' in the DOM tree !== newValue
915+ propValue !== previousValue) {
916+ domNode[propName] = propValue;
917+ }
918+ if (propValue !== previousValue) {
919+ propertiesUpdated = true;
920+ }
921+ } else if (propValue !== previousValue) {
922+ var type = typeof propValue;
923+ if (type !== "function" || !projectionOptions.eventHandlerInterceptor) {
924+ if (projectionOptions.namespace === NAMESPACE_SVG) {
925+ if (propName === "href") {
926+ domNode.setAttributeNS(NAMESPACE_XLINK, propName, propValue);
927+ } else {
928+ domNode.setAttribute(propName, propValue);
929+ }
930+ } else if (type === "string" && propName !== "innerHTML") {
931+ if (propName === "role" && propValue === "") {
932+ domNode.removeAttribute(propName);
933+ } else {
934+ domNode.setAttribute(propName, propValue);
935+ }
936+ } else if (domNode[propName] !== propValue) {
937+ domNode[propName] = propValue;
938+ }
939+ propertiesUpdated = true;
940+ }
941+ }
942+ }
943+ }
944+ return propertiesUpdated;
945+ };
946+ var updateChildren = function(vnode, domNode, oldChildren, newChildren, projectionOptions) {
947+ if (oldChildren === newChildren) {
948+ return false;
949+ }
950+ oldChildren = oldChildren || emptyArray;
951+ newChildren = newChildren || emptyArray;
952+ var oldChildrenLength = oldChildren.length;
953+ var newChildrenLength = newChildren.length;
954+ var oldIndex = 0;
955+ var newIndex = 0;
956+ var i;
957+ var textUpdated = false;
958+ while (newIndex < newChildrenLength) {
959+ var oldChild = oldIndex < oldChildrenLength ? oldChildren[oldIndex] : void 0;
960+ var newChild = newChildren[newIndex];
961+ if (oldChild !== void 0 && same(oldChild, newChild)) {
962+ textUpdated = updateDom(oldChild, newChild, projectionOptions, domNode, oldChildren) || textUpdated;
963+ oldIndex++;
964+ } else {
965+ var findOldIndex = findIndexOfChild(oldChildren, newChild, oldIndex + 1);
966+ if (findOldIndex >= 0) {
967+ for (i = oldIndex; i < findOldIndex; i++) {
968+ nodeToRemove(oldChildren[i]);
969+ checkDistinguishable(oldChildren, i, vnode, "removed");
970+ }
971+ textUpdated = updateDom(oldChildren[findOldIndex], newChild, projectionOptions, domNode, oldChildren) || textUpdated;
972+ oldIndex = findOldIndex + 1;
973+ } else {
974+ createDom(newChild, domNode, oldIndex < oldChildrenLength ? oldChildren[oldIndex].domNode : void 0, projectionOptions);
975+ nodeAdded(newChild);
976+ checkDistinguishable(newChildren, newIndex, vnode, "added");
977+ }
978+ }
979+ newIndex++;
980+ }
981+ if (oldChildrenLength > oldIndex) {
982+ for (i = oldIndex; i < oldChildrenLength; i++) {
983+ nodeToRemove(oldChildren[i]);
984+ checkDistinguishable(oldChildren, i, vnode, "removed");
985+ }
986+ }
987+ return textUpdated;
988+ };
989+ updateDom = function(previous, vnode, projectionOptions, parentNode, oldChildren) {
990+ var domNode = previous.domNode;
991+ var textUpdated = false;
992+ if (previous === vnode) {
993+ return false;
994+ }
995+ var updated = false;
996+ if (vnode.vnodeSelector === "") {
997+ if (vnode.text !== previous.text) {
998+ var newTextNode = domNode.ownerDocument.createTextNode(vnode.text);
999+ try {
1000+ parentNode.replaceChild(newTextNode, domNode);
1001+ } catch (e) {
1002+ parentNode.replaceChild(newTextNode, parentNode.childNodes[oldChildren.indexOf(previous)]);
1003+ }
1004+ vnode.domNode = newTextNode;
1005+ textUpdated = true;
1006+ return textUpdated;
1007+ }
1008+ vnode.domNode = domNode;
1009+ } else {
1010+ if (vnode.vnodeSelector.lastIndexOf("svg", 0) === 0) {
1011+ projectionOptions = extend2(projectionOptions, {
1012+ namespace: NAMESPACE_SVG
1013+ });
1014+ }
1015+ if (previous.text !== vnode.text) {
1016+ updated = true;
1017+ if (vnode.text === void 0) {
1018+ domNode.removeChild(domNode.firstChild);
1019+ } else {
1020+ domNode.textContent = vnode.text;
1021+ }
1022+ }
1023+ vnode.domNode = domNode;
1024+ updated = updateChildren(vnode, domNode, previous.children, vnode.children, projectionOptions) || updated;
1025+ updated = updateProperties(domNode, previous.properties, vnode.properties, projectionOptions) || updated;
1026+ if (vnode.properties && vnode.properties.afterUpdate) {
1027+ vnode.properties.afterUpdate.apply(vnode.properties.bind || vnode.properties, [
1028+ domNode,
1029+ projectionOptions,
1030+ vnode.vnodeSelector,
1031+ vnode.properties,
1032+ vnode.children
1033+ ]);
1034+ }
1035+ }
1036+ if (updated && vnode.properties && vnode.properties.updateAnimation) {
1037+ vnode.properties.updateAnimation(domNode, vnode.properties, previous.properties);
1038+ }
1039+ return textUpdated;
1040+ };
1041+ var createProjection = function(vnode, projectionOptions) {
1042+ return {
1043+ getLastRender: function() {
1044+ return vnode;
1045+ },
1046+ update: function(updatedVnode) {
1047+ if (vnode.vnodeSelector !== updatedVnode.vnodeSelector) {
1048+ 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)");
1049+ }
1050+ var previousVNode = vnode;
1051+ vnode = updatedVnode;
1052+ updateDom(previousVNode, updatedVnode, projectionOptions, previousVNode.domNode.parentNode, [previousVNode]);
1053+ },
1054+ domNode: vnode.domNode
1055+ };
1056+ };
1057+ var DEFAULT_PROJECTION_OPTIONS = {
1058+ namespace: void 0,
1059+ performanceLogger: function() {
1060+ return void 0;
1061+ },
1062+ eventHandlerInterceptor: void 0,
1063+ styleApplyer: function(domNode, styleName, value12) {
1064+ if (styleName.charAt(0) === "-") {
1065+ domNode.style.setProperty(styleName, value12);
1066+ } else {
1067+ domNode.style[styleName] = value12;
1068+ }
1069+ }
1070+ };
1071+ var applyDefaultProjectionOptions = function(projectorOptions) {
1072+ return extend2(DEFAULT_PROJECTION_OPTIONS, projectorOptions);
1073+ };
1074+ var dom = {
1075+ /**
1076+ * Creates a real DOM tree from `vnode`. The [[Projection]] object returned will contain the resulting DOM Node in
1077+ * its [[Projection.domNode|domNode]] property.
1078+ * This is a low-level method. Users will typically use a [[Projector]] instead.
1079+ * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
1080+ * objects may only be rendered once.
1081+ * @param projectionOptions - Options to be used to create and update the projection.
1082+ * @returns The [[Projection]] which also contains the DOM Node that was created.
1083+ */
1084+ create: function(vnode, projectionOptions) {
1085+ projectionOptions = applyDefaultProjectionOptions(projectionOptions);
1086+ createDom(vnode, document.createElement("div"), void 0, projectionOptions);
1087+ return createProjection(vnode, projectionOptions);
1088+ },
1089+ /**
1090+ * Appends a new child node to the DOM which is generated from a [[VNode]].
1091+ * This is a low-level method. Users will typically use a [[Projector]] instead.
1092+ * @param parentNode - The parent node for the new child node.
1093+ * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
1094+ * objects may only be rendered once.
1095+ * @param projectionOptions - Options to be used to create and update the [[Projection]].
1096+ * @returns The [[Projection]] that was created.
1097+ */
1098+ append: function(parentNode, vnode, projectionOptions) {
1099+ projectionOptions = applyDefaultProjectionOptions(projectionOptions);
1100+ createDom(vnode, parentNode, void 0, projectionOptions);
1101+ return createProjection(vnode, projectionOptions);
1102+ },
1103+ /**
1104+ * Inserts a new DOM node which is generated from a [[VNode]].
1105+ * This is a low-level method. Users wil typically use a [[Projector]] instead.
1106+ * @param beforeNode - The node that the DOM Node is inserted before.
1107+ * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function.
1108+ * NOTE: [[VNode]] objects may only be rendered once.
1109+ * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
1110+ * @returns The [[Projection]] that was created.
1111+ */
1112+ insertBefore: function(beforeNode, vnode, projectionOptions) {
1113+ projectionOptions = applyDefaultProjectionOptions(projectionOptions);
1114+ createDom(vnode, beforeNode.parentNode, beforeNode, projectionOptions);
1115+ return createProjection(vnode, projectionOptions);
1116+ },
1117+ /**
1118+ * Merges a new DOM node which is generated from a [[VNode]] with an existing DOM Node.
1119+ * This means that the virtual DOM and the real DOM will have one overlapping element.
1120+ * Therefore the selector for the root [[VNode]] will be ignored, but its properties and children will be applied to the Element provided.
1121+ * This is a low-level method. Users wil typically use a [[Projector]] instead.
1122+ * @param element - The existing element to adopt as the root of the new virtual DOM. Existing attributes and child nodes are preserved.
1123+ * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]] objects
1124+ * may only be rendered once.
1125+ * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
1126+ * @returns The [[Projection]] that was created.
1127+ */
1128+ merge: function(element, vnode, projectionOptions) {
1129+ projectionOptions = applyDefaultProjectionOptions(projectionOptions);
1130+ vnode.domNode = element;
1131+ initPropertiesAndChildren(element, vnode, projectionOptions);
1132+ return createProjection(vnode, projectionOptions);
1133+ },
1134+ /**
1135+ * Replaces an existing DOM node with a node generated from a [[VNode]].
1136+ * This is a low-level method. Users will typically use a [[Projector]] instead.
1137+ * @param element - The node for the [[VNode]] to replace.
1138+ * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
1139+ * objects may only be rendered once.
1140+ * @param projectionOptions - Options to be used to create and update the [[Projection]].
1141+ * @returns The [[Projection]] that was created.
1142+ */
1143+ replace: function(element, vnode, projectionOptions) {
1144+ projectionOptions = applyDefaultProjectionOptions(projectionOptions);
1145+ createDom(vnode, element.parentNode, element, projectionOptions);
1146+ element.parentNode.removeChild(element);
1147+ return createProjection(vnode, projectionOptions);
1148+ }
1149+ };
1150+ var toTextVNode = function(data) {
1151+ return {
1152+ vnodeSelector: "",
1153+ properties: void 0,
1154+ children: void 0,
1155+ text: data.toString(),
1156+ domNode: null
1157+ };
1158+ };
1159+ var appendChildren = function(parentSelector, insertions, main2) {
1160+ for (var i = 0, length_1 = insertions.length; i < length_1; i++) {
1161+ var item = insertions[i];
1162+ if (Array.isArray(item)) {
1163+ appendChildren(parentSelector, item, main2);
1164+ } else {
1165+ if (item !== null && item !== void 0 && item !== false) {
1166+ if (typeof item === "string") {
1167+ item = toTextVNode(item);
1168+ }
1169+ main2.push(item);
1170+ }
1171+ }
1172+ }
1173+ };
1174+ function h(selector, properties, children) {
1175+ if (Array.isArray(properties)) {
1176+ children = properties;
1177+ properties = void 0;
1178+ } else if (properties && (typeof properties === "string" || properties.vnodeSelector) || children && (typeof children === "string" || children.vnodeSelector)) {
1179+ throw new Error("h called with invalid arguments");
1180+ }
1181+ var text5;
1182+ var flattenedChildren;
1183+ if (children && children.length === 1 && typeof children[0] === "string") {
1184+ text5 = children[0];
1185+ } else if (children) {
1186+ flattenedChildren = [];
1187+ appendChildren(selector, children, flattenedChildren);
1188+ if (flattenedChildren.length === 0) {
1189+ flattenedChildren = void 0;
1190+ }
1191+ }
1192+ return {
1193+ vnodeSelector: selector,
1194+ properties,
1195+ children: flattenedChildren,
1196+ text: text5 === "" ? void 0 : text5,
1197+ domNode: null
1198+ };
1199+ }
1200+ var createParentNodePath = function(node, rootNode) {
1201+ var parentNodePath = [];
1202+ while (node && node !== rootNode) {
1203+ parentNodePath.push(node);
1204+ node = node.parentNode;
1205+ }
1206+ return parentNodePath;
1207+ };
1208+ var find2;
1209+ if (Array.prototype.find) {
1210+ find2 = function(items, predicate) {
1211+ return items.find(predicate);
1212+ };
1213+ } else {
1214+ find2 = function(items, predicate) {
1215+ return items.filter(predicate)[0];
1216+ };
1217+ }
1218+ var findVNodeByParentNodePath = function(vnode, parentNodePath) {
1219+ var result = vnode;
1220+ parentNodePath.forEach(function(node) {
1221+ result = result && result.children ? find2(result.children, function(child) {
1222+ return child.domNode === node;
1223+ }) : void 0;
1224+ });
1225+ return result;
1226+ };
1227+ var createEventHandlerInterceptor = function(projector, getProjection, performanceLogger) {
1228+ return function(propertyName, eventHandler, domNode, properties) {
1229+ return modifiedEventHandler;
1230+ };
1231+ function modifiedEventHandler(evt) {
1232+ var _a, _b;
1233+ performanceLogger("domEvent", evt);
1234+ var projection = getProjection();
1235+ var parentNodePath = createParentNodePath(evt.currentTarget, projection.domNode);
1236+ parentNodePath.reverse();
1237+ var matchingVNode = findVNodeByParentNodePath(projection.getLastRender(), parentNodePath);
1238+ projector.scheduleRender();
1239+ var result;
1240+ if (matchingVNode) {
1241+ 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];
1242+ result = listener.apply(matchingVNode.properties.bind || this, arguments);
1243+ }
1244+ performanceLogger("domEventProcessed", evt);
1245+ return result;
1246+ }
1247+ };
1248+ var createProjector = function(projectorOptions) {
1249+ var projector;
1250+ var projectionOptions = applyDefaultProjectionOptions(projectorOptions);
1251+ var performanceLogger = projectionOptions.performanceLogger;
1252+ var renderCompleted = true;
1253+ var scheduled;
1254+ var stopped = false;
1255+ var projections = [];
1256+ var renderFunctions = [];
1257+ var addProjection = function(domFunction, node, renderFunction) {
1258+ var projection;
1259+ var getProjection = function() {
1260+ return projection;
1261+ };
1262+ projectionOptions.eventHandlerInterceptor = createEventHandlerInterceptor(projector, getProjection, performanceLogger);
1263+ projection = domFunction(node, renderFunction(), projectionOptions);
1264+ projections.push(projection);
1265+ renderFunctions.push(renderFunction);
1266+ };
1267+ var doRender = function() {
1268+ scheduled = void 0;
1269+ if (!renderCompleted) {
1270+ return;
1271+ }
1272+ renderCompleted = false;
1273+ performanceLogger("renderStart", void 0);
1274+ for (var i = 0; i < projections.length; i++) {
1275+ var updatedVnode = renderFunctions[i]();
1276+ performanceLogger("rendered", void 0);
1277+ projections[i].update(updatedVnode);
1278+ performanceLogger("patched", void 0);
1279+ }
1280+ performanceLogger("renderDone", void 0);
1281+ renderCompleted = true;
1282+ };
1283+ projector = {
1284+ renderNow: doRender,
1285+ scheduleRender: function() {
1286+ if (!scheduled && !stopped) {
1287+ scheduled = requestAnimationFrame(doRender);
1288+ }
1289+ },
1290+ stop: function() {
1291+ if (scheduled) {
1292+ cancelAnimationFrame(scheduled);
1293+ scheduled = void 0;
1294+ }
1295+ stopped = true;
1296+ },
1297+ resume: function() {
1298+ stopped = false;
1299+ renderCompleted = true;
1300+ projector.scheduleRender();
1301+ },
1302+ append: function(parentNode, renderFunction) {
1303+ addProjection(dom.append, parentNode, renderFunction);
1304+ },
1305+ insertBefore: function(beforeNode, renderFunction) {
1306+ addProjection(dom.insertBefore, beforeNode, renderFunction);
1307+ },
1308+ merge: function(domNode, renderFunction) {
1309+ addProjection(dom.merge, domNode, renderFunction);
1310+ },
1311+ replace: function(domNode, renderFunction) {
1312+ addProjection(dom.replace, domNode, renderFunction);
1313+ },
1314+ detach: function(renderFunction) {
1315+ for (var i = 0; i < renderFunctions.length; i++) {
1316+ if (renderFunctions[i] === renderFunction) {
1317+ renderFunctions.splice(i, 1);
1318+ return projections.splice(i, 1)[0];
1319+ }
1320+ }
1321+ throw new Error("renderFunction was not found");
1322+ }
1323+ };
1324+ return projector;
1325+ };
1326+ function _h(selector) {
1327+ return function(properties) {
1328+ return function(children) {
1329+ return h(selector, properties, children);
1330+ };
1331+ };
1332+ }
1333+ function replace(projector) {
1334+ return function(el) {
1335+ return function(render3) {
1336+ return function() {
1337+ projector.replace(el, render3);
1338+ };
1339+ };
1340+ };
1341+ }
1342+
1343+ // output/Maquette/index.js
1344+ var string = unsafeCoerce2;
1345+ var h2 = _h;
1346+
1347+ // output/Data.Int/foreign.js
1348+ var fromNumberImpl = function(just) {
1349+ return function(nothing) {
1350+ return function(n) {
1351+ return (n | 0) === n ? just(n) : nothing;
1352+ };
1353+ };
1354+ };
1355+ var toNumber = function(n) {
1356+ return n;
1357+ };
1358+
1359+ // output/Data.Number/foreign.js
1360+ var isFiniteImpl = isFinite;
1361+ var round = Math.round;
1362+
1363+ // output/Data.Int/index.js
1364+ var top2 = /* @__PURE__ */ top(boundedInt);
1365+ var bottom2 = /* @__PURE__ */ bottom(boundedInt);
1366+ var fromNumber = /* @__PURE__ */ function() {
1367+ return fromNumberImpl(Just.create)(Nothing.value);
1368+ }();
1369+ var unsafeClamp = function(x) {
1370+ if (!isFiniteImpl(x)) {
1371+ return 0;
1372+ }
1373+ ;
1374+ if (x >= toNumber(top2)) {
1375+ return top2;
1376+ }
1377+ ;
1378+ if (x <= toNumber(bottom2)) {
1379+ return bottom2;
1380+ }
1381+ ;
1382+ if (otherwise) {
1383+ return fromMaybe(0)(fromNumber(x));
1384+ }
1385+ ;
1386+ throw new Error("Failed pattern match at Data.Int (line 72, column 1 - line 72, column 29): " + [x.constructor.name]);
1387+ };
1388+ var round2 = function($37) {
1389+ return unsafeClamp(round($37));
1390+ };
1391+
1392+ // output/Foreign.Object/foreign.js
1393+ function _copyST(m) {
1394+ return function() {
1395+ var r = {};
1396+ for (var k in m) {
1397+ if (hasOwnProperty.call(m, k)) {
1398+ r[k] = m[k];
1399+ }
1400+ }
1401+ return r;
1402+ };
1403+ }
1404+ var empty2 = {};
1405+ function runST(f) {
1406+ return f();
1407+ }
1408+ function _foldM(bind3) {
1409+ return function(f) {
1410+ return function(mz) {
1411+ return function(m) {
1412+ var acc = mz;
1413+ function g(k2) {
1414+ return function(z) {
1415+ return f(z)(k2)(m[k2]);
1416+ };
1417+ }
1418+ for (var k in m) {
1419+ if (hasOwnProperty.call(m, k)) {
1420+ acc = bind3(acc)(g(k));
1421+ }
1422+ }
1423+ return acc;
1424+ };
1425+ };
1426+ };
1427+ }
1428+ function toArrayWithKey(f) {
1429+ return function(m) {
1430+ var r = [];
1431+ for (var k in m) {
1432+ if (hasOwnProperty.call(m, k)) {
1433+ r.push(f(k)(m[k]));
1434+ }
1435+ }
1436+ return r;
1437+ };
1438+ }
1439+ var keys = Object.keys || toArrayWithKey(function(k) {
1440+ return function() {
1441+ return k;
1442+ };
1443+ });
1444+
1445+ // output/Foreign.Object.ST/foreign.js
1446+ var newImpl = function() {
1447+ return {};
1448+ };
1449+ function poke2(k) {
1450+ return function(v) {
1451+ return function(m) {
1452+ return function() {
1453+ m[k] = v;
1454+ return m;
1455+ };
1456+ };
1457+ };
1458+ }
1459+
1460+ // output/Foreign.Object/index.js
1461+ var bindFlipped2 = /* @__PURE__ */ bindFlipped(bindST);
1462+ var thawST = _copyST;
1463+ var singleton2 = function(k) {
1464+ return function(v) {
1465+ return runST(bindFlipped2(poke2(k)(v))(newImpl));
1466+ };
1467+ };
1468+ var mutate = function(f) {
1469+ return function(m) {
1470+ return runST(function __do() {
1471+ var s = thawST(m)();
1472+ f(s)();
1473+ return s;
1474+ });
1475+ };
1476+ };
1477+ var foldM = function(dictMonad) {
1478+ var bind1 = bind(dictMonad.Bind1());
1479+ var pure1 = pure(dictMonad.Applicative0());
1480+ return function(f) {
1481+ return function(z) {
1482+ return _foldM(bind1)(f)(pure1(z));
1483+ };
1484+ };
1485+ };
1486+ var foldM1 = /* @__PURE__ */ foldM(monadST);
1487+ var union = function(m) {
1488+ return mutate(function(s) {
1489+ return foldM1(function(s$prime) {
1490+ return function(k) {
1491+ return function(v) {
1492+ return poke2(k)(v)(s$prime);
1493+ };
1494+ };
1495+ })(s)(m);
1496+ });
1497+ };
1498+
1499+ // output/Record.Unsafe.Union/foreign.js
1500+ function unsafeUnionFn(r1, r2) {
1501+ var copy = {};
1502+ for (var k1 in r2) {
1503+ if ({}.hasOwnProperty.call(r2, k1)) {
1504+ copy[k1] = r2[k1];
1505+ }
1506+ }
1507+ for (var k2 in r1) {
1508+ if ({}.hasOwnProperty.call(r1, k2)) {
1509+ copy[k2] = r1[k2];
1510+ }
1511+ }
1512+ return copy;
1513+ }
1514+
1515+ // output/Record.Unsafe.Union/index.js
1516+ var unsafeUnion = /* @__PURE__ */ runFn2(unsafeUnionFn);
1517+
1518+ // output/Plum.View/index.js
1519+ var show2 = /* @__PURE__ */ show(showInt);
1520+ var show1 = /* @__PURE__ */ show(showNumber);
1521+ var append1 = /* @__PURE__ */ append(semigroupArray);
1522+ var mempty2 = /* @__PURE__ */ mempty(monoidArray);
1523+ var map2 = /* @__PURE__ */ map(functorArray);
1524+ var Px = /* @__PURE__ */ function() {
1525+ function Px2(value0) {
1526+ this.value0 = value0;
1527+ }
1528+ ;
1529+ Px2.create = function(value0) {
1530+ return new Px2(value0);
1531+ };
1532+ return Px2;
1533+ }();
1534+ var Fill = /* @__PURE__ */ function() {
1535+ function Fill2() {
1536+ }
1537+ ;
1538+ Fill2.value = new Fill2();
1539+ return Fill2;
1540+ }();
1541+ var Fit = /* @__PURE__ */ function() {
1542+ function Fit2() {
1543+ }
1544+ ;
1545+ Fit2.value = new Fit2();
1546+ return Fit2;
1547+ }();
1548+ var Max2 = /* @__PURE__ */ function() {
1549+ function Max3(value0, value1) {
1550+ this.value0 = value0;
1551+ this.value1 = value1;
1552+ }
1553+ ;
1554+ Max3.create = function(value0) {
1555+ return function(value1) {
1556+ return new Max3(value0, value1);
1557+ };
1558+ };
1559+ return Max3;
1560+ }();
1561+ var Min2 = /* @__PURE__ */ function() {
1562+ function Min3(value0, value1) {
1563+ this.value0 = value0;
1564+ this.value1 = value1;
1565+ }
1566+ ;
1567+ Min3.create = function(value0) {
1568+ return function(value1) {
1569+ return new Min3(value0, value1);
1570+ };
1571+ };
1572+ return Min3;
1573+ }();
1574+ var X = /* @__PURE__ */ function() {
1575+ function X2() {
1576+ }
1577+ ;
1578+ X2.value = new X2();
1579+ return X2;
1580+ }();
1581+ var Y = /* @__PURE__ */ function() {
1582+ function Y2() {
1583+ }
1584+ ;
1585+ Y2.value = new Y2();
1586+ return Y2;
1587+ }();
1588+ var Grid = /* @__PURE__ */ function() {
1589+ function Grid2() {
1590+ }
1591+ ;
1592+ Grid2.value = new Grid2();
1593+ return Grid2;
1594+ }();
1595+ var Flexbox = /* @__PURE__ */ function() {
1596+ function Flexbox2(value0) {
1597+ this.value0 = value0;
1598+ }
1599+ ;
1600+ Flexbox2.create = function(value0) {
1601+ return new Flexbox2(value0);
1602+ };
1603+ return Flexbox2;
1604+ }();
1605+ var Generic = /* @__PURE__ */ function() {
1606+ function Generic2() {
1607+ }
1608+ ;
1609+ Generic2.value = new Generic2();
1610+ return Generic2;
1611+ }();
1612+ var Span = /* @__PURE__ */ function() {
1613+ function Span2() {
1614+ }
1615+ ;
1616+ Span2.value = new Span2();
1617+ return Span2;
1618+ }();
1619+ var Start = /* @__PURE__ */ function() {
1620+ function Start2() {
1621+ }
1622+ ;
1623+ Start2.value = new Start2();
1624+ return Start2;
1625+ }();
1626+ var Center = /* @__PURE__ */ function() {
1627+ function Center2() {
1628+ }
1629+ ;
1630+ Center2.value = new Center2();
1631+ return Center2;
1632+ }();
1633+ var End = /* @__PURE__ */ function() {
1634+ function End2() {
1635+ }
1636+ ;
1637+ End2.value = new End2();
1638+ return End2;
1639+ }();
1640+ var Spacing = /* @__PURE__ */ function() {
1641+ function Spacing2(value0, value1) {
1642+ this.value0 = value0;
1643+ this.value1 = value1;
1644+ }
1645+ ;
1646+ Spacing2.create = function(value0) {
1647+ return function(value1) {
1648+ return new Spacing2(value0, value1);
1649+ };
1650+ };
1651+ return Spacing2;
1652+ }();
1653+ var Explain = /* @__PURE__ */ function() {
1654+ function Explain2() {
1655+ }
1656+ ;
1657+ Explain2.value = new Explain2();
1658+ return Explain2;
1659+ }();
1660+ var Align = /* @__PURE__ */ function() {
1661+ function Align2(value0, value1) {
1662+ this.value0 = value0;
1663+ this.value1 = value1;
1664+ }
1665+ ;
1666+ Align2.create = function(value0) {
1667+ return function(value1) {
1668+ return new Align2(value0, value1);
1669+ };
1670+ };
1671+ return Align2;
1672+ }();
1673+ var Width = /* @__PURE__ */ function() {
1674+ function Width2(value0) {
1675+ this.value0 = value0;
1676+ }
1677+ ;
1678+ Width2.create = function(value0) {
1679+ return new Width2(value0);
1680+ };
1681+ return Width2;
1682+ }();
1683+ var Height = /* @__PURE__ */ function() {
1684+ function Height2(value0) {
1685+ this.value0 = value0;
1686+ }
1687+ ;
1688+ Height2.create = function(value0) {
1689+ return new Height2(value0);
1690+ };
1691+ return Height2;
1692+ }();
1693+ var Wrapped = /* @__PURE__ */ function() {
1694+ function Wrapped2() {
1695+ }
1696+ ;
1697+ Wrapped2.value = new Wrapped2();
1698+ return Wrapped2;
1699+ }();
1700+ var BackgroundColor = /* @__PURE__ */ function() {
1701+ function BackgroundColor2(value0) {
1702+ this.value0 = value0;
1703+ }
1704+ ;
1705+ BackgroundColor2.create = function(value0) {
1706+ return new BackgroundColor2(value0);
1707+ };
1708+ return BackgroundColor2;
1709+ }();
1710+ var Padding = /* @__PURE__ */ function() {
1711+ function Padding2(value0) {
1712+ this.value0 = value0;
1713+ }
1714+ ;
1715+ Padding2.create = function(value0) {
1716+ return new Padding2(value0);
1717+ };
1718+ return Padding2;
1719+ }();
1720+ var Spread = /* @__PURE__ */ function() {
1721+ function Spread2() {
1722+ }
1723+ ;
1724+ Spread2.value = new Spread2();
1725+ return Spread2;
1726+ }();
1727+ var Opacity = /* @__PURE__ */ function() {
1728+ function Opacity2(value0) {
1729+ this.value0 = value0;
1730+ }
1731+ ;
1732+ Opacity2.create = function(value0) {
1733+ return new Opacity2(value0);
1734+ };
1735+ return Opacity2;
1736+ }();
1737+ var Pointer = /* @__PURE__ */ function() {
1738+ function Pointer2() {
1739+ }
1740+ ;
1741+ Pointer2.value = new Pointer2();
1742+ return Pointer2;
1743+ }();
1744+ var Move = /* @__PURE__ */ function() {
1745+ function Move2(value0) {
1746+ this.value0 = value0;
1747+ }
1748+ ;
1749+ Move2.create = function(value0) {
1750+ return new Move2(value0);
1751+ };
1752+ return Move2;
1753+ }();
1754+ var Clip = /* @__PURE__ */ function() {
1755+ function Clip2(value0) {
1756+ this.value0 = value0;
1757+ }
1758+ ;
1759+ Clip2.create = function(value0) {
1760+ return new Clip2(value0);
1761+ };
1762+ return Clip2;
1763+ }();
1764+ var Column = /* @__PURE__ */ function() {
1765+ function Column2(value0) {
1766+ this.value0 = value0;
1767+ }
1768+ ;
1769+ Column2.create = function(value0) {
1770+ return new Column2(value0);
1771+ };
1772+ return Column2;
1773+ }();
1774+ var Row = /* @__PURE__ */ function() {
1775+ function Row2(value0) {
1776+ this.value0 = value0;
1777+ }
1778+ ;
1779+ Row2.create = function(value0) {
1780+ return new Row2(value0);
1781+ };
1782+ return Row2;
1783+ }();
1784+ var Stack = /* @__PURE__ */ function() {
1785+ function Stack2(value0) {
1786+ this.value0 = value0;
1787+ }
1788+ ;
1789+ Stack2.create = function(value0) {
1790+ return new Stack2(value0);
1791+ };
1792+ return Stack2;
1793+ }();
1794+ var Wrapper = /* @__PURE__ */ function() {
1795+ function Wrapper2(value0) {
1796+ this.value0 = value0;
1797+ }
1798+ ;
1799+ Wrapper2.create = function(value0) {
1800+ return new Wrapper2(value0);
1801+ };
1802+ return Wrapper2;
1803+ }();
1804+ var Text = /* @__PURE__ */ function() {
1805+ function Text2(value0) {
1806+ this.value0 = value0;
1807+ }
1808+ ;
1809+ Text2.create = function(value0) {
1810+ return new Text2(value0);
1811+ };
1812+ return Text2;
1813+ }();
1814+ var Link = /* @__PURE__ */ function() {
1815+ function Link2(value0, value1, value22) {
1816+ this.value0 = value0;
1817+ this.value1 = value1;
1818+ this.value2 = value22;
1819+ }
1820+ ;
1821+ Link2.create = function(value0) {
1822+ return function(value1) {
1823+ return function(value22) {
1824+ return new Link2(value0, value1, value22);
1825+ };
1826+ };
1827+ };
1828+ return Link2;
1829+ }();
1830+ var Download = /* @__PURE__ */ function() {
1831+ function Download2(value0, value1, value22) {
1832+ this.value0 = value0;
1833+ this.value1 = value1;
1834+ this.value2 = value22;
1835+ }
1836+ ;
1837+ Download2.create = function(value0) {
1838+ return function(value1) {
1839+ return function(value22) {
1840+ return new Download2(value0, value1, value22);
1841+ };
1842+ };
1843+ };
1844+ return Download2;
1845+ }();
1846+ var semigroupSkin = {
1847+ append: function(v) {
1848+ return function(v1) {
1849+ return union(v)(v1);
1850+ };
1851+ }
1852+ };
1853+ var append2 = /* @__PURE__ */ append(semigroupSkin);
1854+ var semigroupMutation = {
1855+ append: function(v) {
1856+ return function(v1) {
1857+ return {
1858+ extraSkin: append2(v.extraSkin)(v1.extraSkin)
1859+ };
1860+ };
1861+ }
1862+ };
1863+ var renderableColor = {
1864+ render: function(v) {
1865+ return "rgba(" + (show2(v.r) + ("," + (show2(v.g) + ("," + (show2(v.b) + ("," + (show1(v.a) + ")")))))));
1866+ }
1867+ };
1868+ var monoidSkin = {
1869+ mempty: empty2,
1870+ Semigroup0: function() {
1871+ return semigroupSkin;
1872+ }
1873+ };
1874+ var mempty1 = /* @__PURE__ */ mempty(monoidSkin);
1875+ var foldMap3 = /* @__PURE__ */ foldMap2(monoidSkin);
1876+ var monoidMutation = {
1877+ mempty: {
1878+ extraSkin: mempty1
1879+ },
1880+ Semigroup0: function() {
1881+ return semigroupMutation;
1882+ }
1883+ };
1884+ var mempty22 = /* @__PURE__ */ mempty(monoidMutation);
1885+ var view = function(nerves) {
1886+ return function(meat) {
1887+ return function(bones) {
1888+ return {
1889+ nerves,
1890+ meat,
1891+ bones
1892+ };
1893+ };
1894+ };
1895+ };
1896+ var sk = function(key) {
1897+ return function(val) {
1898+ return singleton2(key)(val);
1899+ };
1900+ };
1901+ var rgb = function(r) {
1902+ return function(g) {
1903+ return function(b) {
1904+ return {
1905+ r: round2(r * 255),
1906+ g: round2(g * 255),
1907+ b: round2(b * 255),
1908+ a: 1
1909+ };
1910+ };
1911+ };
1912+ };
1913+ var render = function(dict) {
1914+ return dict.render;
1915+ };
1916+ var render1 = /* @__PURE__ */ render(renderableColor);
1917+ var renderableLength = {
1918+ render: function(v) {
1919+ if (v instanceof Px) {
1920+ return show2(v.value0) + "px";
1921+ }
1922+ ;
1923+ if (v instanceof Fit) {
1924+ return "fit-content";
1925+ }
1926+ ;
1927+ if (v instanceof Fill) {
1928+ return "100%";
1929+ }
1930+ ;
1931+ if (v instanceof Max2) {
1932+ return "max(" + (show2(v.value0) + ("px," + (render(renderableLength)(v.value1) + ")")));
1933+ }
1934+ ;
1935+ if (v instanceof Min2) {
1936+ return "min(" + (show2(v.value0) + ("px," + (render(renderableLength)(v.value1) + ")")));
1937+ }
1938+ ;
1939+ throw new Error("Failed pattern match at Plum.View (line 131, column 12 - line 136, column 62): " + [v.constructor.name]);
1940+ }
1941+ };
1942+ var render2 = /* @__PURE__ */ render(renderableLength);
1943+ var skin = function(ctx) {
1944+ return function(v) {
1945+ if (v instanceof Spacing) {
1946+ return sk("gap")(show2(v.value0) + ("px " + (show2(v.value1) + "px")));
1947+ }
1948+ ;
1949+ if (v instanceof Explain) {
1950+ return sk("border")("dashed magenta");
1951+ }
1952+ ;
1953+ if (v instanceof Align) {
1954+ if (ctx instanceof Generic) {
1955+ return mempty1;
1956+ }
1957+ ;
1958+ if (ctx instanceof Span) {
1959+ return mempty1;
1960+ }
1961+ ;
1962+ if (ctx instanceof Grid) {
1963+ return sk(function() {
1964+ if (v.value0 instanceof X) {
1965+ return "justify-items";
1966+ }
1967+ ;
1968+ if (v.value0 instanceof Y) {
1969+ return "align-items";
1970+ }
1971+ ;
1972+ throw new Error("Failed pattern match at Plum.View (line 88, column 9 - line 90, column 29): " + [v.value0.constructor.name]);
1973+ }())(function() {
1974+ if (v.value1 instanceof Start) {
1975+ return "start";
1976+ }
1977+ ;
1978+ if (v.value1 instanceof Center) {
1979+ return "center";
1980+ }
1981+ ;
1982+ if (v.value1 instanceof End) {
1983+ return "end";
1984+ }
1985+ ;
1986+ throw new Error("Failed pattern match at Plum.View (line 92, column 9 - line 95, column 23): " + [v.value1.constructor.name]);
1987+ }());
1988+ }
1989+ ;
1990+ if (ctx instanceof Flexbox) {
1991+ return sk(function() {
1992+ var v1 = new Tuple(ctx.value0, v.value0);
1993+ if (v1.value0 instanceof X && v1.value1 instanceof X) {
1994+ return "justify-content";
1995+ }
1996+ ;
1997+ if (v1.value0 instanceof X && v1.value1 instanceof Y) {
1998+ return "align-items";
1999+ }
2000+ ;
2001+ if (v1.value0 instanceof Y && v1.value1 instanceof X) {
2002+ return "align-items";
2003+ }
2004+ ;
2005+ if (v1.value0 instanceof Y && v1.value1 instanceof Y) {
2006+ return "justify-content";
2007+ }
2008+ ;
2009+ throw new Error("Failed pattern match at Plum.View (line 99, column 9 - line 103, column 38): " + [v1.constructor.name]);
2010+ }())(function() {
2011+ if (v.value1 instanceof Start) {
2012+ return "flex-start";
2013+ }
2014+ ;
2015+ if (v.value1 instanceof Center) {
2016+ return "center";
2017+ }
2018+ ;
2019+ if (v.value1 instanceof End) {
2020+ return "flex-end";
2021+ }
2022+ ;
2023+ throw new Error("Failed pattern match at Plum.View (line 105, column 9 - line 108, column 28): " + [v.value1.constructor.name]);
2024+ }());
2025+ }
2026+ ;
2027+ throw new Error("Failed pattern match at Plum.View (line 84, column 26 - line 109, column 8): " + [ctx.constructor.name]);
2028+ }
2029+ ;
2030+ if (v instanceof Width) {
2031+ return sk("width")(render2(v.value0));
2032+ }
2033+ ;
2034+ if (v instanceof Height) {
2035+ return sk("height")(render2(v.value0));
2036+ }
2037+ ;
2038+ if (v instanceof Wrapped) {
2039+ if (ctx instanceof Flexbox) {
2040+ return sk("flex-wrap")("wrap");
2041+ }
2042+ ;
2043+ return mempty1;
2044+ }
2045+ ;
2046+ if (v instanceof BackgroundColor) {
2047+ return sk("background-color")(render1(v.value0));
2048+ }
2049+ ;
2050+ if (v instanceof Padding) {
2051+ return sk("padding")(show2(v.value0.top) + ("px " + (show2(v.value0.right) + ("px " + (show2(v.value0.bottom) + ("px " + (show2(v.value0.left) + "px")))))));
2052+ }
2053+ ;
2054+ if (v instanceof Spread) {
2055+ if (ctx instanceof Flexbox) {
2056+ return sk("justify-content")("space-between");
2057+ }
2058+ ;
2059+ return mempty1;
2060+ }
2061+ ;
2062+ if (v instanceof Opacity) {
2063+ return sk("opacity")(show1(v.value0));
2064+ }
2065+ ;
2066+ if (v instanceof Pointer) {
2067+ return sk("cursor")("pointer");
2068+ }
2069+ ;
2070+ if (v instanceof Move) {
2071+ return sk("transform")("translate(" + (show2(v.value0.x) + ("px, " + (show2(v.value0.y) + ")"))));
2072+ }
2073+ ;
2074+ if (v instanceof Clip && v.value0 instanceof X) {
2075+ return sk("overflow-x")("hidden");
2076+ }
2077+ ;
2078+ if (v instanceof Clip && v.value0 instanceof Y) {
2079+ return sk("overflow-y")("hidden");
2080+ }
2081+ ;
2082+ throw new Error("Failed pattern match at Plum.View (line 81, column 12 - line 125, column 37): " + [v.constructor.name]);
2083+ };
2084+ };
2085+ var hWith = function(el) {
2086+ return function(props) {
2087+ return function(v) {
2088+ return function(children) {
2089+ return h2(el)(unsafeUnion(props)({
2090+ styles: v
2091+ }))(children);
2092+ };
2093+ };
2094+ };
2095+ };
2096+ var h3 = function(el) {
2097+ return function(v) {
2098+ return function(children) {
2099+ return h2(el)({
2100+ styles: v
2101+ })(children);
2102+ };
2103+ };
2104+ };
2105+ var growSkin = function(fire) {
2106+ return function(v) {
2107+ return function(v1) {
2108+ var widthFill = [new Width(Fill.value), new Height(Fill.value)];
2109+ var alignCenter = [new Align(X.value, Center.value), new Align(Y.value, Center.value)];
2110+ var skn = function(ctx) {
2111+ return append2(foldMap3(skin(ctx))(append1(v1.meat)(append1(function() {
2112+ if (ctx instanceof Span) {
2113+ return mempty2;
2114+ }
2115+ ;
2116+ if (ctx instanceof Grid) {
2117+ return widthFill;
2118+ }
2119+ ;
2120+ if (ctx instanceof Flexbox) {
2121+ return widthFill;
2122+ }
2123+ ;
2124+ if (ctx instanceof Generic) {
2125+ return widthFill;
2126+ }
2127+ ;
2128+ throw new Error("Failed pattern match at Plum.View (line 181, column 16 - line 185, column 35): " + [ctx.constructor.name]);
2129+ }())(function() {
2130+ if (ctx instanceof Grid) {
2131+ return alignCenter;
2132+ }
2133+ ;
2134+ if (ctx instanceof Flexbox) {
2135+ return alignCenter;
2136+ }
2137+ ;
2138+ if (ctx instanceof Span) {
2139+ return mempty2;
2140+ }
2141+ ;
2142+ if (ctx instanceof Generic) {
2143+ return alignCenter;
2144+ }
2145+ ;
2146+ throw new Error("Failed pattern match at Plum.View (line 186, column 16 - line 190, column 37): " + [ctx.constructor.name]);
2147+ }()))))(v.extraSkin);
2148+ };
2149+ if (v1.bones instanceof Text) {
2150+ return h3("span")(skn(Span.value))([string(v1.bones.value0)]);
2151+ }
2152+ ;
2153+ if (v1.bones instanceof Wrapper) {
2154+ return h3("div")(append2(skn(new Flexbox(X.value)))(append2(sk("display")("flex"))(sk("flex-direction")("row"))))([growSkin(fire)(mempty22)(v1.bones.value0)]);
2155+ }
2156+ ;
2157+ if (v1.bones instanceof Stack) {
2158+ return h3("div")(append2(skn(Grid.value))(sk("display")("grid")))(map2(growSkin(fire)({
2159+ extraSkin: append2(sk("grid-row")("1"))(sk("grid-column")("1"))
2160+ }))(v1.bones.value0));
2161+ }
2162+ ;
2163+ if (v1.bones instanceof Row) {
2164+ return h3("div")(append2(skn(new Flexbox(X.value)))(append2(sk("display")("flex"))(sk("flex-direction")("row"))))(map2(growSkin(fire)(mempty22))(v1.bones.value0));
2165+ }
2166+ ;
2167+ if (v1.bones instanceof Column) {
2168+ return h3("div")(append2(skn(new Flexbox(Y.value)))(append2(sk("display")("flex"))(sk("flex-direction")("column"))))(map2(growSkin(fire)(mempty22))(v1.bones.value0));
2169+ }
2170+ ;
2171+ if (v1.bones instanceof Link) {
2172+ return hWith("a")({
2173+ href: v1.bones.value0,
2174+ rel: "noopener noreferrer",
2175+ target: function() {
2176+ if (v1.bones.value1.newTab) {
2177+ return "_blank";
2178+ }
2179+ ;
2180+ return "_self";
2181+ }()
2182+ })(append2(skn(new Flexbox(X.value)))(append2(sk("display")("flex"))(sk("flex-direction")("row"))))([growSkin(fire)(mempty22)(v1.bones.value2)]);
2183+ }
2184+ ;
2185+ if (v1.bones instanceof Download) {
2186+ return hWith("a")({
2187+ href: v1.bones.value0,
2188+ download: fromMaybe("")(v1.bones.value1.filename)
2189+ })(append2(skn(new Flexbox(X.value)))(append2(sk("display")("flex"))(sk("flex-direction")("row"))))([growSkin(fire)(mempty22)(v1.bones.value2)]);
2190+ }
2191+ ;
2192+ throw new Error("Failed pattern match at Plum.View (line 193, column 5 - line 215, column 39): " + [v1.bones.constructor.name]);
2193+ };
2194+ };
2195+ };
2196+ var grow = function(fire) {
2197+ return function(v) {
2198+ return growSkin(fire)(mempty22)(v);
2199+ };
2200+ };
2201+
2202+ // output/Web.DOM.NonElementParentNode/foreign.js
2203+ function _getElementById(id) {
2204+ return function(node) {
2205+ return function() {
2206+ return node.getElementById(id);
2207+ };
2208+ };
2209+ }
2210+
2211+ // output/Data.Nullable/foreign.js
2212+ function nullable(a, r, f) {
2213+ return a == null ? r : f(a);
2214+ }
2215+
2216+ // output/Data.Nullable/index.js
2217+ var toMaybe = function(n) {
2218+ return nullable(n, Nothing.value, Just.create);
2219+ };
2220+
2221+ // output/Web.DOM.NonElementParentNode/index.js
2222+ var map3 = /* @__PURE__ */ map(functorEffect);
2223+ var getElementById = function(eid) {
2224+ var $2 = map3(toMaybe);
2225+ var $3 = _getElementById(eid);
2226+ return function($4) {
2227+ return $2($3($4));
2228+ };
2229+ };
2230+
2231+ // output/Web.HTML/foreign.js
2232+ var windowImpl = function() {
2233+ return window;
2234+ };
2235+
2236+ // output/Web.HTML.HTMLDocument/index.js
2237+ var toNonElementParentNode = unsafeCoerce2;
2238+
2239+ // output/Web.HTML.Window/foreign.js
2240+ function document2(window2) {
2241+ return function() {
2242+ return window2.document;
2243+ };
2244+ }
2245+
2246+ // output/Plum/index.js
2247+ var bind2 = /* @__PURE__ */ bind(bindEffect);
2248+ var outerStyle = "html,body{height:100%;padding:0;margin:0;}";
2249+ var run3 = function(id) {
2250+ return function(plum2) {
2251+ return function __do() {
2252+ var modelRef = bind2(plum2.init)($$new)();
2253+ var v = bind2(bind2(windowImpl)(document2))(function() {
2254+ var $6 = getElementById(id);
2255+ return function($7) {
2256+ return $6(toNonElementParentNode($7));
2257+ };
2258+ }())();
2259+ if (v instanceof Just) {
2260+ var projector = createProjector();
2261+ return replace(projector)(v.value0)(function __do2() {
2262+ var model = read(modelRef)();
2263+ var el = grow(function(msg) {
2264+ return function __do3() {
2265+ var m = read(modelRef)();
2266+ var m_ = plum2.update(msg)(m)();
2267+ return write(m_)(modelRef)();
2268+ };
2269+ })(plum2.view(model));
2270+ return h2("div")({
2271+ styles: {
2272+ height: "100%",
2273+ width: "100%"
2274+ }
2275+ })([h2("style")({})([string(outerStyle)]), el]);
2276+ })();
2277+ }
2278+ ;
2279+ if (v instanceof Nothing) {
2280+ return unit;
2281+ }
2282+ ;
2283+ throw new Error("Failed pattern match at Plum (line 25, column 92 - line 39, column 25): " + [v.constructor.name]);
2284+ };
2285+ };
2286+ };
2287+
2288+ // output/Main/index.js
2289+ var pure2 = /* @__PURE__ */ pure(applicativeEffect);
2290+ var map4 = /* @__PURE__ */ map(functorArray);
2291+ var plum = {
2292+ init: /* @__PURE__ */ pure2({
2293+ text: "Test"
2294+ }),
2295+ view: function(model) {
2296+ return view([])([])(new Column([view([])([])(new Link("https://iko.soy", {
2297+ newTab: false
2298+ }, view([])([])(new Text("my website")))), view([])([])(new Row(map4($$const(view([])([new BackgroundColor(rgb(1)(0)(0))])(new Text("hello"))))(range2(1)(100))))]));
2299+ },
2300+ update: function(msg) {
2301+ return function(model) {
2302+ return pure2({
2303+ text: "Button pressed"
2304+ });
2305+ };
2306+ }
2307+ };
2308+ var main = /* @__PURE__ */ run3("plum")(plum);
2309+
2310+ // <stdin>
2311+ main();
2312+})();