@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Data.Monoid.Endo/index.js

@@ -0,0 +1,12 @@
+const Endo = x => x;
+const showEndo = dictShow => ({show: v => "(Endo " + dictShow.show(v) + ")"});
+const semigroupEndo = dictSemigroupoid => ({append: v => v1 => dictSemigroupoid.compose(v)(v1)});
+const ordEndo = dictOrd => dictOrd;
+const monoidEndo = dictCategory => {
+  const $0 = dictCategory.Semigroupoid0();
+  const semigroupEndo1 = {append: v => v1 => $0.compose(v)(v1)};
+  return {mempty: dictCategory.identity, Semigroup0: () => semigroupEndo1};
+};
+const eqEndo = dictEq => dictEq;
+const boundedEndo = dictBounded => dictBounded;
+export {Endo, boundedEndo, eqEndo, monoidEndo, ordEndo, semigroupEndo, showEndo};

package/output-es/Data.Monoid.Generic/index.js

@@ -0,0 +1,11 @@
+import * as Data$dGeneric$dRep from "../Data.Generic.Rep/index.js";
+const genericMonoidNoArguments = {"genericMempty'": Data$dGeneric$dRep.NoArguments};
+const genericMonoidArgument = dictMonoid => ({"genericMempty'": dictMonoid.mempty});
+const genericMempty$p = dict => dict["genericMempty'"];
+const genericMonoidConstructor = dictGenericMonoid => ({"genericMempty'": dictGenericMonoid["genericMempty'"]});
+const genericMonoidProduct = dictGenericMonoid => {
+  const genericMempty$p1 = dictGenericMonoid["genericMempty'"];
+  return dictGenericMonoid1 => ({"genericMempty'": Data$dGeneric$dRep.$Product(genericMempty$p1, dictGenericMonoid1["genericMempty'"])});
+};
+const genericMempty = dictGeneric => dictGenericMonoid => dictGeneric.to(dictGenericMonoid["genericMempty'"]);
+export {genericMempty, genericMempty$p, genericMonoidArgument, genericMonoidConstructor, genericMonoidNoArguments, genericMonoidProduct};

package/output-es/Data.Monoid.Multiplicative/index.js

@@ -0,0 +1,33 @@
+const Multiplicative = x => x;
+const showMultiplicative = dictShow => ({show: v => "(Multiplicative " + dictShow.show(v) + ")"});
+const semigroupMultiplicative = dictSemiring => ({append: v => v1 => dictSemiring.mul(v)(v1)});
+const ordMultiplicative = dictOrd => dictOrd;
+const monoidMultiplicative = dictSemiring => {
+  const semigroupMultiplicative1 = {append: v => v1 => dictSemiring.mul(v)(v1)};
+  return {mempty: dictSemiring.one, Semigroup0: () => semigroupMultiplicative1};
+};
+const functorMultiplicative = {map: f => m => f(m)};
+const eqMultiplicative = dictEq => dictEq;
+const eq1Multiplicative = {eq1: dictEq => dictEq.eq};
+const ord1Multiplicative = {compare1: dictOrd => dictOrd.compare, Eq10: () => eq1Multiplicative};
+const boundedMultiplicative = dictBounded => dictBounded;
+const applyMultiplicative = {apply: v => v1 => v(v1), Functor0: () => functorMultiplicative};
+const bindMultiplicative = {bind: v => f => f(v), Apply0: () => applyMultiplicative};
+const applicativeMultiplicative = {pure: Multiplicative, Apply0: () => applyMultiplicative};
+const monadMultiplicative = {Applicative0: () => applicativeMultiplicative, Bind1: () => bindMultiplicative};
+export {
+  Multiplicative,
+  applicativeMultiplicative,
+  applyMultiplicative,
+  bindMultiplicative,
+  boundedMultiplicative,
+  eq1Multiplicative,
+  eqMultiplicative,
+  functorMultiplicative,
+  monadMultiplicative,
+  monoidMultiplicative,
+  ord1Multiplicative,
+  ordMultiplicative,
+  semigroupMultiplicative,
+  showMultiplicative
+};

package/output-es/Data.NaturalTransformation/index.js

@@ -0,0 +1 @@
+export {};

package/output-es/Data.Newtype/index.js

