@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Web.DOM.NodeType/index.js

@@ -0,0 +1,199 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+const $NodeType = tag => tag;
+const ElementNode = /* #__PURE__ */ $NodeType("ElementNode");
+const AttributeNode = /* #__PURE__ */ $NodeType("AttributeNode");
+const TextNode = /* #__PURE__ */ $NodeType("TextNode");
+const CDATASectionNode = /* #__PURE__ */ $NodeType("CDATASectionNode");
+const EntityReferenceNode = /* #__PURE__ */ $NodeType("EntityReferenceNode");
+const EntityNode = /* #__PURE__ */ $NodeType("EntityNode");
+const ProcessingInstructionNode = /* #__PURE__ */ $NodeType("ProcessingInstructionNode");
+const CommentNode = /* #__PURE__ */ $NodeType("CommentNode");
+const DocumentNode = /* #__PURE__ */ $NodeType("DocumentNode");
+const DocumentTypeNode = /* #__PURE__ */ $NodeType("DocumentTypeNode");
+const DocumentFragmentNode = /* #__PURE__ */ $NodeType("DocumentFragmentNode");
+const NotationNode = /* #__PURE__ */ $NodeType("NotationNode");
+const toEnumNodeType = v => {
+  if (v === 1) { return Data$dMaybe.$Maybe("Just", ElementNode); }
+  if (v === 2) { return Data$dMaybe.$Maybe("Just", AttributeNode); }
+  if (v === 3) { return Data$dMaybe.$Maybe("Just", TextNode); }
+  if (v === 4) { return Data$dMaybe.$Maybe("Just", CDATASectionNode); }
+  if (v === 5) { return Data$dMaybe.$Maybe("Just", EntityReferenceNode); }
+  if (v === 6) { return Data$dMaybe.$Maybe("Just", EntityNode); }
+  if (v === 7) { return Data$dMaybe.$Maybe("Just", ProcessingInstructionNode); }
+  if (v === 8) { return Data$dMaybe.$Maybe("Just", CommentNode); }
+  if (v === 9) { return Data$dMaybe.$Maybe("Just", DocumentNode); }
+  if (v === 10) { return Data$dMaybe.$Maybe("Just", DocumentTypeNode); }
+  if (v === 11) { return Data$dMaybe.$Maybe("Just", DocumentFragmentNode); }
+  if (v === 12) { return Data$dMaybe.$Maybe("Just", NotationNode); }
+  return Data$dMaybe.Nothing;
+};
+const showNodeType = {
+  show: v => {
+    if (v === "ElementNode") { return "ElementNode"; }
+    if (v === "AttributeNode") { return "AttributeNode"; }
+    if (v === "TextNode") { return "TextNode"; }
+    if (v === "CDATASectionNode") { return "CDATASectionNode"; }
+    if (v === "EntityReferenceNode") { return "EntityReferenceNode"; }
+    if (v === "EntityNode") { return "EntityNode"; }
+    if (v === "ProcessingInstructionNode") { return "ProcessingInstructionNode"; }
+    if (v === "CommentNode") { return "CommentNode"; }
+    if (v === "DocumentNode") { return "DocumentNode"; }
+    if (v === "DocumentTypeNode") { return "DocumentTypeNode"; }
+    if (v === "DocumentFragmentNode") { return "DocumentFragmentNode"; }
+    if (v === "NotationNode") { return "NotationNode"; }
+    $runtime.fail();
+  }
+};
+const fromEnumNodeType = v => {
+  if (v === "ElementNode") { return 1; }
+  if (v === "AttributeNode") { return 2; }
+  if (v === "TextNode") { return 3; }
+  if (v === "CDATASectionNode") { return 4; }
+  if (v === "EntityReferenceNode") { return 5; }
+  if (v === "EntityNode") { return 6; }
+  if (v === "ProcessingInstructionNode") { return 7; }
+  if (v === "CommentNode") { return 8; }
+  if (v === "DocumentNode") { return 9; }
+  if (v === "DocumentTypeNode") { return 10; }
+  if (v === "DocumentFragmentNode") { return 11; }
+  if (v === "NotationNode") { return 12; }
+  $runtime.fail();
+};
+const eqNodeType = {
+  eq: x => y => {
+    if (x === "ElementNode") { return y === "ElementNode"; }
+    if (x === "AttributeNode") { return y === "AttributeNode"; }
+    if (x === "TextNode") { return y === "TextNode"; }
+    if (x === "CDATASectionNode") { return y === "CDATASectionNode"; }
+    if (x === "EntityReferenceNode") { return y === "EntityReferenceNode"; }
+    if (x === "EntityNode") { return y === "EntityNode"; }
+    if (x === "ProcessingInstructionNode") { return y === "ProcessingInstructionNode"; }
+    if (x === "CommentNode") { return y === "CommentNode"; }
+    if (x === "DocumentNode") { return y === "DocumentNode"; }
+    if (x === "DocumentTypeNode") { return y === "DocumentTypeNode"; }
+    if (x === "DocumentFragmentNode") { return y === "DocumentFragmentNode"; }
+    return x === "NotationNode" && y === "NotationNode";
+  }
+};
+const ordNodeType = {
+  compare: x => y => Data$dOrd.ordInt.compare((() => {
+    if (x === "ElementNode") { return 1; }
+    if (x === "AttributeNode") { return 2; }
+    if (x === "TextNode") { return 3; }
+    if (x === "CDATASectionNode") { return 4; }
+    if (x === "EntityReferenceNode") { return 5; }
+    if (x === "EntityNode") { return 6; }
+    if (x === "ProcessingInstructionNode") { return 7; }
+    if (x === "CommentNode") { return 8; }
+    if (x === "DocumentNode") { return 9; }
+    if (x === "DocumentTypeNode") { return 10; }
+    if (x === "DocumentFragmentNode") { return 11; }
+    if (x === "NotationNode") { return 12; }
+    $runtime.fail();
+  })())((() => {
+    if (y === "ElementNode") { return 1; }
+    if (y === "AttributeNode") { return 2; }
+    if (y === "TextNode") { return 3; }
+    if (y === "CDATASectionNode") { return 4; }
+    if (y === "EntityReferenceNode") { return 5; }
+    if (y === "EntityNode") { return 6; }
+    if (y === "ProcessingInstructionNode") { return 7; }
+    if (y === "CommentNode") { return 8; }
+    if (y === "DocumentNode") { return 9; }
+    if (y === "DocumentTypeNode") { return 10; }
+    if (y === "DocumentFragmentNode") { return 11; }
+    if (y === "NotationNode") { return 12; }
+    $runtime.fail();
+  })()),
+  Eq0: () => eqNodeType
+};
+const enumNodeType = {
+  succ: a => {
+    const $0 = (() => {
+      if (a === "ElementNode") { return 2; }
+      if (a === "AttributeNode") { return 3; }
+      if (a === "TextNode") { return 4; }
+      if (a === "CDATASectionNode") { return 5; }
+      if (a === "EntityReferenceNode") { return 6; }
+      if (a === "EntityNode") { return 7; }
+      if (a === "ProcessingInstructionNode") { return 8; }
+      if (a === "CommentNode") { return 9; }
+      if (a === "DocumentNode") { return 10; }
+      if (a === "DocumentTypeNode") { return 11; }
+      if (a === "DocumentFragmentNode") { return 12; }
+      if (a === "NotationNode") { return 13; }
+      $runtime.fail();
+    })();
+    if ($0 === 1) { return Data$dMaybe.$Maybe("Just", ElementNode); }
+    if ($0 === 2) { return Data$dMaybe.$Maybe("Just", AttributeNode); }
+    if ($0 === 3) { return Data$dMaybe.$Maybe("Just", TextNode); }
+    if ($0 === 4) { return Data$dMaybe.$Maybe("Just", CDATASectionNode); }
+    if ($0 === 5) { return Data$dMaybe.$Maybe("Just", EntityReferenceNode); }
+    if ($0 === 6) { return Data$dMaybe.$Maybe("Just", EntityNode); }
+    if ($0 === 7) { return Data$dMaybe.$Maybe("Just", ProcessingInstructionNode); }
+    if ($0 === 8) { return Data$dMaybe.$Maybe("Just", CommentNode); }
+    if ($0 === 9) { return Data$dMaybe.$Maybe("Just", DocumentNode); }
+    if ($0 === 10) { return Data$dMaybe.$Maybe("Just", DocumentTypeNode); }
+    if ($0 === 11) { return Data$dMaybe.$Maybe("Just", DocumentFragmentNode); }
+    if ($0 === 12) { return Data$dMaybe.$Maybe("Just", NotationNode); }
+    return Data$dMaybe.Nothing;
+  },
+  pred: a => {
+    const $0 = (() => {
+      if (a === "ElementNode") { return 0; }
+      if (a === "AttributeNode") { return 1; }
+      if (a === "TextNode") { return 2; }
+      if (a === "CDATASectionNode") { return 3; }
+      if (a === "EntityReferenceNode") { return 4; }
+      if (a === "EntityNode") { return 5; }
+      if (a === "ProcessingInstructionNode") { return 6; }
+      if (a === "CommentNode") { return 7; }
+      if (a === "DocumentNode") { return 8; }
+      if (a === "DocumentTypeNode") { return 9; }
+      if (a === "DocumentFragmentNode") { return 10; }
+      if (a === "NotationNode") { return 11; }
+      $runtime.fail();
+    })();
+    if ($0 === 1) { return Data$dMaybe.$Maybe("Just", ElementNode); }
+    if ($0 === 2) { return Data$dMaybe.$Maybe("Just", AttributeNode); }
+    if ($0 === 3) { return Data$dMaybe.$Maybe("Just", TextNode); }
+    if ($0 === 4) { return Data$dMaybe.$Maybe("Just", CDATASectionNode); }
+    if ($0 === 5) { return Data$dMaybe.$Maybe("Just", EntityReferenceNode); }
+    if ($0 === 6) { return Data$dMaybe.$Maybe("Just", EntityNode); }
+    if ($0 === 7) { return Data$dMaybe.$Maybe("Just", ProcessingInstructionNode); }
+    if ($0 === 8) { return Data$dMaybe.$Maybe("Just", CommentNode); }
+    if ($0 === 9) { return Data$dMaybe.$Maybe("Just", DocumentNode); }
+    if ($0 === 10) { return Data$dMaybe.$Maybe("Just", DocumentTypeNode); }
+    if ($0 === 11) { return Data$dMaybe.$Maybe("Just", DocumentFragmentNode); }
+    if ($0 === 12) { return Data$dMaybe.$Maybe("Just", NotationNode); }
+    return Data$dMaybe.Nothing;
+  },
+  Ord0: () => ordNodeType
+};
+const boundedNodeType = {bottom: ElementNode, top: NotationNode, Ord0: () => ordNodeType};
+const boundedEnumNodeType = {cardinality: 12, toEnum: toEnumNodeType, fromEnum: fromEnumNodeType, Bounded0: () => boundedNodeType, Enum1: () => enumNodeType};
+export {
+  $NodeType,
+  AttributeNode,
+  CDATASectionNode,
+  CommentNode,
+  DocumentFragmentNode,
+  DocumentNode,
+  DocumentTypeNode,
+  ElementNode,
+  EntityNode,
+  EntityReferenceNode,
+  NotationNode,
+  ProcessingInstructionNode,
+  TextNode,
+  boundedEnumNodeType,
+  boundedNodeType,
+  enumNodeType,
+  eqNodeType,
+  fromEnumNodeType,
+  ordNodeType,
+  showNodeType,
+  toEnumNodeType
+};

