@explorable-viz/fluid 0.12.3 → 0.12.4

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

@@ -0,0 +1,317 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dBind from "../Control.Bind/index.js";
+import * as Control$dMonad$dRec$dClass from "../Control.Monad.Rec.Class/index.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dArray$dNonEmpty$dInternal from "../Data.Array.NonEmpty.Internal/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dFunctorWithIndex from "../Data.FunctorWithIndex/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$dSemigroup$dFoldable from "../Data.Semigroup.Foldable/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const max = x => y => {
+  const v = Data$dOrd.ordInt.compare(x)(y);
+  if (v === "LT") { return y; }
+  if (v === "EQ") { return x; }
+  if (v === "GT") { return x; }
+  $runtime.fail();
+};
+const intercalate1 = dictSemigroup => {
+  const foldMap12 = Data$dArray$dNonEmpty$dInternal.foldable1NonEmptyArray.foldMap1({append: v => v1 => j => dictSemigroup.append(v(j))(dictSemigroup.append(j)(v1(j)))});
+  return a => foldable => foldMap12(x => v => x)(foldable)(a);
+};
+const transpose = x => Data$dArray.transpose(x);
+const toArray = v => v;
+const unionBy$p = eq => xs => x => Data$dArray.unionBy(eq)(xs)(x);
+const union$p = dictEq => unionBy$p(dictEq.eq);
+const unionBy = eq => xs => x => Data$dArray.unionBy(eq)(xs)(x);
+const union = dictEq => unionBy(dictEq.eq);
+const unzip = x => {
+  const $0 = Data$dArray.unzip(x);
+  return Data$dTuple.$Tuple($0._1, $0._2);
+};
+const updateAt = i => x => x$1 => Data$dArray._updateAt(Data$dMaybe.Just, Data$dMaybe.Nothing, i, x, x$1);
+const zip = xs => ys => Data$dArray.zipWithImpl(Data$dTuple.Tuple, xs, ys);
+const zipWith = f => xs => ys => Data$dArray.zipWithImpl(f, xs, ys);
+const zipWithA = dictApplicative => Data$dArray.zipWithA(dictApplicative);
+const splitAt = i => xs => Data$dArray.splitAt(i)(xs);
+const some = dictAlternative => dictLazy => x => Data$dArray.some(dictAlternative)(dictLazy)(x);
+const snoc$p = xs => x => Data$dArray.snoc(xs)(x);
+const snoc = xs => x => Data$dArray.snoc(xs)(x);
+const singleton = x => [x];
+const replicate = i => x => Data$dArray.replicateImpl(max(1)(i), x);
+const range = x => y => Data$dArray.rangeImpl(x, y);
+const prependArray = xs => ys => [...xs, ...ys];
+const modifyAt = i => f => x => Data$dArray.modifyAt(i)(f)(x);
+const intersectBy$p = eq => xs => Data$dArray.intersectBy(eq)(xs);
+const intersectBy = eq => xs => x => Data$dArray.intersectBy(eq)(xs)(x);
+const intersect$p = dictEq => intersectBy$p(dictEq.eq);
+const intersect = dictEq => intersectBy(dictEq.eq);
+const intercalate = dictSemigroup => intercalate1(dictSemigroup);
+const insertAt = i => x => x$1 => Data$dArray._insertAt(Data$dMaybe.Just, Data$dMaybe.Nothing, i, x, x$1);
+const fromFoldable1 = dictFoldable1 => {
+  const $0 = dictFoldable1.Foldable0().foldr;
+  return x => Data$dArray.fromFoldableImpl($0, x);
+};
+const fromArray = xs => {
+  if (xs.length > 0) { return Data$dMaybe.$Maybe("Just", xs); }
+  return Data$dMaybe.Nothing;
+};
+const fromFoldable = dictFoldable => {
+  const $0 = dictFoldable.foldr;
+  return x => {
+    const $1 = Data$dArray.fromFoldableImpl($0, x);
+    if ($1.length > 0) { return Data$dMaybe.$Maybe("Just", $1); }
+    return Data$dMaybe.Nothing;
+  };
+};
+const transpose$p = x => {
+  const $0 = Data$dArray.transpose(x);
+  if ($0.length > 0) { return Data$dMaybe.$Maybe("Just", $0); }
+  return Data$dMaybe.Nothing;
+};
+const foldr1 = /* #__PURE__ */ (() => Data$dArray$dNonEmpty$dInternal.foldable1NonEmptyArray.foldr1)();
+const foldl1 = /* #__PURE__ */ (() => Data$dArray$dNonEmpty$dInternal.foldable1NonEmptyArray.foldl1)();
+const foldMap1 = dictSemigroup => Data$dArray$dNonEmpty$dInternal.foldable1NonEmptyArray.foldMap1(dictSemigroup);
+const fold1 = dictSemigroup => Data$dArray$dNonEmpty$dInternal.foldable1NonEmptyArray.foldMap1(dictSemigroup)(Data$dSemigroup$dFoldable.identity);
+const difference$p = dictEq => Data$dFoldable.foldrArray(Data$dArray.delete(dictEq));
+const cons$p = x => xs => [x, ...xs];
+const fromNonEmpty = v => [v._1, ...v._2];
+const concatMap = b => a => Control$dBind.arrayBind(a)(b);
+const concat = /* #__PURE__ */ (() => {
+  const $0 = Data$dFunctor.arrayMap(toArray);
+  return x => Data$dArray.concat($0(x));
+})();
+const appendArray = xs => ys => [...xs, ...ys];
+const alterAt = i => f => x => Data$dArray.alterAt(i)(f)(x);
+const head = x => {
+  if (0 < x.length) { return x[0]; }
+  $runtime.fail();
+};
+const init = x => {
+  if (x.length === 0) { $runtime.fail(); }
+  return Data$dArray.sliceImpl(0, x.length - 1 | 0, x);
+};
+const last = x => {
+  const $0 = x.length - 1 | 0;
+  if ($0 >= 0 && $0 < x.length) { return x[$0]; }
+  $runtime.fail();
+};
+const tail = x => {
+  const $0 = Data$dArray.unconsImpl(v => Data$dMaybe.Nothing, v => xs => Data$dMaybe.$Maybe("Just", xs), x);
+  if ($0.tag === "Just") { return $0._1; }
+  $runtime.fail();
+};
+const uncons = x => {
+  const $0 = Data$dArray.unconsImpl(v => Data$dMaybe.Nothing, x$1 => xs => Data$dMaybe.$Maybe("Just", {head: x$1, tail: xs}), x);
+  if ($0.tag === "Just") { return $0._1; }
+  $runtime.fail();
+};
+const toNonEmpty = x => {
+  const $0 = uncons(x);
+  return Data$dNonEmpty.$NonEmpty($0.head, $0.tail);
+};
+const unsnoc = x => {
+  const $0 = Data$dArray.unsnoc(x);
+  if ($0.tag === "Just") { return $0._1; }
+  $runtime.fail();
+};
+const all = p => x => Data$dArray.allImpl(p, x);
+const any = p => x => Data$dArray.anyImpl(p, x);
+const catMaybes = x => Data$dArray.mapMaybe(x$1 => x$1)(x);
+const $$delete = dictEq => x => x$1 => Data$dArray.deleteBy(dictEq.eq)(x)(x$1);
+const deleteAt = i => x => Data$dArray._deleteAt(Data$dMaybe.Just, Data$dMaybe.Nothing, i, x);
+const deleteBy = f => x => x$1 => Data$dArray.deleteBy(f)(x)(x$1);
+const difference = dictEq => Data$dFoldable.foldrArray(Data$dArray.delete(dictEq));
+const drop = i => x => {
+  if (i < 1) { return x; }
+  return Data$dArray.sliceImpl(i, x.length, x);
+};
+const dropEnd = i => x => {
+  const $0 = x.length - i | 0;
+  if ($0 < 1) { return []; }
+  return Data$dArray.sliceImpl(0, $0, x);
+};
+const dropWhile = f => x => Data$dArray.span(f)(x).rest;
+const elem = dictEq => x => x$1 => Data$dArray.elem(dictEq)(x)(x$1);
+const elemIndex = dictEq => x => x$1 => Data$dArray.findIndexImpl(Data$dMaybe.Just, Data$dMaybe.Nothing, v => dictEq.eq(v)(x), x$1);
+const elemLastIndex = dictEq => x => x$1 => Data$dArray.findLastIndexImpl(Data$dMaybe.Just, Data$dMaybe.Nothing, v => dictEq.eq(v)(x), x$1);
+const filter = f => x => Data$dArray.filterImpl(f, x);
+const filterA = dictApplicative => Data$dArray.filterA(dictApplicative);
+const find = p => x => Data$dArray.find(p)(x);
+const findIndex = p => x => Data$dArray.findIndexImpl(Data$dMaybe.Just, Data$dMaybe.Nothing, p, x);
+const findLastIndex = x => x$1 => Data$dArray.findLastIndexImpl(Data$dMaybe.Just, Data$dMaybe.Nothing, x, x$1);
+const findMap = p => x => Data$dArray.findMapImpl(Data$dMaybe.Nothing, Data$dMaybe.isJust, p, x);
+const foldM = dictMonad => f => acc => x => Data$dArray.foldM(dictMonad)(f)(acc)(x);
+const foldRecM = dictMonadRec => {
+  const Monad0 = dictMonadRec.Monad0();
+  const $0 = Monad0.Applicative0();
+  return f => acc => array => dictMonadRec.tailRecM(o => {
+    if (o.b >= array.length) { return $0.pure(Control$dMonad$dRec$dClass.$Step("Done", o.a)); }
+    return Monad0.Bind1().bind(f(o.a)(array[o.b]))(res$p => $0.pure(Control$dMonad$dRec$dClass.$Step("Loop", {a: res$p, b: o.b + 1 | 0})));
+  })({a: acc, b: 0});
+};
+const index = x => $0 => {
+  if ($0 >= 0 && $0 < x.length) { return Data$dMaybe.$Maybe("Just", x[$0]); }
+  return Data$dMaybe.Nothing;
+};
+const length = x => x.length;
+const mapMaybe = f => x => Data$dArray.mapMaybe(f)(x);
+const notElem = dictEq => x => x$1 => Data$dArray.notElem(dictEq)(x)(x$1);
+const partition = f => x => Data$dArray.partitionImpl(f, x);
+const slice = start => end => x => Data$dArray.sliceImpl(start, end, x);
+const span = f => x => Data$dArray.span(f)(x);
+const take = i => x => {
+  if (i < 1) { return []; }
+  return Data$dArray.sliceImpl(0, i, x);
+};
+const takeEnd = i => x => Data$dArray.takeEnd(i)(x);
+const takeWhile = f => x => Data$dArray.span(f)(x).init;
+const toUnfoldable = dictUnfoldable => x => {
+  const len = x.length;
+  return dictUnfoldable.unfoldr(i => {
+    if (i < len) { return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple(x[i], i + 1 | 0)); }
+    return Data$dMaybe.Nothing;
+  })(0);
+};
+const cons = x => x$1 => [x, ...x$1];
+const group = dictEq => {
+  const eq2 = dictEq.eq;
+  return x => Data$dArray.groupBy(eq2)(x);
+};
+const groupAllBy = op => Data$dArray.groupAllBy(op);
+const groupAll = dictOrd => Data$dArray.groupAllBy(dictOrd.compare);
+const groupBy = op => x => Data$dArray.groupBy(op)(x);
+const insert = dictOrd => x => x$1 => Data$dArray.insertBy(dictOrd.compare)(x)(x$1);
+const insertBy = f => x => x$1 => Data$dArray.insertBy(f)(x)(x$1);
+const intersperse = x => x$1 => Data$dArray.intersperse(x)(x$1);
+const mapWithIndex = f => Data$dFunctorWithIndex.mapWithIndexArray(f);
+const modifyAtIndices = dictFoldable => Data$dArray.modifyAtIndices(dictFoldable);
+const nub = dictOrd => x => Data$dArray.nubBy(dictOrd.compare)(x);
+const nubBy = f => x => Data$dArray.nubBy(f)(x);
+const nubByEq = f => x => Data$dArray.nubByEq(f)(x);
+const nubEq = dictEq => x => Data$dArray.nubByEq(dictEq.eq)(x);
+const reverse = x => Data$dArray.reverse(x);
+const scanl = f => x => x$1 => Data$dArray.scanlImpl(f, x, x$1);
+const scanr = f => x => x$1 => Data$dArray.scanrImpl(f, x, x$1);
+const sort = dictOrd => {
+  const compare = dictOrd.compare;
+  return x => Data$dArray.sortBy(compare)(x);
+};
+const sortBy = f => x => Data$dArray.sortBy(f)(x);
+const sortWith = dictOrd => f => x => Data$dArray.sortWith(dictOrd)(f)(x);
+const updateAtIndices = dictFoldable => Data$dArray.updateAtIndices(dictFoldable);
+const unsafeIndex = () => x => $0 => x[$0];
+const toUnfoldable1 = dictUnfoldable1 => xs => {
+  const len = xs.length;
+  return dictUnfoldable1.unfoldr1(i => Data$dTuple.$Tuple(xs[i], i < (len - 1 | 0) ? Data$dMaybe.$Maybe("Just", i + 1 | 0) : Data$dMaybe.Nothing))(0);
+};
+export {
+  all,
+  alterAt,
+  any,
+  appendArray,
+  catMaybes,
+  concat,
+  concatMap,
+  cons,
+  cons$p,
+  $$delete as delete,
+  deleteAt,
+  deleteBy,
+  difference,
+  difference$p,
+  drop,
+  dropEnd,
+  dropWhile,
+  elem,
+  elemIndex,
+  elemLastIndex,
+  filter,
+  filterA,
+  find,
+  findIndex,
+  findLastIndex,
+  findMap,
+  fold1,
+  foldM,
+  foldMap1,
+  foldRecM,
+  foldl1,
+  foldr1,
+  fromArray,
+  fromFoldable,
+  fromFoldable1,
+  fromNonEmpty,
+  group,
+  groupAll,
+  groupAllBy,
+  groupBy,
+  head,
+  index,
+  init,
+  insert,
+  insertAt,
+  insertBy,
+  intercalate,
+  intercalate1,
+  intersect,
+  intersect$p,
+  intersectBy,
+  intersectBy$p,
+  intersperse,
+  last,
+  length,
+  mapMaybe,
+  mapWithIndex,
+  max,
+  modifyAt,
+  modifyAtIndices,
+  notElem,
+  nub,
+  nubBy,
+  nubByEq,
+  nubEq,
+  partition,
+  prependArray,
+  range,
+  replicate,
+  reverse,
+  scanl,
+  scanr,
+  singleton,
+  slice,
+  snoc,
+  snoc$p,
+  some,
+  sort,
+  sortBy,
+  sortWith,
+  span,
+  splitAt,
+  tail,
+  take,
+  takeEnd,
+  takeWhile,
+  toArray,
+  toNonEmpty,
+  toUnfoldable,
+  toUnfoldable1,
+  transpose,
+  transpose$p,
+  uncons,
+  union,
+  union$p,
+  unionBy,
+  unionBy$p,
+  unsafeIndex,
+  unsnoc,
+  unzip,
+  updateAt,
+  updateAtIndices,
+  zip,
+  zipWith,
+  zipWithA
+};

