@explorable-viz/fluid 0.12.3 → 0.12.4

package/output-es/Data.Profunctor.Star/index.js

@@ -0,0 +1,250 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const Star = x => x;
+const semigroupoidStar = dictBind => ({compose: v => v1 => x => dictBind.bind(v1(x))(v)});
+const profunctorStar = dictFunctor => (
+  {
+    dimap: f => g => v => {
+      const $0 = dictFunctor.map(g);
+      return x => $0(v(f(x)));
+    }
+  }
+);
+const strongStar = dictFunctor => {
+  const profunctorStar1 = {
+    dimap: f => g => v => {
+      const $0 = dictFunctor.map(g);
+      return x => $0(v(f(x)));
+    }
+  };
+  return {
+    first: v => v1 => {
+      const $0 = v1._2;
+      return dictFunctor.map(v2 => Data$dTuple.$Tuple(v2, $0))(v(v1._1));
+    },
+    second: v => v1 => dictFunctor.map(Data$dTuple.Tuple(v1._1))(v(v1._2)),
+    Profunctor0: () => profunctorStar1
+  };
+};
+const newtypeStar = {Coercible0: () => {}};
+const invariantStar = dictInvariant => (
+  {
+    imap: f => g => v => {
+      const $0 = dictInvariant.imap(f)(g);
+      return x => $0(v(x));
+    }
+  }
+);
+const hoistStar = f => v => x => f(v(x));
+const functorStar = dictFunctor => (
+  {
+    map: f => v => {
+      const $0 = dictFunctor.map(f);
+      return x => $0(v(x));
+    }
+  }
+);
+const distributiveStar = dictDistributive => {
+  const $0 = dictDistributive.Functor0();
+  const functorStar1 = {
+    map: f => v => {
+      const $1 = $0.map(f);
+      return x => $1(v(x));
+    }
+  };
+  return {
+    distribute: dictFunctor => {
+      const collect1 = dictDistributive.collect(dictFunctor);
+      return f => a => collect1(v => v(a))(f);
+    },
+    collect: dictFunctor => f => {
+      const $1 = distributiveStar(dictDistributive).distribute(dictFunctor);
+      const $2 = dictFunctor.map(f);
+      return x => $1($2(x));
+    },
+    Functor0: () => functorStar1
+  };
+};
+const closedStar = dictDistributive => {
+  const distribute = dictDistributive.distribute(Data$dFunctor.functorFn);
+  const $0 = dictDistributive.Functor0();
+  const profunctorStar1 = {
+    dimap: f => g => v => {
+      const $1 = $0.map(g);
+      return x => $1(v(f(x)));
+    }
+  };
+  return {closed: v => g => distribute(x => v(g(x))), Profunctor0: () => profunctorStar1};
+};
+const choiceStar = dictApplicative => {
+  const Functor0 = dictApplicative.Apply0().Functor0();
+  const profunctorStar1 = {
+    dimap: f => g => v => {
+      const $0 = Functor0.map(g);
+      return x => $0(v(f(x)));
+    }
+  };
+  return {
+    left: v => {
+      const $0 = Functor0.map(Data$dEither.Left);
+      return v2 => {
+        if (v2.tag === "Left") { return $0(v(v2._1)); }
+        if (v2.tag === "Right") { return dictApplicative.pure(Data$dEither.$Either("Right", v2._1)); }
+        $runtime.fail();
+      };
+    },
+    right: v => {
+      const $0 = Functor0.map(Data$dEither.Right);
+      return v2 => {
+        if (v2.tag === "Left") { return dictApplicative.pure(Data$dEither.$Either("Left", v2._1)); }
+        if (v2.tag === "Right") { return $0(v(v2._1)); }
+        $runtime.fail();
+      };
+    },
+    Profunctor0: () => profunctorStar1
+  };
+};
+const categoryStar = dictMonad => {
+  const $0 = dictMonad.Bind1();
+  const semigroupoidStar1 = {compose: v => v1 => x => $0.bind(v1(x))(v)};
+  return {identity: dictMonad.Applicative0().pure, Semigroupoid0: () => semigroupoidStar1};
+};
+const applyStar = dictApply => {
+  const $0 = dictApply.Functor0();
+  const functorStar1 = {
+    map: f => v => {
+      const $1 = $0.map(f);
+      return x => $1(v(x));
+    }
+  };
+  return {apply: v => v1 => a => dictApply.apply(v(a))(v1(a)), Functor0: () => functorStar1};
+};
+const bindStar = dictBind => {
+  const $0 = dictBind.Apply0();
+  const $1 = $0.Functor0();
+  const applyStar1 = (() => {
+    const functorStar1 = {
+      map: f => v => {
+        const $2 = $1.map(f);
+        return x => $2(v(x));
+      }
+    };
+    return {apply: v => v1 => a => $0.apply(v(a))(v1(a)), Functor0: () => functorStar1};
+  })();
+  return {bind: v => f => x => dictBind.bind(v(x))(a => f(a)(x)), Apply0: () => applyStar1};
+};
+const applicativeStar = dictApplicative => {
+  const $0 = dictApplicative.Apply0();
+  const $1 = $0.Functor0();
+  const applyStar1 = (() => {
+    const functorStar1 = {
+      map: f => v => {
+        const $2 = $1.map(f);
+        return x => $2(v(x));
+      }
+    };
+    return {apply: v => v1 => a => $0.apply(v(a))(v1(a)), Functor0: () => functorStar1};
+  })();
+  return {pure: a => v => dictApplicative.pure(a), Apply0: () => applyStar1};
+};
+const monadStar = dictMonad => {
+  const $0 = dictMonad.Applicative0();
+  const $1 = $0.Apply0();
+  const applicativeStar1 = (() => {
+    const $2 = $1.Functor0();
+    const functorStar1 = {
+      map: f => v => {
+        const $3 = $2.map(f);
+        return x => $3(v(x));
+      }
+    };
+    const applyStar1 = {apply: v => v1 => a => $1.apply(v(a))(v1(a)), Functor0: () => functorStar1};
+    return {pure: a => v => $0.pure(a), Apply0: () => applyStar1};
+  })();
+  const bindStar1 = bindStar(dictMonad.Bind1());
+  return {Applicative0: () => applicativeStar1, Bind1: () => bindStar1};
+};
+const altStar = dictAlt => {
+  const $0 = dictAlt.Functor0();
+  const functorStar1 = {
+    map: f => v => {
+      const $1 = $0.map(f);
+      return x => $1(v(x));
+    }
+  };
+  return {alt: v => v1 => a => dictAlt.alt(v(a))(v1(a)), Functor0: () => functorStar1};
+};
+const plusStar = dictPlus => {
+  const empty = dictPlus.empty;
+  const $0 = dictPlus.Alt0();
+  const $1 = $0.Functor0();
+  const altStar1 = (() => {
+    const functorStar1 = {
+      map: f => v => {
+        const $2 = $1.map(f);
+        return x => $2(v(x));
+      }
+    };
+    return {alt: v => v1 => a => $0.alt(v(a))(v1(a)), Functor0: () => functorStar1};
+  })();
+  return {empty: v => empty, Alt0: () => altStar1};
+};
+const alternativeStar = dictAlternative => {
+  const $0 = dictAlternative.Applicative0();
+  const $1 = $0.Apply0();
+  const applicativeStar1 = (() => {
+    const $2 = $1.Functor0();
+    const functorStar1 = {
+      map: f => v => {
+        const $3 = $2.map(f);
+        return x => $3(v(x));
+      }
+    };
+    const applyStar1 = {apply: v => v1 => a => $1.apply(v(a))(v1(a)), Functor0: () => functorStar1};
+    return {pure: a => v => $0.pure(a), Apply0: () => applyStar1};
+  })();
+  const $2 = dictAlternative.Plus1();
+  const empty = $2.empty;
+  const plusStar1 = (() => {
+    const $3 = $2.Alt0();
+    const $4 = $3.Functor0();
+    const functorStar1 = {
+      map: f => v => {
+        const $5 = $4.map(f);
+        return x => $5(v(x));
+      }
+    };
+    const altStar1 = {alt: v => v1 => a => $3.alt(v(a))(v1(a)), Functor0: () => functorStar1};
+    return {empty: v => empty, Alt0: () => altStar1};
+  })();
+  return {Applicative0: () => applicativeStar1, Plus1: () => plusStar1};
+};
+const monadPlusStar = dictMonadPlus => {
+  const monadStar1 = monadStar(dictMonadPlus.Monad0());
+  const alternativeStar1 = alternativeStar(dictMonadPlus.Alternative1());
+  return {Monad0: () => monadStar1, Alternative1: () => alternativeStar1};
+};
+export {
+  Star,
+  altStar,
+  alternativeStar,
+  applicativeStar,
+  applyStar,
+  bindStar,
+  categoryStar,
+  choiceStar,
+  closedStar,
+  distributiveStar,
+  functorStar,
+  hoistStar,
+  invariantStar,
+  monadPlusStar,
+  monadStar,
+  newtypeStar,
+  plusStar,
+  profunctorStar,
+  semigroupoidStar,
+  strongStar
+};