package/output-es/Web.DOM.NonDocumentTypeChildNode/foreign.js

@@ -0,0 +1,11 @@
+export function _previousElementSibling(node) {
+  return function () {
+    return node.previousElementSibling;
+  };
+}
+
+export function _nextElementSibling(node) {
+  return function () {
+    return node.nextElementSibling;
+  };
+}

package/output-es/Web.DOM.NonDocumentTypeChildNode/index.js

@@ -0,0 +1,19 @@
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import {_nextElementSibling, _previousElementSibling} from "./foreign.js";
+const previousElementSibling = x => {
+  const $0 = _previousElementSibling(x);
+  return () => {
+    const a$p = $0();
+    return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+  };
+};
+const nextElementSibling = x => {
+  const $0 = _nextElementSibling(x);
+  return () => {
+    const a$p = $0();
+    return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+  };
+};
+export {nextElementSibling, previousElementSibling};
+export * from "./foreign.js";

package/output-es/Web.DOM.NonElementParentNode/foreign.js

@@ -0,0 +1,7 @@
+export function _getElementById(id) {
+  return function (node) {
+    return function () {
+      return node.getElementById(id);
+    };
+  };
+}

package/output-es/Web.DOM.NonElementParentNode/index.js

@@ -0,0 +1,15 @@
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import {_getElementById} from "./foreign.js";
+const getElementById = eid => {
+  const $0 = _getElementById(eid);
+  return x => {
+    const $1 = $0(x);
+    return () => {
+      const a$p = $1();
+      return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+    };
+  };
+};
+export {getElementById};
+export * from "./foreign.js";