package/output-es/Data.Array.NonEmpty.Internal/foreign.js

@@ -0,0 +1,77 @@
+export const foldr1Impl = function (f, xs) {
+  var acc = xs[xs.length - 1];
+  for (var i = xs.length - 2; i >= 0; i--) {
+    acc = f(xs[i])(acc);
+  }
+  return acc;
+};
+
+export const foldl1Impl = function (f, xs) {
+  var acc = xs[0];
+  var len = xs.length;
+  for (var i = 1; i < len; i++) {
+    acc = f(acc)(xs[i]);
+  }
+  return acc;
+};
+
+export const traverse1Impl = function () {
+  function Cont(fn) {
+    this.fn = fn;
+  }
+
+  var emptyList = {};
+
+  var ConsCell = function (head, tail) {
+    this.head = head;
+    this.tail = tail;
+  };
+
+  function finalCell(head) {
+    return new ConsCell(head, emptyList);
+  }
+
+  function consList(x) {
+    return function (xs) {
+      return new ConsCell(x, xs);
+    };
+  }
+
+  function listToArray(list) {
+    var arr = [];
+    var xs = list;
+    while (xs !== emptyList) {
+      arr.push(xs.head);
+      xs = xs.tail;
+    }
+    return arr;
+  }
+
+  return function (apply, map, f) {
+    var buildFrom = function (x, ys) {
+      return apply(map(consList)(f(x)))(ys);
+    };
+
+    var go = function (acc, currentLen, xs) {
+      if (currentLen === 0) {
+        return acc;
+      } else {
+        var last = xs[currentLen - 1];
+        return new Cont(function () {
+          var built = go(buildFrom(last, acc), currentLen - 1, xs);
+          return built;
+        });
+      }
+    };
+
+    return function (array) {
+      var acc = map(finalCell)(f(array[array.length - 1]));
+      var result = go(acc, array.length - 1, array);
+      while (result instanceof Cont) {
+        result = result.fn();
+      }
+
+      return map(listToArray)(result);
+    };
+  };
+}();

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