package/output-es/Data.Profunctor.Strong/index.js

@@ -0,0 +1,19 @@
+import * as Data$dProfunctor from "../Data.Profunctor/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const identity = x => x;
+const strongFn = /* #__PURE__ */ (() => (
+  {first: a2b => v => Data$dTuple.$Tuple(a2b(v._1), v._2), second: Data$dTuple.functorTuple.map, Profunctor0: () => Data$dProfunctor.profunctorFn}
+))();
+const second = dict => dict.second;
+const first = dict => dict.first;
+const splitStrong = dictCategory => {
+  const $0 = dictCategory.Semigroupoid0();
+  return dictStrong => l => r => $0.compose(dictStrong.second(r))(dictStrong.first(l));
+};
+const fanout = dictCategory => {
+  const identity1 = dictCategory.identity;
+  const $0 = dictCategory.Semigroupoid0();
+  const $1 = dictCategory.Semigroupoid0();
+  return dictStrong => l => r => $0.compose($1.compose(dictStrong.second(r))(dictStrong.first(l)))(dictStrong.Profunctor0().dimap(identity)(a => Data$dTuple.$Tuple(a, a))(identity1));
+};
+export {fanout, first, identity, second, splitStrong, strongFn};

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

@@ -0,0 +1,5 @@
+// module Data.Reflectable
+
+export const unsafeCoerce = function (arg) {
+  return arg;
+};

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