package/output-es/Web.DOM.ParentNode/foreign.js

@@ -0,0 +1,28 @@
+var getEffProp = function (name) {
+  return function (node) {
+    return function () {
+      return node[name];
+    };
+  };
+};
+
+export const children = getEffProp("children");
+export const _firstElementChild = getEffProp("firstElementChild");
+export const _lastElementChild = getEffProp("lastElementChild");
+export const childElementCount = getEffProp("childElementCount");
+
+export function _querySelector(selector) {
+  return function (node) {
+    return function () {
+      return node.querySelector(selector);
+    };
+  };
+}
+
+export function querySelectorAll(selector) {
+  return function (node) {
+    return function () {
+      return node.querySelectorAll(selector);
+    };
+  };
+}

package/output-es/Web.DOM.ParentNode/index.js

@@ -0,0 +1,35 @@
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import {_firstElementChild, _lastElementChild, _querySelector, childElementCount, children, querySelectorAll} from "./foreign.js";
+const QuerySelector = x => x;
+const querySelector = qs => {
+  const $0 = _querySelector(qs);
+  return x => {
+    const $1 = $0(x);
+    return () => {
+      const a$p = $1();
+      return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+    };
+  };
+};
+const ordQuerySelector = Data$dOrd.ordString;
+const newtypeQuerySelector = {Coercible0: () => {}};
+const lastElementChild = x => {
+  const $0 = _lastElementChild(x);
+  return () => {
+    const a$p = $0();
+    return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+  };
+};
+const firstElementChild = x => {
+  const $0 = _firstElementChild(x);
+  return () => {
+    const a$p = $0();
+    return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+  };
+};
+const eqQuerySelector = Data$dEq.eqString;
+export {QuerySelector, eqQuerySelector, firstElementChild, lastElementChild, newtypeQuerySelector, ordQuerySelector, querySelector};
+export * from "./foreign.js";

