@explorable-viz/fluid 0.12.2 → 0.12.4

package/output-es/File/index.js

@@ -0,0 +1,125 @@
+import * as $runtime from "../runtime.js";
+import * as Affjax from "../Affjax/index.js";
+import * as Affjax$dResponseFormat from "../Affjax.ResponseFormat/index.js";
+import * as Affjax$dWeb from "../Affjax.Web/index.js";
+import * as Control$dApply from "../Control.Apply/index.js";
+import * as Control$dMonad$dExcept$dTrans from "../Control.Monad.Except.Trans/index.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dHTTP$dMethod from "../Data.HTTP.Method/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dMonoid from "../Data.Monoid/index.js";
+import * as Data$dSemigroup from "../Data.Semigroup/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Effect$dAff from "../Effect.Aff/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+const bindExceptT = /* #__PURE__ */ Control$dMonad$dExcept$dTrans.bindExceptT(Effect$dAff.monadAff);
+const applicativeExceptT = /* #__PURE__ */ Control$dMonad$dExcept$dTrans.applicativeExceptT(Effect$dAff.monadAff);
+const Folder = x => x;
+const FileCxt = x => x;
+const File = x => x;
+const showFolder = Data$dShow.showString;
+const showFile = Data$dShow.showString;
+const show = /* #__PURE__ */ Data$dShow.showArrayImpl(Data$dShow.showStringImpl);
+const semigroupFolder = {append: v => v1 => v + "/" + v1};
+const semigroupFile = Data$dSemigroup.semigroupString;
+const newtypeFolder_ = {Coercible0: () => {}};
+const newtypeFile_ = {Coercible0: () => {}};
+const monoidFile = Data$dMonoid.monoidString;
+const loadFileAff = {
+  loadFileFromPath: dictMonadError => dictMonadAff => v => Effect$dAff._bind(bindExceptT.bind(dictMonadAff.liftAff(Effect$dAff._bind(Affjax.request(Affjax$dWeb.driver)({
+    method: Data$dEither.$Either("Left", Data$dHTTP$dMethod.GET),
+    url: v,
+    headers: [],
+    content: Data$dMaybe.Nothing,
+    username: Data$dMaybe.Nothing,
+    password: Data$dMaybe.Nothing,
+    withCredentials: false,
+    responseFormat: Affjax$dResponseFormat.$ResponseFormat("String", Affjax$dResponseFormat.identity),
+    timeout: Data$dMaybe.Nothing
+  }))(resp => Effect$dAff._pure((() => {
+    if (resp.tag === "Right") {
+      if (resp._1.status === 200) { return Data$dEither.$Either("Right", Data$dTuple.$Tuple(resp._1, v)); }
+      return Data$dEither.$Either("Left", Affjax.RequestFailedError);
+    }
+    if (resp.tag === "Left") { return Data$dEither.$Either("Left", resp._1); }
+    $runtime.fail();
+  })()))))(v1 => {
+    const $0 = v1._1;
+    return bindExceptT.bind(applicativeExceptT.pure())(() => applicativeExceptT.pure($0.body));
+  }))(result => Effect$dAff._pure((() => {
+    if (result.tag === "Left") { return Data$dMaybe.Nothing; }
+    if (result.tag === "Right") { return Data$dMaybe.$Maybe("Just", result._1); }
+    $runtime.fail();
+  })()))
+};
+const prependFolder = v => v1 => v + "/" + v1;
+const loadFileFromPath = dict => dict.loadFileFromPath;
+const loadFileStateT = dictMonadAff => {
+  const $0 = dictMonadAff.MonadEffect0().Monad0();
+  return dictMonadError => dictLoadFile => {
+    const loadFileFromPath1 = dictLoadFile.loadFileFromPath(dictMonadError)(dictMonadAff);
+    return {
+      loadFileFromPath: dictMonadError1 => dictMonadAff1 => x => {
+        const $1 = loadFileFromPath1(x);
+        return s => $0.Bind1().bind($1)(x$1 => $0.Applicative0().pure(Data$dTuple.$Tuple(x$1, s)));
+      }
+    };
+  };
+};
+const loadFileWriterT = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  return dictMonadError => dictMonadAff => {
+    const $0 = dictMonadAff.MonadEffect0().Monad0();
+    return dictLoadFile => {
+      const loadFileFromPath1 = dictLoadFile.loadFileFromPath(dictMonadError)(dictMonadAff);
+      return {loadFileFromPath: dictMonadError1 => dictMonadAff1 => x => $0.Bind1().bind(loadFileFromPath1(x))(a => $0.Applicative0().pure(Data$dTuple.$Tuple(a, mempty)))};
+    };
+  };
+};
+const loadFile = dictLoadFile => dictMonad => {
+  const $0 = dictMonad.Applicative0();
+  return dictMonadError => {
+    const loadFileFromPath2 = dictLoadFile.loadFileFromPath(dictMonadError);
+    return dictMonadAff => {
+      const loadFileFromPath3 = loadFileFromPath2(dictMonadAff);
+      return folders => file => {
+        const paths = Control$dApply.arrayApply(Data$dFunctor.arrayMap(prependFolder)(folders))([file]);
+        return dictMonad.Bind1().bind(Data$dArray.foldM(dictMonad)(v => v1 => {
+          if (v.tag === "Just") { return $0.pure(Data$dMaybe.$Maybe("Just", v._1)); }
+          if (v.tag === "Nothing") { return loadFileFromPath3(v1); }
+          $runtime.fail();
+        })(Data$dMaybe.Nothing)(paths))(result => {
+          if (result.tag === "Just") { return $0.pure(result._1); }
+          if (result.tag === "Nothing") { return Effect$dException.throwException(Effect$dException.error("File not found in any path: " + show(paths)))(); }
+          $runtime.fail();
+        });
+      };
+    };
+  };
+};
+const fluidExtension = ".fld";
+export {
+  File,
+  FileCxt,
+  Folder,
+  applicativeExceptT,
+  bindExceptT,
+  fluidExtension,
+  loadFile,
+  loadFileAff,
+  loadFileFromPath,
+  loadFileStateT,
+  loadFileWriterT,
+  monoidFile,
+  newtypeFile_,
+  newtypeFolder_,
+  prependFolder,
+  semigroupFile,
+  semigroupFolder,
+  show,
+  showFile,
+  showFolder
+};