@@ -0,0 +1,10 @@
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {unsafeCoerce} from "./foreign.js";
+const reifiableString = {};
+const reifiableOrdering = {};
+const reifiableInt = {};
+const reifiableBoolean = {};
+const reifyType = () => s => f => unsafeCoerce(dictReflectable => f(dictReflectable))({reflectType: v => s})(Type$dProxy.Proxy);
+const reflectType = dict => dict.reflectType;
+export {reflectType, reifiableBoolean, reifiableInt, reifiableOrdering, reifiableString, reifyType};
+export * from "./foreign.js";

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

@@ -0,0 +1,12 @@
+export const intSub = function (x) {
+  return function (y) {
+    /* jshint bitwise: false */
+    return x - y | 0;
+  };
+};
+
+export const numSub = function (n1) {
+  return function (n2) {
+    return n1 - n2;
+  };
+};

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

@@ -0,0 +1,50 @@
+import * as Data$dSemiring from "../Data.Semiring/index.js";
+import * as Record$dUnsafe from "../Record.Unsafe/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {intSub, numSub} from "./foreign.js";
+const subRecord = dict => dict.subRecord;
+const sub = dict => dict.sub;
+const ringUnit = {sub: v => v1 => {}, Semiring0: () => Data$dSemiring.semiringUnit};
+const ringRecordNil = {subRecord: v => v1 => v2 => ({}), SemiringRecord0: () => Data$dSemiring.semiringRecordNil};
+const ringRecordCons = dictIsSymbol => () => dictRingRecord => {
+  const semiringRecordCons1 = Data$dSemiring.semiringRecordCons(dictIsSymbol)()(dictRingRecord.SemiringRecord0());
+  return dictRing => {
+    const semiringRecordCons2 = semiringRecordCons1(dictRing.Semiring0());
+    return {
+      subRecord: v => ra => rb => {
+        const key = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+        const $$get = Record$dUnsafe.unsafeGet(key);
+        return Record$dUnsafe.unsafeSet(key)(dictRing.sub($$get(ra))($$get(rb)))(dictRingRecord.subRecord(Type$dProxy.Proxy)(ra)(rb));
+      },
+      SemiringRecord0: () => semiringRecordCons2
+    };
+  };
+};
+const ringRecord = () => dictRingRecord => {
+  const $0 = dictRingRecord.SemiringRecord0();
+  const semiringRecord1 = {
+    add: $0.addRecord(Type$dProxy.Proxy),
+    mul: $0.mulRecord(Type$dProxy.Proxy),
+    one: $0.oneRecord(Type$dProxy.Proxy)(Type$dProxy.Proxy),
+    zero: $0.zeroRecord(Type$dProxy.Proxy)(Type$dProxy.Proxy)
+  };
+  return {sub: dictRingRecord.subRecord(Type$dProxy.Proxy), Semiring0: () => semiringRecord1};
+};
+const ringProxy = {sub: v => v1 => Type$dProxy.Proxy, Semiring0: () => Data$dSemiring.semiringProxy};
+const ringNumber = {sub: numSub, Semiring0: () => Data$dSemiring.semiringNumber};
+const ringInt = {sub: intSub, Semiring0: () => Data$dSemiring.semiringInt};
+const ringFn = dictRing => {
+  const $0 = dictRing.Semiring0();
+  const zero1 = $0.zero;
+  const semiringFn = (() => {
+    const one1 = $0.one;
+    return {add: f => g => x => $0.add(f(x))(g(x)), zero: v => zero1, mul: f => g => x => $0.mul(f(x))(g(x)), one: v => one1};
+  })();
+  return {sub: f => g => x => dictRing.sub(f(x))(g(x)), Semiring0: () => semiringFn};
+};
+const negate = dictRing => {
+  const zero = dictRing.Semiring0().zero;
+  return a => dictRing.sub(zero)(a);
+};
+export {negate, ringFn, ringInt, ringNumber, ringProxy, ringRecord, ringRecordCons, ringRecordNil, ringUnit, sub, subRecord};
+export * from "./foreign.js";

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

