@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Effect.Aff/index.js

@@ -0,0 +1,268 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dError$dClass from "../Control.Monad.Error.Class/index.js";
+import * as Control$dParallel from "../Control.Parallel/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Partial from "../Partial/index.js";
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import {
+  _bind,
+  _catchError,
+  _delay,
+  _fork,
+  _killAll,
+  _liftEffect,
+  _makeFiber,
+  _makeSupervisedFiber,
+  _map,
+  _parAffAlt,
+  _parAffApply,
+  _parAffMap,
+  _pure,
+  _sequential,
+  _throwError,
+  generalBracket,
+  makeAff
+} from "./foreign.js";
+const Canceler = x => x;
+const suspendAff = /* #__PURE__ */ _fork(false);
+const newtypeCanceler = {Coercible0: () => {}};
+const functorParAff = {map: _parAffMap};
+const functorAff = {map: _map};
+const forkAff = /* #__PURE__ */ _fork(true);
+const ffiUtil = {
+  isLeft: v => {
+    if (v.tag === "Left") { return true; }
+    if (v.tag === "Right") { return false; }
+    $runtime.fail();
+  },
+  fromLeft: v => {
+    if (v.tag === "Left") { return v._1; }
+    if (v.tag === "Right") { return Partial._crashWith("unsafeFromLeft: Right"); }
+    $runtime.fail();
+  },
+  fromRight: v => {
+    if (v.tag === "Right") { return v._1; }
+    if (v.tag === "Left") { return Partial._crashWith("unsafeFromRight: Left"); }
+    $runtime.fail();
+  },
+  left: Data$dEither.Left,
+  right: Data$dEither.Right
+};
+const makeFiber = aff => _makeFiber(ffiUtil, aff);
+const launchAff = aff => {
+  const $0 = _makeFiber(ffiUtil, aff);
+  return () => {
+    const fiber = $0();
+    fiber.run();
+    return fiber;
+  };
+};
+const launchAff_ = x => {
+  const $0 = _makeFiber(ffiUtil, x);
+  return () => {
+    const fiber = $0();
+    fiber.run();
+  };
+};
+const launchSuspendedAff = makeFiber;
+const delay = v => _delay(Data$dEither.Right, v);
+const bracket = acquire => completed => generalBracket(acquire)({killed: v => completed, failed: v => completed, completed: v => completed});
+const applyParAff = {apply: _parAffApply, Functor0: () => functorParAff};
+const semigroupParAff = dictSemigroup => (
+  {
+    append: (() => {
+      const $0 = dictSemigroup.append;
+      return a => b => _parAffApply(_parAffMap($0)(a))(b);
+    })()
+  }
+);
+const monadAff = {Applicative0: () => applicativeAff, Bind1: () => bindAff};
+const bindAff = {bind: _bind, Apply0: () => applyAff};
+const applyAff = {apply: f => a => _bind(f)(f$p => _bind(a)(a$p => applicativeAff.pure(f$p(a$p)))), Functor0: () => functorAff};
+const applicativeAff = {pure: _pure, Apply0: () => applyAff};
+const cancelWith = aff => v => generalBracket(_pure())({killed: e => v1 => v(e), failed: v$1 => _pure, completed: v$1 => _pure})(v$1 => aff);
+const $$finally = fin => a => generalBracket(_pure())({killed: v => v$1 => fin, failed: v => v$1 => fin, completed: v => v$1 => fin})(v => a);
+const invincible = a => {
+  const $0 = _pure();
+  return generalBracket(a)({killed: v => v$1 => $0, failed: v => v$1 => $0, completed: v => v$1 => $0})(_pure);
+};
+const lazyAff = {defer: f => _bind(_pure())(f)};
+const parallelAff = {parallel: Unsafe$dCoerce.unsafeCoerce, sequential: _sequential, Apply0: () => applyAff, Apply1: () => applyParAff};
+const applicativeParAff = {pure: x => _pure(x), Apply0: () => applyParAff};
+const parSequence_ = /* #__PURE__ */ Control$dParallel.parTraverse_(parallelAff)(applicativeParAff)(Data$dFoldable.foldableArray)(Control$dParallel.identity);
+const monoidParAff = dictMonoid => {
+  const semigroupParAff1 = {
+    append: (() => {
+      const $0 = dictMonoid.Semigroup0().append;
+      return a => b => _parAffApply(_parAffMap($0)(a))(b);
+    })()
+  };
+  return {mempty: _pure(dictMonoid.mempty), Semigroup0: () => semigroupParAff1};
+};
+const semigroupCanceler = {append: v => v1 => err => parSequence_([v(err), v1(err)])};
+const semigroupAff = dictSemigroup => (
+  {
+    append: (() => {
+      const $0 = dictSemigroup.append;
+      return a => b => applyAff.apply(_map($0)(a))(b);
+    })()
+  }
+);
+const monadEffectAff = {liftEffect: _liftEffect, Monad0: () => monadAff};
+const effectCanceler = x => {
+  const $0 = _liftEffect(x);
+  return v => $0;
+};
+const joinFiber = v => makeAff(k => {
+  const $0 = v.join(k);
+  return () => {
+    const a$p = $0();
+    const $1 = _liftEffect(a$p);
+    return v$1 => $1;
+  };
+});
+const functorFiber = {map: f => t => _makeFiber(ffiUtil, _map(f)(joinFiber(t)))()};
+const applyFiber = {apply: t1 => t2 => _makeFiber(ffiUtil, applyAff.apply(joinFiber(t1))(joinFiber(t2)))(), Functor0: () => functorFiber};
+const applicativeFiber = {pure: a => _makeFiber(ffiUtil, _pure(a))(), Apply0: () => applyFiber};
+const killFiber = e => v => _bind(_liftEffect(v.isSuspended))(suspended => {
+  if (suspended) {
+    return _liftEffect((() => {
+      const $0 = v.kill(e, v$1 => () => {});
+      return () => {$0();};
+    })());
+  }
+  return makeAff(k => {
+    const $0 = v.kill(e, k);
+    return () => {
+      const a$p = $0();
+      const $1 = _liftEffect(a$p);
+      return v$1 => $1;
+    };
+  });
+});
+const fiberCanceler = x => a => killFiber(a)(x);
+const supervise = aff => {
+  const killError = Effect$dException.error("[Aff] Child fiber outlived parent");
+  return generalBracket(_liftEffect((() => {
+    const $0 = _makeSupervisedFiber(ffiUtil, aff);
+    return () => {
+      const sup = $0();
+      sup.fiber.run();
+      return sup;
+    };
+  })()))({
+    killed: err => sup => parSequence_([killFiber(err)(sup.fiber), makeAff(k => _killAll(err, sup.supervisor, k(Data$dEither.$Either("Right", undefined))))]),
+    failed: v => sup => makeAff(k => _killAll(killError, sup.supervisor, k(Data$dEither.$Either("Right", undefined)))),
+    completed: v => sup => makeAff(k => _killAll(killError, sup.supervisor, k(Data$dEither.$Either("Right", undefined))))
+  })(x => joinFiber(x.fiber));
+};
+const monadSTAff = {liftST: x => _liftEffect(x), Monad0: () => monadAff};
+const monadThrowAff = {throwError: _throwError, Monad0: () => monadAff};
+const monadErrorAff = {catchError: _catchError, MonadThrow0: () => monadThrowAff};
+const $$try = /* #__PURE__ */ Control$dMonad$dError$dClass.try(monadErrorAff);
+const attempt = $$try;
+const runAff = k => aff => {
+  const $0 = _makeFiber(ffiUtil, _bind($$try(aff))(x => _liftEffect(k(x))));
+  return () => {
+    const fiber = $0();
+    fiber.run();
+    return fiber;
+  };
+};
+const runAff_ = k => aff => {
+  const $0 = runAff(k)(aff);
+  return () => {$0();};
+};
+const runSuspendedAff = k => aff => _makeFiber(ffiUtil, _bind($$try(aff))(x => _liftEffect(k(x))));
+const monadRecAff = {
+  tailRecM: k => {
+    const go = a => _bind(k(a))(res => {
+      if (res.tag === "Done") { return _pure(res._1); }
+      if (res.tag === "Loop") { return go(res._1); }
+      $runtime.fail();
+    });
+    return go;
+  },
+  Monad0: () => monadAff
+};
+const monoidAff = dictMonoid => {
+  const semigroupAff1 = semigroupAff(dictMonoid.Semigroup0());
+  return {mempty: _pure(dictMonoid.mempty), Semigroup0: () => semigroupAff1};
+};
+const nonCanceler = /* #__PURE__ */ (() => {
+  const $0 = _pure();
+  return v => $0;
+})();
+const monoidCanceler = {mempty: nonCanceler, Semigroup0: () => semigroupCanceler};
+const never = /* #__PURE__ */ makeAff(v => () => nonCanceler);
+const apathize = /* #__PURE__ */ (() => {
+  const $0 = _map(v => {});
+  return x => $0($$try(x));
+})();
+const altParAff = {alt: _parAffAlt, Functor0: () => functorParAff};
+const altAff = {alt: a1 => a2 => _catchError(a1)(v => a2), Functor0: () => functorAff};
+const plusAff = {empty: /* #__PURE__ */ _throwError(/* #__PURE__ */ Effect$dException.error("Always fails")), Alt0: () => altAff};
+const plusParAff = /* #__PURE__ */ (() => ({empty: plusAff.empty, Alt0: () => altParAff}))();
+const alternativeParAff = {Applicative0: () => applicativeParAff, Plus1: () => plusParAff};
+export {
+  Canceler,
+  altAff,
+  altParAff,
+  alternativeParAff,
+  apathize,
+  applicativeAff,
+  applicativeFiber,
+  applicativeParAff,
+  applyAff,
+  applyFiber,
+  applyParAff,
+  attempt,
+  bindAff,
+  bracket,
+  cancelWith,
+  delay,
+  effectCanceler,
+  ffiUtil,
+  fiberCanceler,
+  $$finally as finally,
+  forkAff,
+  functorAff,
+  functorFiber,
+  functorParAff,
+  invincible,
+  joinFiber,
+  killFiber,
+  launchAff,
+  launchAff_,
+  launchSuspendedAff,
+  lazyAff,
+  makeFiber,
+  monadAff,
+  monadEffectAff,
+  monadErrorAff,
+  monadRecAff,
+  monadSTAff,
+  monadThrowAff,
+  monoidAff,
+  monoidCanceler,
+  monoidParAff,
+  never,
+  newtypeCanceler,
+  nonCanceler,
+  parSequence_,
+  parallelAff,
+  plusAff,
+  plusParAff,
+  runAff,
+  runAff_,
+  runSuspendedAff,
+  semigroupAff,
+  semigroupCanceler,
+  semigroupParAff,
+  supervise,
+  suspendAff,
+  $$try as try
+};
+export * from "./foreign.js";

