@explorable-viz/fluid 0.12.2 → 0.12.4

package/output-es/Web.HTML.HTMLTrackElement/index.js

@@ -0,0 +1,44 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dHTML$dHTMLTrackElement$dReadyState from "../Web.HTML.HTMLTrackElement.ReadyState/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+import {default as $$default, _readyState, kind, label, setDefault, setKind, setLabel, setSrc, setSrclang, src, srclang} from "./foreign.js";
+const toParentNode = Unsafe$dCoerce.unsafeCoerce;
+const toNonDocumentTypeChildNode = Unsafe$dCoerce.unsafeCoerce;
+const toNode = Unsafe$dCoerce.unsafeCoerce;
+const toHTMLElement = Unsafe$dCoerce.unsafeCoerce;
+const toEventTarget = Unsafe$dCoerce.unsafeCoerce;
+const toElement = Unsafe$dCoerce.unsafeCoerce;
+const toChildNode = Unsafe$dCoerce.unsafeCoerce;
+const readyState = el => () => {
+  const a$p = _readyState(el);
+  if (a$p === 0) { return Web$dHTML$dHTMLTrackElement$dReadyState.None; }
+  if (a$p === 1) { return Web$dHTML$dHTMLTrackElement$dReadyState.Loading; }
+  if (a$p === 2) { return Web$dHTML$dHTMLTrackElement$dReadyState.Loaded; }
+  if (a$p === 3) { return Web$dHTML$dHTMLTrackElement$dReadyState.Error; }
+  return Web$dHTML$dHTMLTrackElement$dReadyState.None;
+};
+const fromParentNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLTrackElement");
+const fromNonDocumentTypeChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLTrackElement");
+const fromNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLTrackElement");
+const fromHTMLElement = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLTrackElement");
+const fromEventTarget = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLTrackElement");
+const fromElement = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLTrackElement");
+const fromChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLTrackElement");
+export {
+  fromChildNode,
+  fromElement,
+  fromEventTarget,
+  fromHTMLElement,
+  fromNode,
+  fromNonDocumentTypeChildNode,
+  fromParentNode,
+  readyState,
+  toChildNode,
+  toElement,
+  toEventTarget,
+  toHTMLElement,
+  toNode,
+  toNonDocumentTypeChildNode,
+  toParentNode
+};
+export * from "./foreign.js";

package/output-es/Web.HTML.HTMLTrackElement.ReadyState/index.js