@@ -0,0 +1,51 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+const wrap = () => Unsafe$dCoerce.unsafeCoerce;
+const unwrap = () => Unsafe$dCoerce.unsafeCoerce;
+const underF2 = () => () => () => () => v => Unsafe$dCoerce.unsafeCoerce;
+const underF = () => () => () => () => v => Unsafe$dCoerce.unsafeCoerce;
+const under2 = () => () => v => Unsafe$dCoerce.unsafeCoerce;
+const under = () => () => v => Unsafe$dCoerce.unsafeCoerce;
+const un = () => v => Unsafe$dCoerce.unsafeCoerce;
+const traverse = () => () => v => Unsafe$dCoerce.unsafeCoerce;
+const overF2 = () => () => () => () => v => Unsafe$dCoerce.unsafeCoerce;
+const overF = () => () => () => () => v => Unsafe$dCoerce.unsafeCoerce;
+const over2 = () => () => v => Unsafe$dCoerce.unsafeCoerce;
+const over = () => () => v => Unsafe$dCoerce.unsafeCoerce;
+const newtypeMultiplicative = {Coercible0: () => {}};
+const newtypeLast = {Coercible0: () => {}};
+const newtypeFirst = {Coercible0: () => {}};
+const newtypeEndo = {Coercible0: () => {}};
+const newtypeDual = {Coercible0: () => {}};
+const newtypeDisj = {Coercible0: () => {}};
+const newtypeConj = {Coercible0: () => {}};
+const newtypeAdditive = {Coercible0: () => {}};
+const modify = () => fn => t => fn(t);
+const collect = () => () => v => Unsafe$dCoerce.unsafeCoerce;
+const alaF = () => () => () => () => v => Unsafe$dCoerce.unsafeCoerce;
+const ala = () => () => () => v => f => f(Unsafe$dCoerce.unsafeCoerce);
+export {
+  ala,
+  alaF,
+  collect,
+  modify,
+  newtypeAdditive,
+  newtypeConj,
+  newtypeDisj,
+  newtypeDual,
+  newtypeEndo,
+  newtypeFirst,
+  newtypeLast,
+  newtypeMultiplicative,
+  over,
+  over2,
+  overF,
+  overF2,
+  traverse,
+  un,
+  under,
+  under2,
+  underF,
+  underF2,
+  unwrap,
+  wrap
+};

package/output-es/Data.NonEmpty/index.js