package/output-es/Effect.Aff.Class/index.js

@@ -0,0 +1,114 @@
+import * as Control$dMonad$dCont$dTrans from "../Control.Monad.Cont.Trans/index.js";
+import * as Control$dMonad$dExcept$dTrans from "../Control.Monad.Except.Trans/index.js";
+import * as Control$dMonad$dList$dTrans from "../Control.Monad.List.Trans/index.js";
+import * as Control$dMonad$dMaybe$dTrans from "../Control.Monad.Maybe.Trans/index.js";
+import * as Control$dMonad$dRWS$dTrans from "../Control.Monad.RWS.Trans/index.js";
+import * as Control$dMonad$dReader$dTrans from "../Control.Monad.Reader.Trans/index.js";
+import * as Control$dMonad$dState$dTrans from "../Control.Monad.State.Trans/index.js";
+import * as Control$dMonad$dWriter$dTrans from "../Control.Monad.Writer.Trans/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Effect$dAff from "../Effect.Aff/index.js";
+const monadAffAff = {liftAff: x => x, MonadEffect0: () => Effect$dAff.monadEffectAff};
+const liftAff = dict => dict.liftAff;
+const monadAffContT = dictMonadAff => {
+  const MonadEffect0 = dictMonadAff.MonadEffect0();
+  const monadEffectContT = Control$dMonad$dCont$dTrans.monadEffectContT(MonadEffect0);
+  return {
+    liftAff: (() => {
+      const $0 = MonadEffect0.Monad0().Bind1().bind;
+      return x => $0(dictMonadAff.liftAff(x));
+    })(),
+    MonadEffect0: () => monadEffectContT
+  };
+};
+const monadAffExceptT = dictMonadAff => {
+  const MonadEffect0 = dictMonadAff.MonadEffect0();
+  const monadEffectExceptT = Control$dMonad$dExcept$dTrans.monadEffectExceptT(MonadEffect0);
+  return {
+    liftAff: (() => {
+      const $0 = MonadEffect0.Monad0();
+      return x => $0.Bind1().bind(dictMonadAff.liftAff(x))(a => $0.Applicative0().pure(Data$dEither.$Either("Right", a)));
+    })(),
+    MonadEffect0: () => monadEffectExceptT
+  };
+};
+const monadAffListT = dictMonadAff => {
+  const MonadEffect0 = dictMonadAff.MonadEffect0();
+  const monadEffectListT = Control$dMonad$dList$dTrans.monadEffectListT(MonadEffect0);
+  return {
+    liftAff: (() => {
+      const $0 = Control$dMonad$dList$dTrans.fromEffect(MonadEffect0.Monad0().Applicative0());
+      return x => $0(dictMonadAff.liftAff(x));
+    })(),
+    MonadEffect0: () => monadEffectListT
+  };
+};
+const monadAffMaybe = dictMonadAff => {
+  const MonadEffect0 = dictMonadAff.MonadEffect0();
+  const monadEffectMaybe = Control$dMonad$dMaybe$dTrans.monadEffectMaybe(MonadEffect0);
+  return {
+    liftAff: (() => {
+      const $0 = MonadEffect0.Monad0();
+      return x => $0.Bind1().bind(dictMonadAff.liftAff(x))(a$p => $0.Applicative0().pure(Data$dMaybe.$Maybe("Just", a$p)));
+    })(),
+    MonadEffect0: () => monadEffectMaybe
+  };
+};
+const monadAffRWS = dictMonadAff => {
+  const MonadEffect0 = dictMonadAff.MonadEffect0();
+  const Monad0 = MonadEffect0.Monad0();
+  return dictMonoid => {
+    const monadEffectRWS = Control$dMonad$dRWS$dTrans.monadEffectRWS(dictMonoid)(MonadEffect0);
+    return {
+      liftAff: (() => {
+        const mempty = dictMonoid.mempty;
+        return x => {
+          const $0 = dictMonadAff.liftAff(x);
+          return v => s => Monad0.Bind1().bind($0)(a => Monad0.Applicative0().pure(Control$dMonad$dRWS$dTrans.$RWSResult(s, a, mempty)));
+        };
+      })(),
+      MonadEffect0: () => monadEffectRWS
+    };
+  };
+};
+const monadAffReader = dictMonadAff => {
+  const monadEffectReader = Control$dMonad$dReader$dTrans.monadEffectReader(dictMonadAff.MonadEffect0());
+  return {
+    liftAff: x => {
+      const $0 = dictMonadAff.liftAff(x);
+      return v => $0;
+    },
+    MonadEffect0: () => monadEffectReader
+  };
+};
+const monadAffState = dictMonadAff => {
+  const MonadEffect0 = dictMonadAff.MonadEffect0();
+  const monadEffectState = Control$dMonad$dState$dTrans.monadEffectState(MonadEffect0);
+  return {
+    liftAff: (() => {
+      const $0 = MonadEffect0.Monad0();
+      return x => {
+        const $1 = dictMonadAff.liftAff(x);
+        return s => $0.Bind1().bind($1)(x$1 => $0.Applicative0().pure(Data$dTuple.$Tuple(x$1, s)));
+      };
+    })(),
+    MonadEffect0: () => monadEffectState
+  };
+};
+const monadAffWriter = dictMonadAff => {
+  const MonadEffect0 = dictMonadAff.MonadEffect0();
+  const Monad0 = MonadEffect0.Monad0();
+  return dictMonoid => {
+    const monadEffectWriter = Control$dMonad$dWriter$dTrans.monadEffectWriter(dictMonoid)(MonadEffect0);
+    return {
+      liftAff: (() => {
+        const mempty = dictMonoid.mempty;
+        return x => Monad0.Bind1().bind(dictMonadAff.liftAff(x))(a => Monad0.Applicative0().pure(Data$dTuple.$Tuple(a, mempty)));
+      })(),
+      MonadEffect0: () => monadEffectWriter
+    };
+  };
+};
+export {liftAff, monadAffAff, monadAffContT, monadAffExceptT, monadAffListT, monadAffMaybe, monadAffRWS, monadAffReader, monadAffState, monadAffWriter};