package/output-es/Fluid/index.js

@@ -0,0 +1,229 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dReader$dTrans from "../Control.Monad.Reader.Trans/index.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+import * as Data$dString$dCommon from "../Data.String.Common/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Effect$dAff from "../Effect.Aff/index.js";
+import * as Effect$dAff$dClass from "../Effect.Aff.Class/index.js";
+import * as Effect$dConsole from "../Effect.Console/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Eval from "../Eval/index.js";
+import * as ExitCodes from "../ExitCodes/index.js";
+import * as File from "../File/index.js";
+import * as Module from "../Module/index.js";
+import * as Module$dNode from "../Module.Node/index.js";
+import * as Options$dApplicative$dBuilder from "../Options.Applicative.Builder/index.js";
+import * as Options$dApplicative$dBuilder$dInternal from "../Options.Applicative.Builder.Internal/index.js";
+import * as Options$dApplicative$dExtra from "../Options.Applicative.Extra/index.js";
+import * as Options$dApplicative$dInternal$dUtils from "../Options.Applicative.Internal.Utils/index.js";
+import * as Options$dApplicative$dTypes from "../Options.Applicative.Types/index.js";
+import * as Parse from "../Parse/index.js";
+import * as Pretty from "../Pretty/index.js";
+import * as Pretty$dDoc from "../Pretty.Doc/index.js";
+import * as Primitive$dDefs from "../Primitive.Defs/index.js";
+import * as Val from "../Val/index.js";
+const $Command = (tag, _1) => ({tag, _1});
+const $EvalArgs = _1 => ({tag: "EvalArgs", _1});
+const bind = /* #__PURE__ */ (() => Control$dMonad$dReader$dTrans.bindReaderT(Effect$dAff.bindAff).bind)();
+const loadFileNodeT = /* #__PURE__ */ Module$dNode.loadFileNodeT(Effect$dAff.monadAff);
+const monadErrorErrorNodeT = /* #__PURE__ */ Control$dMonad$dReader$dTrans.monadErrorReaderT(Effect$dAff.monadErrorAff);
+const monadAffNodeT = /* #__PURE__ */ Effect$dAff$dClass.monadAffReader(Effect$dAff$dClass.monadAffAff);
+const loadFile = /* #__PURE__ */ File.loadFile(loadFileNodeT)(/* #__PURE__ */ Control$dMonad$dReader$dTrans.monadReaderT(Effect$dAff.monadAff))(monadErrorErrorNodeT)(monadAffNodeT);
+const monadReaderFileCxtNodeT = /* #__PURE__ */ Control$dMonad$dReader$dTrans.monadReaderReaderT(Effect$dAff.monadAff);
+const prepConfig = /* #__PURE__ */ Module.prepConfig(monadAffNodeT)(monadErrorErrorNodeT)(monadReaderFileCxtNodeT)(loadFileNodeT);
+const graphEval = /* #__PURE__ */ Eval.graphEval(monadAffNodeT)(monadReaderFileCxtNodeT)(loadFileNodeT)(monadErrorErrorNodeT);
+const EvalArgs = value0 => $EvalArgs(value0);
+const Evaluate = value0 => $Command("Evaluate", value0);
+const Parse_ = value0 => $Command("Parse_", value0);
+const parseLocal = /* #__PURE__ */ Options$dApplicative$dTypes.$Parser(
+  "AltP",
+  /* #__PURE__ */ Options$dApplicative$dBuilder.flag$p(true)(/* #__PURE__ */ (() => {
+    const $0 = Options$dApplicative$dBuilder.help("Are you running fluid as a library?");
+    const $1 = $0._2._1.tag === "Nothing" ? Data$dMaybe.Nothing : $0._2._1;
+    const $2 = $0._2._2.tag === "Nothing" ? Data$dMaybe.Nothing : $0._2._2;
+    return Options$dApplicative$dBuilder$dInternal.$Mod(
+      x => $0._1({
+        flagNames: [Options$dApplicative$dTypes.$OptName("OptShort", "l"), Options$dApplicative$dTypes.$OptName("OptLong", "local"), ...x.flagNames],
+        flagActive: x.flagActive
+      }),
+      Options$dApplicative$dBuilder$dInternal.$DefaultProp($1.tag === "Nothing" ? Data$dMaybe.Nothing : $1, $2.tag === "Nothing" ? Data$dMaybe.Nothing : $2),
+      x => $0._3(x)
+    );
+  })()),
+  /* #__PURE__ */ Options$dApplicative$dTypes.$Parser("NilP", false)
+);
+const parseEvaluate = /* #__PURE__ */ (() => Options$dApplicative$dTypes.$Parser(
+  "MultP",
+  Options$dApplicative$dTypes.$MultPE(
+    Options$dApplicative$dTypes.$Parser(
+      "MultP",
+      Options$dApplicative$dTypes.$MultPE(
+        Options$dApplicative$dTypes.parserFunctor.map(v => v1 => v2 => $EvalArgs({local: v, fileName: v1, fluidSrcPath: v2}))(parseLocal),
+        Options$dApplicative$dBuilder.option(Options$dApplicative$dTypes.readerAsk)((() => {
+          const $0 = Options$dApplicative$dBuilder.help("The file to parse");
+          const $1 = $0._2._1.tag === "Nothing" ? Data$dMaybe.Nothing : $0._2._1;
+          const $2 = $0._2._2.tag === "Nothing" ? Data$dMaybe.Nothing : $0._2._2;
+          return Options$dApplicative$dBuilder$dInternal.$Mod(
+            x => $0._1({
+              optNames: [Options$dApplicative$dTypes.$OptName("OptShort", "f"), Options$dApplicative$dTypes.$OptName("OptLong", "file"), ...x.optNames],
+              optCompleter: x.optCompleter,
+              optNoArgError: x.optNoArgError
+            }),
+            Options$dApplicative$dBuilder$dInternal.$DefaultProp($1.tag === "Nothing" ? Data$dMaybe.Nothing : $1, $2.tag === "Nothing" ? Data$dMaybe.Nothing : $2),
+            x => $0._3(x)
+          );
+        })())
+      )
+    ),
+    Options$dApplicative$dTypes.parserFunctor.map(File.Folder)(Options$dApplicative$dBuilder.option(Options$dApplicative$dTypes.readerAsk)((() => {
+      const $0 = Options$dApplicative$dBuilder.help("The path containing the program files");
+      const $1 = $0._2._1.tag === "Nothing" ? Data$dMaybe.Nothing : $0._2._1;
+      const $2 = $0._2._2.tag === "Nothing" ? Data$dMaybe.Nothing : $0._2._2;
+      return Options$dApplicative$dBuilder$dInternal.$Mod(
+        x => $0._1({
+          optNames: [Options$dApplicative$dTypes.$OptName("OptShort", "p"), Options$dApplicative$dTypes.$OptName("OptLong", "fluid-src-path"), ...x.optNames],
+          optCompleter: x.optCompleter,
+          optNoArgError: x.optNoArgError
+        }),
+        Options$dApplicative$dBuilder$dInternal.$DefaultProp($1.tag === "Nothing" ? Data$dMaybe.Nothing : $1, $2.tag === "Nothing" ? Data$dMaybe.Nothing : $2),
+        x => $0._3(x)
+      );
+    })()))
+  )
+))();
+const fluidLibraryPath = "node_modules/@explorable-viz/fluid";
+const parse = v => {
+  const fluidSrcPaths = [v._1.fluidSrcPath, ...v._1.local ? ["node_modules/@explorable-viz/fluid/dist/fluid/fluid"] : []];
+  return bind(loadFile(fluidSrcPaths)(v._1.fileName))(fluidSrc => {
+    const v1 = Parse.parse(Parse.withImports(Parse.expr))(fluidSrc);
+    if (v1.tag === "Left") {
+      const $0 = Effect$dAff._pure(v1._1);
+      return v$1 => $0;
+    }
+    if (v1.tag === "Right") {
+      const $0 = Effect$dAff._pure(Pretty$dDoc.renderWithIndent(Pretty$dDoc.Stmt)(0)(0)(Pretty.prettyExpr(Val.annUnit).pretty(v1._1._1))._1);
+      return v$1 => $0;
+    }
+    $runtime.fail();
+  })({fluidSrcPaths});
+};
+const evaluate = v => {
+  const fluidSrcPaths = [v._1.fluidSrcPath, ...v._1.local ? ["node_modules/@explorable-viz/fluid/dist/fluid/fluid"] : []];
+  return bind(loadFile(fluidSrcPaths)(v._1.fileName))(fluidSrc => bind(prepConfig(Primitive$dDefs.primitives)(fluidSrc))(v1 => bind(graphEval(v1.gconfig)(v1.e))(v2 => {
+    const $0 = Effect$dAff._pure(Val.functorVal.map(v$1 => {})(v2["outα"]));
+    return v$1 => $0;
+  })))({fluidSrcPaths});
+};
+const dispatchCommand = v => {
+  if (v.tag === "Evaluate") {
+    return Effect$dAff._bind(evaluate(v._1))(v1 => Effect$dAff._liftEffect(Effect$dConsole.log(Pretty$dDoc.renderWithIndent(Pretty$dDoc.Stmt)(0)(0)(Pretty.prettyVal(Val.highlightableUnit).pretty(v1))._1)));
+  }
+  if (v.tag === "Parse_") { return Effect$dAff._bind(parse(v._1))(r => Effect$dAff._liftEffect(Effect$dConsole.log(r))); }
+  $runtime.fail();
+};
+const commands = /* #__PURE__ */ (() => (
+  {evaluate: Options$dApplicative$dTypes.parserFunctor.map(Evaluate)(parseEvaluate), parse: Options$dApplicative$dTypes.parserFunctor.map(Parse_)(parseEvaluate)}
+))();
+const commandParser = /* #__PURE__ */ Options$dApplicative$dBuilder.subparser(/* #__PURE__ */ (() => {
+  const $0 = Options$dApplicative$dBuilder.command("evaluate")(Options$dApplicative$dBuilder.progDesc("Evaluate a file")({
+    infoParser: commands.evaluate,
+    infoFullDesc: true,
+    infoProgDesc: Data$dMaybe.Nothing,
+    infoHeader: Data$dMaybe.Nothing,
+    infoFooter: Data$dMaybe.Nothing,
+    infoFailureCode: ExitCodes.Error,
+    infoPolicy: Options$dApplicative$dTypes.Intersperse
+  }));
+  const $1 = Options$dApplicative$dBuilder.command("parse")(Options$dApplicative$dBuilder.progDesc("Parse a file")({
+    infoParser: commands.parse,
+    infoFullDesc: true,
+    infoProgDesc: Data$dMaybe.Nothing,
+    infoHeader: Data$dMaybe.Nothing,
+    infoFooter: Data$dMaybe.Nothing,
+    infoFailureCode: ExitCodes.Error,
+    infoPolicy: Options$dApplicative$dTypes.Intersperse
+  }));
+  return Options$dApplicative$dBuilder$dInternal.$Mod(
+    x => $1._1($0._1(x)),
+    Options$dApplicative$dBuilder$dInternal.$DefaultProp($1._2._1.tag === "Nothing" ? $0._2._1 : $1._2._1, $1._2._2.tag === "Nothing" ? $0._2._2 : $1._2._2),
+    x => $1._3($0._3(x))
+  );
+})());
+const callback = v => {
+  if (v.tag === "Left") { return Effect$dConsole.log(Effect$dException.showErrorImpl(v._1)); }
+  if (v.tag === "Right") { return () => {}; }
+  $runtime.fail();
+};
+const main = /* #__PURE__ */ (() => {
+  const $0 = Effect$dAff.runAff(callback)(Effect$dAff._bind(Effect$dAff._liftEffect((() => {
+    const $0 = Options$dApplicative$dBuilder.header("parse - a simple parser")(Options$dApplicative$dBuilder.progDesc("Parse a file")({
+      infoFullDesc: true,
+      infoFailureCode: ExitCodes.Error,
+      infoFooter: Data$dMaybe.Nothing,
+      infoHeader: Data$dMaybe.Nothing,
+      infoParser: Options$dApplicative$dInternal$dUtils.apApplyFlipped(Options$dApplicative$dTypes.parserApply)(commandParser)(Options$dApplicative$dExtra.helper),
+      infoPolicy: Options$dApplicative$dTypes.Intersperse,
+      infoProgDesc: Data$dMaybe.Nothing
+    }));
+    return () => {
+      const a$p = Options$dApplicative$dExtra.getArgs();
+      return Options$dApplicative$dExtra.handleParseResult(Options$dApplicative$dExtra.execParserPure(Options$dApplicative$dBuilder.defaultPrefs)($0)(a$p))();
+    };
+  })()))(dispatchCommand));
+  return () => {$0();};
+})();
+const between = p1 => p2 => f => s => {
+  const $0 = Data$dString$dCodeUnits.stripPrefix(p1)(s);
+  const v = (() => {
+    if ($0.tag === "Just") { return Data$dString$dCodeUnits.stripSuffix(p2)($0._1); }
+    if ($0.tag === "Nothing") { return Data$dMaybe.Nothing; }
+    $runtime.fail();
+  })();
+  if (v.tag === "Just") { return f(v._1); }
+  if (v.tag === "Nothing") {
+    return Data$dEither.$Either("Left", "Expected (Pattern " + Data$dShow.showStringImpl(p1) + ")...(Pattern " + Data$dShow.showStringImpl(p2) + ") but got ...");
+  }
+  $runtime.fail();
+};
+const parseImports$p = open => close => between(open)(close)(s => Data$dEither.$Either(
+  "Right",
+  Data$dFunctor.arrayMap(Data$dString$dCommon.trim)(Data$dArray.filterImpl(x => x !== "", Data$dString$dCommon.split(",")(s)))
+));
+const parsePair = /* #__PURE__ */ between("(")(")")(s => {
+  const v = Data$dString$dCommon.split(",")(s);
+  if (v.length === 2) { return Data$dEither.$Either("Right", Data$dTuple.$Tuple(Data$dString$dCommon.trim(v[0]), Data$dString$dCommon.trim(v[1]))); }
+  return Data$dEither.$Either("Left", "Expected a pair but got " + s);
+});
+export {
+  $Command,
+  $EvalArgs,
+  EvalArgs,
+  Evaluate,
+  Parse_,
+  between,
+  bind,
+  callback,
+  commandParser,
+  commands,
+  dispatchCommand,
+  evaluate,
+  fluidLibraryPath,
+  graphEval,
+  loadFile,
+  loadFileNodeT,
+  main,
+  monadAffNodeT,
+  monadErrorErrorNodeT,
+  monadReaderFileCxtNodeT,
+  parse,
+  parseEvaluate,
+  parseImports$p,
+  parseLocal,
+  parsePair,
+  prepConfig
+};