@@ -0,0 +1,90 @@
+// | This module exports the `NonEmptyArray` constructor.
+// |
+// | It is **NOT** intended for public use and is **NOT** versioned.
+// |
+// | Its content may change **in any way**, **at any time** and
+// | **without notice**.
+import * as Control$dAlt from "../Control.Alt/index.js";
+import * as Control$dApplicative from "../Control.Applicative/index.js";
+import * as Control$dApply from "../Control.Apply/index.js";
+import * as Control$dBind from "../Control.Bind/index.js";
+import * as Control$dMonad from "../Control.Monad/index.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dFoldableWithIndex from "../Data.FoldableWithIndex/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dFunctorWithIndex from "../Data.FunctorWithIndex/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dSemigroup from "../Data.Semigroup/index.js";
+import * as Data$dSemigroup$dTraversable from "../Data.Semigroup.Traversable/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dTraversable from "../Data.Traversable/index.js";
+import * as Data$dTraversableWithIndex from "../Data.TraversableWithIndex/index.js";
+import * as Data$dUnfoldable1 from "../Data.Unfoldable1/index.js";
+import {foldl1Impl, foldr1Impl, traverse1Impl} from "./foreign.js";
+const NonEmptyArray = x => x;
+const unfoldable1NonEmptyArray = Data$dUnfoldable1.unfoldable1Array;
+const traversableWithIndexNonEmptyArray = Data$dTraversableWithIndex.traversableWithIndexArray;
+const traversableNonEmptyArray = Data$dTraversable.traversableArray;
+const showNonEmptyArray = dictShow => ({show: v => "(NonEmptyArray " + Data$dShow.showArrayImpl(dictShow.show)(v) + ")"});
+const semigroupNonEmptyArray = Data$dSemigroup.semigroupArray;
+const ordNonEmptyArray = dictOrd => Data$dOrd.ordArray(dictOrd);
+const ord1NonEmptyArray = Data$dOrd.ord1Array;
+const monadNonEmptyArray = Control$dMonad.monadArray;
+const functorWithIndexNonEmptyArray = Data$dFunctorWithIndex.functorWithIndexArray;
+const functorNonEmptyArray = Data$dFunctor.functorArray;
+const foldableWithIndexNonEmptyArray = Data$dFoldableWithIndex.foldableWithIndexArray;
+const foldableNonEmptyArray = Data$dFoldable.foldableArray;
+const foldable1NonEmptyArray = {
+  foldMap1: dictSemigroup => {
+    const append = dictSemigroup.append;
+    return f => {
+      const $0 = Data$dFunctor.arrayMap(f);
+      const $1 = foldable1NonEmptyArray.foldl1(append);
+      return x => $1($0(x));
+    };
+  },
+  foldr1: $0 => $1 => foldr1Impl($0, $1),
+  foldl1: $0 => $1 => foldl1Impl($0, $1),
+  Foldable0: () => Data$dFoldable.foldableArray
+};
+const traversable1NonEmptyArray = {
+  traverse1: dictApply => {
+    const apply = dictApply.apply;
+    const map = dictApply.Functor0().map;
+    return f => traverse1Impl(apply, map, f);
+  },
+  sequence1: dictApply => traversable1NonEmptyArray.traverse1(dictApply)(Data$dSemigroup$dTraversable.identity),
+  Foldable10: () => foldable1NonEmptyArray,
+  Traversable1: () => Data$dTraversable.traversableArray
+};
+const eqNonEmptyArray = dictEq => ({eq: Data$dEq.eqArrayImpl(dictEq.eq)});
+const eq1NonEmptyArray = Data$dEq.eq1Array;
+const bindNonEmptyArray = Control$dBind.bindArray;
+const applyNonEmptyArray = Control$dApply.applyArray;
+const applicativeNonEmptyArray = Control$dApplicative.applicativeArray;
+const altNonEmptyArray = Control$dAlt.altArray;
+export {
+  NonEmptyArray,
+  altNonEmptyArray,
+  applicativeNonEmptyArray,
+  applyNonEmptyArray,
+  bindNonEmptyArray,
+  eq1NonEmptyArray,
+  eqNonEmptyArray,
+  foldable1NonEmptyArray,
+  foldableNonEmptyArray,
+  foldableWithIndexNonEmptyArray,
+  functorNonEmptyArray,
+  functorWithIndexNonEmptyArray,
+  monadNonEmptyArray,
+  ord1NonEmptyArray,
+  ordNonEmptyArray,
+  semigroupNonEmptyArray,
+  showNonEmptyArray,
+  traversable1NonEmptyArray,
+  traversableNonEmptyArray,
+  traversableWithIndexNonEmptyArray,
+  unfoldable1NonEmptyArray
+};
+export * from "./foreign.js";