@@ -0,0 +1,217 @@
+// | This module defines a generic non-empty data structure, which adds an
+// | additional element to any container type.
+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 $NonEmpty = (_1, _2) => ({tag: "NonEmpty", _1, _2});
+const NonEmpty = value0 => value1 => $NonEmpty(value0, value1);
+const unfoldable1NonEmpty = dictUnfoldable => (
+  {
+    unfoldr1: f => b => {
+      const $0 = f(b);
+      return $NonEmpty(
+        $0._1,
+        dictUnfoldable.unfoldr(v1 => {
+          if (v1.tag === "Just") { return Data$dMaybe.$Maybe("Just", f(v1._1)); }
+          return Data$dMaybe.Nothing;
+        })($0._2)
+      );
+    }
+  }
+);
+const tail = v => v._2;
+const singleton = dictPlus => {
+  const empty = dictPlus.empty;
+  return a => $NonEmpty(a, empty);
+};
+const showNonEmpty = dictShow => dictShow1 => ({show: v => "(NonEmpty " + dictShow.show(v._1) + " " + dictShow1.show(v._2) + ")"});
+const semigroupNonEmpty = dictApplicative => dictSemigroup => (
+  {append: v => v1 => $NonEmpty(v._1, dictSemigroup.append(v._2)(dictSemigroup.append(dictApplicative.pure(v1._1))(v1._2)))}
+);
+const oneOf = dictAlternative => v => dictAlternative.Plus1().Alt0().alt(dictAlternative.Applicative0().pure(v._1))(v._2);
+const head = v => v._1;
+const functorNonEmpty = dictFunctor => ({map: f => m => $NonEmpty(f(m._1), dictFunctor.map(f)(m._2))});
+const functorWithIndex = dictFunctorWithIndex => {
+  const $0 = dictFunctorWithIndex.Functor0();
+  const functorNonEmpty1 = {map: f => m => $NonEmpty(f(m._1), $0.map(f)(m._2))};
+  return {
+    mapWithIndex: f => v => $NonEmpty(f(Data$dMaybe.Nothing)(v._1), dictFunctorWithIndex.mapWithIndex(x => f(Data$dMaybe.$Maybe("Just", x)))(v._2)),
+    Functor0: () => functorNonEmpty1
+  };
+};
+const fromNonEmpty = f => v => f(v._1)(v._2);
+const foldableNonEmpty = dictFoldable => (
+  {
+    foldMap: dictMonoid => {
+      const foldMap1 = dictFoldable.foldMap(dictMonoid);
+      return f => v => dictMonoid.Semigroup0().append(f(v._1))(foldMap1(f)(v._2));
+    },
+    foldl: f => b => v => dictFoldable.foldl(f)(f(b)(v._1))(v._2),
+    foldr: f => b => v => f(v._1)(dictFoldable.foldr(f)(b)(v._2))
+  }
+);
+const foldableWithIndexNonEmpty = dictFoldableWithIndex => {
+  const $0 = dictFoldableWithIndex.Foldable0();
+  const foldableNonEmpty1 = {
+    foldMap: dictMonoid => {
+      const foldMap1 = $0.foldMap(dictMonoid);
+      return f => v => dictMonoid.Semigroup0().append(f(v._1))(foldMap1(f)(v._2));
+    },
+    foldl: f => b => v => $0.foldl(f)(f(b)(v._1))(v._2),
+    foldr: f => b => v => f(v._1)($0.foldr(f)(b)(v._2))
+  };
+  return {
+    foldMapWithIndex: dictMonoid => {
+      const foldMapWithIndex1 = dictFoldableWithIndex.foldMapWithIndex(dictMonoid);
+      return f => v => dictMonoid.Semigroup0().append(f(Data$dMaybe.Nothing)(v._1))(foldMapWithIndex1(x => f(Data$dMaybe.$Maybe("Just", x)))(v._2));
+    },
+    foldlWithIndex: f => b => v => dictFoldableWithIndex.foldlWithIndex(x => f(Data$dMaybe.$Maybe("Just", x)))(f(Data$dMaybe.Nothing)(b)(v._1))(v._2),
+    foldrWithIndex: f => b => v => f(Data$dMaybe.Nothing)(v._1)(dictFoldableWithIndex.foldrWithIndex(x => f(Data$dMaybe.$Maybe("Just", x)))(b)(v._2)),
+    Foldable0: () => foldableNonEmpty1
+  };
+};
+const traversableNonEmpty = dictTraversable => {
+  const $0 = dictTraversable.Functor0();
+  const functorNonEmpty1 = {map: f => m => $NonEmpty(f(m._1), $0.map(f)(m._2))};
+  const $1 = dictTraversable.Foldable1();
+  const foldableNonEmpty1 = {
+    foldMap: dictMonoid => {
+      const foldMap1 = $1.foldMap(dictMonoid);
+      return f => v => dictMonoid.Semigroup0().append(f(v._1))(foldMap1(f)(v._2));
+    },
+    foldl: f => b => v => $1.foldl(f)(f(b)(v._1))(v._2),
+    foldr: f => b => v => f(v._1)($1.foldr(f)(b)(v._2))
+  };
+  return {
+    sequence: dictApplicative => {
+      const Apply0 = dictApplicative.Apply0();
+      const sequence1 = dictTraversable.sequence(dictApplicative);
+      return v => Apply0.apply(Apply0.Functor0().map(NonEmpty)(v._1))(sequence1(v._2));
+    },
+    traverse: dictApplicative => {
+      const Apply0 = dictApplicative.Apply0();
+      const traverse1 = dictTraversable.traverse(dictApplicative);
+      return f => v => Apply0.apply(Apply0.Functor0().map(NonEmpty)(f(v._1)))(traverse1(f)(v._2));
+    },
+    Functor0: () => functorNonEmpty1,
+    Foldable1: () => foldableNonEmpty1
+  };
+};
+const traversableWithIndexNonEmpty = dictTraversableWithIndex => {
+  const $0 = dictTraversableWithIndex.FunctorWithIndex0();
+  const $1 = $0.Functor0();
+  const functorWithIndex1 = (() => {
+    const functorNonEmpty1 = {map: f => m => $NonEmpty(f(m._1), $1.map(f)(m._2))};
+    return {mapWithIndex: f => v => $NonEmpty(f(Data$dMaybe.Nothing)(v._1), $0.mapWithIndex(x => f(Data$dMaybe.$Maybe("Just", x)))(v._2)), Functor0: () => functorNonEmpty1};
+  })();
+  const foldableWithIndexNonEmpty1 = foldableWithIndexNonEmpty(dictTraversableWithIndex.FoldableWithIndex1());
+  const traversableNonEmpty1 = traversableNonEmpty(dictTraversableWithIndex.Traversable2());
+  return {
+    traverseWithIndex: dictApplicative => {
+      const Apply0 = dictApplicative.Apply0();
+      const traverseWithIndex1 = dictTraversableWithIndex.traverseWithIndex(dictApplicative);
+      return f => v => Apply0.apply(Apply0.Functor0().map(NonEmpty)(f(Data$dMaybe.Nothing)(v._1)))(traverseWithIndex1(x => f(Data$dMaybe.$Maybe("Just", x)))(v._2));
+    },
+    FunctorWithIndex0: () => functorWithIndex1,
+    FoldableWithIndex1: () => foldableWithIndexNonEmpty1,
+    Traversable2: () => traversableNonEmpty1
+  };
+};
+const foldable1NonEmpty = dictFoldable => {
+  const foldableNonEmpty1 = {
+    foldMap: dictMonoid => {
+      const foldMap1 = dictFoldable.foldMap(dictMonoid);
+      return f => v => dictMonoid.Semigroup0().append(f(v._1))(foldMap1(f)(v._2));
+    },
+    foldl: f => b => v => dictFoldable.foldl(f)(f(b)(v._1))(v._2),
+    foldr: f => b => v => f(v._1)(dictFoldable.foldr(f)(b)(v._2))
+  };
+  return {
+    foldMap1: dictSemigroup => f => v => dictFoldable.foldl(s => a1 => dictSemigroup.append(s)(f(a1)))(f(v._1))(v._2),
+    foldr1: f => v => {
+      const $0 = f(v._1);
+      const $1 = dictFoldable.foldr(a1 => {
+        const $1 = f(a1);
+        return x => Data$dMaybe.$Maybe(
+          "Just",
+          (() => {
+            if (x.tag === "Nothing") { return a1; }
+            if (x.tag === "Just") { return $1(x._1); }
+            $runtime.fail();
+          })()
+        );
+      })(Data$dMaybe.Nothing)(v._2);
+      if ($1.tag === "Nothing") { return v._1; }
+      if ($1.tag === "Just") { return $0($1._1); }
+      $runtime.fail();
+    },
+    foldl1: f => v => dictFoldable.foldl(f)(v._1)(v._2),
+    Foldable0: () => foldableNonEmpty1
+  };
+};
+const foldl1 = dictFoldable => foldable1NonEmpty(dictFoldable).foldl1;
+const eqNonEmpty = dictEq1 => dictEq => {
+  const eq11 = dictEq1.eq1(dictEq);
+  return {eq: x => y => dictEq.eq(x._1)(y._1) && eq11(x._2)(y._2)};
+};
+const ordNonEmpty = dictOrd1 => {
+  const $0 = dictOrd1.Eq10();
+  return dictOrd => {
+    const compare11 = dictOrd1.compare1(dictOrd);
+    const $1 = dictOrd.Eq0();
+    const eq11 = $0.eq1($1);
+    const eqNonEmpty2 = {eq: x => y => $1.eq(x._1)(y._1) && eq11(x._2)(y._2)};
+    return {
+      compare: x => y => {
+        const v = dictOrd.compare(x._1)(y._1);
+        if (v === "LT") { return Data$dOrdering.LT; }
+        if (v === "GT") { return Data$dOrdering.GT; }
+        return compare11(x._2)(y._2);
+      },
+      Eq0: () => eqNonEmpty2
+    };
+  };
+};
+const eq1NonEmpty = dictEq1 => (
+  {
+    eq1: dictEq => {
+      const eq11 = dictEq1.eq1(dictEq);
+      return x => y => dictEq.eq(x._1)(y._1) && eq11(x._2)(y._2);
+    }
+  }
+);
+const ord1NonEmpty = dictOrd1 => {
+  const ordNonEmpty1 = ordNonEmpty(dictOrd1);
+  const $0 = dictOrd1.Eq10();
+  const eq1NonEmpty1 = {
+    eq1: dictEq => {
+      const eq11 = $0.eq1(dictEq);
+      return x => y => dictEq.eq(x._1)(y._1) && eq11(x._2)(y._2);
+    }
+  };
+  return {compare1: dictOrd => ordNonEmpty1(dictOrd).compare, Eq10: () => eq1NonEmpty1};
+};
+export {
+  $NonEmpty,
+  NonEmpty,
+  eq1NonEmpty,
+  eqNonEmpty,
+  foldable1NonEmpty,
+  foldableNonEmpty,
+  foldableWithIndexNonEmpty,
+  foldl1,
+  fromNonEmpty,
+  functorNonEmpty,
+  functorWithIndex,
+  head,
+  oneOf,
+  ord1NonEmpty,
+  ordNonEmpty,
+  semigroupNonEmpty,
+  showNonEmpty,
+  singleton,
+  tail,
+  traversableNonEmpty,
+  traversableWithIndexNonEmpty,
+  unfoldable1NonEmpty
+};