package/output-es/Web.DOM.ProcessingInstruction/foreign.js

@@ -0,0 +1,5 @@
+export function target(pi) {
+  return function () {
+    return pi.target;
+  };
+}

package/output-es/Web.DOM.ProcessingInstruction/index.js

@@ -0,0 +1,15 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+import {target} from "./foreign.js";
+const toNonDocumentTypeChildNode = Unsafe$dCoerce.unsafeCoerce;
+const toNode = Unsafe$dCoerce.unsafeCoerce;
+const toEventTarget = Unsafe$dCoerce.unsafeCoerce;
+const toChildNode = Unsafe$dCoerce.unsafeCoerce;
+const toCharacterData = Unsafe$dCoerce.unsafeCoerce;
+const fromNonDocumentTypeChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("ProcessingInstruction");
+const fromNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("ProcessingInstruction");
+const fromEventTarget = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("ProcessingInstruction");
+const fromChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("ProcessingInstruction");
+const fromCharacterData = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("ProcessingInstruction");
+export {fromCharacterData, fromChildNode, fromEventTarget, fromNode, fromNonDocumentTypeChildNode, toCharacterData, toChildNode, toEventTarget, toNode, toNonDocumentTypeChildNode};
+export * from "./foreign.js";

package/output-es/Web.DOM.ShadowRoot/foreign.js