@@ -0,0 +1,109 @@
+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 $ReadyState = tag => tag;
+const None = /* #__PURE__ */ $ReadyState("None");
+const Loading = /* #__PURE__ */ $ReadyState("Loading");
+const Loaded = /* #__PURE__ */ $ReadyState("Loaded");
+const $$Error = /* #__PURE__ */ $ReadyState("Error");
+const toEnumReadyState = v => {
+  if (v === 0) { return Data$dMaybe.$Maybe("Just", None); }
+  if (v === 1) { return Data$dMaybe.$Maybe("Just", Loading); }
+  if (v === 2) { return Data$dMaybe.$Maybe("Just", Loaded); }
+  if (v === 3) { return Data$dMaybe.$Maybe("Just", $$Error); }
+  return Data$dMaybe.Nothing;
+};
+const showReadyState = {
+  show: v => {
+    if (v === "None") { return "None"; }
+    if (v === "Loading") { return "Loading"; }
+    if (v === "Loaded") { return "Loaded"; }
+    if (v === "Error") { return "Error"; }
+    $runtime.fail();
+  }
+};
+const fromEnumReadyState = v => {
+  if (v === "None") { return 0; }
+  if (v === "Loading") { return 1; }
+  if (v === "Loaded") { return 2; }
+  if (v === "Error") { return 3; }
+  $runtime.fail();
+};
+const eqReadyState = {
+  eq: x => y => {
+    if (x === "None") { return y === "None"; }
+    if (x === "Loading") { return y === "Loading"; }
+    if (x === "Loaded") { return y === "Loaded"; }
+    return x === "Error" && y === "Error";
+  }
+};
+const ordReadyState = {
+  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 === "Loading") {
+      if (y === "Loading") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Loading") { return Data$dOrdering.GT; }
+    if (x === "Loaded") {
+      if (y === "Loaded") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Loaded") { return Data$dOrdering.GT; }
+    if (x === "Error" && y === "Error") { return Data$dOrdering.EQ; }
+    $runtime.fail();
+  },
+  Eq0: () => eqReadyState
+};
+const enumReadyState = {
+  succ: a => {
+    const $0 = (() => {
+      if (a === "None") { return 1; }
+      if (a === "Loading") { return 2; }
+      if (a === "Loaded") { return 3; }
+      if (a === "Error") { return 4; }
+      $runtime.fail();
+    })();
+    if ($0 === 0) { return Data$dMaybe.$Maybe("Just", None); }
+    if ($0 === 1) { return Data$dMaybe.$Maybe("Just", Loading); }
+    if ($0 === 2) { return Data$dMaybe.$Maybe("Just", Loaded); }
+    if ($0 === 3) { return Data$dMaybe.$Maybe("Just", $$Error); }
+    return Data$dMaybe.Nothing;
+  },
+  pred: a => {
+    const $0 = (() => {
+      if (a === "None") { return -1; }
+      if (a === "Loading") { return 0; }
+      if (a === "Loaded") { return 1; }
+      if (a === "Error") { return 2; }
+      $runtime.fail();
+    })();
+    if ($0 === 0) { return Data$dMaybe.$Maybe("Just", None); }
+    if ($0 === 1) { return Data$dMaybe.$Maybe("Just", Loading); }
+    if ($0 === 2) { return Data$dMaybe.$Maybe("Just", Loaded); }
+    if ($0 === 3) { return Data$dMaybe.$Maybe("Just", $$Error); }
+    return Data$dMaybe.Nothing;
+  },
+  Ord0: () => ordReadyState
+};
+const boundedReadyState = {bottom: None, top: $$Error, Ord0: () => ordReadyState};
+const boundedEnumReadyState = {cardinality: 4, toEnum: toEnumReadyState, fromEnum: fromEnumReadyState, Bounded0: () => boundedReadyState, Enum1: () => enumReadyState};
+export {
+  $ReadyState,
+  $$Error as Error,
+  Loaded,
+  Loading,
+  None,
+  boundedEnumReadyState,
+  boundedReadyState,
+  enumReadyState,
+  eqReadyState,
+  fromEnumReadyState,
+  ordReadyState,
+  showReadyState,
+  toEnumReadyState
+};

package/output-es/Web.HTML.HTMLUListElement/index.js

@@ -0,0 +1,32 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+const toParentNode = Unsafe$dCoerce.unsafeCoerce;
+const toNonDocumentTypeChildNode = Unsafe$dCoerce.unsafeCoerce;
+const toNode = Unsafe$dCoerce.unsafeCoerce;
+const toHTMLElement = Unsafe$dCoerce.unsafeCoerce;
+const toEventTarget = Unsafe$dCoerce.unsafeCoerce;
+const toElement = Unsafe$dCoerce.unsafeCoerce;
+const toChildNode = Unsafe$dCoerce.unsafeCoerce;
+const fromParentNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLUListElement");
+const fromNonDocumentTypeChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLUListElement");
+const fromNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLUListElement");
+const fromHTMLElement = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLUListElement");
+const fromEventTarget = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLUListElement");
+const fromElement = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLUListElement");
+const fromChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLUListElement");
+export {
+  fromChildNode,
+  fromElement,
+  fromEventTarget,
+  fromHTMLElement,
+  fromNode,
+  fromNonDocumentTypeChildNode,
+  fromParentNode,
+  toChildNode,
+  toElement,
+  toEventTarget,
+  toHTMLElement,
+  toNode,
+  toNonDocumentTypeChildNode,
+  toParentNode
+};

package/output-es/Web.HTML.HTMLVideoElement/foreign.js