package/output-es/Foreign/foreign.js

@@ -0,0 +1,19 @@
+export function typeOf(value) {
+  return typeof value;
+}
+
+export function tagOf(value) {
+  return Object.prototype.toString.call(value).slice(8, -1);
+}
+
+export function isNull(value) {
+  return value === null;
+}
+
+export function isUndefined(value) {
+  return value === undefined;
+}
+
+export const isArray = Array.isArray || function (value) {
+  return Object.prototype.toString.call(value) === "[object Array]";
+};

package/output-es/Foreign/index.js

@@ -0,0 +1,171 @@
+// | This module defines types and functions for working with _foreign_
+// | data.
+// |
+// | `ExceptT (NonEmptyList ForeignError) m` is used in this library
+// | to encode possible failures when dealing with foreign data.
+// |
+// | The `Alt` instance for `ExceptT` allows us to accumulate errors,
+// | unlike `Either`, which preserves only the last error.
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dExcept$dTrans from "../Control.Monad.Except.Trans/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dInt from "../Data.Int/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNonEmpty from "../Data.NonEmpty/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import {isArray, isNull, isUndefined, tagOf, typeOf} from "./foreign.js";
+const $ForeignError = (tag, _1, _2) => ({tag, _1, _2});
+const ForeignError = value0 => $ForeignError("ForeignError", value0);
+const TypeMismatch = value0 => value1 => $ForeignError("TypeMismatch", value0, value1);
+const ErrorAtIndex = value0 => value1 => $ForeignError("ErrorAtIndex", value0, value1);
+const ErrorAtProperty = value0 => value1 => $ForeignError("ErrorAtProperty", value0, value1);
+const unsafeToForeign = Unsafe$dCoerce.unsafeCoerce;
+const unsafeFromForeign = Unsafe$dCoerce.unsafeCoerce;
+const showForeignError = {
+  show: v => {
+    if (v.tag === "ForeignError") { return "(ForeignError " + Data$dShow.showStringImpl(v._1) + ")"; }
+    if (v.tag === "ErrorAtIndex") { return "(ErrorAtIndex " + Data$dShow.showIntImpl(v._1) + " " + showForeignError.show(v._2) + ")"; }
+    if (v.tag === "ErrorAtProperty") { return "(ErrorAtProperty " + Data$dShow.showStringImpl(v._1) + " " + showForeignError.show(v._2) + ")"; }
+    if (v.tag === "TypeMismatch") { return "(TypeMismatch " + Data$dShow.showStringImpl(v._1) + " " + Data$dShow.showStringImpl(v._2) + ")"; }
+    $runtime.fail();
+  }
+};
+const renderForeignError = v => {
+  if (v.tag === "ForeignError") { return v._1; }
+  if (v.tag === "ErrorAtIndex") { return "Error at array index " + Data$dShow.showIntImpl(v._1) + ": " + renderForeignError(v._2); }
+  if (v.tag === "ErrorAtProperty") { return "Error at property " + Data$dShow.showStringImpl(v._1) + ": " + renderForeignError(v._2); }
+  if (v.tag === "TypeMismatch") { return "Type mismatch: expected " + v._1 + ", found " + v._2; }
+  $runtime.fail();
+};
+const readUndefined = dictMonad => {
+  const $0 = Control$dMonad$dExcept$dTrans.applicativeExceptT(dictMonad);
+  return value => {
+    if (isUndefined(value)) { return $0.pure(Data$dMaybe.Nothing); }
+    return $0.pure(Data$dMaybe.$Maybe("Just", value));
+  };
+};
+const readNullOrUndefined = dictMonad => {
+  const $0 = Control$dMonad$dExcept$dTrans.applicativeExceptT(dictMonad);
+  return value => {
+    if (isNull(value) || isUndefined(value)) { return $0.pure(Data$dMaybe.Nothing); }
+    return $0.pure(Data$dMaybe.$Maybe("Just", value));
+  };
+};
+const readNull = dictMonad => {
+  const $0 = Control$dMonad$dExcept$dTrans.applicativeExceptT(dictMonad);
+  return value => {
+    if (isNull(value)) { return $0.pure(Data$dMaybe.Nothing); }
+    return $0.pure(Data$dMaybe.$Maybe("Just", value));
+  };
+};
+const fail = dictMonad => x => Control$dMonad$dExcept$dTrans.monadThrowExceptT(dictMonad).throwError(Data$dNonEmpty.$NonEmpty(x, Data$dList$dTypes.Nil));
+const readArray = dictMonad => value => {
+  if (isArray(value)) { return Control$dMonad$dExcept$dTrans.applicativeExceptT(dictMonad).pure(value); }
+  return Control$dMonad$dExcept$dTrans.monadThrowExceptT(dictMonad).throwError(Data$dNonEmpty.$NonEmpty($ForeignError("TypeMismatch", "array", tagOf(value)), Data$dList$dTypes.Nil));
+};
+const unsafeReadTagged = dictMonad => tag => value => {
+  if (tagOf(value) === tag) { return Control$dMonad$dExcept$dTrans.applicativeExceptT(dictMonad).pure(value); }
+  return Control$dMonad$dExcept$dTrans.monadThrowExceptT(dictMonad).throwError(Data$dNonEmpty.$NonEmpty($ForeignError("TypeMismatch", tag, tagOf(value)), Data$dList$dTypes.Nil));
+};
+const readBoolean = dictMonad => unsafeReadTagged(dictMonad)("Boolean");
+const readNumber = dictMonad => unsafeReadTagged(dictMonad)("Number");
+const readInt = dictMonad => value => {
+  const error = Data$dEither.$Either("Left", Data$dNonEmpty.$NonEmpty($ForeignError("TypeMismatch", "Int", tagOf(value)), Data$dList$dTypes.Nil));
+  return dictMonad.Bind1().Apply0().Functor0().map(v2 => {
+    if (v2.tag === "Left") { return error; }
+    if (v2.tag === "Right") {
+      const $0 = Data$dInt.fromNumber(v2._1);
+      if ($0.tag === "Nothing") { return error; }
+      if ($0.tag === "Just") { return Data$dEither.$Either("Right", $0._1); }
+    }
+    $runtime.fail();
+  })(unsafeReadTagged(dictMonad)("Number")(value));
+};
+const readString = dictMonad => unsafeReadTagged(dictMonad)("String");
+const readChar = dictMonad => value => {
+  const error = Data$dEither.$Either("Left", Data$dNonEmpty.$NonEmpty($ForeignError("TypeMismatch", "Char", tagOf(value)), Data$dList$dTypes.Nil));
+  return dictMonad.Bind1().Apply0().Functor0().map(v2 => {
+    if (v2.tag === "Left") { return error; }
+    if (v2.tag === "Right") {
+      const $0 = Data$dString$dCodeUnits.toChar(v2._1);
+      if ($0.tag === "Nothing") { return error; }
+      if ($0.tag === "Just") { return Data$dEither.$Either("Right", $0._1); }
+    }
+    $runtime.fail();
+  })(unsafeReadTagged(dictMonad)("String")(value));
+};
+const eqForeignError = {
+  eq: x => y => {
+    if (x.tag === "ForeignError") { return y.tag === "ForeignError" && x._1 === y._1; }
+    if (x.tag === "TypeMismatch") { return y.tag === "TypeMismatch" && x._1 === y._1 && x._2 === y._2; }
+    if (x.tag === "ErrorAtIndex") { return y.tag === "ErrorAtIndex" && x._1 === y._1 && eqForeignError.eq(x._2)(y._2); }
+    return x.tag === "ErrorAtProperty" && y.tag === "ErrorAtProperty" && x._1 === y._1 && eqForeignError.eq(x._2)(y._2);
+  }
+};
+const ordForeignError = {
+  compare: x => y => {
+    if (x.tag === "ForeignError") {
+      if (y.tag === "ForeignError") { return Data$dOrd.ordString.compare(x._1)(y._1); }
+      return Data$dOrdering.LT;
+    }
+    if (y.tag === "ForeignError") { return Data$dOrdering.GT; }
+    if (x.tag === "TypeMismatch") {
+      if (y.tag === "TypeMismatch") {
+        const v = Data$dOrd.ordString.compare(x._1)(y._1);
+        if (v === "LT") { return Data$dOrdering.LT; }
+        if (v === "GT") { return Data$dOrdering.GT; }
+        return Data$dOrd.ordString.compare(x._2)(y._2);
+      }
+      return Data$dOrdering.LT;
+    }
+    if (y.tag === "TypeMismatch") { return Data$dOrdering.GT; }
+    if (x.tag === "ErrorAtIndex") {
+      if (y.tag === "ErrorAtIndex") {
+        const v = Data$dOrd.ordInt.compare(x._1)(y._1);
+        if (v === "LT") { return Data$dOrdering.LT; }
+        if (v === "GT") { return Data$dOrdering.GT; }
+        return ordForeignError.compare(x._2)(y._2);
+      }
+      return Data$dOrdering.LT;
+    }
+    if (y.tag === "ErrorAtIndex") { return Data$dOrdering.GT; }
+    if (x.tag === "ErrorAtProperty" && y.tag === "ErrorAtProperty") {
+      const v = Data$dOrd.ordString.compare(x._1)(y._1);
+      if (v === "LT") { return Data$dOrdering.LT; }
+      if (v === "GT") { return Data$dOrdering.GT; }
+      return ordForeignError.compare(x._2)(y._2);
+    }
+    $runtime.fail();
+  },
+  Eq0: () => eqForeignError
+};
+export {
+  $ForeignError,
+  ErrorAtIndex,
+  ErrorAtProperty,
+  ForeignError,
+  TypeMismatch,
+  eqForeignError,
+  fail,
+  ordForeignError,
+  readArray,
+  readBoolean,
+  readChar,
+  readInt,
+  readNull,
+  readNullOrUndefined,
+  readNumber,
+  readString,
+  readUndefined,
+  renderForeignError,
+  showForeignError,
+  unsafeFromForeign,
+  unsafeReadTagged,
+  unsafeToForeign
+};
+export * from "./foreign.js";