package/output-es/Data.Nullable/foreign.js

@@ -0,0 +1,12 @@
+/* eslint-disable no-eq-null, eqeqeq */
+
+const nullImpl = null;
+export { nullImpl as null };
+
+export function nullable(a, r, f) {
+  return a == null ? r : f(a);
+}
+
+export function notNull(x) {
+  return x;
+}

package/output-es/Data.Nullable/index.js

@@ -0,0 +1,53 @@
+// | This module defines types and functions for working with nullable types
+// | using the FFI.
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+import {null as $$null, notNull, nullable} from "./foreign.js";
+const toNullable = v2 => {
+  if (v2.tag === "Nothing") { return $$null; }
+  if (v2.tag === "Just") { return notNull(v2._1); }
+  $runtime.fail();
+};
+const toMaybe = n => nullable(n, Data$dMaybe.Nothing, Data$dMaybe.Just);
+const showNullable = dictShow => (
+  {
+    show: x => {
+      const $0 = nullable(x, Data$dMaybe.Nothing, Data$dMaybe.Just);
+      if ($0.tag === "Nothing") { return "null"; }
+      if ($0.tag === "Just") { return dictShow.show($0._1); }
+      $runtime.fail();
+    }
+  }
+);
+const eqNullable = dictEq => (
+  {
+    eq: x => y => {
+      const $0 = nullable(x, Data$dMaybe.Nothing, Data$dMaybe.Just);
+      const $1 = nullable(y, Data$dMaybe.Nothing, Data$dMaybe.Just);
+      if ($0.tag === "Nothing") { return $1.tag === "Nothing"; }
+      return $0.tag === "Just" && $1.tag === "Just" && dictEq.eq($0._1)($1._1);
+    }
+  }
+);
+const ordNullable = dictOrd => {
+  const eqNullable1 = eqNullable(dictOrd.Eq0());
+  return {
+    compare: x => y => {
+      const $0 = nullable(x, Data$dMaybe.Nothing, Data$dMaybe.Just);
+      const $1 = nullable(y, Data$dMaybe.Nothing, Data$dMaybe.Just);
+      if ($0.tag === "Nothing") {
+        if ($1.tag === "Nothing") { return Data$dOrdering.EQ; }
+        return Data$dOrdering.LT;
+      }
+      if ($1.tag === "Nothing") { return Data$dOrdering.GT; }
+      if ($0.tag === "Just" && $1.tag === "Just") { return dictOrd.compare($0._1)($1._1); }
+      $runtime.fail();
+    },
+    Eq0: () => eqNullable1
+  };
+};
+const eq1Nullable = {eq1: dictEq => eqNullable(dictEq).eq};
+const ord1Nullable = {compare1: dictOrd => ordNullable(dictOrd).compare, Eq10: () => eq1Nullable};
+export {eq1Nullable, eqNullable, ord1Nullable, ordNullable, showNullable, toMaybe, toNullable};
+export * from "./foreign.js";