@@ -0,0 +1,10 @@
+import * as Data$dGeneric$dRep from "../Data.Generic.Rep/index.js";
+const genericSub$p = dict => dict["genericSub'"];
+const genericSub = dictGeneric => dictGenericRing => x => y => dictGeneric.to(dictGenericRing["genericSub'"](dictGeneric.from(x))(dictGeneric.from(y)));
+const genericRingProduct = dictGenericRing => dictGenericRing1 => (
+  {"genericSub'": v => v1 => Data$dGeneric$dRep.$Product(dictGenericRing["genericSub'"](v._1)(v1._1), dictGenericRing1["genericSub'"](v._2)(v1._2))}
+);
+const genericRingNoArguments = {"genericSub'": v => v1 => Data$dGeneric$dRep.NoArguments};
+const genericRingConstructor = dictGenericRing => ({"genericSub'": v => v1 => dictGenericRing["genericSub'"](v)(v1)});
+const genericRingArgument = dictRing => ({"genericSub'": v => v1 => dictRing.sub(v)(v1)});
+export {genericRingArgument, genericRingConstructor, genericRingNoArguments, genericRingProduct, genericSub, genericSub$p};

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

@@ -0,0 +1,13 @@
+export const concatString = function (s1) {
+  return function (s2) {
+    return s1 + s2;
+  };
+};
+
+export const concatArray = function (xs) {
+  return function (ys) {
+    if (xs.length === 0) return ys;
+    if (ys.length === 0) return xs;
+    return xs.concat(ys);
+  };
+};

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