package/output-es/Effect.Aff.Compat/index.js

@@ -0,0 +1,14 @@
+// | This module provides compatability functions for constructing `Aff`s which
+// | are defined via the FFI.
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Effect$dAff from "../Effect.Aff/index.js";
+const EffectFnCanceler = x => x;
+const EffectFnAff = x => x;
+const fromEffectFnAff = v => Effect$dAff.makeAff(k => () => {
+  const v1 = v(x => k(Data$dEither.$Either("Left", x))(), x => k(Data$dEither.$Either("Right", x))());
+  return e => Effect$dAff.makeAff(k2 => () => {
+    v1(e, x => k2(Data$dEither.$Either("Left", x))(), x => k2(Data$dEither.$Either("Right", x))());
+    return Effect$dAff.nonCanceler;
+  });
+});
+export {EffectFnAff, EffectFnCanceler, fromEffectFnAff};

package/output-es/Effect.Class/index.js

@@ -0,0 +1,4 @@
+import * as Effect from "../Effect/index.js";
+const monadEffectEffect = {liftEffect: x => x, Monad0: () => Effect.monadEffect};
+const liftEffect = dict => dict.liftEffect;
+export {liftEffect, monadEffectEffect};

package/output-es/Effect.Class.Console/index.js

@@ -0,0 +1,25 @@
+import * as Effect$dConsole from "../Effect.Console/index.js";
+const warnShow = dictMonadEffect => dictShow => x => dictMonadEffect.liftEffect(Effect$dConsole.warn(dictShow.show(x)));
+const warn = dictMonadEffect => x => dictMonadEffect.liftEffect(Effect$dConsole.warn(x));
+const timeLog = dictMonadEffect => x => dictMonadEffect.liftEffect(Effect$dConsole.timeLog(x));
+const timeEnd = dictMonadEffect => x => dictMonadEffect.liftEffect(Effect$dConsole.timeEnd(x));
+const time = dictMonadEffect => x => dictMonadEffect.liftEffect(Effect$dConsole.time(x));
+const logShow = dictMonadEffect => dictShow => x => dictMonadEffect.liftEffect(Effect$dConsole.log(dictShow.show(x)));
+const log = dictMonadEffect => x => dictMonadEffect.liftEffect(Effect$dConsole.log(x));
+const infoShow = dictMonadEffect => dictShow => x => dictMonadEffect.liftEffect(Effect$dConsole.info(dictShow.show(x)));
+const info = dictMonadEffect => x => dictMonadEffect.liftEffect(Effect$dConsole.info(x));
+const groupEnd = dictMonadEffect => dictMonadEffect.liftEffect(Effect$dConsole.groupEnd);
+const groupCollapsed = dictMonadEffect => x => dictMonadEffect.liftEffect(Effect$dConsole.groupCollapsed(x));
+const group = dictMonadEffect => x => dictMonadEffect.liftEffect(Effect$dConsole.group(x));
+const grouped = dictMonadEffect => {
+  const Monad0 = dictMonadEffect.Monad0();
+  const Bind1 = Monad0.Bind1();
+  const groupEnd1 = dictMonadEffect.liftEffect(Effect$dConsole.groupEnd);
+  return name => inner => Bind1.bind(dictMonadEffect.liftEffect(Effect$dConsole.group(name)))(() => Bind1.bind(inner)(result => Bind1.bind(groupEnd1)(() => Monad0.Applicative0().pure(result))));
+};
+const errorShow = dictMonadEffect => dictShow => x => dictMonadEffect.liftEffect(Effect$dConsole.error(dictShow.show(x)));
+const error = dictMonadEffect => x => dictMonadEffect.liftEffect(Effect$dConsole.error(x));
+const debugShow = dictMonadEffect => dictShow => x => dictMonadEffect.liftEffect(Effect$dConsole.debug(dictShow.show(x)));
+const debug = dictMonadEffect => x => dictMonadEffect.liftEffect(Effect$dConsole.debug(x));
+const clear = dictMonadEffect => dictMonadEffect.liftEffect(Effect$dConsole.clear);
+export {clear, debug, debugShow, error, errorShow, group, groupCollapsed, groupEnd, grouped, info, infoShow, log, logShow, time, timeEnd, timeLog, warn, warnShow};