package/output-es/Data.Array.Partial/index.js

@@ -0,0 +1,7 @@
+// | Partial helper functions for working with immutable arrays.
+import * as Data$dArray from "../Data.Array/index.js";
+const tail = () => xs => Data$dArray.sliceImpl(1, xs.length, xs);
+const last = () => xs => xs[xs.length - 1 | 0];
+const init = () => xs => Data$dArray.sliceImpl(0, xs.length - 1 | 0, xs);
+const head = () => xs => xs[0];
+export {head, init, last, tail};

package/output-es/Data.Array.ST/foreign.js

@@ -0,0 +1,107 @@
+function newSTArray() {
+  return [];
+}
+export { newSTArray as new };
+
+export const peekImpl = function (just, nothing, i, xs) {
+  return i >= 0 && i < xs.length ? just(xs[i]) : nothing;
+};
+
+export const pokeImpl = function (i, a, xs) {
+  var ret = i >= 0 && i < xs.length;
+  if (ret) xs[i] = a;
+  return ret;
+};
+
+export const lengthImpl = function (xs) {
+  return xs.length;
+};
+
+export const popImpl = function (just, nothing, xs) {
+  return xs.length > 0 ? just(xs.pop()) : nothing;
+};
+
+export const pushAllImpl = function (as, xs) {
+  return xs.push.apply(xs, as);
+};
+
+export const shiftImpl = function (just, nothing, xs) {
+  return xs.length > 0 ? just(xs.shift()) : nothing;
+};
+
+export const unshiftAllImpl = function (as, xs) {
+  return xs.unshift.apply(xs, as);
+};
+
+export const spliceImpl = function (i, howMany, bs, xs) {
+  return xs.splice.apply(xs, [i, howMany].concat(bs));
+};
+
+function unsafeFreezeThawImpl(xs) {
+  return xs;
+}
+
+export const unsafeFreezeImpl = unsafeFreezeThawImpl;
+
+export const unsafeThawImpl = unsafeFreezeThawImpl;
+
+function copyImpl(xs) {
+  return xs.slice();
+}
+
+export const freezeImpl = copyImpl;
+
+export const thawImpl = copyImpl;
+
+export const sortByImpl = (function () {
+  function mergeFromTo(compare, fromOrdering, xs1, xs2, from, to) {
+    var mid;
+    var i;
+    var j;
+    var k;
+    var x;
+    var y;
+    var c;
+
+    mid = from + ((to - from) >> 1);
+    if (mid - from > 1) mergeFromTo(compare, fromOrdering, xs2, xs1, from, mid);
+    if (to - mid > 1) mergeFromTo(compare, fromOrdering, xs2, xs1, mid, to);
+
+    i = from;
+    j = mid;
+    k = from;
+    while (i < mid && j < to) {
+      x = xs2[i];
+      y = xs2[j];
+      c = fromOrdering(compare(x)(y));
+      if (c > 0) {
+        xs1[k++] = y;
+        ++j;
+      } else {
+        xs1[k++] = x;
+        ++i;
+      }
+    }
+    while (i < mid) {
+      xs1[k++] = xs2[i++];
+    }
+    while (j < to) {
+      xs1[k++] = xs2[j++];
+    }
+  }
+
+  return function (compare, fromOrdering, xs) {
+    if (xs.length < 2) return xs;
+
+    mergeFromTo(compare, fromOrdering, xs, xs.slice(0), 0, xs.length);
+
+    return xs;
+  };
+})();
+
+export const toAssocArrayImpl = function (xs) {
+  var n = xs.length;
+  var as = new Array(n);
+  for (var i = 0; i < n; i++) as[i] = { value: xs[i], index: i };
+  return as;
+};

