purs-tidy/bundle/Main/index.js

A syntax tidy-upper (formatter) for PureScript.

// output-es/runtime.js
function binding(init2) {
  let state = 0;
  let value;
  return () => {
    if (state === 2) {
      return value;
    }
    if (state === 1) {
      throw new Error("Binding demanded before initialized");
    }
    state = 1;
    value = init2();
    state = 2;
    return value;
  };
}
function* range(lo, hi) {
  for (let i = lo; i < hi; i++) {
    yield i;
  }
}
function fail() {
  throw new Error("Failed pattern match");
}
function intDiv(x, y) {
  if (y > 0)
    return Math.floor(x / y);
  if (y < 0)
    return -Math.floor(x / -y);
  return 0;
}

// output-es/Data.Function/index.js
var $$const = (a) => (v) => a;
var applyFlipped = (x) => (f) => f(x);
var apply = (f) => (x) => f(x);

// output-es/Control.Semigroupoid/index.js
var semigroupoidFn = { compose: (f) => (g) => (x) => f(g(x)) };

// output-es/Type.Proxy/index.js
var $$$Proxy = () => ({ tag: "Proxy" });
var $$Proxy = /* @__PURE__ */ $$$Proxy();

// output-es/Data.Functor/foreign.js
var arrayMap = function(f) {
  return function(arr) {
    var l = arr.length;
    var result = new Array(l);
    for (var i = 0; i < l; i++) {
      result[i] = f(arr[i]);
    }
    return result;
  };
};

// output-es/Data.Functor/index.js
var functorArray = { map: arrayMap };

// output-es/Control.Apply/index.js
var identity = (x) => x;

// output-es/Control.Bind/foreign.js
var arrayBind = function(arr) {
  return function(f) {
    var result = [];
    for (var i = 0, l = arr.length; i < l; i++) {
      Array.prototype.push.apply(result, f(arr[i]));
    }
    return result;
  };
};

// output-es/Control.Bind/index.js
var identity2 = (x) => x;

// output-es/Record.Unsafe/foreign.js
var unsafeGet = function(label) {
  return function(rec) {
    return rec[label];
  };
};

// output-es/Data.Show/foreign.js
var showIntImpl = function(n) {
  return n.toString();
};

// output-es/Data.Ordering/index.js
var $Ordering = (tag) => tag;
var LT = /* @__PURE__ */ $Ordering("LT");
var GT = /* @__PURE__ */ $Ordering("GT");
var EQ = /* @__PURE__ */ $Ordering("EQ");

// output-es/Data.Maybe/index.js
var $Maybe = (tag, _1) => ({ tag, _1 });
var Nothing = /* @__PURE__ */ $Maybe("Nothing");
var Just = (value0) => $Maybe("Just", value0);
var monoidMaybe = (dictSemigroup) => {
  const semigroupMaybe1 = {
    append: (v) => (v1) => {
      if (v.tag === "Nothing") {
        return v1;
      }
      if (v1.tag === "Nothing") {
        return v;
      }
      if (v.tag === "Just" && v1.tag === "Just") {
        return $Maybe("Just", dictSemigroup.append(v._1)(v1._1));
      }
      fail();
    }
  };
  return { mempty: Nothing, Semigroup0: () => semigroupMaybe1 };
};
var isNothing = (v2) => {
  if (v2.tag === "Nothing") {
    return true;
  }
  if (v2.tag === "Just") {
    return false;
  }
  fail();
};
var isJust = (v2) => {
  if (v2.tag === "Nothing") {
    return false;
  }
  if (v2.tag === "Just") {
    return true;
  }
  fail();
};
var functorMaybe = {
  map: (v) => (v1) => {
    if (v1.tag === "Just") {
      return $Maybe("Just", v(v1._1));
    }
    return Nothing;
  }
};
var ordMaybe = (dictOrd) => {
  const $0 = dictOrd.Eq0();
  const eqMaybe1 = {
    eq: (x) => (y) => {
      if (x.tag === "Nothing") {
        return y.tag === "Nothing";
      }
      return x.tag === "Just" && y.tag === "Just" && $0.eq(x._1)(y._1);
    }
  };
  return {
    compare: (x) => (y) => {
      if (x.tag === "Nothing") {
        if (y.tag === "Nothing") {
          return EQ;
        }
        return LT;
      }
      if (y.tag === "Nothing") {
        return GT;
      }
      if (x.tag === "Just" && y.tag === "Just") {
        return dictOrd.compare(x._1)(y._1);
      }
      fail();
    },
    Eq0: () => eqMaybe1
  };
};
var applyMaybe = {
  apply: (v) => (v1) => {
    if (v.tag === "Just") {
      if (v1.tag === "Just") {
        return $Maybe("Just", v._1(v1._1));
      }
      return Nothing;
    }
    if (v.tag === "Nothing") {
      return Nothing;
    }
    fail();
  },
  Functor0: () => functorMaybe
};

// output-es/Data.Either/index.js
var $Either = (tag, _1) => ({ tag, _1 });
var Left = (value0) => $Either("Left", value0);
var Right = (value0) => $Either("Right", value0);
var functorEither = {
  map: (f) => (m) => {
    if (m.tag === "Left") {
      return $Either("Left", m._1);
    }
    if (m.tag === "Right") {
      return $Either("Right", f(m._1));
    }
    fail();
  }
};
var applyEither = {
  apply: (v) => (v1) => {
    if (v.tag === "Left") {
      return $Either("Left", v._1);
    }
    if (v.tag === "Right") {
      if (v1.tag === "Left") {
        return $Either("Left", v1._1);
      }
      if (v1.tag === "Right") {
        return $Either("Right", v._1(v1._1));
      }
    }
    fail();
  },
  Functor0: () => functorEither
};
var applicativeEither = { pure: Right, Apply0: () => applyEither };

// output-es/Effect/foreign.js
var pureE = function(a) {
  return function() {
    return a;
  };
};
var bindE = function(a) {
  return function(f) {
    return function() {
      return f(a())();
    };
  };
};

// output-es/Effect/index.js
var monadEffect = { Applicative0: () => applicativeEffect, Bind1: () => bindEffect };
var bindEffect = { bind: bindE, Apply0: () => applyEffect };
var applyEffect = {
  apply: (f) => (a) => () => {
    const f$p = f();
    const a$p = a();
    return applicativeEffect.pure(f$p(a$p))();
  },
  Functor0: () => functorEffect
};
var applicativeEffect = { pure: pureE, Apply0: () => applyEffect };
var functorEffect = {
  map: (f) => (a) => () => {
    const a$p = a();
    return f(a$p);
  }
};

// output-es/Data.Array.ST/foreign.js
var pushAll = function(as) {
  return function(xs) {
    return function() {
      return xs.push.apply(xs, as);
    };
  };
};
var unsafeThaw = function(xs) {
  return function() {
    return xs;
  };
};
function copyImpl(xs) {
  return function() {
    return xs.slice();
  };
}
var thaw = copyImpl;

// output-es/Data.Array.ST/index.js
var push = (a) => pushAll([a]);