package/output-es/Data.Number/foreign.js

@@ -0,0 +1,80 @@
+/* globals exports */
+export const nan = NaN;
+const isNaNImpl = isNaN;
+export { isNaNImpl as isNaN };
+export const infinity = Infinity;
+const isFiniteImpl = isFinite;
+export { isFiniteImpl as isFinite };
+
+export function fromStringImpl(str, isFinite, just, nothing) {
+  var num = parseFloat(str);
+  if (isFinite(num)) {
+    return just(num);
+  } else {
+    return nothing;
+  }
+}
+
+export const abs = Math.abs;
+
+export const acos = Math.acos;
+
+export const asin = Math.asin;
+
+export const atan = Math.atan;
+
+export const atan2 = function (y) {
+  return function (x) {
+    return Math.atan2(y, x);
+  };
+};
+
+export const ceil = Math.ceil;
+
+export const cos = Math.cos;
+
+export const exp = Math.exp;
+
+export const floor = Math.floor;
+
+export const log = Math.log;
+
+export const max = function (n1) {
+  return function (n2) {
+    return Math.max(n1, n2);
+  };
+};
+
+export const min = function (n1) {
+  return function (n2) {
+    return Math.min(n1, n2);
+  };
+};
+
+export const pow = function (n) {
+  return function (p) {
+    return Math.pow(n, p);
+  };
+};
+
+export const remainder = function (n) {
+  return function (m) {
+    return n % m;
+  };
+};
+
+export const round = Math.round;
+
+export const sign = Math.sign ? Math.sign : function(x) {
+  return x === 0 || x !== x ? x : (x < 0 ? -1 : 1);
+};
+
+export const sin = Math.sin;
+
+export const sqrt = Math.sqrt;
+
+export const tan = Math.tan;
+
+export const trunc = Math.trunc ? Math.trunc : function(x) {
+  return x < 0 ? Math.ceil(x) : Math.floor(x);
+}