@@ -0,0 +1,9 @@
+export function _mode(el) {
+  return el.mode;
+}
+
+export function host(el) {
+  return function() {
+    return el.host;
+  };
+}

package/output-es/Web.DOM.ShadowRoot/index.js

@@ -0,0 +1,23 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import {_mode, host} from "./foreign.js";
+const $ShadowRootMode = tag => tag;
+const Open = /* #__PURE__ */ $ShadowRootMode("Open");
+const Closed = /* #__PURE__ */ $ShadowRootMode("Closed");
+const toNode = Unsafe$dCoerce.unsafeCoerce;
+const showShadowRootMode = {
+  show: v => {
+    if (v === "Open") { return "open"; }
+    if (v === "Closed") { return "closed"; }
+    $runtime.fail();
+  }
+};
+const mode = x => {
+  const $0 = _mode(x);
+  if ($0 === "open") { return Data$dMaybe.$Maybe("Just", Open); }
+  if ($0 === "closed") { return Data$dMaybe.$Maybe("Just", Closed); }
+  return Data$dMaybe.Nothing;
+};
+export {$ShadowRootMode, Closed, Open, mode, showShadowRootMode, toNode};
+export * from "./foreign.js";

package/output-es/Web.DOM.Text/foreign.js

@@ -0,0 +1,13 @@
+export function splitText(offset) {
+  return function (t) {
+    return function () {
+      return t.splitText(offset);
+    };
+  };
+}
+
+export function wholeText(t) {
+  return function () {
+    return t.wholeText;
+  };
+}

package/output-es/Web.DOM.Text/index.js

@@ -0,0 +1,15 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+import {splitText, wholeText} from "./foreign.js";
+const toNonDocumentTypeChildNode = Unsafe$dCoerce.unsafeCoerce;
+const toNode = Unsafe$dCoerce.unsafeCoerce;
+const toEventTarget = Unsafe$dCoerce.unsafeCoerce;
+const toChildNode = Unsafe$dCoerce.unsafeCoerce;
+const toCharacterData = Unsafe$dCoerce.unsafeCoerce;
+const fromNonDocumentTypeChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Text");
+const fromNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Text");
+const fromEventTarget = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Text");
+const fromChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Text");
+const fromCharacterData = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Text");
+export {fromCharacterData, fromChildNode, fromEventTarget, fromNode, fromNonDocumentTypeChildNode, toCharacterData, toChildNode, toEventTarget, toNode, toNonDocumentTypeChildNode};
+export * from "./foreign.js";

package/output-es/Web.Event.CustomEvent/foreign.js

@@ -0,0 +1,18 @@
+const newSimple = function(ty) {
+  return function () {
+    return new CustomEvent(ty);
+  };
+};
+export { newSimple as new };
+
+export function newOptionsImpl (ty) {
+  return function (opt) {
+    return function () {
+      return new CustomEvent(ty, opt);
+    };
+  };
+}
+
+export function detail(e) {
+  return e.detail;
+}