// output-es/Data.Array.ST.Iterator/index.js
var $Iterator = (_1, _2) => ({ tag: "Iterator", _1, _2 });
var pushWhile = (p) => (iter) => (array) => () => {
  let $$break2 = false;
  const $0 = iter._2;
  while (/* @__PURE__ */ (() => {
    const $1 = $$break2;
    return !$1;
  })()) {
    const i = $0.value;
    const mx = iter._1(i);
    if (mx.tag === "Just" && p(mx._1)) {
      array.push(mx._1);
      iter._2.value;
      const $1 = iter._2.value;
      iter._2.value = $1 + 1 | 0;
      continue;
    }
    $$break2 = true;
  }
};
var iterate = (iter) => (f) => () => {
  let $$break2 = false;
  const $0 = iter._2;
  while (/* @__PURE__ */ (() => {
    const $1 = $$break2;
    return !$1;
  })()) {
    const i = $0.value;
    const $1 = $0.value;
    $0.value = $1 + 1 | 0;
    const mx = iter._1(i);
    if (mx.tag === "Just") {
      f(mx._1)();
      continue;
    }
    if (mx.tag === "Nothing") {
      $$break2 = true;
      continue;
    }
    fail();
  }
};

// output-es/Data.Foldable/foreign.js
var foldrArray = function(f) {
  return function(init2) {
    return function(xs) {
      var acc = init2;
      var len = xs.length;
      for (var i = len - 1; i >= 0; i--) {
        acc = f(xs[i])(acc);
      }
      return acc;
    };
  };
};
var foldlArray = function(f) {
  return function(init2) {
    return function(xs) {
      var acc = init2;
      var len = xs.length;
      for (var i = 0; i < len; i++) {
        acc = f(acc)(xs[i]);
      }
      return acc;
    };
  };
};

// output-es/Data.Foldable/index.js
var identity3 = (x) => x;
var traverse_ = (dictApplicative) => {
  const $0 = dictApplicative.Apply0();
  return (dictFoldable) => (f) => dictFoldable.foldr((x) => {
    const $1 = f(x);
    return (b) => $0.apply($0.Functor0().map((v) => identity)($1))(b);
  })(dictApplicative.pure());
};
var for_ = (dictApplicative) => {
  const traverse_1 = traverse_(dictApplicative);
  return (dictFoldable) => {
    const $0 = traverse_1(dictFoldable);
    return (b) => (a) => $0(a)(b);
  };
};
var foldableMaybe = {
  foldr: (v) => (v1) => (v2) => {
    if (v2.tag === "Nothing") {
      return v1;
    }
    if (v2.tag === "Just") {
      return v(v2._1)(v1);
    }
    fail();
  },
  foldl: (v) => (v1) => (v2) => {
    if (v2.tag === "Nothing") {
      return v1;
    }
    if (v2.tag === "Just") {
      return v(v1)(v2._1);
    }
    fail();
  },
  foldMap: (dictMonoid) => {
    const mempty2 = dictMonoid.mempty;
    return (v) => (v1) => {
      if (v1.tag === "Nothing") {
        return mempty2;
      }
      if (v1.tag === "Just") {
        return v(v1._1);
      }
      fail();
    };
  }
};
var foldableArray = {
  foldr: foldrArray,
  foldl: foldlArray,
  foldMap: (dictMonoid) => {
    const mempty2 = dictMonoid.mempty;
    return (f) => foldableArray.foldr((x) => (acc) => dictMonoid.Semigroup0().append(f(x))(acc))(mempty2);
  }
};
var find = (dictFoldable) => (p) => dictFoldable.foldl((v) => (v1) => {
  if (v.tag === "Nothing" && p(v1)) {
    return $Maybe("Just", v1);
  }
  return v;
})(Nothing);

// output-es/Data.Eq/foreign.js
var refEq = function(r1) {
  return function(r2) {
    return r1 === r2;
  };
};
var eqBooleanImpl = refEq;
var eqIntImpl = refEq;
var eqNumberImpl = refEq;
var eqStringImpl = refEq;
var eqArrayImpl = function(f) {
  return function(xs) {
    return function(ys) {
      if (xs.length !== ys.length)
        return false;
      for (var i = 0; i < xs.length; i++) {
        if (!f(xs[i])(ys[i]))
          return false;
      }
      return true;
    };
  };
};

// output-es/Data.Eq/index.js
var eqString = { eq: eqStringImpl };
var eqNumber = { eq: eqNumberImpl };
var eqInt = { eq: eqIntImpl };
var eqBoolean = { eq: eqBooleanImpl };

// output-es/Data.Ord/foreign.js
var unsafeCompareImpl = function(lt) {
  return function(eq2) {
    return function(gt) {
      return function(x) {
        return function(y) {
          return x < y ? lt : x === y ? eq2 : gt;
        };
      };
    };
  };
};
var ordBooleanImpl = unsafeCompareImpl;
var ordIntImpl = unsafeCompareImpl;
var ordNumberImpl = unsafeCompareImpl;
var ordStringImpl = unsafeCompareImpl;
var ordArrayImpl = function(f) {
  return function(xs) {
    return function(ys) {
      var i = 0;
      var xlen = xs.length;
      var ylen = ys.length;
      while (i < xlen && i < ylen) {
        var x = xs[i];
        var y = ys[i];
        var o = f(x)(y);
        if (o !== 0) {
          return o;
        }
        i++;
      }
      if (xlen === ylen) {
        return 0;
      } else if (xlen > ylen) {
        return -1;
      } else {
        return 1;
      }
    };
  };
};

// output-es/Data.Ord/index.js
var ordString = { compare: /* @__PURE__ */ ordStringImpl(LT)(EQ)(GT), Eq0: () => eqString };
var ordNumber = { compare: /* @__PURE__ */ ordNumberImpl(LT)(EQ)(GT), Eq0: () => eqNumber };
var ordInt = { compare: /* @__PURE__ */ ordIntImpl(LT)(EQ)(GT), Eq0: () => eqInt };
var ordBoolean = { compare: /* @__PURE__ */ ordBooleanImpl(LT)(EQ)(GT), Eq0: () => eqBoolean };
var ordArray = (dictOrd) => {
  const eqArray = { eq: eqArrayImpl(dictOrd.Eq0().eq) };
  return {
    compare: (xs) => (ys) => ordInt.compare(0)(ordArrayImpl((x) => (y) => {
      const v = dictOrd.compare(x)(y);
      if (v === "EQ") {
        return 0;
      }
      if (v === "LT") {
        return 1;
      }
      if (v === "GT") {
        return -1;
      }
      fail();
    })(xs)(ys)),
    Eq0: () => eqArray
  };
};

// output-es/Unsafe.Coerce/foreign.js
var unsafeCoerce = function(x) {
  return x;
};

// output-es/Data.Tuple/index.js
var $Tuple = (_1, _2) => ({ tag: "Tuple", _1, _2 });
var Tuple = (value0) => (value1) => $Tuple(value0, value1);
var snd = (v) => v._2;
var fst = (v) => v._1;
var ordTuple = (dictOrd) => {
  const $0 = dictOrd.Eq0();
  return (dictOrd1) => {
    const $1 = dictOrd1.Eq0();
    const eqTuple2 = { eq: (x) => (y) => $0.eq(x._1)(y._1) && $1.eq(x._2)(y._2) };
    return {
      compare: (x) => (y) => {
        const v = dictOrd.compare(x._1)(y._1);
        if (v === "LT") {
          return LT;
        }
        if (v === "GT") {
          return GT;
        }
        return dictOrd1.compare(x._2)(y._2);
      },
      Eq0: () => eqTuple2
    };
  };
};