package/output-es/Effect.Console/foreign.js

@@ -0,0 +1,67 @@
+export const log = function (s) {
+  return function () {
+    console.log(s);
+  };
+};
+
+export const warn = function (s) {
+  return function () {
+    console.warn(s);
+  };
+};
+
+export const error = function (s) {
+  return function () {
+    console.error(s);
+  };
+};
+
+export const info = function (s) {
+  return function () {
+    console.info(s);
+  };
+};
+
+export const debug = function (s) {
+  return function () {
+    console.debug(s);
+  };
+};
+
+export const time = function (s) {
+  return function () {
+    console.time(s);
+  };
+};
+
+export const timeLog = function (s) {
+  return function () {
+    console.timeLog(s);
+  };
+};
+
+export const timeEnd = function (s) {
+  return function () {
+    console.timeEnd(s);
+  };
+};
+
+export const clear = function () {
+  console.clear();
+};
+
+export const group = function (s) {
+  return function () {
+    console.group(s);
+  };
+};
+
+export const groupCollapsed = function (s) {
+  return function () {
+    console.groupCollapsed(s);
+  };
+};
+
+export const groupEnd = function () {
+  console.groupEnd();
+};

package/output-es/Effect.Console/index.js

@@ -0,0 +1,17 @@
+import {clear, debug, error, group, groupCollapsed, groupEnd, info, log, time, timeEnd, timeLog, warn} from "./foreign.js";
+const warnShow = dictShow => a => warn(dictShow.show(a));
+const logShow = dictShow => a => log(dictShow.show(a));
+const infoShow = dictShow => a => info(dictShow.show(a));
+const grouped = name => inner => {
+  const $0 = group(name);
+  return () => {
+    $0();
+    const result = inner();
+    groupEnd();
+    return result;
+  };
+};
+const errorShow = dictShow => a => error(dictShow.show(a));
+const debugShow = dictShow => a => debug(dictShow.show(a));
+export {debugShow, errorShow, grouped, infoShow, logShow, warnShow};
+export * from "./foreign.js";