package/output-es/Foreign.Index/foreign.js

@@ -0,0 +1,11 @@
+export function unsafeReadPropImpl(f, s, key, value) {
+  return value == null ? f : s(value[key]);
+}
+
+export function unsafeHasOwnProperty(prop, value) {
+  return Object.prototype.hasOwnProperty.call(value, prop);
+}
+
+export function unsafeHasProperty(prop, value) {
+  return prop in value;
+}

package/output-es/Foreign.Index/index.js

@@ -0,0 +1,80 @@
+// | This module defines a type class for types which act like
+// | _property indices_.
+import * as Control$dMonad$dExcept$dTrans from "../Control.Monad.Except.Trans/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dNonEmpty from "../Data.NonEmpty/index.js";
+import * as Foreign from "../Foreign/index.js";
+import {unsafeHasOwnProperty, unsafeHasProperty, unsafeReadPropImpl} from "./foreign.js";
+const unsafeReadProp = dictMonad => {
+  const pure = Control$dMonad$dExcept$dTrans.applicativeExceptT(dictMonad).pure;
+  return k => value => unsafeReadPropImpl(
+    Control$dMonad$dExcept$dTrans.monadThrowExceptT(dictMonad).throwError(Data$dNonEmpty.$NonEmpty(
+      Foreign.$ForeignError("TypeMismatch", "object", Foreign.typeOf(value)),
+      Data$dList$dTypes.Nil
+    )),
+    pure,
+    k,
+    value
+  );
+};
+const readProp = dictMonad => unsafeReadProp(dictMonad);
+const readIndex = dictMonad => unsafeReadProp(dictMonad);
+const ix = dict => dict.ix;
+const index = dict => dict.index;
+const indexableExceptT = dictMonad => {
+  const $0 = Control$dMonad$dExcept$dTrans.bindExceptT(dictMonad);
+  return {ix: dictIndex => f => i => $0.bind(f)(a => dictIndex.index(a)(i))};
+};
+const indexableForeign = dictMonad => ({ix: dictIndex => dictIndex.index});
+const hasPropertyImpl = v => v1 => {
+  if (Foreign.isNull(v1)) { return false; }
+  if (Foreign.isUndefined(v1)) { return false; }
+  return (Foreign.typeOf(v1) === "object" || Foreign.typeOf(v1) === "function") && unsafeHasProperty(v, v1);
+};
+const hasProperty = dict => dict.hasProperty;
+const hasOwnPropertyImpl = v => v1 => {
+  if (Foreign.isNull(v1)) { return false; }
+  if (Foreign.isUndefined(v1)) { return false; }
+  return (Foreign.typeOf(v1) === "object" || Foreign.typeOf(v1) === "function") && unsafeHasOwnProperty(v, v1);
+};
+const indexInt = dictMonad => (
+  {
+    index: (() => {
+      const $0 = unsafeReadProp(dictMonad);
+      return b => a => $0(a)(b);
+    })(),
+    hasProperty: hasPropertyImpl,
+    hasOwnProperty: hasOwnPropertyImpl,
+    errorAt: Foreign.ErrorAtIndex
+  }
+);
+const indexString = dictMonad => (
+  {
+    index: (() => {
+      const $0 = unsafeReadProp(dictMonad);
+      return b => a => $0(a)(b);
+    })(),
+    hasProperty: hasPropertyImpl,
+    hasOwnProperty: hasOwnPropertyImpl,
+    errorAt: Foreign.ErrorAtProperty
+  }
+);
+const hasOwnProperty = dict => dict.hasOwnProperty;
+const errorAt = dict => dict.errorAt;
+export {
+  errorAt,
+  hasOwnProperty,
+  hasOwnPropertyImpl,
+  hasProperty,
+  hasPropertyImpl,
+  index,
+  indexInt,
+  indexString,
+  indexableExceptT,
+  indexableForeign,
+  ix,
+  readIndex,
+  readProp,
+  unsafeReadProp
+};
+export * from "./foreign.js";

package/output-es/Foreign.Keys/foreign.js

@@ -0,0 +1,9 @@
+export const unsafeKeys = Object.keys || function (value) {
+  var keys = [];
+  for (var prop in value) {
+    if (Object.prototype.hasOwnProperty.call(value, prop)) {
+      keys.push(prop);
+    }
+  }
+  return keys;
+};