// output-es/Data.Traversable/foreign.js
var traverseArrayImpl = /* @__PURE__ */ function() {
  function array1(a) {
    return [a];
  }
  function array2(a) {
    return function(b) {
      return [a, b];
    };
  }
  function array3(a) {
    return function(b) {
      return function(c) {
        return [a, b, c];
      };
    };
  }
  function concat22(xs) {
    return function(ys) {
      return xs.concat(ys);
    };
  }
  return function(apply2) {
    return function(map) {
      return function(pure) {
        return function(f) {
          return function(array) {
            function go(bot, top) {
              switch (top - bot) {
                case 0:
                  return pure([]);
                case 1:
                  return map(array1)(f(array[bot]));
                case 2:
                  return apply2(map(array2)(f(array[bot])))(f(array[bot + 1]));
                case 3:
                  return apply2(apply2(map(array3)(f(array[bot])))(f(array[bot + 1])))(f(array[bot + 2]));
                default:
                  var pivot = bot + Math.floor((top - bot) / 4) * 2;
                  return apply2(map(concat22)(go(bot, pivot)))(go(pivot, top));
              }
            }
            return go(0, array.length);
          };
        };
      };
    };
  };
}();

// output-es/Data.Traversable/index.js
var identity4 = (x) => x;
var traversableMaybe = {
  traverse: (dictApplicative) => (v) => (v1) => {
    if (v1.tag === "Nothing") {
      return dictApplicative.pure(Nothing);
    }
    if (v1.tag === "Just") {
      return dictApplicative.Apply0().Functor0().map(Just)(v(v1._1));
    }
    fail();
  },
  sequence: (dictApplicative) => (v) => {
    if (v.tag === "Nothing") {
      return dictApplicative.pure(Nothing);
    }
    if (v.tag === "Just") {
      return dictApplicative.Apply0().Functor0().map(Just)(v._1);
    }
    fail();
  },
  Functor0: () => functorMaybe,
  Foldable1: () => foldableMaybe
};
var traversableArray = {
  traverse: (dictApplicative) => {
    const Apply0 = dictApplicative.Apply0();
    return traverseArrayImpl(Apply0.apply)(Apply0.Functor0().map)(dictApplicative.pure);
  },
  sequence: (dictApplicative) => traversableArray.traverse(dictApplicative)(identity4),
  Functor0: () => functorArray,
  Foldable1: () => foldableArray
};