@@ -0,0 +1,25 @@
+import * as Data$dVoid from "../Data.Void/index.js";
+import * as Record$dUnsafe from "../Record.Unsafe/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {concatArray, concatString} from "./foreign.js";
+const semigroupVoid = {append: v => Data$dVoid.absurd};
+const semigroupUnit = {append: v => v1 => {}};
+const semigroupString = {append: concatString};
+const semigroupRecordNil = {appendRecord: v => v1 => v2 => ({})};
+const semigroupProxy = {append: v => v1 => Type$dProxy.Proxy};
+const semigroupArray = {append: concatArray};
+const appendRecord = dict => dict.appendRecord;
+const semigroupRecord = () => dictSemigroupRecord => ({append: dictSemigroupRecord.appendRecord(Type$dProxy.Proxy)});
+const append = dict => dict.append;
+const semigroupFn = dictSemigroup => ({append: f => g => x => dictSemigroup.append(f(x))(g(x))});
+const semigroupRecordCons = dictIsSymbol => () => dictSemigroupRecord => dictSemigroup => (
+  {
+    appendRecord: v => ra => rb => {
+      const key = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+      const $$get = Record$dUnsafe.unsafeGet(key);
+      return Record$dUnsafe.unsafeSet(key)(dictSemigroup.append($$get(ra))($$get(rb)))(dictSemigroupRecord.appendRecord(Type$dProxy.Proxy)(ra)(rb));
+    }
+  }
+);
+export {append, appendRecord, semigroupArray, semigroupFn, semigroupProxy, semigroupRecord, semigroupRecordCons, semigroupRecordNil, semigroupString, semigroupUnit, semigroupVoid};
+export * from "./foreign.js";

package/output-es/Data.Semigroup.First/index.js

@@ -0,0 +1,14 @@
+const First = x => x;
+const showFirst = dictShow => ({show: v => "(First " + dictShow.show(v) + ")"});
+const semigroupFirst = {append: x => v => x};
+const ordFirst = dictOrd => dictOrd;
+const functorFirst = {map: f => m => f(m)};
+const eqFirst = dictEq => dictEq;
+const eq1First = {eq1: dictEq => dictEq.eq};
+const ord1First = {compare1: dictOrd => dictOrd.compare, Eq10: () => eq1First};
+const boundedFirst = dictBounded => dictBounded;
+const applyFirst = {apply: v => v1 => v(v1), Functor0: () => functorFirst};
+const bindFirst = {bind: v => f => f(v), Apply0: () => applyFirst};
+const applicativeFirst = {pure: First, Apply0: () => applyFirst};
+const monadFirst = {Applicative0: () => applicativeFirst, Bind1: () => bindFirst};
+export {First, applicativeFirst, applyFirst, bindFirst, boundedFirst, eq1First, eqFirst, functorFirst, monadFirst, ord1First, ordFirst, semigroupFirst, showFirst};

package/output-es/Data.Semigroup.Foldable/index.js