package/output-es/Data.Number/index.js

@@ -0,0 +1,15 @@
+// | Functions for working with PureScripts builtin `Number` type.
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import {abs, acos, asin, atan, atan2, ceil, cos, exp, floor, fromStringImpl, infinity, isFinite, isNaN, log, max, min, nan, pow, remainder, round, sign, sin, sqrt, tan, trunc} from "./foreign.js";
+const tau = 6.283185307179586;
+const sqrt2 = 1.4142135623730951;
+const sqrt1_2 = 0.7071067811865476;
+const pi = 3.141592653589793;
+const log2e = 1.4426950408889634;
+const log10e = 0.4342944819032518;
+const ln2 = 0.6931471805599453;
+const ln10 = 2.302585092994046;
+const fromString = str => fromStringImpl(str, isFinite, Data$dMaybe.Just, Data$dMaybe.Nothing);
+const e = 2.718281828459045;
+export {e, fromString, ln10, ln2, log10e, log2e, pi, sqrt1_2, sqrt2, tau};
+export * from "./foreign.js";

package/output-es/Data.Number.Approximate/index.js

@@ -0,0 +1,13 @@
+// | This module defines functions for comparing numbers.
+import * as Data$dNumber from "../Data.Number/index.js";
+const Tolerance = x => x;
+const Fraction = x => x;
+const eqRelative = v => v1 => v2 => {
+  if (v1 === 0.0) { return Data$dNumber.abs(v2) <= v; }
+  if (v2 === 0.0) { return Data$dNumber.abs(v1) <= v; }
+  return Data$dNumber.abs(v1 - v2) <= v * Data$dNumber.abs(v1 + v2) / 2.0;
+};
+const eqApproximate = /* #__PURE__ */ eqRelative(0.000001);
+const neqApproximate = x => y => !eqRelative(0.000001)(x)(y);
+const eqAbsolute = v => x => y => Data$dNumber.abs(x - y) <= v;
+export {Fraction, Tolerance, eqAbsolute, eqApproximate, eqRelative, neqApproximate};

package/output-es/Data.Number.Format/foreign.js

@@ -0,0 +1,12 @@
+function wrap(method) {
+  return function(d) {
+    return function(num) {
+      return method.apply(num, [d]);
+    };
+  };
+}
+
+export const toPrecisionNative = wrap(Number.prototype.toPrecision);
+export const toFixedNative = wrap(Number.prototype.toFixed);
+export const toExponentialNative = wrap(Number.prototype.toExponential);
+export function toString(num) { return num.toString(); }

package/output-es/Data.Number.Format/index.js