package/output-es/Effect.Exception/foreign.js

@@ -0,0 +1,45 @@
+export function showErrorImpl(err) {
+  return err.stack || err.toString();
+}
+
+export function error(msg) {
+  return new Error(msg);
+}
+
+export function message(e) {
+  return e.message;
+}
+
+export function name(e) {
+  return e.name || "Error";
+}
+
+export function stackImpl(just) {
+  return function (nothing) {
+    return function (e) {
+      return e.stack ? just(e.stack) : nothing;
+    };
+  };
+}
+
+export function throwException(e) {
+  return function () {
+    throw e;
+  };
+}
+
+export function catchException(c) {
+  return function (t) {
+    return function () {
+      try {
+        return t();
+      } catch (e) {
+        if (e instanceof Error || Object.prototype.toString.call(e) === "[object Error]") {
+          return c(e)();
+        } else {
+          return c(new Error(e.toString()))();
+        }
+      }
+    };
+  };
+}

package/output-es/Effect.Exception/index.js

@@ -0,0 +1,14 @@
+// | This module defines an effect, actions and handlers for working
+// | with JavaScript exceptions.
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import {catchException, error, message, name, showErrorImpl, stackImpl, throwException} from "./foreign.js";
+const $$try = action => catchException(x => () => Data$dEither.$Either("Left", x))(() => {
+  const a$p = action();
+  return Data$dEither.$Either("Right", a$p);
+});
+const $$throw = x => throwException(error(x));
+const stack = /* #__PURE__ */ stackImpl(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const showError = {show: showErrorImpl};
+export {showError, stack, $$throw as throw, $$try as try};
+export * from "./foreign.js";

package/output-es/Effect.Exception.Unsafe/index.js

@@ -0,0 +1,4 @@
+import * as Effect$dException from "../Effect.Exception/index.js";
+const unsafeThrowException = x => Effect$dException.throwException(x)();
+const unsafeThrow = x => Effect$dException.throwException(Effect$dException.error(x))();
+export {unsafeThrow, unsafeThrowException};

package/output-es/Effect.Now/foreign.js

@@ -0,0 +1,8 @@
+export function now() {
+  return Date.now();
+}
+
+export function getTimezoneOffset() {
+  var n = new Date(Date.now());
+  return n.getTimezoneOffset();
+}

package/output-es/Effect.Now/index.js

@@ -0,0 +1,16 @@
+import * as Data$dDateTime$dInstant from "../Data.DateTime.Instant/index.js";
+import {getTimezoneOffset, now} from "./foreign.js";
+const nowTime = () => {
+  const a$p = now();
+  return Data$dDateTime$dInstant.toDateTime(a$p)._2;
+};
+const nowDateTime = () => {
+  const a$p = now();
+  return Data$dDateTime$dInstant.toDateTime(a$p);
+};
+const nowDate = () => {
+  const a$p = now();
+  return Data$dDateTime$dInstant.toDateTime(a$p)._1;
+};
+export {nowDate, nowDateTime, nowTime};
+export * from "./foreign.js";

package/output-es/Effect.Random/foreign.js

@@ -0,0 +1 @@
+export const random = Math.random;

package/output-es/Effect.Random/index.js

@@ -0,0 +1,17 @@
+import * as Data$dInt from "../Data.Int/index.js";
+import * as Data$dNumber from "../Data.Number/index.js";
+import {random} from "./foreign.js";
+const randomRange = min => max => () => {
+  const n = random();
+  return n * (max - min) + min;
+};
+const randomInt = low => high => () => {
+  const n = random();
+  return Data$dInt.unsafeClamp(Data$dNumber.floor((Data$dInt.toNumber(high) - Data$dInt.toNumber(low) + 1.0) * n + Data$dInt.toNumber(low)));
+};
+const randomBool = () => {
+  const a$p = random();
+  return a$p < 0.5;
+};
+export {randomBool, randomInt, randomRange};
+export * from "./foreign.js";

package/output-es/Effect.Ref/foreign.js

@@ -0,0 +1,37 @@
+export const _new = function (val) {
+  return function () {
+    return { value: val };
+  };
+};
+
+export const newWithSelf = function (f) {
+  return function () {
+    var ref = { value: null };
+    ref.value = f(ref);
+    return ref;
+  };
+};
+
+export const read = function (ref) {
+  return function () {
+    return ref.value;
+  };
+};
+
+export const modifyImpl = function (f) {
+  return function (ref) {
+    return function () {
+      var t = f(ref.value);
+      ref.value = t.state;
+      return t.value;
+    };
+  };
+};
+
+export const write = function (val) {
+  return function (ref) {
+    return function () {
+      ref.value = val;
+    };
+  };
+};