@@ -0,0 +1,143 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dApply from "../Control.Apply/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dFunction from "../Data.Function/index.js";
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+const $FoldRight1 = (_1, _2) => ({tag: "FoldRight1", _1, _2});
+const identity = x => x;
+const FoldRight1 = value0 => value1 => $FoldRight1(value0, value1);
+const semigroupAct = dictApply => ({append: v => v1 => dictApply.apply(dictApply.Functor0().map(v$1 => Control$dApply.identity)(v))(v1)});
+const mkFoldRight1 = /* #__PURE__ */ FoldRight1(Data$dFunction.const);
+const foldr1 = dict => dict.foldr1;
+const foldl1 = dict => dict.foldl1;
+const maximumBy = dictFoldable1 => cmp => dictFoldable1.foldl1(x => y => {
+  if (cmp(x)(y) === "GT") { return x; }
+  return y;
+});
+const minimumBy = dictFoldable1 => cmp => dictFoldable1.foldl1(x => y => {
+  if (cmp(x)(y) === "LT") { return x; }
+  return y;
+});
+const foldableTuple = {foldMap1: dictSemigroup => f => v => f(v._2), foldr1: v => v1 => v1._2, foldl1: v => v1 => v1._2, Foldable0: () => Data$dFoldable.foldableTuple};
+const foldableMultiplicative = {foldr1: v => v1 => v1, foldl1: v => v1 => v1, foldMap1: dictSemigroup => f => v => f(v), Foldable0: () => Data$dFoldable.foldableMultiplicative};
+const foldableIdentity = {foldMap1: dictSemigroup => f => v => f(v), foldl1: v => v1 => v1, foldr1: v => v1 => v1, Foldable0: () => Data$dFoldable.foldableIdentity};
+const foldableDual = {foldr1: v => v1 => v1, foldl1: v => v1 => v1, foldMap1: dictSemigroup => f => v => f(v), Foldable0: () => Data$dFoldable.foldableDual};
+const foldRight1Semigroup = {
+  append: v => v1 => {
+    const $0 = v._2;
+    return $FoldRight1(a => f => v._1(f($0)(v1._1(a)(f)))(f), v1._2);
+  }
+};
+const semigroupDual = {
+  append: v => v1 => {
+    const $0 = v1._2;
+    return $FoldRight1(a => f => v1._1(f($0)(v._1(a)(f)))(f), v._2);
+  }
+};
+const foldMap1DefaultR = dictFoldable1 => dictFunctor => dictSemigroup => {
+  const append = dictSemigroup.append;
+  return f => {
+    const $0 = dictFunctor.map(f);
+    const $1 = dictFoldable1.foldr1(append);
+    return x => $1($0(x));
+  };
+};
+const foldMap1DefaultL = dictFoldable1 => dictFunctor => dictSemigroup => {
+  const append = dictSemigroup.append;
+  return f => {
+    const $0 = dictFunctor.map(f);
+    const $1 = dictFoldable1.foldl1(append);
+    return x => $1($0(x));
+  };
+};
+const foldMap1 = dict => dict.foldMap1;
+const foldl1Default = dictFoldable1 => {
+  const $0 = dictFoldable1.foldMap1(semigroupDual)(mkFoldRight1);
+  return x => a => {
+    const $1 = $0(a);
+    return $1._1($1._2)(b => a$1 => x(a$1)(b));
+  };
+};
+const foldr1Default = dictFoldable1 => {
+  const $0 = dictFoldable1.foldMap1(foldRight1Semigroup)(mkFoldRight1);
+  return b => a => {
+    const $1 = $0(a);
+    return $1._1($1._2)(b);
+  };
+};
+const intercalateMap = dictFoldable1 => dictSemigroup => {
+  const foldMap12 = dictFoldable1.foldMap1({append: v => v1 => j => dictSemigroup.append(v(j))(dictSemigroup.append(j)(v1(j)))});
+  return j => f => foldable => foldMap12(x => {
+    const $0 = f(x);
+    return v => $0;
+  })(foldable)(j);
+};
+const intercalate = dictFoldable1 => dictSemigroup => {
+  const foldMap12 = dictFoldable1.foldMap1({append: v => v1 => j => dictSemigroup.append(v(j))(dictSemigroup.append(j)(v1(j)))});
+  return a => foldable => foldMap12(x => v => x)(foldable)(a);
+};
+const maximum = dictOrd => {
+  const semigroupMax = {
+    append: v => v1 => {
+      const v$1 = dictOrd.compare(v)(v1);
+      if (v$1 === "LT") { return v1; }
+      if (v$1 === "EQ") { return v; }
+      if (v$1 === "GT") { return v; }
+      $runtime.fail();
+    }
+  };
+  return dictFoldable1 => dictFoldable1.foldMap1(semigroupMax)(Unsafe$dCoerce.unsafeCoerce);
+};
+const minimum = dictOrd => {
+  const semigroupMin = {
+    append: v => v1 => {
+      const v$1 = dictOrd.compare(v)(v1);
+      if (v$1 === "LT") { return v; }
+      if (v$1 === "EQ") { return v; }
+      if (v$1 === "GT") { return v1; }
+      $runtime.fail();
+    }
+  };
+  return dictFoldable1 => dictFoldable1.foldMap1(semigroupMin)(Unsafe$dCoerce.unsafeCoerce);
+};
+const traverse1_ = dictFoldable1 => dictApply => {
+  const $0 = dictApply.Functor0();
+  const foldMap12 = dictFoldable1.foldMap1(semigroupAct(dictApply));
+  return f => t => $0.map(v => {})(foldMap12(x => f(x))(t));
+};
+const for1_ = dictFoldable1 => dictApply => {
+  const $0 = traverse1_(dictFoldable1)(dictApply);
+  return b => a => $0(a)(b);
+};
+const sequence1_ = dictFoldable1 => dictApply => traverse1_(dictFoldable1)(dictApply)(identity);
+const fold1 = dictFoldable1 => dictSemigroup => dictFoldable1.foldMap1(dictSemigroup)(identity);
+export {
+  $FoldRight1,
+  FoldRight1,
+  fold1,
+  foldMap1,
+  foldMap1DefaultL,
+  foldMap1DefaultR,
+  foldRight1Semigroup,
+  foldableDual,
+  foldableIdentity,
+  foldableMultiplicative,
+  foldableTuple,
+  foldl1,
+  foldl1Default,
+  foldr1,
+  foldr1Default,
+  for1_,
+  identity,
+  intercalate,
+  intercalateMap,
+  maximum,
+  maximumBy,
+  minimum,
+  minimumBy,
+  mkFoldRight1,
+  semigroupAct,
+  semigroupDual,
+  sequence1_,
+  traverse1_
+};

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