package/output-es/Data.Array.ST/index.js

@@ -0,0 +1,82 @@
+// | Helper functions for working with mutable arrays using the `ST` effect.
+// |
+// | This module can be used when performance is important and mutation is a local effect.
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dST$dUncurried from "../Control.Monad.ST.Uncurried/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import {
+  new as $$new,
+  freezeImpl,
+  lengthImpl,
+  peekImpl,
+  pokeImpl,
+  popImpl,
+  pushAllImpl,
+  shiftImpl,
+  sortByImpl,
+  spliceImpl,
+  thawImpl,
+  toAssocArrayImpl,
+  unsafeFreezeImpl,
+  unsafeThawImpl,
+  unshiftAllImpl
+} from "./foreign.js";
+const unshiftAll = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn2(unshiftAllImpl);
+const unshift = a => Control$dMonad$dST$dUncurried.runSTFn2(unshiftAllImpl)([a]);
+const unsafeThaw = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn1(unsafeThawImpl);
+const unsafeFreeze = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn1(unsafeFreezeImpl);
+const toAssocArray = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn1(toAssocArrayImpl);
+const thaw = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn1(thawImpl);
+const withArray = f => xs => () => {
+  const result = [...xs];
+  f(result)();
+  return result;
+};
+const splice = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn4(spliceImpl);
+const sortBy = comp => Control$dMonad$dST$dUncurried.runSTFn3(sortByImpl)(comp)(v => {
+  if (v === "GT") { return 1; }
+  if (v === "EQ") { return 0; }
+  if (v === "LT") { return -1; }
+  $runtime.fail();
+});
+const sortWith = dictOrd => f => sortBy(x => y => dictOrd.compare(f(x))(f(y)));
+const sort = dictOrd => sortBy(dictOrd.compare);
+const shift = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn3(shiftImpl)(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const run = st => st();
+const pushAll = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn2(pushAllImpl);
+const push = a => Control$dMonad$dST$dUncurried.runSTFn2(pushAllImpl)([a]);
+const pop = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn3(popImpl)(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const poke = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn3(pokeImpl);
+const peek = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn4(peekImpl)(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const modify = i => f => xs => () => {
+  const entry = peekImpl(Data$dMaybe.Just, Data$dMaybe.Nothing, i, xs);
+  if (entry.tag === "Just") { return pokeImpl(i, f(entry._1), xs); }
+  if (entry.tag === "Nothing") { return false; }
+  $runtime.fail();
+};
+const length = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn1(lengthImpl);
+const freeze = /* #__PURE__ */ Control$dMonad$dST$dUncurried.runSTFn1(freezeImpl);
+export {
+  freeze,
+  length,
+  modify,
+  peek,
+  poke,
+  pop,
+  push,
+  pushAll,
+  run,
+  shift,
+  sort,
+  sortBy,
+  sortWith,
+  splice,
+  thaw,
+  toAssocArray,
+  unsafeFreeze,
+  unsafeThaw,
+  unshift,
+  unshiftAll,
+  withArray
+};
+export * from "./foreign.js";