package/output-es/Web.Event.CustomEvent/index.js

@@ -0,0 +1,20 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+import {new as $$new, detail, newOptionsImpl} from "./foreign.js";
+const toEvent = Unsafe$dCoerce.unsafeCoerce;
+const newWithOptions = ty => v => newOptionsImpl(ty)({
+  detail: (() => {
+    if (v.detail.tag === "Nothing") { return Data$dNullable.null; }
+    if (v.detail.tag === "Just") { return Data$dNullable.notNull(v.detail._1); }
+    $runtime.fail();
+  })(),
+  bubbles: v.bubbles,
+  cancelable: v.cancelable,
+  composed: v.composed
+});
+const new$p = ty => det => newWithOptions(ty)({detail: det, bubbles: false, cancelable: false, composed: false});
+const fromEvent = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("CustomEvent");
+export {fromEvent, new$p, newWithOptions, toEvent};
+export * from "./foreign.js";

package/output-es/Web.Event.Event/foreign.js

@@ -0,0 +1,51 @@
+export function bubbles(e) {
+  return e.bubbles;
+}
+
+export function cancelable(e) {
+  return e.cancelable;
+}
+
+export function _currentTarget(e) {
+  return e.currentTarget;
+}
+
+export function defaultPrevented(e) {
+  return function() {
+    return e.defaultPrevented;
+  };
+}
+
+export function eventPhaseIndex(e) {
+  return e.eventPhase;
+}
+
+export function _target(e) {
+  return e.target;
+}
+
+export function timeStamp(e) {
+  return e.timeStamp;
+}
+
+export function type_(e) {
+  return e.type;
+}
+
+export function preventDefault(e) {
+  return function () {
+    return e.preventDefault();
+  };
+}
+
+export function stopImmediatePropagation(e) {
+  return function () {
+    return e.stopImmediatePropagation();
+  };
+}
+
+export function stopPropagation(e) {
+  return function () {
+    return e.stopPropagation();
+  };
+}

package/output-es/Web.Event.Event/index.js

@@ -0,0 +1,23 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Web$dEvent$dEventPhase from "../Web.Event.EventPhase/index.js";
+import {_currentTarget, _target, bubbles, cancelable, defaultPrevented, eventPhaseIndex, preventDefault, stopImmediatePropagation, stopPropagation, timeStamp, type_} from "./foreign.js";
+const EventType = x => x;
+const target = x => Data$dNullable.nullable(_target(x), Data$dMaybe.Nothing, Data$dMaybe.Just);
+const ordEventType = Data$dOrd.ordString;
+const newtypeEventType = {Coercible0: () => {}};
+const eventPhase = () => x => {
+  const $0 = eventPhaseIndex(x);
+  if ($0 === 0) { return Web$dEvent$dEventPhase.None; }
+  if ($0 === 1) { return Web$dEvent$dEventPhase.Capturing; }
+  if ($0 === 2) { return Web$dEvent$dEventPhase.AtTarget; }
+  if ($0 === 3) { return Web$dEvent$dEventPhase.Bubbling; }
+  $runtime.fail();
+};
+const eqEventType = Data$dEq.eqString;
+const currentTarget = x => Data$dNullable.nullable(_currentTarget(x), Data$dMaybe.Nothing, Data$dMaybe.Just);
+export {EventType, currentTarget, eqEventType, eventPhase, newtypeEventType, ordEventType, target};
+export * from "./foreign.js";

package/output-es/Web.Event.EventPhase/index.js