@@ -0,0 +1,11 @@
+import * as Data$dGeneric$dRep from "../Data.Generic.Rep/index.js";
+const genericSemigroupNoConstructors = {"genericAppend'": a => v => a};
+const genericSemigroupNoArguments = {"genericAppend'": a => v => a};
+const genericSemigroupArgument = dictSemigroup => ({"genericAppend'": v => v1 => dictSemigroup.append(v)(v1)});
+const genericAppend$p = dict => dict["genericAppend'"];
+const genericSemigroupConstructor = dictGenericSemigroup => ({"genericAppend'": v => v1 => dictGenericSemigroup["genericAppend'"](v)(v1)});
+const genericSemigroupProduct = dictGenericSemigroup => dictGenericSemigroup1 => (
+  {"genericAppend'": v => v1 => Data$dGeneric$dRep.$Product(dictGenericSemigroup["genericAppend'"](v._1)(v1._1), dictGenericSemigroup1["genericAppend'"](v._2)(v1._2))}
+);
+const genericAppend = dictGeneric => dictGenericSemigroup => x => y => dictGeneric.to(dictGenericSemigroup["genericAppend'"](dictGeneric.from(x))(dictGeneric.from(y)));
+export {genericAppend, genericAppend$p, genericSemigroupArgument, genericSemigroupConstructor, genericSemigroupNoArguments, genericSemigroupNoConstructors, genericSemigroupProduct};

package/output-es/Data.Semigroup.Last/index.js