@@ -0,0 +1,53 @@
+// | A module for formatting numbers as strings.
+// |
+// | Usage:
+// | ``` purs
+// | > let x = 1234.56789
+// |
+// | > toStringWith (precision 6) x
+// | "1234.57"
+// |
+// | > toStringWith (fixed 3) x
+// | "1234.568"
+// |
+// | > toStringWith (exponential 2) x
+// | "1.23e+3"
+// | ```
+// |
+// | The main method of this module is the `toStringWith` function that accepts
+// | a `Format` argument which can be constructed through one of the smart
+// | constructors `precision`, `fixed` and `exponential`. Internally, the
+// | number will be formatted with JavaScripts `toPrecision`, `toFixed` or
+// | `toExponential`.
+import * as $runtime from "../runtime.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import {toExponentialNative, toFixedNative, toPrecisionNative, toString} from "./foreign.js";
+const $Format = (tag, _1) => ({tag, _1});
+const clamp = low => hi => x => {
+  const v = Data$dOrd.ordInt.compare(low)(x);
+  const $0 = (() => {
+    if (v === "LT") { return x; }
+    if (v === "EQ") { return low; }
+    if (v === "GT") { return low; }
+    $runtime.fail();
+  })();
+  const v$1 = Data$dOrd.ordInt.compare(hi)($0);
+  if (v$1 === "LT") { return hi; }
+  if (v$1 === "EQ") { return hi; }
+  if (v$1 === "GT") { return $0; }
+  $runtime.fail();
+};
+const Precision = value0 => $Format("Precision", value0);
+const Fixed = value0 => $Format("Fixed", value0);
+const Exponential = value0 => $Format("Exponential", value0);
+const toStringWith = v => {
+  if (v.tag === "Precision") { return toPrecisionNative(v._1); }
+  if (v.tag === "Fixed") { return toFixedNative(v._1); }
+  if (v.tag === "Exponential") { return toExponentialNative(v._1); }
+  $runtime.fail();
+};
+const precision = x => $Format("Precision", clamp(1)(21)(x));
+const fixed = x => $Format("Fixed", clamp(0)(20)(x));
+const exponential = x => $Format("Exponential", clamp(0)(20)(x));
+export {$Format, Exponential, Fixed, Precision, clamp, exponential, fixed, precision, toStringWith};
+export * from "./foreign.js";

package/output-es/Data.Op/index.js

@@ -0,0 +1,13 @@
+const Op = x => x;
+const semigroupoidOp = {compose: v => v1 => x => v1(v(x))};
+const semigroupOp = dictSemigroup => ({append: f => g => x => dictSemigroup.append(f(x))(g(x))});
+const newtypeOp = {Coercible0: () => {}};
+const monoidOp = dictMonoid => {
+  const mempty1 = dictMonoid.mempty;
+  const $0 = dictMonoid.Semigroup0();
+  const semigroupFn = {append: f => g => x => $0.append(f(x))(g(x))};
+  return {mempty: v => mempty1, Semigroup0: () => semigroupFn};
+};
+const contravariantOp = {cmap: f => v => x => v(f(x))};
+const categoryOp = {identity: x => x, Semigroupoid0: () => semigroupoidOp};
+export {Op, categoryOp, contravariantOp, monoidOp, newtypeOp, semigroupOp, semigroupoidOp};

package/output-es/Data.Ord/foreign.js

@@ -0,0 +1,43 @@
+var unsafeCompareImpl = function (lt) {
+  return function (eq) {
+    return function (gt) {
+      return function (x) {
+        return function (y) {
+          return x < y ? lt : x === y ? eq : gt;
+        };
+      };
+    };
+  };
+};
+
+export const ordBooleanImpl = unsafeCompareImpl;
+export const ordIntImpl = unsafeCompareImpl;
+export const ordNumberImpl = unsafeCompareImpl;
+export const ordStringImpl = unsafeCompareImpl;
+export const ordCharImpl = unsafeCompareImpl;
+
+export const ordArrayImpl = function (f) {
+  return function (xs) {
+    return function (ys) {
+      var i = 0;
+      var xlen = xs.length;
+      var ylen = ys.length;
+      while (i < xlen && i < ylen) {
+        var x = xs[i];
+        var y = ys[i];
+        var o = f(x)(y);
+        if (o !== 0) {
+          return o;
+        }
+        i++;
+      }
+      if (xlen === ylen) {
+        return 0;
+      } else if (xlen > ylen) {
+        return -1;
+      } else {
+        return 1;
+      }
+    };
+  };
+};