@@ -0,0 +1,1467 @@
1+(() => {
2+ // output/Data.Functor/foreign.js
3+ var arrayMap = function(f) {
4+ return function(arr) {
5+ var l = arr.length;
6+ var result = new Array(l);
7+ for (var i = 0; i < l; i++) {
8+ result[i] = f(arr[i]);
9+ }
10+ return result;
11+ };
12+ };
13+
14+ // output/Data.Unit/foreign.js
15+ var unit = void 0;
16+
17+ // output/Data.Functor/index.js
18+ var map = function(dict) {
19+ return dict.map;
20+ };
21+ var functorArray = {
22+ map: arrayMap
23+ };
24+
25+ // output/Control.Apply/index.js
26+ var apply = function(dict) {
27+ return dict.apply;
28+ };
29+
30+ // output/Control.Applicative/index.js
31+ var pure = function(dict) {
32+ return dict.pure;
33+ };
34+ var liftA1 = function(dictApplicative) {
35+ var apply2 = apply(dictApplicative.Apply0());
36+ var pure1 = pure(dictApplicative);
37+ return function(f) {
38+ return function(a) {
39+ return apply2(pure1(f))(a);
40+ };
41+ };
42+ };
43+
44+ // output/Effect/foreign.js
45+ var pureE = function(a) {
46+ return function() {
47+ return a;
48+ };
49+ };
50+ var bindE = function(a) {
51+ return function(f) {
52+ return function() {
53+ return f(a())();
54+ };
55+ };
56+ };
57+
58+ // output/Control.Bind/foreign.js
59+ var arrayBind = typeof Array.prototype.flatMap === "function" ? function(arr) {
60+ return function(f) {
61+ return arr.flatMap(f);
62+ };
63+ } : function(arr) {
64+ return function(f) {
65+ var result = [];
66+ var l = arr.length;
67+ for (var i = 0; i < l; i++) {
68+ var xs = f(arr[i]);
69+ var k = xs.length;
70+ for (var j = 0; j < k; j++) {
71+ result.push(xs[j]);
72+ }
73+ }
74+ return result;
75+ };
76+ };
77+
78+ // output/Control.Bind/index.js
79+ var bind = function(dict) {
80+ return dict.bind;
81+ };
82+
83+ // output/Control.Monad/index.js
84+ var ap = function(dictMonad) {
85+ var bind3 = bind(dictMonad.Bind1());
86+ var pure3 = pure(dictMonad.Applicative0());
87+ return function(f) {
88+ return function(a) {
89+ return bind3(f)(function(f$prime) {
90+ return bind3(a)(function(a$prime) {
91+ return pure3(f$prime(a$prime));
92+ });
93+ });
94+ };
95+ };
96+ };
97+
98+ // output/Data.Semigroup/index.js
99+ var append = function(dict) {
100+ return dict.append;
101+ };
102+
103+ // output/Data.Monoid/index.js
104+ var mempty = function(dict) {
105+ return dict.mempty;
106+ };
107+
108+ // output/Effect/index.js
109+ var $runtime_lazy = function(name14, moduleName, init) {
110+ var state2 = 0;
111+ var val;
112+ return function(lineNumber) {
113+ if (state2 === 2) return val;
114+ if (state2 === 1) throw new ReferenceError(name14 + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);
115+ state2 = 1;
116+ val = init();
117+ state2 = 2;
118+ return val;
119+ };
120+ };
121+ var monadEffect = {
122+ Applicative0: function() {
123+ return applicativeEffect;
124+ },
125+ Bind1: function() {
126+ return bindEffect;
127+ }
128+ };
129+ var bindEffect = {
130+ bind: bindE,
131+ Apply0: function() {
132+ return $lazy_applyEffect(0);
133+ }
134+ };
135+ var applicativeEffect = {
136+ pure: pureE,
137+ Apply0: function() {
138+ return $lazy_applyEffect(0);
139+ }
140+ };
141+ var $lazy_functorEffect = /* @__PURE__ */ $runtime_lazy("functorEffect", "Effect", function() {
142+ return {
143+ map: liftA1(applicativeEffect)
144+ };
145+ });
146+ var $lazy_applyEffect = /* @__PURE__ */ $runtime_lazy("applyEffect", "Effect", function() {
147+ return {
148+ apply: ap(monadEffect),
149+ Functor0: function() {
150+ return $lazy_functorEffect(0);
151+ }
152+ };
153+ });
154+ var functorEffect = /* @__PURE__ */ $lazy_functorEffect(20);
155+
156+ // output/Data.Bounded/foreign.js
157+ var topChar = String.fromCharCode(65535);
158+ var bottomChar = String.fromCharCode(0);
159+ var topNumber = Number.POSITIVE_INFINITY;
160+ var bottomNumber = Number.NEGATIVE_INFINITY;
161+
162+ // output/Data.Show/foreign.js
163+ var showIntImpl = function(n) {
164+ return n.toString();
165+ };
166+
167+ // output/Data.Show/index.js
168+ var showInt = {
169+ show: showIntImpl
170+ };
171+ var show = function(dict) {
172+ return dict.show;
173+ };
174+
175+ // output/Data.Maybe/index.js
176+ var Nothing = /* @__PURE__ */ function() {
177+ function Nothing2() {
178+ }
179+ ;
180+ Nothing2.value = new Nothing2();
181+ return Nothing2;
182+ }();
183+ var Just = /* @__PURE__ */ function() {
184+ function Just2(value0) {
185+ this.value0 = value0;
186+ }
187+ ;
188+ Just2.create = function(value0) {
189+ return new Just2(value0);
190+ };
191+ return Just2;
192+ }();
193+
194+ // output/Effect.Ref/foreign.js
195+ var _new = function(val) {
196+ return function() {
197+ return { value: val };
198+ };
199+ };
200+ var read = function(ref) {
201+ return function() {
202+ return ref.value;
203+ };
204+ };
205+ var write = function(val) {
206+ return function(ref) {
207+ return function() {
208+ ref.value = val;
209+ };
210+ };
211+ };
212+
213+ // output/Effect.Ref/index.js
214+ var $$new = _new;
215+
216+ // output/Maquette/foreign.js
217+ var NAMESPACE_W3 = "http://www.w3.org/";
218+ var NAMESPACE_SVG = NAMESPACE_W3 + "2000/svg";
219+ var NAMESPACE_XLINK = NAMESPACE_W3 + "1999/xlink";
220+ var emptyArray = [];
221+ var extend = function(base, overrides) {
222+ var result = {};
223+ Object.keys(base).forEach(function(key) {
224+ result[key] = base[key];
225+ });
226+ if (overrides) {
227+ Object.keys(overrides).forEach(function(key) {
228+ result[key] = overrides[key];
229+ });
230+ }
231+ return result;
232+ };
233+ var same = function(vnode1, vnode2) {
234+ if (vnode1.vnodeSelector !== vnode2.vnodeSelector) {
235+ return false;
236+ }
237+ if (vnode1.properties && vnode2.properties) {
238+ if (vnode1.properties.key !== vnode2.properties.key) {
239+ return false;
240+ }
241+ return vnode1.properties.bind === vnode2.properties.bind;
242+ }
243+ return !vnode1.properties && !vnode2.properties;
244+ };
245+ var checkStyleValue = function(styleValue) {
246+ if (typeof styleValue !== "string") {
247+ throw new Error("Style values must be strings");
248+ }
249+ };
250+ var findIndexOfChild = function(children, sameAs, start2) {
251+ if (sameAs.vnodeSelector !== "") {
252+ for (var i = start2; i < children.length; i++) {
253+ if (same(children[i], sameAs)) {
254+ return i;
255+ }
256+ }
257+ }
258+ return -1;
259+ };
260+ var checkDistinguishable = function(childNodes, indexToCheck, parentVNode, operation) {
261+ var childNode = childNodes[indexToCheck];
262+ if (childNode.vnodeSelector === "") {
263+ return;
264+ }
265+ var properties = childNode.properties;
266+ var key = properties ? properties.key === void 0 ? properties.bind : properties.key : void 0;
267+ if (!key) {
268+ for (var i = 0; i < childNodes.length; i++) {
269+ if (i !== indexToCheck) {
270+ var node = childNodes[i];
271+ if (same(node, childNode)) {
272+ throw {
273+ 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."),
274+ parentNode: parentVNode,
275+ childNode
276+ };
277+ }
278+ }
279+ }
280+ }
281+ };
282+ var nodeAdded = function(vNode) {
283+ if (vNode.properties) {
284+ var enterAnimation = vNode.properties.enterAnimation;
285+ if (enterAnimation) {
286+ enterAnimation(vNode.domNode, vNode.properties);
287+ }
288+ }
289+ };
290+ var removedNodes = [];
291+ var requestedIdleCallback = false;
292+ var visitRemovedNode = function(node) {
293+ (node.children || []).forEach(visitRemovedNode);
294+ if (node.properties && node.properties.afterRemoved) {
295+ node.properties.afterRemoved.apply(node.properties.bind || node.properties, [
296+ node.domNode
297+ ]);
298+ }
299+ };
300+ var processPendingNodeRemovals = function() {
301+ requestedIdleCallback = false;
302+ removedNodes.forEach(visitRemovedNode);
303+ removedNodes.length = 0;
304+ };
305+ var scheduleNodeRemoval = function(vNode) {
306+ removedNodes.push(vNode);
307+ if (!requestedIdleCallback) {
308+ requestedIdleCallback = true;
309+ if (typeof window !== "undefined" && "requestIdleCallback" in window) {
310+ window.requestIdleCallback(processPendingNodeRemovals, { timeout: 16 });
311+ } else {
312+ setTimeout(processPendingNodeRemovals, 16);
313+ }
314+ }
315+ };
316+ var nodeToRemove = function(vNode) {
317+ var domNode = vNode.domNode;
318+ if (vNode.properties) {
319+ var exitAnimation = vNode.properties.exitAnimation;
320+ if (exitAnimation) {
321+ domNode.style.pointerEvents = "none";
322+ var removeDomNode = function() {
323+ if (domNode.parentNode) {
324+ domNode.parentNode.removeChild(domNode);
325+ scheduleNodeRemoval(vNode);
326+ }
327+ };
328+ exitAnimation(domNode, removeDomNode, vNode.properties);
329+ return;
330+ }
331+ }
332+ if (domNode.parentNode) {
333+ domNode.parentNode.removeChild(domNode);
334+ scheduleNodeRemoval(vNode);
335+ }
336+ };
337+ var vnodeOnlyProps = [
338+ "afterCreate",
339+ "afterUpdate",
340+ "afterRemoved",
341+ "enterAnimation",
342+ "exitAnimation",
343+ "updateAnimation"
344+ ];
345+ function filterVNodeOnlyProps(name14) {
346+ return !vnodeOnlyProps.includes(name14);
347+ }
348+ var setProperties = function(domNode, properties, projectionOptions) {
349+ if (!properties) {
350+ return;
351+ }
352+ var eventHandlerInterceptor = projectionOptions.eventHandlerInterceptor;
353+ var propNames = Object.keys(properties).filter(filterVNodeOnlyProps);
354+ var propCount = propNames.length;
355+ for (var i = 0; i < propCount; i++) {
356+ var propName = propNames[i];
357+ var propValue = properties[propName];
358+ if (propName === "className") {
359+ throw new Error('Property "className" is not supported, use "class".');
360+ } else if (propName === "class") {
361+ toggleClasses(domNode, propValue, true);
362+ } else if (propName === "classes") {
363+ var classNames = Object.keys(propValue);
364+ var classNameCount = classNames.length;
365+ for (var j = 0; j < classNameCount; j++) {
366+ var className = classNames[j];
367+ if (propValue[className]) {
368+ domNode.classList.add(className);
369+ }
370+ }
371+ } else if (propName === "styles") {
372+ var styleNames = Object.keys(propValue);
373+ var styleCount = styleNames.length;
374+ for (var j = 0; j < styleCount; j++) {
375+ var styleName = styleNames[j];
376+ var styleValue = propValue[styleName];
377+ if (styleValue) {
378+ checkStyleValue(styleValue);
379+ projectionOptions.styleApplyer(domNode, styleName, styleValue);
380+ }
381+ }
382+ } else if (propName === "on" && propValue) {
383+ for (var _i = 0, _a = Object.entries(properties.on); _i < _a.length; _i++) {
384+ var _b = _a[_i], key = _b[0], handler = _b[1];
385+ var listener = typeof handler === "function" ? handler : handler.listener;
386+ if (eventHandlerInterceptor) {
387+ listener = eventHandlerInterceptor(key, listener, domNode, properties);
388+ }
389+ if (listener) {
390+ domNode.addEventListener(key, listener, typeof handler === "function" ? void 0 : handler.options);
391+ }
392+ }
393+ } else if (propName !== "key" && propValue !== null && propValue !== void 0) {
394+ var type = typeof propValue;
395+ if (type === "function") {
396+ if (propName.lastIndexOf("on", 0) === 0) {
397+ if (eventHandlerInterceptor) {
398+ propValue = eventHandlerInterceptor(propName, propValue, domNode, properties);
399+ }
400+ }
401+ domNode[propName] = propValue;
402+ } else if (projectionOptions.namespace === NAMESPACE_SVG) {
403+ if (propName === "href") {
404+ domNode.setAttributeNS(NAMESPACE_XLINK, propName, propValue);
405+ } else {
406+ domNode.setAttribute(propName, propValue);
407+ }
408+ } else if (type === "string" && propName !== "value" && propName !== "innerHTML") {
409+ domNode.setAttribute(propName, propValue);
410+ } else {
411+ domNode[propName] = propValue;
412+ }
413+ }
414+ }
415+ };
416+ var addChildren = function(domNode, children, projectionOptions) {
417+ if (!children) {
418+ return;
419+ }
420+ for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
421+ var child = children_1[_i];
422+ createDom(child, domNode, void 0, projectionOptions);
423+ }
424+ };
425+ var initPropertiesAndChildren = function(domNode, vnode, projectionOptions) {
426+ addChildren(domNode, vnode.children, projectionOptions);
427+ if (vnode.text) {
428+ domNode.textContent = vnode.text;
429+ }
430+ setProperties(domNode, vnode.properties, projectionOptions);
431+ if (vnode.properties && vnode.properties.afterCreate) {
432+ vnode.properties.afterCreate.apply(vnode.properties.bind || vnode.properties, [
433+ domNode,
434+ projectionOptions,
435+ vnode.vnodeSelector,
436+ vnode.properties,
437+ vnode.children
438+ ]);
439+ }
440+ };
441+ var createDom = function(vnode, parentNode, insertBefore, projectionOptions) {
442+ var _a;
443+ var domNode;
444+ var start2 = 0;
445+ var vnodeSelector = vnode.vnodeSelector;
446+ var doc = parentNode.ownerDocument;
447+ if (vnodeSelector === "") {
448+ if (vnode.domNode) {
449+ vnode.domNode.nodeValue = vnode.text;
450+ } else {
451+ domNode = vnode.domNode = doc.createTextNode(vnode.text);
452+ if (insertBefore !== void 0) {
453+ parentNode.insertBefore(domNode, insertBefore);
454+ } else {
455+ parentNode.appendChild(domNode);
456+ }
457+ }
458+ } else {
459+ for (var i = 0; i <= vnodeSelector.length; ++i) {
460+ var c = vnodeSelector.charAt(i);
461+ if (i === vnodeSelector.length || c === "." || c === "#") {
462+ var type = vnodeSelector.charAt(start2 - 1);
463+ var found = vnodeSelector.slice(start2, i);
464+ if (type === ".") {
465+ domNode.classList.add(found);
466+ } else if (type === "#") {
467+ domNode.id = found;
468+ } else {
469+ if (found === "svg") {
470+ projectionOptions = extend(projectionOptions, {
471+ namespace: NAMESPACE_SVG
472+ });
473+ }
474+ if (projectionOptions.namespace !== void 0) {
475+ domNode = vnode.domNode = doc.createElementNS(projectionOptions.namespace, found);
476+ } else {
477+ 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));
478+ if (found === "input" && vnode.properties && vnode.properties.type !== void 0) {
479+ domNode.setAttribute("type", vnode.properties.type);
480+ }
481+ }
482+ if (insertBefore !== void 0) {
483+ parentNode.insertBefore(domNode, insertBefore);
484+ } else if (domNode.parentNode !== parentNode) {
485+ parentNode.appendChild(domNode);
486+ }
487+ }
488+ start2 = i + 1;
489+ }
490+ }
491+ initPropertiesAndChildren(domNode, vnode, projectionOptions);
492+ }
493+ };
494+ var updateDom;
495+ var toggleClasses = function(domNode, classes, on2) {
496+ if (!classes) {
497+ return;
498+ }
499+ classes.split(" ").forEach(function(classToToggle) {
500+ if (classToToggle) {
501+ domNode.classList.toggle(classToToggle, on2);
502+ }
503+ });
504+ };
505+ var updateProperties = function(domNode, previousProperties, properties, projectionOptions) {
506+ if (!properties) {
507+ return;
508+ }
509+ var propertiesUpdated = false;
510+ var propNames = Object.keys(properties).filter(filterVNodeOnlyProps);
511+ var propCount = propNames.length;
512+ for (var i = 0; i < propCount; i++) {
513+ var propName = propNames[i];
514+ var propValue = properties[propName];
515+ var previousValue = previousProperties[propName];
516+ if (propName === "class") {
517+ if (previousValue !== propValue) {
518+ toggleClasses(domNode, previousValue, false);
519+ toggleClasses(domNode, propValue, true);
520+ }
521+ } else if (propName === "classes") {
522+ var classList = domNode.classList;
523+ var classNames = Object.keys(propValue);
524+ var classNameCount = classNames.length;
525+ for (var j = 0; j < classNameCount; j++) {
526+ var className = classNames[j];
527+ var on2 = !!propValue[className];
528+ var previousOn = !!previousValue[className];
529+ if (on2 === previousOn) {
530+ continue;
531+ }
532+ propertiesUpdated = true;
533+ if (on2) {
534+ classList.add(className);
535+ } else {
536+ classList.remove(className);
537+ }
538+ }
539+ } else if (propName === "styles") {
540+ var styleNames = Object.keys(propValue);
541+ var styleCount = styleNames.length;
542+ for (var j = 0; j < styleCount; j++) {
543+ var styleName = styleNames[j];
544+ var newStyleValue = propValue[styleName];
545+ var oldStyleValue = previousValue[styleName];
546+ if (newStyleValue === oldStyleValue) {
547+ continue;
548+ }
549+ propertiesUpdated = true;
550+ if (newStyleValue) {
551+ checkStyleValue(newStyleValue);
552+ projectionOptions.styleApplyer(domNode, styleName, newStyleValue);
553+ } else {
554+ projectionOptions.styleApplyer(domNode, styleName, "");
555+ }
556+ }
557+ } else {
558+ if (!propValue && typeof previousValue === "string") {
559+ propValue = "";
560+ }
561+ if (propName === "value") {
562+ var domValue = domNode[propName];
563+ if (domValue !== propValue && // The 'value' in the DOM tree !== newValue
564+ propValue !== previousValue) {
565+ domNode[propName] = propValue;
566+ }
567+ if (propValue !== previousValue) {
568+ propertiesUpdated = true;
569+ }
570+ } else if (propValue !== previousValue) {
571+ var type = typeof propValue;
572+ if (type !== "function" || !projectionOptions.eventHandlerInterceptor) {
573+ if (projectionOptions.namespace === NAMESPACE_SVG) {
574+ if (propName === "href") {
575+ domNode.setAttributeNS(NAMESPACE_XLINK, propName, propValue);
576+ } else {
577+ domNode.setAttribute(propName, propValue);
578+ }
579+ } else if (type === "string" && propName !== "innerHTML") {
580+ if (propName === "role" && propValue === "") {
581+ domNode.removeAttribute(propName);
582+ } else {
583+ domNode.setAttribute(propName, propValue);
584+ }
585+ } else if (domNode[propName] !== propValue) {
586+ domNode[propName] = propValue;
587+ }
588+ propertiesUpdated = true;
589+ }
590+ }
591+ }
592+ }
593+ return propertiesUpdated;
594+ };
595+ var updateChildren = function(vnode, domNode, oldChildren, newChildren, projectionOptions) {
596+ if (oldChildren === newChildren) {
597+ return false;
598+ }
599+ oldChildren = oldChildren || emptyArray;
600+ newChildren = newChildren || emptyArray;
601+ var oldChildrenLength = oldChildren.length;
602+ var newChildrenLength = newChildren.length;
603+ var oldIndex = 0;
604+ var newIndex = 0;
605+ var i;
606+ var textUpdated = false;
607+ while (newIndex < newChildrenLength) {
608+ var oldChild = oldIndex < oldChildrenLength ? oldChildren[oldIndex] : void 0;
609+ var newChild = newChildren[newIndex];
610+ if (oldChild !== void 0 && same(oldChild, newChild)) {
611+ textUpdated = updateDom(oldChild, newChild, projectionOptions, domNode, oldChildren) || textUpdated;
612+ oldIndex++;
613+ } else {
614+ var findOldIndex = findIndexOfChild(oldChildren, newChild, oldIndex + 1);
615+ if (findOldIndex >= 0) {
616+ for (i = oldIndex; i < findOldIndex; i++) {
617+ nodeToRemove(oldChildren[i]);
618+ checkDistinguishable(oldChildren, i, vnode, "removed");
619+ }
620+ textUpdated = updateDom(oldChildren[findOldIndex], newChild, projectionOptions, domNode, oldChildren) || textUpdated;
621+ oldIndex = findOldIndex + 1;
622+ } else {
623+ createDom(newChild, domNode, oldIndex < oldChildrenLength ? oldChildren[oldIndex].domNode : void 0, projectionOptions);
624+ nodeAdded(newChild);
625+ checkDistinguishable(newChildren, newIndex, vnode, "added");
626+ }
627+ }
628+ newIndex++;
629+ }
630+ if (oldChildrenLength > oldIndex) {
631+ for (i = oldIndex; i < oldChildrenLength; i++) {
632+ nodeToRemove(oldChildren[i]);
633+ checkDistinguishable(oldChildren, i, vnode, "removed");
634+ }
635+ }
636+ return textUpdated;
637+ };
638+ updateDom = function(previous, vnode, projectionOptions, parentNode, oldChildren) {
639+ var domNode = previous.domNode;
640+ var textUpdated = false;
641+ if (previous === vnode) {
642+ return false;
643+ }
644+ var updated = false;
645+ if (vnode.vnodeSelector === "") {
646+ if (vnode.text !== previous.text) {
647+ var newTextNode = domNode.ownerDocument.createTextNode(vnode.text);
648+ try {
649+ parentNode.replaceChild(newTextNode, domNode);
650+ } catch (e) {
651+ parentNode.replaceChild(newTextNode, parentNode.childNodes[oldChildren.indexOf(previous)]);
652+ }
653+ vnode.domNode = newTextNode;
654+ textUpdated = true;
655+ return textUpdated;
656+ }
657+ vnode.domNode = domNode;
658+ } else {
659+ if (vnode.vnodeSelector.lastIndexOf("svg", 0) === 0) {
660+ projectionOptions = extend(projectionOptions, {
661+ namespace: NAMESPACE_SVG
662+ });
663+ }
664+ if (previous.text !== vnode.text) {
665+ updated = true;
666+ if (vnode.text === void 0) {
667+ domNode.removeChild(domNode.firstChild);
668+ } else {
669+ domNode.textContent = vnode.text;
670+ }
671+ }
672+ vnode.domNode = domNode;
673+ updated = updateChildren(vnode, domNode, previous.children, vnode.children, projectionOptions) || updated;
674+ updated = updateProperties(domNode, previous.properties, vnode.properties, projectionOptions) || updated;
675+ if (vnode.properties && vnode.properties.afterUpdate) {
676+ vnode.properties.afterUpdate.apply(vnode.properties.bind || vnode.properties, [
677+ domNode,
678+ projectionOptions,
679+ vnode.vnodeSelector,
680+ vnode.properties,
681+ vnode.children
682+ ]);
683+ }
684+ }
685+ if (updated && vnode.properties && vnode.properties.updateAnimation) {
686+ vnode.properties.updateAnimation(domNode, vnode.properties, previous.properties);
687+ }
688+ return textUpdated;
689+ };
690+ var createProjection = function(vnode, projectionOptions) {
691+ return {
692+ getLastRender: function() {
693+ return vnode;
694+ },
695+ update: function(updatedVnode) {
696+ if (vnode.vnodeSelector !== updatedVnode.vnodeSelector) {
697+ 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)");
698+ }
699+ var previousVNode = vnode;
700+ vnode = updatedVnode;
701+ updateDom(previousVNode, updatedVnode, projectionOptions, previousVNode.domNode.parentNode, [previousVNode]);
702+ },
703+ domNode: vnode.domNode
704+ };
705+ };
706+ var DEFAULT_PROJECTION_OPTIONS = {
707+ namespace: void 0,
708+ performanceLogger: function() {
709+ return void 0;
710+ },
711+ eventHandlerInterceptor: void 0,
712+ styleApplyer: function(domNode, styleName, value12) {
713+ if (styleName.charAt(0) === "-") {
714+ domNode.style.setProperty(styleName, value12);
715+ } else {
716+ domNode.style[styleName] = value12;
717+ }
718+ }
719+ };
720+ var applyDefaultProjectionOptions = function(projectorOptions) {
721+ return extend(DEFAULT_PROJECTION_OPTIONS, projectorOptions);
722+ };
723+ var dom = {
724+ /**
725+ * Creates a real DOM tree from `vnode`. The [[Projection]] object returned will contain the resulting DOM Node in
726+ * its [[Projection.domNode|domNode]] property.
727+ * This is a low-level method. Users will typically use a [[Projector]] instead.
728+ * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
729+ * objects may only be rendered once.
730+ * @param projectionOptions - Options to be used to create and update the projection.
731+ * @returns The [[Projection]] which also contains the DOM Node that was created.
732+ */
733+ create: function(vnode, projectionOptions) {
734+ projectionOptions = applyDefaultProjectionOptions(projectionOptions);
735+ createDom(vnode, document.createElement("div"), void 0, projectionOptions);
736+ return createProjection(vnode, projectionOptions);
737+ },
738+ /**
739+ * Appends a new child node to the DOM which is generated from a [[VNode]].
740+ * This is a low-level method. Users will typically use a [[Projector]] instead.
741+ * @param parentNode - The parent node for the new child node.
742+ * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
743+ * objects may only be rendered once.
744+ * @param projectionOptions - Options to be used to create and update the [[Projection]].
745+ * @returns The [[Projection]] that was created.
746+ */
747+ append: function(parentNode, vnode, projectionOptions) {
748+ projectionOptions = applyDefaultProjectionOptions(projectionOptions);
749+ createDom(vnode, parentNode, void 0, projectionOptions);
750+ return createProjection(vnode, projectionOptions);
751+ },
752+ /**
753+ * Inserts a new DOM node which is generated from a [[VNode]].
754+ * This is a low-level method. Users wil typically use a [[Projector]] instead.
755+ * @param beforeNode - The node that the DOM Node is inserted before.
756+ * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function.
757+ * NOTE: [[VNode]] objects may only be rendered once.
758+ * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
759+ * @returns The [[Projection]] that was created.
760+ */
761+ insertBefore: function(beforeNode, vnode, projectionOptions) {
762+ projectionOptions = applyDefaultProjectionOptions(projectionOptions);
763+ createDom(vnode, beforeNode.parentNode, beforeNode, projectionOptions);
764+ return createProjection(vnode, projectionOptions);
765+ },
766+ /**
767+ * Merges a new DOM node which is generated from a [[VNode]] with an existing DOM Node.
768+ * This means that the virtual DOM and the real DOM will have one overlapping element.
769+ * Therefore the selector for the root [[VNode]] will be ignored, but its properties and children will be applied to the Element provided.
770+ * This is a low-level method. Users wil typically use a [[Projector]] instead.
771+ * @param element - The existing element to adopt as the root of the new virtual DOM. Existing attributes and child nodes are preserved.
772+ * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]] objects
773+ * may only be rendered once.
774+ * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
775+ * @returns The [[Projection]] that was created.
776+ */
777+ merge: function(element, vnode, projectionOptions) {
778+ projectionOptions = applyDefaultProjectionOptions(projectionOptions);
779+ vnode.domNode = element;
780+ initPropertiesAndChildren(element, vnode, projectionOptions);
781+ return createProjection(vnode, projectionOptions);
782+ },
783+ /**
784+ * Replaces an existing DOM node with a node generated from a [[VNode]].
785+ * This is a low-level method. Users will typically use a [[Projector]] instead.
786+ * @param element - The node for the [[VNode]] to replace.
787+ * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
788+ * objects may only be rendered once.
789+ * @param projectionOptions - Options to be used to create and update the [[Projection]].
790+ * @returns The [[Projection]] that was created.
791+ */
792+ replace: function(element, vnode, projectionOptions) {
793+ projectionOptions = applyDefaultProjectionOptions(projectionOptions);
794+ createDom(vnode, element.parentNode, element, projectionOptions);
795+ element.parentNode.removeChild(element);
796+ return createProjection(vnode, projectionOptions);
797+ }
798+ };
799+ var toTextVNode = function(data) {
800+ return {
801+ vnodeSelector: "",
802+ properties: void 0,
803+ children: void 0,
804+ text: data.toString(),
805+ domNode: null
806+ };
807+ };
808+ var appendChildren = function(parentSelector, insertions, main2) {
809+ for (var i = 0, length_1 = insertions.length; i < length_1; i++) {
810+ var item = insertions[i];
811+ if (Array.isArray(item)) {
812+ appendChildren(parentSelector, item, main2);
813+ } else {
814+ if (item !== null && item !== void 0 && item !== false) {
815+ if (typeof item === "string") {
816+ item = toTextVNode(item);
817+ }
818+ main2.push(item);
819+ }
820+ }
821+ }
822+ };
823+ function h(selector, properties, children) {
824+ if (Array.isArray(properties)) {
825+ children = properties;
826+ properties = void 0;
827+ } else if (properties && (typeof properties === "string" || properties.vnodeSelector) || children && (typeof children === "string" || children.vnodeSelector)) {
828+ throw new Error("h called with invalid arguments");
829+ }
830+ var text5;
831+ var flattenedChildren;
832+ if (children && children.length === 1 && typeof children[0] === "string") {
833+ text5 = children[0];
834+ } else if (children) {
835+ flattenedChildren = [];
836+ appendChildren(selector, children, flattenedChildren);
837+ if (flattenedChildren.length === 0) {
838+ flattenedChildren = void 0;
839+ }
840+ }
841+ return {
842+ vnodeSelector: selector,
843+ properties,
844+ children: flattenedChildren,
845+ text: text5 === "" ? void 0 : text5,
846+ domNode: null
847+ };
848+ }
849+ var createParentNodePath = function(node, rootNode) {
850+ var parentNodePath = [];
851+ while (node && node !== rootNode) {
852+ parentNodePath.push(node);
853+ node = node.parentNode;
854+ }
855+ return parentNodePath;
856+ };
857+ var find;
858+ if (Array.prototype.find) {
859+ find = function(items, predicate) {
860+ return items.find(predicate);
861+ };
862+ } else {
863+ find = function(items, predicate) {
864+ return items.filter(predicate)[0];
865+ };
866+ }
867+ var findVNodeByParentNodePath = function(vnode, parentNodePath) {
868+ var result = vnode;
869+ parentNodePath.forEach(function(node) {
870+ result = result && result.children ? find(result.children, function(child) {
871+ return child.domNode === node;
872+ }) : void 0;
873+ });
874+ return result;
875+ };
876+ var createEventHandlerInterceptor = function(projector, getProjection, performanceLogger) {
877+ return function(propertyName, eventHandler, domNode, properties) {
878+ return modifiedEventHandler;
879+ };
880+ function modifiedEventHandler(evt) {
881+ var _a, _b;
882+ performanceLogger("domEvent", evt);
883+ var projection = getProjection();
884+ var parentNodePath = createParentNodePath(evt.currentTarget, projection.domNode);
885+ parentNodePath.reverse();
886+ var matchingVNode = findVNodeByParentNodePath(projection.getLastRender(), parentNodePath);
887+ projector.scheduleRender();
888+ var result;
889+ if (matchingVNode) {
890+ 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];
891+ result = listener.apply(matchingVNode.properties.bind || this, arguments);
892+ }
893+ performanceLogger("domEventProcessed", evt);
894+ return result;
895+ }
896+ };
897+ var createProjector = function(projectorOptions) {
898+ var projector;
899+ var projectionOptions = applyDefaultProjectionOptions(projectorOptions);
900+ var performanceLogger = projectionOptions.performanceLogger;
901+ var renderCompleted = true;
902+ var scheduled;
903+ var stopped = false;
904+ var projections = [];
905+ var renderFunctions = [];
906+ var addProjection = function(domFunction, node, renderFunction) {
907+ var projection;
908+ var getProjection = function() {
909+ return projection;
910+ };
911+ projectionOptions.eventHandlerInterceptor = createEventHandlerInterceptor(projector, getProjection, performanceLogger);
912+ projection = domFunction(node, renderFunction(), projectionOptions);
913+ projections.push(projection);
914+ renderFunctions.push(renderFunction);
915+ };
916+ var doRender = function() {
917+ scheduled = void 0;
918+ if (!renderCompleted) {
919+ return;
920+ }
921+ renderCompleted = false;
922+ performanceLogger("renderStart", void 0);
923+ for (var i = 0; i < projections.length; i++) {
924+ var updatedVnode = renderFunctions[i]();
925+ performanceLogger("rendered", void 0);
926+ projections[i].update(updatedVnode);
927+ performanceLogger("patched", void 0);
928+ }
929+ performanceLogger("renderDone", void 0);
930+ renderCompleted = true;
931+ };
932+ projector = {
933+ renderNow: doRender,
934+ scheduleRender: function() {
935+ if (!scheduled && !stopped) {
936+ scheduled = requestAnimationFrame(doRender);
937+ }
938+ },
939+ stop: function() {
940+ if (scheduled) {
941+ cancelAnimationFrame(scheduled);
942+ scheduled = void 0;
943+ }
944+ stopped = true;
945+ },
946+ resume: function() {
947+ stopped = false;
948+ renderCompleted = true;
949+ projector.scheduleRender();
950+ },
951+ append: function(parentNode, renderFunction) {
952+ addProjection(dom.append, parentNode, renderFunction);
953+ },
954+ insertBefore: function(beforeNode, renderFunction) {
955+ addProjection(dom.insertBefore, beforeNode, renderFunction);
956+ },
957+ merge: function(domNode, renderFunction) {
958+ addProjection(dom.merge, domNode, renderFunction);
959+ },
960+ replace: function(domNode, renderFunction) {
961+ addProjection(dom.replace, domNode, renderFunction);
962+ },
963+ detach: function(renderFunction) {
964+ for (var i = 0; i < renderFunctions.length; i++) {
965+ if (renderFunctions[i] === renderFunction) {
966+ renderFunctions.splice(i, 1);
967+ return projections.splice(i, 1)[0];
968+ }
969+ }
970+ throw new Error("renderFunction was not found");
971+ }
972+ };
973+ return projector;
974+ };
975+ function _h(selector) {
976+ return function(properties) {
977+ return function(children) {
978+ return h(selector, properties, children);
979+ };
980+ };
981+ }
982+ function replace(projector) {
983+ return function(el) {
984+ return function(render) {
985+ return function() {
986+ projector.replace(el, render);
987+ };
988+ };
989+ };
990+ }
991+
992+ // output/Unsafe.Coerce/foreign.js
993+ var unsafeCoerce2 = function(x) {
994+ return x;
995+ };
996+
997+ // output/Maquette/index.js
998+ var string = unsafeCoerce2;
999+ var h2 = _h;
1000+
1001+ // output/Data.Array/foreign.js
1002+ var replicateFill = function(count, value12) {
1003+ if (count < 1) {
1004+ return [];
1005+ }
1006+ var result = new Array(count);
1007+ return result.fill(value12);
1008+ };
1009+ var replicatePolyfill = function(count, value12) {
1010+ var result = [];
1011+ var n = 0;
1012+ for (var i = 0; i < count; i++) {
1013+ result[n++] = value12;
1014+ }
1015+ return result;
1016+ };
1017+ var replicateImpl = typeof Array.prototype.fill === "function" ? replicateFill : replicatePolyfill;
1018+
1019+ // output/Control.Monad.ST.Internal/foreign.js
1020+ var map_ = function(f) {
1021+ return function(a) {
1022+ return function() {
1023+ return f(a());
1024+ };
1025+ };
1026+ };
1027+ var pure_ = function(a) {
1028+ return function() {
1029+ return a;
1030+ };
1031+ };
1032+ var bind_ = function(a) {
1033+ return function(f) {
1034+ return function() {
1035+ return f(a())();
1036+ };
1037+ };
1038+ };
1039+
1040+ // output/Control.Monad.ST.Internal/index.js
1041+ var $runtime_lazy2 = function(name14, moduleName, init) {
1042+ var state2 = 0;
1043+ var val;
1044+ return function(lineNumber) {
1045+ if (state2 === 2) return val;
1046+ if (state2 === 1) throw new ReferenceError(name14 + " was needed before it finished initializing (module " + moduleName + ", line " + lineNumber + ")", moduleName, lineNumber);
1047+ state2 = 1;
1048+ val = init();
1049+ state2 = 2;
1050+ return val;
1051+ };
1052+ };
1053+ var functorST = {
1054+ map: map_
1055+ };
1056+ var monadST = {
1057+ Applicative0: function() {
1058+ return applicativeST;
1059+ },
1060+ Bind1: function() {
1061+ return bindST;
1062+ }
1063+ };
1064+ var bindST = {
1065+ bind: bind_,
1066+ Apply0: function() {
1067+ return $lazy_applyST(0);
1068+ }
1069+ };
1070+ var applicativeST = {
1071+ pure: pure_,
1072+ Apply0: function() {
1073+ return $lazy_applyST(0);
1074+ }
1075+ };
1076+ var $lazy_applyST = /* @__PURE__ */ $runtime_lazy2("applyST", "Control.Monad.ST.Internal", function() {
1077+ return {
1078+ apply: ap(monadST),
1079+ Functor0: function() {
1080+ return functorST;
1081+ }
1082+ };
1083+ });
1084+
1085+ // output/Data.Foldable/foreign.js
1086+ var foldrArray = function(f) {
1087+ return function(init) {
1088+ return function(xs) {
1089+ var acc = init;
1090+ var len = xs.length;
1091+ for (var i = len - 1; i >= 0; i--) {
1092+ acc = f(xs[i])(acc);
1093+ }
1094+ return acc;
1095+ };
1096+ };
1097+ };
1098+ var foldlArray = function(f) {
1099+ return function(init) {
1100+ return function(xs) {
1101+ var acc = init;
1102+ var len = xs.length;
1103+ for (var i = 0; i < len; i++) {
1104+ acc = f(acc)(xs[i]);
1105+ }
1106+ return acc;
1107+ };
1108+ };
1109+ };
1110+
1111+ // output/Data.Foldable/index.js
1112+ var foldr = function(dict) {
1113+ return dict.foldr;
1114+ };
1115+ var foldMapDefaultR = function(dictFoldable) {
1116+ var foldr2 = foldr(dictFoldable);
1117+ return function(dictMonoid) {
1118+ var append2 = append(dictMonoid.Semigroup0());
1119+ var mempty2 = mempty(dictMonoid);
1120+ return function(f) {
1121+ return foldr2(function(x) {
1122+ return function(acc) {
1123+ return append2(f(x))(acc);
1124+ };
1125+ })(mempty2);
1126+ };
1127+ };
1128+ };
1129+ var foldableArray = {
1130+ foldr: foldrArray,
1131+ foldl: foldlArray,
1132+ foldMap: function(dictMonoid) {
1133+ return foldMapDefaultR(foldableArray)(dictMonoid);
1134+ }
1135+ };
1136+ var foldMap = function(dict) {
1137+ return dict.foldMap;
1138+ };
1139+
1140+ // output/Data.Array/index.js
1141+ var foldMap1 = /* @__PURE__ */ foldMap(foldableArray);
1142+ var foldMap2 = function(dictMonoid) {
1143+ return foldMap1(dictMonoid);
1144+ };
1145+
1146+ // output/Foreign.Object/foreign.js
1147+ function _copyST(m) {
1148+ return function() {
1149+ var r = {};
1150+ for (var k in m) {
1151+ if (hasOwnProperty.call(m, k)) {
1152+ r[k] = m[k];
1153+ }
1154+ }
1155+ return r;
1156+ };
1157+ }
1158+ var empty2 = {};
1159+ function runST(f) {
1160+ return f();
1161+ }
1162+ function _foldM(bind3) {
1163+ return function(f) {
1164+ return function(mz) {
1165+ return function(m) {
1166+ var acc = mz;
1167+ function g(k2) {
1168+ return function(z) {
1169+ return f(z)(k2)(m[k2]);
1170+ };
1171+ }
1172+ for (var k in m) {
1173+ if (hasOwnProperty.call(m, k)) {
1174+ acc = bind3(acc)(g(k));
1175+ }
1176+ }
1177+ return acc;
1178+ };
1179+ };
1180+ };
1181+ }
1182+ function toArrayWithKey(f) {
1183+ return function(m) {
1184+ var r = [];
1185+ for (var k in m) {
1186+ if (hasOwnProperty.call(m, k)) {
1187+ r.push(f(k)(m[k]));
1188+ }
1189+ }
1190+ return r;
1191+ };
1192+ }
1193+ var keys = Object.keys || toArrayWithKey(function(k) {
1194+ return function() {
1195+ return k;
1196+ };
1197+ });
1198+
1199+ // output/Foreign.Object.ST/foreign.js
1200+ function poke2(k) {
1201+ return function(v) {
1202+ return function(m) {
1203+ return function() {
1204+ m[k] = v;
1205+ return m;
1206+ };
1207+ };
1208+ };
1209+ }
1210+
1211+ // output/Foreign.Object/index.js
1212+ var thawST = _copyST;
1213+ var mutate = function(f) {
1214+ return function(m) {
1215+ return runST(function __do() {
1216+ var s2 = thawST(m)();
1217+ f(s2)();
1218+ return s2;
1219+ });
1220+ };
1221+ };
1222+ var insert = function(k) {
1223+ return function(v) {
1224+ return mutate(poke2(k)(v));
1225+ };
1226+ };
1227+ var fromHomogeneous = function() {
1228+ return unsafeCoerce2;
1229+ };
1230+ var foldM = function(dictMonad) {
1231+ var bind1 = bind(dictMonad.Bind1());
1232+ var pure1 = pure(dictMonad.Applicative0());
1233+ return function(f) {
1234+ return function(z) {
1235+ return _foldM(bind1)(f)(pure1(z));
1236+ };
1237+ };
1238+ };
1239+ var foldM1 = /* @__PURE__ */ foldM(monadST);
1240+ var union = function(m) {
1241+ return mutate(function(s2) {
1242+ return foldM1(function(s$prime) {
1243+ return function(k) {
1244+ return function(v) {
1245+ return poke2(k)(v)(s$prime);
1246+ };
1247+ };
1248+ })(s2)(m);
1249+ });
1250+ };
1251+
1252+ // output/Plum.View/index.js
1253+ var fromHomogeneous2 = /* @__PURE__ */ fromHomogeneous();
1254+ var show2 = /* @__PURE__ */ show(showInt);
1255+ var map2 = /* @__PURE__ */ map(functorArray);
1256+ var Flexbox = /* @__PURE__ */ function() {
1257+ function Flexbox2() {
1258+ }
1259+ ;
1260+ Flexbox2.value = new Flexbox2();
1261+ return Flexbox2;
1262+ }();
1263+ var Spacing = /* @__PURE__ */ function() {
1264+ function Spacing2(value0, value1) {
1265+ this.value0 = value0;
1266+ this.value1 = value1;
1267+ }
1268+ ;
1269+ Spacing2.create = function(value0) {
1270+ return function(value1) {
1271+ return new Spacing2(value0, value1);
1272+ };
1273+ };
1274+ return Spacing2;
1275+ }();
1276+ var semigroupRenderedAttribut = {
1277+ append: function(v1) {
1278+ return function(v2) {
1279+ return {
1280+ styles: union(v1.styles)(v2.styles)
1281+ };
1282+ };
1283+ }
1284+ };
1285+ var monoidRenderedAttribute = {
1286+ mempty: {
1287+ styles: empty2
1288+ },
1289+ Semigroup0: function() {
1290+ return semigroupRenderedAttribut;
1291+ }
1292+ };
1293+ var foldMap3 = /* @__PURE__ */ foldMap2(monoidRenderedAttribute);
1294+ var withStyles = function() {
1295+ return function(v1) {
1296+ return function(styles) {
1297+ return {
1298+ styles: union(v1.styles)(fromHomogeneous2(styles))
1299+ };
1300+ };
1301+ };
1302+ };
1303+ var withStyles1 = /* @__PURE__ */ withStyles();
1304+ var unView = function(v1) {
1305+ return v1;
1306+ };
1307+ var spacing = function(x) {
1308+ return new Spacing(x, x);
1309+ };
1310+ var s = function(x) {
1311+ return function(v1) {
1312+ return string(x);
1313+ };
1314+ };
1315+ var renderAttribute = function(_ctx) {
1316+ return function(attr) {
1317+ return {
1318+ styles: insert("gap")(show2(attr.value0) + ("px " + (show2(attr.value1) + "px")))(empty2)
1319+ };
1320+ };
1321+ };
1322+ var renderAttributes = function(ctx) {
1323+ return foldMap3(renderAttribute(ctx));
1324+ };
1325+ var renderWithStyles = function() {
1326+ return function(ctx) {
1327+ return function(attrs) {
1328+ return function(styles) {
1329+ return withStyles1(renderAttributes(ctx)(attrs))(styles);
1330+ };
1331+ };
1332+ };
1333+ };
1334+ var renderWithStyles1 = /* @__PURE__ */ renderWithStyles();
1335+ var button = function(v1) {
1336+ return function(v2) {
1337+ return function(fire) {
1338+ return h2("div")({
1339+ onclick: fire(v2.onPress)
1340+ })([unView(v2.view)(fire)]);
1341+ };
1342+ };
1343+ };
1344+ var _v = function(el) {
1345+ return function(attr) {
1346+ return function(children) {
1347+ return function(fire) {
1348+ return h2(el)(attr)(map2(function(v1) {
1349+ return v1(fire);
1350+ })(children));
1351+ };
1352+ };
1353+ };
1354+ };
1355+ var row = function(attrs) {
1356+ return function(children) {
1357+ return _v("div")(renderWithStyles1(Flexbox.value)(attrs)({
1358+ display: "flex",
1359+ "flex-direction": "row"
1360+ }))(children);
1361+ };
1362+ };
1363+
1364+ // output/Web.DOM.NonElementParentNode/foreign.js
1365+ function _getElementById(id) {
1366+ return function(node) {
1367+ return function() {
1368+ return node.getElementById(id);
1369+ };
1370+ };
1371+ }
1372+
1373+ // output/Data.Nullable/foreign.js
1374+ function nullable(a, r, f) {
1375+ return a == null ? r : f(a);
1376+ }
1377+
1378+ // output/Data.Nullable/index.js
1379+ var toMaybe = function(n) {
1380+ return nullable(n, Nothing.value, Just.create);
1381+ };
1382+
1383+ // output/Web.DOM.NonElementParentNode/index.js
1384+ var map3 = /* @__PURE__ */ map(functorEffect);
1385+ var getElementById = function(eid) {
1386+ var $2 = map3(toMaybe);
1387+ var $3 = _getElementById(eid);
1388+ return function($4) {
1389+ return $2($3($4));
1390+ };
1391+ };
1392+
1393+ // output/Web.HTML/foreign.js
1394+ var windowImpl = function() {
1395+ return window;
1396+ };
1397+
1398+ // output/Web.HTML.HTMLDocument/index.js
1399+ var toNonElementParentNode = unsafeCoerce2;
1400+
1401+ // output/Web.HTML.Window/foreign.js
1402+ function document2(window2) {
1403+ return function() {
1404+ return window2.document;
1405+ };
1406+ }
1407+
1408+ // output/Plum/index.js
1409+ var bind2 = /* @__PURE__ */ bind(bindEffect);
1410+ var run3 = function(id) {
1411+ return function(plum2) {
1412+ return function __do() {
1413+ var modelRef = bind2(plum2.init)($$new)();
1414+ var v = bind2(bind2(windowImpl)(document2))(function() {
1415+ var $6 = getElementById(id);
1416+ return function($7) {
1417+ return $6(toNonElementParentNode($7));
1418+ };
1419+ }())();
1420+ if (v instanceof Just) {
1421+ var projector = createProjector();
1422+ return replace(projector)(v.value0)(function __do2() {
1423+ var model = read(modelRef)();
1424+ return unView(plum2.view(model))(function(msg) {
1425+ return function __do3() {
1426+ var m = read(modelRef)();
1427+ var m_ = plum2.update(msg)(m)();
1428+ return write(m_)(modelRef)();
1429+ };
1430+ });
1431+ })();
1432+ }
1433+ ;
1434+ if (v instanceof Nothing) {
1435+ return unit;
1436+ }
1437+ ;
1438+ throw new Error("Failed pattern match at Plum (line 24, column 92 - line 36, column 25): " + [v.constructor.name]);
1439+ };
1440+ };
1441+ };
1442+
1443+ // output/Main/index.js
1444+ var pure2 = /* @__PURE__ */ pure(applicativeEffect);
1445+ var plum = {
1446+ init: /* @__PURE__ */ pure2({
1447+ text: "Test"
1448+ }),
1449+ view: function(model) {
1450+ return row([spacing(16)])([s(model.text), button([])({
1451+ onPress: unit,
1452+ view: s("Button")
1453+ })]);
1454+ },
1455+ update: function(msg) {
1456+ return function(model) {
1457+ return pure2({
1458+ text: "Button pressed"
1459+ });
1460+ };
1461+ }
1462+ };
1463+ var main = /* @__PURE__ */ run3("plum")(plum);
1464+
1465+ // <stdin>
1466+ main();
1467+})();