@@ -0,0 +1,99 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const $EventPhase = tag => tag;
+const None = /* #__PURE__ */ $EventPhase("None");
+const Capturing = /* #__PURE__ */ $EventPhase("Capturing");
+const AtTarget = /* #__PURE__ */ $EventPhase("AtTarget");
+const Bubbling = /* #__PURE__ */ $EventPhase("Bubbling");
+const toEnumEventPhase = v => {
+  if (v === 0) { return Data$dMaybe.$Maybe("Just", None); }
+  if (v === 1) { return Data$dMaybe.$Maybe("Just", Capturing); }
+  if (v === 2) { return Data$dMaybe.$Maybe("Just", AtTarget); }
+  if (v === 3) { return Data$dMaybe.$Maybe("Just", Bubbling); }
+  return Data$dMaybe.Nothing;
+};
+const fromEnumEventPhase = v => {
+  if (v === "None") { return 0; }
+  if (v === "Capturing") { return 1; }
+  if (v === "AtTarget") { return 2; }
+  if (v === "Bubbling") { return 3; }
+  $runtime.fail();
+};
+const eqEventPhase = {
+  eq: x => y => {
+    if (x === "None") { return y === "None"; }
+    if (x === "Capturing") { return y === "Capturing"; }
+    if (x === "AtTarget") { return y === "AtTarget"; }
+    return x === "Bubbling" && y === "Bubbling";
+  }
+};
+const ordEventPhase = {
+  compare: x => y => {
+    if (x === "None") {
+      if (y === "None") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "None") { return Data$dOrdering.GT; }
+    if (x === "Capturing") {
+      if (y === "Capturing") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Capturing") { return Data$dOrdering.GT; }
+    if (x === "AtTarget") {
+      if (y === "AtTarget") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "AtTarget") { return Data$dOrdering.GT; }
+    if (x === "Bubbling" && y === "Bubbling") { return Data$dOrdering.EQ; }
+    $runtime.fail();
+  },
+  Eq0: () => eqEventPhase
+};
+const enumEventPhase = {
+  succ: a => {
+    const $0 = (() => {
+      if (a === "None") { return 1; }
+      if (a === "Capturing") { return 2; }
+      if (a === "AtTarget") { return 3; }
+      if (a === "Bubbling") { return 4; }
+      $runtime.fail();
+    })();
+    if ($0 === 0) { return Data$dMaybe.$Maybe("Just", None); }
+    if ($0 === 1) { return Data$dMaybe.$Maybe("Just", Capturing); }
+    if ($0 === 2) { return Data$dMaybe.$Maybe("Just", AtTarget); }
+    if ($0 === 3) { return Data$dMaybe.$Maybe("Just", Bubbling); }
+    return Data$dMaybe.Nothing;
+  },
+  pred: a => {
+    const $0 = (() => {
+      if (a === "None") { return -1; }
+      if (a === "Capturing") { return 0; }
+      if (a === "AtTarget") { return 1; }
+      if (a === "Bubbling") { return 2; }
+      $runtime.fail();
+    })();
+    if ($0 === 0) { return Data$dMaybe.$Maybe("Just", None); }
+    if ($0 === 1) { return Data$dMaybe.$Maybe("Just", Capturing); }
+    if ($0 === 2) { return Data$dMaybe.$Maybe("Just", AtTarget); }
+    if ($0 === 3) { return Data$dMaybe.$Maybe("Just", Bubbling); }
+    return Data$dMaybe.Nothing;
+  },
+  Ord0: () => ordEventPhase
+};
+const boundedEventPhase = {bottom: None, top: Bubbling, Ord0: () => ordEventPhase};
+const boundedEnumEventPhase = {cardinality: 4, toEnum: toEnumEventPhase, fromEnum: fromEnumEventPhase, Bounded0: () => boundedEventPhase, Enum1: () => enumEventPhase};
+export {
+  $EventPhase,
+  AtTarget,
+  Bubbling,
+  Capturing,
+  None,
+  boundedEnumEventPhase,
+  boundedEventPhase,
+  enumEventPhase,
+  eqEventPhase,
+  fromEnumEventPhase,
+  ordEventPhase,
+  toEnumEventPhase
+};