// output-es/Data.Array/foreign.js
var range2 = function(start) {
  return function(end) {
    var step = start > end ? -1 : 1;
    var result = new Array(step * (end - start) + 1);
    var i = start, n = 0;
    while (i !== end) {
      result[n++] = i;
      i += step;
    }
    result[n] = i;
    return result;
  };
};
var replicateFill = function(count) {
  return function(value) {
    if (count < 1) {
      return [];
    }
    var result = new Array(count);
    return result.fill(value);
  };
};
var replicatePolyfill = function(count) {
  return function(value) {
    var result = [];
    var n = 0;
    for (var i = 0; i < count; i++) {
      result[n++] = value;
    }
    return result;
  };
};
var replicate = typeof Array.prototype.fill === "function" ? replicateFill : replicatePolyfill;
var fromFoldableImpl = /* @__PURE__ */ function() {
  function Cons2(head, tail2) {
    this.head = head;
    this.tail = tail2;
  }
  var emptyList = {};
  function curryCons(head) {
    return function(tail2) {
      return new Cons2(head, tail2);
    };
  }
  function listToArray(list) {
    var result = [];
    var count = 0;
    var xs = list;
    while (xs !== emptyList) {
      result[count++] = xs.head;
      xs = xs.tail;
    }
    return result;
  }
  return function(foldr) {
    return function(xs) {
      return listToArray(foldr(curryCons)(emptyList)(xs));
    };
  };
}();
var unconsImpl = function(empty4) {
  return function(next) {
    return function(xs) {
      return xs.length === 0 ? empty4({}) : next(xs[0])(xs.slice(1));
    };
  };
};
var indexImpl = function(just) {
  return function(nothing) {
    return function(xs) {
      return function(i) {
        return i < 0 || i >= xs.length ? nothing : just(xs[i]);
      };
    };
  };
};
var findMapImpl = function(nothing) {
  return function(isJust2) {
    return function(f) {
      return function(xs) {
        for (var i = 0; i < xs.length; i++) {
          var result = f(xs[i]);
          if (isJust2(result))
            return result;
        }
        return nothing;
      };
    };
  };
};
var findIndexImpl = function(just) {
  return function(nothing) {
    return function(f) {
      return function(xs) {
        for (var i = 0, l = xs.length; i < l; i++) {
          if (f(xs[i]))
            return just(i);
        }
        return nothing;
      };
    };
  };
};
var reverse = function(l) {
  return l.slice().reverse();
};
var filter = function(f) {
  return function(xs) {
    return xs.filter(f);
  };
};
var partition = function(f) {
  return function(xs) {
    var yes = [];
    var no = [];
    for (var i = 0; i < xs.length; i++) {
      var x = xs[i];
      if (f(x))
        yes.push(x);
      else
        no.push(x);
    }
    return { yes, no };
  };
};
var sortByImpl2 = /* @__PURE__ */ function() {
  function mergeFromTo(compare4, 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(compare4, fromOrdering, xs2, xs1, from, mid);
    if (to - mid > 1)
      mergeFromTo(compare4, fromOrdering, xs2, xs1, mid, to);
    i = from;
    j = mid;
    k = from;
    while (i < mid && j < to) {
      x = xs2[i];
      y = xs2[j];
      c = fromOrdering(compare4(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(compare4) {
    return function(fromOrdering) {
      return function(xs) {
        var out;
        if (xs.length < 2)
          return xs;
        out = xs.slice(0);
        mergeFromTo(compare4, fromOrdering, out, xs.slice(0), 0, xs.length);
        return out;
      };
    };
  };
}();
var slice = function(s) {
  return function(e) {
    return function(l) {
      return l.slice(s, e);
    };
  };
};
var zipWith = function(f) {
  return function(xs) {
    return function(ys) {
      var l = xs.length < ys.length ? xs.length : ys.length;
      var result = new Array(l);
      for (var i = 0; i < l; i++) {
        result[i] = f(xs[i])(ys[i]);
      }
      return result;
    };
  };
};
var all = function(p) {
  return function(xs) {
    var len = xs.length;
    for (var i = 0; i < len; i++) {
      if (!p(xs[i]))
        return false;
    }
    return true;
  };
};

// output-es/Data.Array/index.js
var intercalate1 = (dictMonoid) => {
  const $0 = dictMonoid.Semigroup0();
  const mempty2 = dictMonoid.mempty;
  return (sep2) => (xs) => foldlArray((v) => (v1) => {
    if (v.init) {
      return { init: false, acc: v1 };
    }
    return { init: false, acc: $0.append(v.acc)($0.append(sep2)(v1)) };
  })({ init: true, acc: mempty2 })(xs).acc;
};
var zip = /* @__PURE__ */ zipWith(Tuple);
var uncons = /* @__PURE__ */ unconsImpl((v) => Nothing)((x) => (xs) => $Maybe("Just", { head: x, tail: xs }));
var tail = /* @__PURE__ */ unconsImpl((v) => Nothing)((v) => (xs) => $Maybe("Just", xs));
var sortBy = (comp) => sortByImpl2(comp)((v) => {
  if (v === "GT") {
    return 1;
  }
  if (v === "EQ") {
    return 0;
  }
  if (v === "LT") {
    return -1;
  }
  fail();
});
var sortWith = (dictOrd) => (f) => sortBy((x) => (y) => dictOrd.compare(f(x))(f(y)));
var snoc = (xs) => (x) => (() => {
  const $0 = push(x);
  const $1 = thaw(xs);
  return () => {
    const result = $1();
    $0(result)();
    return result;
  };
})()();
var intersperse = (a) => (arr) => {
  const v = arr.length;
  if (v < 2) {
    return arr;
  }
  const out = [];
  out.push(arr[0]);
  for (const idx of range(1, v)) {
    out.push(a);
    out.push(arr[idx]);
  }
  return out;
};
var init = (xs) => {
  if (xs.length === 0) {
    return Nothing;
  }
  return $Maybe("Just", slice(0)(xs.length - 1 | 0)(xs));
};
var index = /* @__PURE__ */ indexImpl(Just)(Nothing);
var unsnoc = (xs) => applyMaybe.apply((() => {
  const $0 = init(xs);
  if ($0.tag === "Just") {
    return $Maybe(
      "Just",
      (() => {
        const $1 = $0._1;
        return (v1) => ({ init: $1, last: v1 });
      })()
    );
  }
  return Nothing;
})())(index(xs)(xs.length - 1 | 0));
var unzip = (xs) => {
  const fsts = [];
  const snds = [];
  const $0 = { value: 0 };
  iterate($Iterator((v) => index(xs)(v), $0))((v) => {
    const $1 = v._2;
    const $2 = () => fsts.push(v._1);
    return () => {
      $2();
      snds.push($1);
    };
  })();
  return $Tuple(fsts, snds);
};
var nubBy = (comp) => (xs) => {
  const indexedAndSorted = sortBy((x) => (y) => comp(x._2)(y._2))(zipWith(Tuple)(range2(0)(xs.length - 1 | 0))(xs));
  const v = index(indexedAndSorted)(0);
  if (v.tag === "Nothing") {
    return [];
  }
  if (v.tag === "Just") {
    return arrayMap(snd)(sortWith(ordInt)(fst)((() => {
      const $0 = unsafeThaw([v._1]);
      return () => {
        const result = $0();
        for (const v1 of indexedAndSorted) {
          const $1 = comp((() => {
            const $12 = index(result)(result.length - 1 | 0);
            if ($12.tag === "Just") {
              return $12._1._2;
            }
            fail();
          })())(v1._2);
          const $2 = () => result.push(v1);
          if ($1 === "LT" || $1 === "GT" || $1 !== "EQ") {
            $2();
          }
        }
        return result;
      };
    })()()));
  }
  fail();
};
var groupBy = (op) => (xs) => {
  const result = [];
  const $0 = { value: 0 };
  const iter = $Iterator((v) => index(xs)(v), $0);
  iterate(iter)((x) => () => {
    const sub1 = [];
    sub1.push(x);
    pushWhile(op(x))(iter)(sub1)();
    result.push(sub1);
  })();
  return result;
};
var findMap = /* @__PURE__ */ findMapImpl(Nothing)(isJust);
var findIndex = /* @__PURE__ */ findIndexImpl(Just)(Nothing);
var elem = (dictEq) => (a) => (arr) => {
  const $0 = findIndex((v) => dictEq.eq(v)(a))(arr);
  if ($0.tag === "Nothing") {
    return false;
  }
  if ($0.tag === "Just") {
    return true;
  }
  fail();
};
var drop = (n) => (xs) => {
  if (n < 1) {
    return xs;
  }
  return slice(n)(xs.length)(xs);
};
var concatMap = (b) => (a) => arrayBind(a)(b);
var mapMaybe = (f) => concatMap((x) => {
  const $0 = f(x);
  if ($0.tag === "Nothing") {
    return [];
  }
  if ($0.tag === "Just") {
    return [$0._1];
  }
  fail();
});

// output-es/Data.Void/index.js
var absurd = (a) => {
  const spin = (spin$a0$copy) => {
    let spin$a0 = spin$a0$copy, spin$c = true, spin$r;
    while (spin$c) {
      const v = spin$a0;
      spin$a0 = v;
    }
    return spin$r;
  };
  return spin(a);
};

// output-es/Data.Semigroup/foreign.js
var concatString = function(s1) {
  return function(s2) {
    return s1 + s2;
  };
};
var concatArray = function(xs) {
  return function(ys) {
    if (xs.length === 0)
      return ys;
    if (ys.length === 0)
      return xs;
    return xs.concat(ys);
  };
};

// output-es/Data.Semigroup/index.js
var semigroupUnit = { append: (v) => (v1) => {
} };
var semigroupString = { append: concatString };
var semigroupArray = { append: concatArray };

// output-es/Data.FoldableWithIndex/index.js
var traverseWithIndex_ = (dictApplicative) => {
  const $0 = dictApplicative.Apply0();
  return (dictFoldableWithIndex) => (f) => dictFoldableWithIndex.foldrWithIndex((i) => {
    const $1 = f(i);
    return (x) => {
      const $2 = $1(x);
      return (b) => $0.apply($0.Functor0().map((v) => identity)($2))(b);
    };
  })(dictApplicative.pure());
};
var forWithIndex_ = (dictApplicative) => {
  const traverseWithIndex_1 = traverseWithIndex_(dictApplicative);
  return (dictFoldableWithIndex) => {
    const $0 = traverseWithIndex_1(dictFoldableWithIndex);
    return (b) => (a) => $0(a)(b);
  };
};

// output-es/Data.Unfoldable1/foreign.js
var unfoldr1ArrayImpl = function(isNothing2) {
  return function(fromJust3) {
    return function(fst2) {
      return function(snd2) {
        return function(f) {
          return function(b) {
            var result = [];
            var value = b;
            while (true) {
              var tuple = f(value);
              result.push(fst2(tuple));
              var maybe = snd2(tuple);
              if (isNothing2(maybe))
                return result;
              value = fromJust3(maybe);
            }
          };
        };
      };
    };
  };
};

// output-es/Data.Unfoldable1/index.js
var fromJust = (v) => {
  if (v.tag === "Just") {
    return v._1;
  }
  fail();
};
var unfoldable1Array = { unfoldr1: /* @__PURE__ */ unfoldr1ArrayImpl(isNothing)(fromJust)(fst)(snd) };

// output-es/Data.Array.NonEmpty.Internal/foreign.js
var foldr1Impl = function(f) {
  return function(xs) {
    var acc = xs[xs.length - 1];
    for (var i = xs.length - 2; i >= 0; i--) {
      acc = f(xs[i])(acc);
    }
    return acc;
  };
};

// output-es/Data.Number/foreign.js
var isFiniteImpl = isFinite;
function fromStringImpl(str, isFinite2, just, nothing) {
  var num = parseFloat(str);
  if (isFinite2(num)) {
    return just(num);
  } else {
    return nothing;
  }
}
var ceil = Math.ceil;

// output-es/Data.Int/foreign.js
var fromNumberImpl = function(just) {
  return function(nothing) {
    return function(n) {
      return (n | 0) === n ? just(n) : nothing;
    };
  };
};
var toNumber = function(n) {
  return n;
};
var fromStringAsImpl = function(just) {
  return function(nothing) {
    return function(radix) {
      var digits;
      if (radix < 11) {
        digits = "[0-" + (radix - 1).toString() + "]";
      } else if (radix === 11) {
        digits = "[0-9a]";
      } else {
        digits = "[0-9a-" + String.fromCharCode(86 + radix) + "]";
      }
      var pattern = new RegExp("^[\\+\\-]?" + digits + "+$", "i");
      return function(s) {
        if (pattern.test(s)) {
          var i = parseInt(s, radix);
          return (i | 0) === i ? just(i) : nothing;
        } else {
          return nothing;
        }
      };
    };
  };
};

// output-es/Data.Int/index.js
var fromStringAs = /* @__PURE__ */ fromStringAsImpl(Just)(Nothing);
var fromString = /* @__PURE__ */ fromStringAs(10);
var fromNumber = /* @__PURE__ */ fromNumberImpl(Just)(Nothing);
var unsafeClamp = (x) => {
  if (!isFiniteImpl(x)) {
    return 0;
  }
  if (x >= toNumber(2147483647)) {
    return 2147483647;
  }
  if (x <= toNumber(-2147483648)) {
    return -2147483648;
  }
  const $0 = fromNumber(x);
  if ($0.tag === "Nothing") {
    return 0;
  }
  if ($0.tag === "Just") {
    return $0._1;
  }
  fail();
};

// output-es/Data.NonEmpty/index.js
var $NonEmpty = (_1, _2) => ({ tag: "NonEmpty", _1, _2 });

// output-es/Data.List.Types/index.js
var $List = (tag, _1, _2) => ({ tag, _1, _2 });
var Nil = /* @__PURE__ */ $List("Nil");
var Cons = (value0) => (value1) => $List("Cons", value0, value1);
var listMap = (f) => {
  const chunkedRevMap = (chunkedRevMap$a0$copy) => (chunkedRevMap$a1$copy) => {
    let chunkedRevMap$a0 = chunkedRevMap$a0$copy, chunkedRevMap$a1 = chunkedRevMap$a1$copy, chunkedRevMap$c = true, chunkedRevMap$r;
    while (chunkedRevMap$c) {
      const v = chunkedRevMap$a0, v1 = chunkedRevMap$a1;
      if (v1.tag === "Cons" && v1._2.tag === "Cons" && v1._2._2.tag === "Cons") {
        chunkedRevMap$a0 = $List("Cons", v1, v);
        chunkedRevMap$a1 = v1._2._2._2;
        continue;
      }
      const reverseUnrolledMap = (reverseUnrolledMap$a0$copy) => (reverseUnrolledMap$a1$copy) => {
        let reverseUnrolledMap$a0 = reverseUnrolledMap$a0$copy, reverseUnrolledMap$a1 = reverseUnrolledMap$a1$copy, reverseUnrolledMap$c = true, reverseUnrolledMap$r;
        while (reverseUnrolledMap$c) {
          const v2 = reverseUnrolledMap$a0, v3 = reverseUnrolledMap$a1;
          if (v2.tag === "Cons" && v2._1.tag === "Cons" && v2._1._2.tag === "Cons" && v2._1._2._2.tag === "Cons") {
            reverseUnrolledMap$a0 = v2._2;
            reverseUnrolledMap$a1 = $List("Cons", f(v2._1._1), $List("Cons", f(v2._1._2._1), $List("Cons", f(v2._1._2._2._1), v3)));
            continue;
          }
          reverseUnrolledMap$c = false;
          reverseUnrolledMap$r = v3;
        }
        return reverseUnrolledMap$r;
      };
      chunkedRevMap$c = false;
      chunkedRevMap$r = reverseUnrolledMap(v)((() => {
        if (v1.tag === "Cons") {
          if (v1._2.tag === "Cons") {
            if (v1._2._2.tag === "Nil") {
              return $List("Cons", f(v1._1), $List("Cons", f(v1._2._1), Nil));
            }
            return Nil;
          }
          if (v1._2.tag === "Nil") {
            return $List("Cons", f(v1._1), Nil);
          }
        }
        return Nil;
      })());
    }
    return chunkedRevMap$r;
  };
  return chunkedRevMap(Nil);
};
var foldableList = {
  foldr: (f) => (b) => {
    const $0 = foldableList.foldl((b$1) => (a) => f(a)(b$1))(b);
    const go = (go$a0$copy) => (go$a1$copy) => {
      let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
      while (go$c) {
        const v = go$a0, v1 = go$a1;
        if (v1.tag === "Nil") {
          go$c = false;
          go$r = v;
          continue;
        }
        if (v1.tag === "Cons") {
          go$a0 = $List("Cons", v1._1, v);
          go$a1 = v1._2;
          continue;
        }
        fail();
      }
      return go$r;
    };
    const $1 = go(Nil);
    return (x) => $0($1(x));
  },
  foldl: (f) => {
    const go = (go$a0$copy) => (go$a1$copy) => {
      let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
      while (go$c) {
        const b = go$a0, v = go$a1;
        if (v.tag === "Nil") {
          go$c = false;
          go$r = b;
          continue;
        }
        if (v.tag === "Cons") {
          go$a0 = f(b)(v._1);
          go$a1 = v._2;
          continue;
        }
        fail();
      }
      return go$r;
    };
    return go;
  },
  foldMap: (dictMonoid) => {
    const mempty2 = dictMonoid.mempty;
    return (f) => foldableList.foldl((acc) => {
      const $0 = dictMonoid.Semigroup0().append(acc);
      return (x) => $0(f(x));
    })(mempty2);
  }
};
var foldableNonEmptyList = {
  foldMap: (dictMonoid) => {
    const foldMap13 = foldableList.foldMap(dictMonoid);
    return (f) => (v) => dictMonoid.Semigroup0().append(f(v._1))(foldMap13(f)(v._2));
  },
  foldl: (f) => (b) => (v) => {
    const go = (go$a0$copy) => (go$a1$copy) => {
      let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
      while (go$c) {
        const b$1 = go$a0, v$1 = go$a1;
        if (v$1.tag === "Nil") {
          go$c = false;
          go$r = b$1;
          continue;
        }
        if (v$1.tag === "Cons") {
          go$a0 = f(b$1)(v$1._1);
          go$a1 = v$1._2;
          continue;
        }
        fail();
      }
      return go$r;
    };
    return go(f(b)(v._1))(v._2);
  },
  foldr: (f) => (b) => (v) => f(v._1)(foldableList.foldr(f)(b)(v._2))
};
var eq1List = {
  eq1: (dictEq) => (xs) => (ys) => {
    const go = (v) => (v1) => (v2) => {
      if (!v2) {
        return false;
      }
      if (v.tag === "Nil") {
        return v1.tag === "Nil" && v2;
      }
      return v.tag === "Cons" && v1.tag === "Cons" && go(v._2)(v1._2)(v2 && dictEq.eq(v1._1)(v._1));
    };
    return go(xs)(ys)(true);
  }
};
var ord1List = {
  compare1: (dictOrd) => (xs) => (ys) => {
    const go = (go$a0$copy) => (go$a1$copy) => {
      let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
      while (go$c) {
        const v = go$a0, v1 = go$a1;
        if (v.tag === "Nil") {
          if (v1.tag === "Nil") {
            go$c = false;
            go$r = EQ;
            continue;
          }
          go$c = false;
          go$r = LT;
          continue;
        }
        if (v1.tag === "Nil") {
          go$c = false;
          go$r = GT;
          continue;
        }
        if (v.tag === "Cons" && v1.tag === "Cons") {
          const v2 = dictOrd.compare(v._1)(v1._1);
          if (v2 === "EQ") {
            go$a0 = v._2;
            go$a1 = v1._2;
            continue;
          }
          go$c = false;
          go$r = v2;
          continue;
        }
        fail();
      }
      return go$r;
    };
    return go(xs)(ys);
  },
  Eq10: () => eq1List
};
var ordList = (dictOrd) => {
  const $0 = dictOrd.Eq0();
  const eqList1 = {
    eq: (xs) => (ys) => {
      const go = (v) => (v1) => (v2) => {
        if (!v2) {
          return false;
        }
        if (v.tag === "Nil") {
          return v1.tag === "Nil" && v2;
        }
        return v.tag === "Cons" && v1.tag === "Cons" && go(v._2)(v1._2)(v2 && $0.eq(v1._1)(v._1));
      };
      return go(xs)(ys)(true);
    }
  };
  return { compare: ord1List.compare1(dictOrd), Eq0: () => eqList1 };
};

// output-es/Data.List/index.js
var toUnfoldable = (dictUnfoldable) => dictUnfoldable.unfoldr((xs) => {
  if (xs.tag === "Nil") {
    return Nothing;
  }
  if (xs.tag === "Cons") {
    return $Maybe("Just", $Tuple(xs._1, xs._2));
  }
  fail();
});
var reverse2 = /* @__PURE__ */ (() => {
  const go = (go$a0$copy) => (go$a1$copy) => {
    let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
    while (go$c) {
      const v = go$a0, v1 = go$a1;
      if (v1.tag === "Nil") {
        go$c = false;
        go$r = v;
        continue;
      }
      if (v1.tag === "Cons") {
        go$a0 = $List("Cons", v1._1, v);
        go$a1 = v1._2;
        continue;
      }
      fail();
    }
    return go$r;
  };
  return go(Nil);
})();

// output-es/Data.Semiring/foreign.js
var intAdd = function(x) {
  return function(y) {
    return x + y | 0;
  };
};

// output-es/Data.EuclideanRing/foreign.js
var intMod = function(x) {
  return function(y) {
    if (y === 0)
      return 0;
    var yy = Math.abs(y);
    return (x % yy + yy) % yy;
  };
};

// output-es/Data.Monoid/index.js
var monoidUnit = { mempty: void 0, Semigroup0: () => semigroupUnit };
var monoidString = { mempty: "", Semigroup0: () => semigroupString };
var monoidArray = { mempty: [], Semigroup0: () => semigroupArray };
var monoidRecord = () => (dictMonoidRecord) => {
  const semigroupRecord1 = { append: dictMonoidRecord.SemigroupRecord0().appendRecord($$Proxy) };
  return { mempty: dictMonoidRecord.memptyRecord($$Proxy), Semigroup0: () => semigroupRecord1 };
};
var power = (dictMonoid) => {
  const mempty12 = dictMonoid.mempty;
  const $0 = dictMonoid.Semigroup0();
  return (x) => {
    const go = (p) => {
      if (p <= 0) {
        return mempty12;
      }
      if (p === 1) {
        return x;
      }
      if (intMod(p)(2) === 0) {
        const x$p2 = go(intDiv(p, 2));
        return $0.append(x$p2)(x$p2);
      }
      const x$p = go(intDiv(p, 2));
      return $0.append(x$p)($0.append(x$p)(x));
    };
    return go;
  };
};

// output-es/Data.Bounded/foreign.js
var topChar = String.fromCharCode(65535);
var bottomChar = String.fromCharCode(0);
var topNumber = Number.POSITIVE_INFINITY;
var bottomNumber = Number.NEGATIVE_INFINITY;

// output-es/Data.Enum/foreign.js
function toCharCode(c) {
  return c.charCodeAt(0);
}
function fromCharCode(c) {
  return String.fromCharCode(c);
}

// output-es/Data.Enum/index.js
var charToEnum = (v) => {
  if (v >= -2147483648 && v <= 2147483647) {
    return $Maybe("Just", fromCharCode(v));
  }
  return Nothing;
};

// output-es/Data.String.Unsafe/foreign.js
var charAt = function(i) {
  return function(s) {
    if (i >= 0 && i < s.length)
      return s.charAt(i);
    throw new Error("Data.String.Unsafe.charAt: Invalid index.");
  };
};

// output-es/Data.String.CodeUnits/foreign.js
var singleton = function(c) {
  return c;
};
var _charAt = function(just) {
  return function(nothing) {
    return function(i) {
      return function(s) {
        return i >= 0 && i < s.length ? just(s.charAt(i)) : nothing;
      };
    };
  };
};
var length2 = function(s) {
  return s.length;
};
var _indexOf = function(just) {
  return function(nothing) {
    return function(x) {
      return function(s) {
        var i = s.indexOf(x);
        return i === -1 ? nothing : just(i);
      };
    };
  };
};
var _indexOfStartingAt = function(just) {
  return function(nothing) {
    return function(x) {
      return function(startAt) {
        return function(s) {
          if (startAt < 0 || startAt > s.length)
            return nothing;
          var i = s.indexOf(x, startAt);
          return i === -1 ? nothing : just(i);
        };
      };
    };
  };
};
var take = function(n) {
  return function(s) {
    return s.substr(0, n);
  };
};
var drop2 = function(n) {
  return function(s) {
    return s.substring(n);
  };
};
var splitAt = function(i) {
  return function(s) {
    return { before: s.substring(0, i), after: s.substring(i) };
  };
};

// output-es/Data.String.CodeUnits/index.js
var stripSuffix = (v) => (str) => {
  const v1 = splitAt(length2(str) - length2(v) | 0)(str);
  if (v1.after === v) {
    return $Maybe("Just", v1.before);
  }
  return Nothing;
};
var stripPrefix = (v) => (str) => {
  const v1 = splitAt(length2(v))(str);
  if (v1.before === v) {
    return $Maybe("Just", v1.after);
  }
  return Nothing;
};
var indexOf$p = /* @__PURE__ */ _indexOfStartingAt(Just)(Nothing);
var indexOf = /* @__PURE__ */ _indexOf(Just)(Nothing);
var charAt2 = /* @__PURE__ */ _charAt(Just)(Nothing);

// output-es/Data.String.Common/foreign.js
var replaceAll = function(s1) {
  return function(s2) {
    return function(s3) {
      return s3.replace(new RegExp(s1.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"), "g"), s2);
    };
  };
};
var split = function(sep2) {
  return function(s) {
    return s.split(sep2);
  };
};
var joinWith = function(s) {
  return function(xs) {
    return xs.join(s);
  };
};

// output-es/Data.Unfoldable/foreign.js
var unfoldrArrayImpl = function(isNothing2) {
  return function(fromJust3) {
    return function(fst2) {
      return function(snd2) {
        return function(f) {
          return function(b) {
            var result = [];
            var value = b;
            while (true) {
              var maybe = f(value);
              if (isNothing2(maybe))
                return result;
              var tuple = fromJust3(maybe);
              result.push(fst2(tuple));
              value = snd2(tuple);
            }
          };
        };
      };
    };
  };
};

// output-es/Data.Unfoldable/index.js
var fromJust2 = (v) => {
  if (v.tag === "Just") {
    return v._1;
  }
  fail();
};
var unfoldableArray = {
  unfoldr: /* @__PURE__ */ unfoldrArrayImpl(isNothing)(fromJust2)(fst)(snd),
  Unfoldable10: () => unfoldable1Array
};

// output-es/Data.String.CodePoints/foreign.js
var hasArrayFrom = typeof Array.from === "function";
var hasStringIterator = typeof Symbol !== "undefined" && Symbol != null && typeof Symbol.iterator !== "undefined" && typeof String.prototype[Symbol.iterator] === "function";
var hasFromCodePoint = typeof String.prototype.fromCodePoint === "function";
var hasCodePointAt = typeof String.prototype.codePointAt === "function";
var _unsafeCodePointAt0 = function(fallback) {
  return hasCodePointAt ? function(str) {
    return str.codePointAt(0);
  } : fallback;
};
var _countPrefix = function(fallback) {
  return function(unsafeCodePointAt02) {
    if (hasStringIterator) {
      return function(pred) {
        return function(str) {
          var iter = str[Symbol.iterator]();
          for (var cpCount = 0; ; ++cpCount) {
            var o = iter.next();
            if (o.done)
              return cpCount;
            var cp = unsafeCodePointAt02(o.value);
            if (!pred(cp))
              return cpCount;
          }
        };
      };
    }
    return fallback;
  };
};
var _singleton = function(fallback) {
  return hasFromCodePoint ? String.fromCodePoint : fallback;
};
var _take = function(fallback) {
  return function(n) {
    if (hasStringIterator) {
      return function(str) {
        var accum = "";
        var iter = str[Symbol.iterator]();
        for (var i = 0; i < n; ++i) {
          var o = iter.next();
          if (o.done)
            return accum;
          accum += o.value;
        }
        return accum;
      };
    }
    return fallback(n);
  };
};
var _toCodePointArray = function(fallback) {
  return function(unsafeCodePointAt02) {
    if (hasArrayFrom) {
      return function(str) {
        return Array.from(str, unsafeCodePointAt02);
      };
    }
    return fallback;
  };
};

// output-es/Data.String.CodePoints/index.js
var uncons2 = (s) => {
  const v = length2(s);
  if (v === 0) {
    return Nothing;
  }
  if (v === 1) {
    return $Maybe("Just", { head: toCharCode(charAt(0)(s)), tail: "" });
  }
  const cu1 = toCharCode(charAt(1)(s));
  const cu0 = toCharCode(charAt(0)(s));
  if (55296 <= cu0 && cu0 <= 56319 && 56320 <= cu1 && cu1 <= 57343) {
    return $Maybe("Just", { head: (((cu0 - 55296 | 0) * 1024 | 0) + (cu1 - 56320 | 0) | 0) + 65536 | 0, tail: drop2(2)(s) });
  }
  return $Maybe("Just", { head: cu0, tail: drop2(1)(s) });
};
var unconsButWithTuple = (s) => {
  const $0 = uncons2(s);
  if ($0.tag === "Just") {
    return $Maybe("Just", $Tuple($0._1.head, $0._1.tail));
  }
  return Nothing;
};
var toCodePointArrayFallback = (s) => unfoldableArray.unfoldr(unconsButWithTuple)(s);
var unsafeCodePointAt0Fallback = (s) => {
  const cu0 = toCharCode(charAt(0)(s));
  if (55296 <= cu0 && cu0 <= 56319 && length2(s) > 1) {
    const cu1 = toCharCode(charAt(1)(s));
    if (56320 <= cu1 && cu1 <= 57343) {
      return (((cu0 - 55296 | 0) * 1024 | 0) + (cu1 - 56320 | 0) | 0) + 65536 | 0;
    }
  }
  return cu0;
};
var unsafeCodePointAt0 = /* @__PURE__ */ _unsafeCodePointAt0(unsafeCodePointAt0Fallback);
var toCodePointArray = /* @__PURE__ */ _toCodePointArray(toCodePointArrayFallback)(unsafeCodePointAt0);
var fromCharCode2 = (x) => singleton((() => {
  if (x >= -2147483648 && x <= 2147483647) {
    return fromCharCode(x);
  }
  if (x < 0) {
    return "\0";
  }
  return "\uFFFF";
})());
var singletonFallback = (v) => {
  if (v <= 65535) {
    return fromCharCode2(v);
  }
  return fromCharCode2(intDiv(v - 65536 | 0, 1024) + 55296 | 0) + fromCharCode2(intMod(v - 65536 | 0)(1024) + 56320 | 0);
};
var singleton2 = /* @__PURE__ */ _singleton(singletonFallback);
var takeFallback = (v) => (v1) => {
  if (v < 1) {
    return "";
  }
  const v2 = uncons2(v1);
  if (v2.tag === "Just") {
    return singleton2(v2._1.head) + takeFallback(v - 1 | 0)(v2._1.tail);
  }
  return v1;
};
var take2 = /* @__PURE__ */ _take(takeFallback);
var eqCodePoint = { eq: (x) => (y) => x === y };
var ordCodePoint = { compare: (x) => (y) => ordInt.compare(x)(y), Eq0: () => eqCodePoint };
var countTail = (countTail$a0$copy) => (countTail$a1$copy) => (countTail$a2$copy) => {
  let countTail$a0 = countTail$a0$copy, countTail$a1 = countTail$a1$copy, countTail$a2 = countTail$a2$copy, countTail$c = true, countTail$r;
  while (countTail$c) {
    const p = countTail$a0, s = countTail$a1, accum = countTail$a2;
    const v = uncons2(s);
    if (v.tag === "Just" && p(v._1.head)) {
      countTail$a0 = p;
      countTail$a1 = v._1.tail;
      countTail$a2 = accum + 1 | 0;
      continue;
    }
    countTail$c = false;
    countTail$r = accum;
  }
  return countTail$r;
};
var countFallback = (p) => (s) => countTail(p)(s)(0);
var countPrefix2 = /* @__PURE__ */ _countPrefix(countFallback)(unsafeCodePointAt0);
var codePointFromChar = (x) => toCharCode(x);
var boundedCodePoint = { bottom: 0, top: 1114111, Ord0: () => ordCodePoint };
var boundedEnumCodePoint = {
  cardinality: 1114112,
  fromEnum: (v) => v,
  toEnum: (n) => {
    if (n >= 0 && n <= 1114111) {
      return $Maybe("Just", n);
    }
    return Nothing;
  },
  Bounded0: () => boundedCodePoint,
  Enum1: () => enumCodePoint
};
var enumCodePoint = {
  succ: (a) => {
    const $0 = a + 1 | 0;
    if ($0 >= 0 && $0 <= 1114111) {
      return $Maybe("Just", $0);
    }
    return Nothing;
  },
  pred: (a) => {
    const $0 = a - 1 | 0;
    if ($0 >= 0 && $0 <= 1114111) {
      return $Maybe("Just", $0);
    }
    return Nothing;
  },
  Ord0: () => ordCodePoint
};

// output-es/Record.Builder/foreign.js
function unsafeInsert(l) {
  return function(a) {
    return function(rec) {
      rec[l] = a;
      return rec;
    };
  };
}

// output-es/Record.Builder/index.js
var buildFromScratch = (a) => a({});

// output-es/ArgParse.Basic/index.js
var $ArgError = (_1, _2) => ({ tag: "ArgError", _1, _2 });
var $ArgErrorMsg = (tag, _1) => ({ tag, _1 });
var $ArgHelp = (tag, _1, _2, _3) => ({ tag, _1, _2, _3 });
var $ArgParser = (_1, _2) => ({ tag: "ArgParser", _1, _2 });
var $ArgResult = (tag, _1, _2) => ({ tag, _1, _2 });
var $HelpClass = (tag, _1) => ({ tag, _1 });
var $HelpFmt = (tag, _1) => ({ tag, _1 });
var intercalate2 = /* @__PURE__ */ intercalate1(monoidString);
var power2 = /* @__PURE__ */ power(monoidString);
var max2 = (x) => (y) => {
  const v = ordInt.compare(x)(y);
  if (v === "LT") {
    return y;
  }
  if (v === "EQ") {
    return x;
  }
  if (v === "GT") {
    return x;
  }
  fail();
};
var eq = /* @__PURE__ */ eqArrayImpl(eqStringImpl);
var compare = /* @__PURE__ */ (() => ordArray(ordString).compare)();
var intercalate12 = /* @__PURE__ */ intercalate1(monoidArray);
var fromFoldable = /* @__PURE__ */ foldrArray(Cons)(Nil);
var identity8 = (x) => x;
var ExpectedFlag = /* @__PURE__ */ $ArgErrorMsg("ExpectedFlag");
var ExpectedArgValue = /* @__PURE__ */ $ArgErrorMsg("ExpectedArgValue");
var ExpectedArg = /* @__PURE__ */ $ArgErrorMsg("ExpectedArg");
var DuplicateArg = /* @__PURE__ */ $ArgErrorMsg("DuplicateArg");
var ShowHelp = /* @__PURE__ */ $ArgErrorMsg("ShowHelp");
var ArgError = (value0) => (value1) => $ArgError(value0, value1);
var ArgFail = /* @__PURE__ */ $ArgResult("ArgFail");
var unformat = (doc) => (unf) => (v) => {
  const go = (v1) => ({
    step: (stk) => (args) => {
      const v2 = v1.step(stk)(args);
      if (v2.tag === "ArgHalt") {
        if (v2._1._1.tag === "Cons") {
          return $ArgResult("ArgHalt", $ArgError($List("Cons", $ArgHelp("HelpFormat", doc, v._1), v2._1._1._2), v2._1._2));
        }
        return $ArgResult("ArgHalt", v2._1);
      }
      if (v2.tag === "ArgMatch") {
        return $ArgResult("ArgMatch", go(v2._1), v2._2);
      }
      if (v2.tag === "ArgFail") {
        return ArgFail;
      }
      fail();
    },
    done: (stk) => {
      const $0 = v1.done($List("Cons", $ArgHelp("HelpFormat", doc, v._1), stk));
      return (() => {
        if ($0.tag === "Left") {
          const $1 = $0._1;
          return (v$1) => $Either("Left", $1);
        }
        if ($0.tag === "Right") {
          const $1 = $0._1;
          return (f) => f($1);
        }
        fail();
      })()((value) => {
        const $1 = ArgError($List("Cons", $ArgHelp("HelpFormat", doc, v._1), stk));
        const $2 = unf(value);
        if ($2.tag === "Left") {
          return $Either("Left", $1($ArgErrorMsg("UnformatFailed", $2._1)));
        }
        if ($2.tag === "Right") {
          return $Either("Right", $2._1);
        }
        fail();
      });
    },
    saturated: v1.saturated
  });
  return $ArgParser($ArgHelp("HelpFormat", doc, v._1), go(v._2));
};
var semigroupHelp = {
  append: (v) => (v1) => {
    if (v.tag === "HelpArgs") {
      if (v1.tag === "HelpArgs") {
        return $ArgHelp("HelpArgs", [...v._1, ...v1._1]);
      }
      return $ArgHelp("HelpArgs", snoc(v._1)(v1));
    }
    if (v1.tag === "HelpArgs") {
      return $ArgHelp("HelpArgs", [v, ...v1._1]);
    }
    return $ArgHelp("HelpArgs", [v, v1]);
  }
};
var printHelpTable$p = (stk) => (v) => {
  if (v.tag === "HelpFlag") {
    const names = intercalate2(",")(v._1);
    if (stk.tag === "Cons" && stk._1.tag === "HelpFormat") {
      return [$Tuple($HelpClass("IsFlag", v._1), [$HelpFmt("Text", names + " " + stk._1._1), $HelpFmt("Text", v._2)])];
    }
    return [$Tuple($HelpClass("IsFlag", v._1), [$HelpFmt("Text", names), $HelpFmt("Text", v._2)])];
  }
  if (v.tag === "HelpAny") {
    if (stk.tag === "Cons" && stk._1.tag === "HelpFormat") {
      return [$Tuple($HelpClass("IsAny", stk._1._1), [$HelpFmt("Text", stk._1._1), $HelpFmt("Text", v._1)])];
    }
    return [$Tuple($HelpClass("IsAny", "ANY"), [$HelpFmt("Text", "ANY"), $HelpFmt("Text", v._1)])];
  }
  if (v.tag === "HelpRest") {
    return [$Tuple($HelpClass("IsAny", "--"), [$HelpFmt("Text", "--"), $HelpFmt("Text", v._1)])];
  }
  if (v.tag === "HelpCommand") {
    return [$Tuple($HelpClass("IsCommand", v._1), [$HelpFmt("Text", intercalate2(",")(v._1)), $HelpFmt("Text", v._2)])];
  }
  if (v.tag === "HelpFormat") {
    return printHelpTable$p($List("Cons", $ArgHelp("HelpFormat", v._1, v._2), stk))(v._2);
  }
  if (v.tag === "HelpChoose") {
    return arrayBind(v._2)(printHelpTable$p(stk));
  }
  if (v.tag === "HelpArgs") {
    return arrayBind(v._1)(printHelpTable$p(stk));
  }
  fail();
};
var parserHelp = (v) => v._1;
var parseArgs$p = (parseArgs$p$a0$copy) => (parseArgs$p$a1$copy) => (parseArgs$p$a2$copy) => {
  let parseArgs$p$a0 = parseArgs$p$a0$copy, parseArgs$p$a1 = parseArgs$p$a1$copy, parseArgs$p$a2 = parseArgs$p$a2$copy, parseArgs$p$c = true, parseArgs$p$r;
  while (parseArgs$p$c) {
    const v = parseArgs$p$a0, stk = parseArgs$p$a1, args = parseArgs$p$a2;
    const v1 = v.step(stk)(args);
    if (v1.tag === "ArgHalt") {
      parseArgs$p$c = false;
      parseArgs$p$r = $Either("Left", v1._1);
      continue;
    }
    if (v1.tag === "ArgMatch") {
      parseArgs$p$a0 = v1._1;
      parseArgs$p$a1 = stk;
      parseArgs$p$a2 = v1._2;
      continue;
    }
    if (v1.tag =