@@ -0,0 +1,14 @@
+const Last = x => x;
+const showLast = dictShow => ({show: v => "(Last " + dictShow.show(v) + ")"});
+const semigroupLast = {append: v => x => x};
+const ordLast = dictOrd => dictOrd;
+const functorLast = {map: f => m => f(m)};
+const eqLast = dictEq => dictEq;
+const eq1Last = {eq1: dictEq => dictEq.eq};
+const ord1Last = {compare1: dictOrd => dictOrd.compare, Eq10: () => eq1Last};
+const boundedLast = dictBounded => dictBounded;
+const applyLast = {apply: v => v1 => v(v1), Functor0: () => functorLast};
+const bindLast = {bind: v => f => f(v), Apply0: () => applyLast};
+const applicativeLast = {pure: Last, Apply0: () => applyLast};
+const monadLast = {Applicative0: () => applicativeLast, Bind1: () => bindLast};
+export {Last, applicativeLast, applyLast, bindLast, boundedLast, eq1Last, eqLast, functorLast, monadLast, ord1Last, ordLast, semigroupLast, showLast};

package/output-es/Data.Semigroup.Traversable/index.js

@@ -0,0 +1,39 @@
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Data$dMonoid$dDual from "../Data.Monoid.Dual/index.js";
+import * as Data$dMonoid$dMultiplicative from "../Data.Monoid.Multiplicative/index.js";
+import * as Data$dSemigroup$dFoldable from "../Data.Semigroup.Foldable/index.js";
+import * as Data$dTraversable from "../Data.Traversable/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const identity = x => x;
+const traverse1 = dict => dict.traverse1;
+const traversableTuple = {
+  traverse1: dictApply => f => v => dictApply.Functor0().map(Data$dTuple.Tuple(v._1))(f(v._2)),
+  sequence1: dictApply => v => dictApply.Functor0().map(Data$dTuple.Tuple(v._1))(v._2),
+  Foldable10: () => Data$dSemigroup$dFoldable.foldableTuple,
+  Traversable1: () => Data$dTraversable.traversableTuple
+};
+const traversableIdentity = {
+  traverse1: dictApply => f => v => dictApply.Functor0().map(Data$dIdentity.Identity)(f(v)),
+  sequence1: dictApply => v => dictApply.Functor0().map(Data$dIdentity.Identity)(v),
+  Foldable10: () => Data$dSemigroup$dFoldable.foldableIdentity,
+  Traversable1: () => Data$dTraversable.traversableIdentity
+};
+const sequence1Default = dictTraversable1 => dictApply => dictTraversable1.traverse1(dictApply)(identity);
+const traversableDual = {
+  traverse1: dictApply => f => v => dictApply.Functor0().map(Data$dMonoid$dDual.Dual)(f(v)),
+  sequence1: dictApply => traversableDual.traverse1(dictApply)(identity),
+  Foldable10: () => Data$dSemigroup$dFoldable.foldableDual,
+  Traversable1: () => Data$dTraversable.traversableDual
+};
+const traversableMultiplicative = {
+  traverse1: dictApply => f => v => dictApply.Functor0().map(Data$dMonoid$dMultiplicative.Multiplicative)(f(v)),
+  sequence1: dictApply => traversableMultiplicative.traverse1(dictApply)(identity),
+  Foldable10: () => Data$dSemigroup$dFoldable.foldableMultiplicative,
+  Traversable1: () => Data$dTraversable.traversableMultiplicative
+};
+const sequence1 = dict => dict.sequence1;
+const traverse1Default = dictTraversable1 => dictApply => {
+  const sequence12 = dictTraversable1.sequence1(dictApply);
+  return f => ta => sequence12(dictTraversable1.Traversable1().Functor0().map(f)(ta));
+};
+export {identity, sequence1, sequence1Default, traversableDual, traversableIdentity, traversableMultiplicative, traversableTuple, traverse1, traverse1Default};

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

@@ -0,0 +1,25 @@
+export const intAdd = function (x) {
+  return function (y) {
+    /* jshint bitwise: false */
+    return x + y | 0;
+  };
+};
+
+export const intMul = function (x) {
+  return function (y) {
+    /* jshint bitwise: false */
+    return x * y | 0;
+  };
+};
+
+export const numAdd = function (n1) {
+  return function (n2) {
+    return n1 + n2;
+  };
+};
+
+export const numMul = function (n1) {
+  return function (n2) {
+    return n1 * n2;
+  };
+};