@@ -0,0 +1,63 @@
+// ----------------------------------------------------------------------------
+
+export function width(video) {
+  return function () {
+    return video.width;
+  };
+}
+
+export function setWidth(width) {
+  return function (video) {
+    return function () {
+      video.width = width;
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function height(video) {
+  return function () {
+    return video.height;
+  };
+}
+
+export function setHeight(height) {
+  return function (video) {
+    return function () {
+      video.height = height;
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function videoWidth(video) {
+  return function () {
+    return video.videoWidth;
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function videoHeight(video) {
+  return function () {
+    return video.videoHeight;
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function poster(video) {
+  return function () {
+    return video.poster;
+  };
+}
+
+export function setPoster(poster) {
+  return function (video) {
+    return function () {
+      video.poster = poster;
+    };
+  };
+}

package/output-es/Web.HTML.HTMLVideoElement/index.js

@@ -0,0 +1,38 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+import {height, poster, setHeight, setPoster, setWidth, videoHeight, videoWidth, width} from "./foreign.js";
+const toParentNode = Unsafe$dCoerce.unsafeCoerce;
+const toNonDocumentTypeChildNode = Unsafe$dCoerce.unsafeCoerce;
+const toNode = Unsafe$dCoerce.unsafeCoerce;
+const toHTMLMediaElement = Unsafe$dCoerce.unsafeCoerce;
+const toHTMLElement = Unsafe$dCoerce.unsafeCoerce;
+const toEventTarget = Unsafe$dCoerce.unsafeCoerce;
+const toElement = Unsafe$dCoerce.unsafeCoerce;
+const toChildNode = Unsafe$dCoerce.unsafeCoerce;
+const fromParentNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLVideoElement");
+const fromNonDocumentTypeChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLVideoElement");
+const fromNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLVideoElement");
+const fromHTMLMediaElement = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLVideoElement");
+const fromHTMLElement = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLVideoElement");
+const fromEventTarget = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLVideoElement");
+const fromElement = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLVideoElement");
+const fromChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("HTMLVideoElement");
+export {
+  fromChildNode,
+  fromElement,
+  fromEventTarget,
+  fromHTMLElement,
+  fromHTMLMediaElement,
+  fromNode,
+  fromNonDocumentTypeChildNode,
+  fromParentNode,
+  toChildNode,
+  toElement,
+  toEventTarget,
+  toHTMLElement,
+  toHTMLMediaElement,
+  toNode,
+  toNonDocumentTypeChildNode,
+  toParentNode
+};
+export * from "./foreign.js";

package/output-es/Web.HTML.History/foreign.js

@@ -0,0 +1,49 @@
+export function back(history) {
+  return function() {
+    return history.back();
+  };
+}
+
+export function forward(history) {
+  return function() {
+    return history.forward();
+  };
+}
+
+export function go(delta) {
+  return function(history) {
+    return function() {
+      return history.go(delta);
+    };
+  };
+}
+
+export function pushState(a) {
+  return function(docTitle) {
+    return function(url) {
+      return function(history) {
+        return function() {
+          return history.pushState(a, docTitle, url);
+        };
+      };
+    };
+  };
+}
+
+export function replaceState(a) {
+  return function(docTitle) {
+    return function(url) {
+      return function(history) {
+        return function() {
+          return history.replaceState(a, docTitle, url);
+        };
+      };
+    };
+  };
+}
+
+export function state(history) {
+  return function() {
+    return history.state;
+  };
+}

package/output-es/Web.HTML.History/index.js

@@ -0,0 +1,16 @@
+import * as Data$dOrd from "../Data.Ord/index.js";
+import {back, forward, go, pushState, replaceState, state} from "./foreign.js";
+const URL = x => x;
+const DocumentTitle = x => x;
+const Delta = x => x;
+const newtypeURL = {Coercible0: () => {}};
+const newtypeDocumentTitle = {Coercible0: () => {}};
+const newtypeDelta = {Coercible0: () => {}};
+const eqURL = {eq: x => y => x === y};
+const ordURL = {compare: x => y => Data$dOrd.ordString.compare(x)(y), Eq0: () => eqURL};
+const eqDocumentTitle = {eq: x => y => x === y};
+const ordDocumentTitle = {compare: x => y => Data$dOrd.ordString.compare(x)(y), Eq0: () => eqDocumentTitle};
+const eqDelta = {eq: x => y => x === y};
+const ordDelta = {compare: x => y => Data$dOrd.ordInt.compare(x)(y), Eq0: () => eqDelta};
+export {Delta, DocumentTitle, URL, eqDelta, eqDocumentTitle, eqURL, newtypeDelta, newtypeDocumentTitle, newtypeURL, ordDelta, ordDocumentTitle, ordURL};
+export * from "./foreign.js";

package/output-es/Web.HTML.Location/foreign.js

@@ -0,0 +1,169 @@
+export function hash(location) {
+  return function () {
+    return location.hash;
+  };
+}
+
+export function setHash(hash) {
+  return function (location) {
+    return function () {
+      location.hash = hash;
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function host(location) {
+  return function () {
+    return location.host;
+  };
+}
+
+export function setHost(host) {
+  return function (location) {
+    return function () {
+      location.host = host;
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function hostname(location) {
+  return function () {
+    return location.hostname;
+  };
+}
+
+export function setHostname(hostname) {
+  return function (location) {
+    return function () {
+      location.hostname = hostname;
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function href(location) {
+  return function () {
+    return location.href;
+  };
+}
+
+export function setHref(href) {
+  return function (location) {
+    return function () {
+      location.href = href;
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function origin(location) {
+  return function () {
+    return location.origin;
+  };
+}
+
+export function setOrigin(origin) {
+  return function (location) {
+    return function () {
+      location.origin = origin;
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function pathname(location) {
+  return function () {
+    return location.pathname;
+  };
+}
+
+export function setPathname(pathname) {
+  return function (location) {
+    return function () {
+      location.pathname = pathname;
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function port(location) {
+  return function () {
+    return location.port;
+  };
+}
+
+export function setPort(port) {
+  return function (location) {
+    return function () {
+      location.port = port;
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function protocol(location) {
+  return function () {
+    return location.protocol;
+  };
+}
+
+export function setProtocol(protocol) {
+  return function (location) {
+    return function () {
+      location.protocol = protocol;
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function search(location) {
+  return function () {
+    return location.search;
+  };
+}
+
+export function setSearch(search) {
+  return function (location) {
+    return function () {
+      location.search = search;
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function assign(url) {
+  return function (location) {
+    return function () {
+      location.assign(url);
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function replace(url) {
+  return function (location) {
+    return function () {
+      location.replace(url);
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+export function reload(location) {
+  return function () {
+    location.reload();
+  };
+}

package/output-es/Web.HTML.Location/index.js

@@ -0,0 +1,25 @@
+import {
+  assign,
+  hash,
+  host,
+  hostname,
+  href,
+  origin,
+  pathname,
+  port,
+  protocol,
+  reload,
+  replace,
+  search,
+  setHash,
+  setHost,
+  setHostname,
+  setHref,
+  setOrigin,
+  setPathname,
+  setPort,
+  setProtocol,
+  setSearch
+} from "./foreign.js";
+export {};
+export * from "./foreign.js";

package/output-es/Web.HTML.Navigator/foreign.js

@@ -0,0 +1,29 @@
+export function language(navigator) {
+  return function () {
+    return navigator.language;
+  };
+}
+
+export function languages(navigator) {
+  return function () {
+    return navigator.languages;
+  };
+}
+
+export function onLine(navigator) {
+  return function () {
+    return navigator.onLine;
+  };
+}
+
+export function platform(navigator) {
+  return function () {
+    return navigator.platform;
+  };
+}
+
+export function userAgent(navigator) {
+  return function () {
+    return navigator.userAgent;
+  };
+}

package/output-es/Web.HTML.Navigator/index.js

@@ -0,0 +1,3 @@
+import {language, languages, onLine, platform, userAgent} from "./foreign.js";
+export {};
+export * from "./foreign.js";

package/output-es/Web.HTML.SelectionMode/index.js

@@ -0,0 +1,62 @@
+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 $SelectionMode = tag => tag;
+const Preserve = /* #__PURE__ */ $SelectionMode("Preserve");
+const Select = /* #__PURE__ */ $SelectionMode("Select");
+const Start = /* #__PURE__ */ $SelectionMode("Start");
+const End = /* #__PURE__ */ $SelectionMode("End");
+const showSelectionMode = {
+  show: v => {
+    if (v === "Preserve") { return "Preserve"; }
+    if (v === "Select") { return "Select"; }
+    if (v === "Start") { return "Start"; }
+    if (v === "End") { return "End"; }
+    $runtime.fail();
+  }
+};
+const print = v => {
+  if (v === "Preserve") { return "preserve"; }
+  if (v === "Select") { return "select"; }
+  if (v === "Start") { return "start"; }
+  if (v === "End") { return "end"; }
+  $runtime.fail();
+};
+const parse = v => {
+  if (v === "preserve") { return Data$dMaybe.$Maybe("Just", Preserve); }
+  if (v === "select") { return Data$dMaybe.$Maybe("Just", Select); }
+  if (v === "start") { return Data$dMaybe.$Maybe("Just", Start); }
+  if (v === "end") { return Data$dMaybe.$Maybe("Just", End); }
+  return Data$dMaybe.Nothing;
+};
+const eqSelectionMode = {
+  eq: x => y => {
+    if (x === "Preserve") { return y === "Preserve"; }
+    if (x === "Select") { return y === "Select"; }
+    if (x === "Start") { return y === "Start"; }
+    return x === "End" && y === "End";
+  }
+};
+const ordSelectionMode = {
+  compare: x => y => {
+    if (x === "Preserve") {
+      if (y === "Preserve") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Preserve") { return Data$dOrdering.GT; }
+    if (x === "Select") {
+      if (y === "Select") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Select") { return Data$dOrdering.GT; }
+    if (x === "Start") {
+      if (y === "Start") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Start") { return Data$dOrdering.GT; }
+    if (x === "End" && y === "End") { return Data$dOrdering.EQ; }
+    $runtime.fail();
+  },
+  Eq0: () => eqSelectionMode
+};
+export {$SelectionMode, End, Preserve, Select, Start, eqSelectionMode, ordSelectionMode, parse, print, showSelectionMode};

package/output-es/Web.HTML.ValidityState/foreign.js

@@ -0,0 +1,3 @@
+export function readProp(prop, vs) {
+  return vs[prop];
+}

package/output-es/Web.HTML.ValidityState/index.js

@@ -0,0 +1,15 @@
+import * as Effect$dUncurried from "../Effect.Uncurried/index.js";
+import {readProp} from "./foreign.js";
+const valueMissing = /* #__PURE__ */ Effect$dUncurried.runEffectFn2(readProp)("valueMissing");
+const valid = /* #__PURE__ */ Effect$dUncurried.runEffectFn2(readProp)("valid");
+const typeMismatch = /* #__PURE__ */ Effect$dUncurried.runEffectFn2(readProp)("typeMismatch");
+const tooShort = /* #__PURE__ */ Effect$dUncurried.runEffectFn2(readProp)("tooShort");
+const tooLong = /* #__PURE__ */ Effect$dUncurried.runEffectFn2(readProp)("tooLong");
+const stepMismatch = /* #__PURE__ */ Effect$dUncurried.runEffectFn2(readProp)("stepMismatch");
+const rangeUnderflow = /* #__PURE__ */ Effect$dUncurried.runEffectFn2(readProp)("rangeUnderflow");
+const rangeOverflow = /* #__PURE__ */ Effect$dUncurried.runEffectFn2(readProp)("rangeOverflow");
+const patternMismatch = /* #__PURE__ */ Effect$dUncurried.runEffectFn2(readProp)("patternMismatch");
+const customError = /* #__PURE__ */ Effect$dUncurried.runEffectFn2(readProp)("customError");
+const badInput = /* #__PURE__ */ Effect$dUncurried.runEffectFn2(readProp)("badInput");
+export {badInput, customError, patternMismatch, rangeOverflow, rangeUnderflow, stepMismatch, tooLong, tooShort, typeMismatch, valid, valueMissing};
+export * from "./foreign.js";