@explorable-viz/fluid
Version:
Fluid is an experimental programming language which integrates a bidirectional dynamic analysis to connect outputs to data sources in a fine-grained way. Fluid is implemented in PureScript and runs in the browser.
1,903 lines (1,842 loc) • 1.63 MB
JavaScript
// output-es/runtime.js
function binding(init6) {
let state = 0;
let value;
return () => {
if (state === 2) {
return value;
}
if (state === 1) {
throw new Error("Binding demanded before initialized");
}
state = 1;
value = init6();
state = 2;
return value;
};
}
function fail() {
throw new Error("Failed pattern match");
}
function intDiv(x2, y2) {
if (y2 > 0)
return Math.floor(x2 / y2);
if (y2 < 0)
return -Math.floor(x2 / -y2);
return 0;
}
// output-es/Record.Unsafe/foreign.js
var unsafeSet = function(label) {
return function(value) {
return function(rec) {
var copy2 = {};
for (var key in rec) {
if ({}.hasOwnProperty.call(rec, key)) {
copy2[key] = rec[key];
}
}
copy2[label] = value;
return copy2;
};
};
};
// output-es/Type.Proxy/index.js
var $$$Proxy = () => ({ tag: "Proxy" });
var $$Proxy = /* @__PURE__ */ $$$Proxy();
// output-es/Data.Eq/foreign.js
var refEq = function(r1) {
return function(r2) {
return r1 === r2;
};
};
var eqIntImpl = refEq;
var eqNumberImpl = refEq;
var eqCharImpl = 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 eqUnit = { eq: (v) => (v1) => true };
var eqString = { eq: eqStringImpl };
var eqNumber = { eq: eqNumberImpl };
var eqInt = { eq: eqIntImpl };
var eqChar = { eq: eqCharImpl };
// 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.Ord/foreign.js
var unsafeCompareImpl = function(lt) {
return function(eq2) {
return function(gt) {
return function(x2) {
return function(y2) {
return x2 < y2 ? lt : x2 === y2 ? eq2 : gt;
};
};
};
};
};
var ordIntImpl = unsafeCompareImpl;
var ordNumberImpl = unsafeCompareImpl;
var ordStringImpl = unsafeCompareImpl;
// 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 };
// output-es/Data.Show/foreign.js
var showIntImpl = function(n) {
return n.toString();
};
var showNumberImpl = function(n) {
var str = n.toString();
return isNaN(str + ".0") ? str : str + ".0";
};
var showCharImpl = function(c) {
var code = c.charCodeAt(0);
if (code < 32 || code === 127) {
switch (c) {
case "\x07":
return "'\\a'";
case "\b":
return "'\\b'";
case "\f":
return "'\\f'";
case "\n":
return "'\\n'";
case "\r":
return "'\\r'";
case " ":
return "'\\t'";
case "\v":
return "'\\v'";
}
return "'\\" + code.toString(10) + "'";
}
return c === "'" || c === "\\" ? "'\\" + c + "'" : "'" + c + "'";
};
var showStringImpl = function(s) {
var l = s.length;
return '"' + s.replace(
/[\0-\x1F\x7F"\\]/g,
function(c, i) {
switch (c) {
case '"':
case "\\":
return "\\" + c;
case "\x07":
return "\\a";
case "\b":
return "\\b";
case "\f":
return "\\f";
case "\n":
return "\\n";
case "\r":
return "\\r";
case " ":
return "\\t";
case "\v":
return "\\v";
}
var k = i + 1;
var empty4 = k < l && s[k] >= "0" && s[k] <= "9" ? "\\&" : "";
return "\\" + c.charCodeAt(0).toString(10) + empty4;
}
) + '"';
};
var showArrayImpl = function(f) {
return function(xs) {
var ss = [];
for (var i = 0, l = xs.length; i < l; i++) {
ss[i] = f(xs[i]);
}
return "[" + ss.join(",") + "]";
};
};
var cons = function(head) {
return function(tail4) {
return [head].concat(tail4);
};
};
var intercalate = function(separator) {
return function(xs) {
return xs.join(separator);
};
};
// output-es/Data.Show/index.js
var showString = { show: showStringImpl };
var showNumber = { show: showNumberImpl };
var showInt = { show: showIntImpl };
var showBoolean = {
show: (v) => {
if (v) {
return "true";
}
return "false";
}
};
// output-es/Affjax.RequestHeader/index.js
var $RequestHeader = (tag, _1, _2) => ({ tag, _1, _2 });
// output-es/Data.Generic.Rep/index.js
var $NoArguments = () => ({ tag: "NoArguments" });
var $Product = (_1, _2) => ({ tag: "Product", _1, _2 });
var $Sum = (tag, _1) => ({ tag, _1 });
var NoArguments = /* @__PURE__ */ $NoArguments();
// output-es/Data.Maybe/index.js
var $Maybe = (tag, _1) => ({ tag, _1 });
var Nothing = /* @__PURE__ */ $Maybe("Nothing");
var Just = (value0) => $Maybe("Just", value0);
var isNothing = (v2) => {
if (v2.tag === "Nothing") {
return true;
}
if (v2.tag === "Just") {
return false;
}
fail();
};
var functorMaybe = {
map: (v) => (v1) => {
if (v1.tag === "Just") {
return $Maybe("Just", v(v1._1));
}
return Nothing;
}
};
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
};
var applicativeMaybe = { pure: Just, Apply0: () => applyMaybe };
// output-es/Affjax.ResponseFormat/index.js
var $ResponseFormat = (tag, _1) => ({ tag, _1 });
var identity = (x2) => x2;
// output-es/Affjax.ResponseHeader/index.js
var $ResponseHeader = (_1, _2) => ({ tag: "ResponseHeader", _1, _2 });
var ResponseHeader = (value0) => (value1) => $ResponseHeader(value0, value1);
// 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 choose = (dictAlt) => {
const $0 = dictAlt.Functor0();
return (a) => (b) => dictAlt.alt($0.map(Left)(a))($0.map(Right)(b));
};
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 };
var altEither = {
alt: (v) => (v1) => {
if (v.tag === "Left") {
return v1;
}
return v;
},
Functor0: () => functorEither
};
// 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/Effect.Exception/foreign.js
function showErrorImpl(err) {
return err.stack || err.toString();
}
function error(msg) {
return new Error(msg);
}
function message(e) {
return e.message;
}
function throwException(e) {
return function() {
throw e;
};
}
// output-es/Control.Monad.Error.Class/index.js
var monadThrowEffect = { throwError: throwException, Monad0: () => monadEffect };
var $$try = (dictMonadError) => {
const Monad0 = dictMonadError.MonadThrow0().Monad0();
return (a) => dictMonadError.catchError(Monad0.Bind1().Apply0().Functor0().map(Right)(a))((x2) => Monad0.Applicative0().pure($Either("Left", x2)));
};
// output-es/Data.Function/index.js
var $$const = (a) => (v) => a;
var applyFlipped = (x2) => (f) => f(x2);
var apply = (f) => (x2) => f(x2);
// output-es/Control.Semigroupoid/index.js
var semigroupoidFn = { compose: (f) => (g) => (x2) => f(g(x2)) };
// 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 identity2 = (x2) => x2;
// 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 identity3 = (x2) => x2;
// output-es/Data.Identity/index.js
var Identity = (x2) => x2;
var functorIdentity = { map: (f) => (m) => f(m) };
var applyIdentity = { apply: (v) => (v1) => v(v1), Functor0: () => functorIdentity };
var bindIdentity = { bind: (v) => (f) => f(v), Apply0: () => applyIdentity };
var applicativeIdentity = { pure: Identity, Apply0: () => applyIdentity };
var monadIdentity = { Applicative0: () => applicativeIdentity, Bind1: () => bindIdentity };
// output-es/Control.Monad.Rec.Class/index.js
var $Step = (tag, _1) => ({ tag, _1 });
var Loop = (value0) => $Step("Loop", value0);
var monadRecIdentity = {
tailRecM: (f) => {
const go = (go$a0$copy) => {
let go$a0 = go$a0$copy, go$c = true, go$r;
while (go$c) {
const v = go$a0;
if (v.tag === "Loop") {
go$a0 = f(v._1);
continue;
}
if (v.tag === "Done") {
go$c = false;
go$r = v._1;
continue;
}
fail();
}
return go$r;
};
return (x2) => go(f(x2));
},
Monad0: () => monadIdentity
};
// output-es/Data.Tuple/index.js
var $Tuple = (_1, _2) => ({ tag: "Tuple", _1, _2 });
var Tuple = (value0) => (value1) => $Tuple(value0, value1);
var swap = (v) => $Tuple(v._2, v._1);
var snd = (v) => v._2;
var functorTuple = { map: (f) => (m) => $Tuple(m._1, f(m._2)) };
var fst = (v) => v._1;
var ordTuple = (dictOrd) => {
const $0 = dictOrd.Eq0();
return (dictOrd1) => {
const $1 = dictOrd1.Eq0();
const eqTuple2 = { eq: (x2) => (y2) => $0.eq(x2._1)(y2._1) && $1.eq(x2._2)(y2._2) };
return {
compare: (x2) => (y2) => {
const v = dictOrd.compare(x2._1)(y2._1);
if (v === "LT") {
return LT;
}
if (v === "GT") {
return GT;
}
return dictOrd1.compare(x2._2)(y2._2);
},
Eq0: () => eqTuple2
};
};
};
// output-es/Control.Monad.Except.Trans/index.js
var bindExceptT = (dictMonad) => ({
bind: (v) => (k) => dictMonad.Bind1().bind(v)((v2) => {
if (v2.tag === "Left") {
return dictMonad.Applicative0().pure($Either("Left", v2._1));
}
if (v2.tag === "Right") {
return k(v2._1);
}
fail();
}),
Apply0: () => applyExceptT(dictMonad)
});
var applyExceptT = (dictMonad) => {
const $0 = dictMonad.Bind1().Apply0().Functor0();
const functorExceptT1 = {
map: (f) => $0.map((m) => {
if (m.tag === "Left") {
return $Either("Left", m._1);
}
if (m.tag === "Right") {
return $Either("Right", f(m._1));
}
fail();
})
};
return {
apply: (() => {
const $1 = bindExceptT(dictMonad);
return (f) => (a) => $1.bind(f)((f$p) => $1.bind(a)((a$p) => applicativeExceptT(dictMonad).pure(f$p(a$p))));
})(),
Functor0: () => functorExceptT1
};
};
var applicativeExceptT = (dictMonad) => ({ pure: (x2) => dictMonad.Applicative0().pure($Either("Right", x2)), Apply0: () => applyExceptT(dictMonad) });
var monadThrowExceptT = (dictMonad) => {
const monadExceptT1 = { Applicative0: () => applicativeExceptT(dictMonad), Bind1: () => bindExceptT(dictMonad) };
return { throwError: (x2) => dictMonad.Applicative0().pure($Either("Left", x2)), Monad0: () => monadExceptT1 };
};
var monadErrorExceptT = (dictMonad) => {
const monadThrowExceptT1 = monadThrowExceptT(dictMonad);
return {
catchError: (v) => (k) => dictMonad.Bind1().bind(v)((v2) => {
if (v2.tag === "Left") {
return k(v2._1);
}
if (v2.tag === "Right") {
return dictMonad.Applicative0().pure($Either("Right", v2._1));
}
fail();
}),
MonadThrow0: () => monadThrowExceptT1
};
};
var altExceptT = (dictSemigroup) => (dictMonad) => {
const Bind1 = dictMonad.Bind1();
const $0 = dictMonad.Applicative0();
const $1 = Bind1.Apply0().Functor0();
const functorExceptT1 = {
map: (f) => $1.map((m) => {
if (m.tag === "Left") {
return $Either("Left", m._1);
}
if (m.tag === "Right") {
return $Either("Right", f(m._1));
}
fail();
})
};
return {
alt: (v) => (v1) => Bind1.bind(v)((rm) => {
if (rm.tag === "Right") {
return $0.pure($Either("Right", rm._1));
}
if (rm.tag === "Left") {
const $2 = rm._1;
return Bind1.bind(v1)((rn) => {
if (rn.tag === "Right") {
return $0.pure($Either("Right", rn._1));
}
if (rn.tag === "Left") {
return $0.pure($Either("Left", dictSemigroup.append($2)(rn._1)));
}
fail();
});
}
fail();
}),
Functor0: () => functorExceptT1
};
};
// output-es/Control.Monad.ST.Internal/foreign.js
var map_ = function(f) {
return function(a) {
return function() {
return f(a());
};
};
};
var pure_ = function(a) {
return function() {
return a;
};
};
var bind_ = function(a) {
return function(f) {
return function() {
return f(a())();
};
};
};
// output-es/Control.Monad.ST.Internal/index.js
var functorST = { map: map_ };
var monadST = { Applicative0: () => applicativeST, Bind1: () => bindST };
var bindST = { bind: bind_, Apply0: () => applyST };
var applyST = {
apply: (f) => (a) => () => {
const f$p = f();
const a$p = a();
return applicativeST.pure(f$p(a$p))();
},
Functor0: () => functorST
};
var applicativeST = { pure: pure_, Apply0: () => applyST };
var monadRecST = {
tailRecM: (f) => (a) => {
const $0 = f(a);
return () => {
const $1 = $0();
let r = $1;
while ((() => {
const $22 = r;
return $22.tag === "Loop";
})()) {
const v = r;
if (v.tag === "Loop") {
const e = f(v._1)();
r = e;
continue;
}
if (v.tag === "Done") {
continue;
}
fail();
}
const $2 = r;
if ($2.tag === "Done") {
return $2._1;
}
fail();
};
},
Monad0: () => monadST
};
// 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;
var sortByImpl = function() {
function mergeFromTo(compare2, fromOrdering, xs1, xs2, from, to) {
var mid;
var i;
var j;
var k;
var x2;
var y2;
var c;
mid = from + (to - from >> 1);
if (mid - from > 1)
mergeFromTo(compare2, fromOrdering, xs2, xs1, from, mid);
if (to - mid > 1)
mergeFromTo(compare2, fromOrdering, xs2, xs1, mid, to);
i = from;
j = mid;
k = from;
while (i < mid && j < to) {
x2 = xs2[i];
y2 = xs2[j];
c = fromOrdering(compare2(x2)(y2));
if (c > 0) {
xs1[k++] = y2;
++j;
} else {
xs1[k++] = x2;
++i;
}
}
while (i < mid) {
xs1[k++] = xs2[i++];
}
while (j < to) {
xs1[k++] = xs2[j++];
}
}
return function(compare2) {
return function(fromOrdering) {
return function(xs) {
return function() {
if (xs.length < 2)
return xs;
mergeFromTo(compare2, fromOrdering, xs, xs.slice(0), 0, xs.length);
return xs;
};
};
};
};
}();
// output-es/Data.Array.ST/index.js
var push = (a) => pushAll([a]);
// output-es/Data.Foldable/foreign.js
var foldrArray = function(f) {
return function(init6) {
return function(xs) {
var acc = init6;
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(init6) {
return function(xs) {
var acc = init6;
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 identity4 = (x2) => x2;
var monoidEndo = /* @__PURE__ */ (() => {
const semigroupEndo1 = { append: (v) => (v1) => (x2) => v(v1(x2)) };
return { mempty: (x2) => x2, Semigroup0: () => semigroupEndo1 };
})();
var traverse_ = (dictApplicative) => {
const $0 = dictApplicative.Apply0();
return (dictFoldable) => (f) => dictFoldable.foldr((x2) => {
const $1 = f(x2);
return (b) => $0.apply($0.Functor0().map((v) => identity2)($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 foldableTuple = { foldr: (f) => (z) => (v) => f(v._2)(z), foldl: (f) => (z) => (v) => f(z)(v._2), foldMap: (dictMonoid) => (f) => (v) => f(v._2) };
var foldableArray = {
foldr: foldrArray,
foldl: foldlArray,
foldMap: (dictMonoid) => {
const mempty = dictMonoid.mempty;
return (f) => foldableArray.foldr((x2) => (acc) => dictMonoid.Semigroup0().append(f(x2))(acc))(mempty);
}
};
var foldrDefault = (dictFoldable) => {
const foldMap22 = dictFoldable.foldMap(monoidEndo);
return (c) => (u) => (xs) => foldMap22((x2) => c(x2))(xs)(u);
};
// output-es/Unsafe.Coerce/foreign.js
var unsafeCoerce = function(x2) {
return x2;
};
// output-es/Data.Traversable/foreign.js
var traverseArrayImpl = 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 concat2(xs) {
return function(ys) {
return xs.concat(ys);
};
}
return function(apply4) {
return function(map3) {
return function(pure3) {
return function(f) {
return function(array4) {
function go(bot2, top3) {
switch (top3 - bot2) {
case 0:
return pure3([]);
case 1:
return map3(array1)(f(array4[bot2]));
case 2:
return apply4(map3(array2)(f(array4[bot2])))(f(array4[bot2 + 1]));
case 3:
return apply4(apply4(map3(array3)(f(array4[bot2])))(f(array4[bot2 + 1])))(f(array4[bot2 + 2]));
default:
var pivot = bot2 + Math.floor((top3 - bot2) / 4) * 2;
return apply4(map3(concat2)(go(bot2, pivot)))(go(pivot, top3));
}
}
return go(0, array4.length);
};
};
};
};
};
}();
// output-es/Data.Traversable/index.js
var identity5 = (x2) => x2;
var traversableTuple = {
traverse: (dictApplicative) => (f) => (v) => dictApplicative.Apply0().Functor0().map(Tuple(v._1))(f(v._2)),
sequence: (dictApplicative) => (v) => dictApplicative.Apply0().Functor0().map(Tuple(v._1))(v._2),
Functor0: () => functorTuple,
Foldable1: () => foldableTuple
};
var traversableArray = {
traverse: (dictApplicative) => {
const Apply0 = dictApplicative.Apply0();
return traverseArrayImpl(Apply0.apply)(Apply0.Functor0().map)(dictApplicative.pure);
},
sequence: (dictApplicative) => traversableArray.traverse(dictApplicative)(identity5),
Functor0: () => functorArray,
Foldable1: () => foldableArray
};
// output-es/Data.Array/foreign.js
var range = function(start2) {
return function(end) {
var step = start2 > end ? -1 : 1;
var result = new Array(step * (end - start2) + 1);
var i = start2, 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 = function() {
function Cons2(head, tail4) {
this.head = head;
this.tail = tail4;
}
var emptyList = {};
function curryCons(head) {
return function(tail4) {
return new Cons2(head, tail4);
};
}
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(foldr2) {
return function(xs) {
return listToArray(foldr2(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 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 _updateAt = function(just) {
return function(nothing) {
return function(i) {
return function(a) {
return function(l) {
if (i < 0 || i >= l.length)
return nothing;
var l1 = l.slice();
l1[i] = a;
return just(l1);
};
};
};
};
};
var concat = function(xss) {
if (xss.length <= 1e4) {
return Array.prototype.concat.apply([], xss);
}
var result = [];
for (var i = 0, l = xss.length; i < l; i++) {
var xs = xss[i];
for (var j = 0, m = xs.length; j < m; j++) {
result.push(xs[j]);
}
}
return result;
};
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 x2 = xs[i];
if (f(x2))
yes.push(x2);
else
no.push(x2);
}
return { yes, no };
};
};
var sortByImpl2 = function() {
function mergeFromTo(compare2, fromOrdering, xs1, xs2, from, to) {
var mid;
var i;
var j;
var k;
var x2;
var y2;
var c;
mid = from + (to - from >> 1);
if (mid - from > 1)
mergeFromTo(compare2, fromOrdering, xs2, xs1, from, mid);
if (to - mid > 1)
mergeFromTo(compare2, fromOrdering, xs2, xs1, mid, to);
i = from;
j = mid;
k = from;
while (i < mid && j < to) {
x2 = xs2[i];
y2 = xs2[j];
c = fromOrdering(compare2(x2)(y2));
if (c > 0) {
xs1[k++] = y2;
++j;
} else {
xs1[k++] = x2;
++i;
}
}
while (i < mid) {
xs1[k++] = xs2[i++];
}
while (j < to) {
xs1[k++] = xs2[j++];
}
}
return function(compare2) {
return function(fromOrdering) {
return function(xs) {
var out;
if (xs.length < 2)
return xs;
out = xs.slice(0);
mergeFromTo(compare2, 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;
};
};
};
// output-es/Data.Array/index.js
var zip = /* @__PURE__ */ zipWith(Tuple);
var updateAt = /* @__PURE__ */ _updateAt(Just)(Nothing);
var uncons = /* @__PURE__ */ unconsImpl((v) => Nothing)((x2) => (xs) => $Maybe("Just", { head: x2, tail: xs }));
var toUnfoldable = (dictUnfoldable) => (xs) => {
const len = xs.length;
return dictUnfoldable.unfoldr((i) => {
if (i < len) {
return $Maybe("Just", $Tuple(xs[i], i + 1 | 0));
}
return Nothing;
})(0);
};
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((x2) => (y2) => dictOrd.compare(f(x2))(f(y2)));
var snoc = (xs) => (x2) => (() => {
const $0 = push(x2);
const $1 = thaw(xs);
return () => {
const result = $1();
$0(result)();
return result;
};
})()();
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 nubBy = (comp) => (xs) => {
const indexedAndSorted = sortBy((x2) => (y2) => comp(x2._2)(y2._2))(zipWith(Tuple)(range(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 findIndex = /* @__PURE__ */ findIndexImpl(Just)(Nothing);
var notElem = (dictEq) => (a) => (arr) => {
const $0 = findIndex((v) => dictEq.eq(v)(a))(arr);
if ($0.tag === "Nothing") {
return true;
}
if ($0.tag === "Just") {
return false;
}
fail();
};
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 cons2 = (x2) => (xs) => [x2, ...xs];
var some = (dictAlternative) => (dictLazy) => (v) => dictAlternative.Applicative0().Apply0().apply(dictAlternative.Plus1().Alt0().Functor0().map(cons2)(v))(dictLazy.defer((v1) => many(dictAlternative)(dictLazy)(v)));
var many = (dictAlternative) => (dictLazy) => (v) => dictAlternative.Plus1().Alt0().alt(some(dictAlternative)(dictLazy)(v))(dictAlternative.Applicative0().pure([]));
// 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.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
};
var replicate2 = (dictUnfoldable) => (n) => (v) => dictUnfoldable.unfoldr((i) => {
if (i <= 0) {
return Nothing;
}
return $Maybe("Just", $Tuple(v, i - 1 | 0));
})(n);
// output-es/Foreign.Object/foreign.js
var empty = {};
function _fmapObject(m0, f) {
var m = {};
for (var k in m0) {
if (hasOwnProperty.call(m0, k)) {
m[k] = f(m0[k]);
}
}
return m;
}
function _mapWithKey(m0, f) {
var m = {};
for (var k in m0) {
if (hasOwnProperty.call(m0, k)) {
m[k] = f(k)(m0[k]);
}
}
return m;
}
function _foldM(bind) {
return function(f) {
return function(mz) {
return function(m) {
var acc = mz;
function g(k2) {
return function(z) {
return f(z)(k2)(m[k2]);
};
}
for (var k in m) {
if (hasOwnProperty.call(m, k)) {
acc = bind(acc)(g(k));
}
}
return acc;
};
};
};
}
function all2(f) {
return function(m) {
for (var k in m) {
if (hasOwnProperty.call(m, k) && !f(k)(m[k]))
return false;
}
return true;
};
}
function size(m) {
var s = 0;
for (var k in m) {
if (hasOwnProperty.call(m, k)) {
++s;
}
}
return s;
}
function _lookup(no, yes, k, m) {
return k in m ? yes(m[k]) : no;
}
function toArrayWithKey(f) {
return function(m) {
var r = [];
for (var k in m) {
if (hasOwnProperty.call(m, k)) {
r.push(f(k)(m[k]));
}
}
return r;
};
}
var keys = Object.keys || toArrayWithKey(function(k) {
return function() {
return k;
};
});
// output-es/Foreign.Object/index.js
var identity6 = (x2) => x2;
var values = /* @__PURE__ */ toArrayWithKey((v) => (v1) => v1);
var toAscUnfoldable = (dictUnfoldable) => {
const $0 = sortWith(ordString)(fst);
const $1 = toArrayWithKey(Tuple);
return (x2) => toUnfoldable(dictUnfoldable)($0($1(x2)));
};
var singleton = (k) => (v) => {
const $0 = {};
$0[k] = v;
return $0;
};
var mutate = (f) => (m) => {
const s = { ...m };
f(s)();
return s;
};
var member = ($0) => ($1) => _lookup(false, (v) => true, $0, $1);
var mapWithKey = (f) => (m) => _mapWithKey(m, f);
var lookup = ($0) => ($1) => _lookup(Nothing, Just, $0, $1);
var isSubmap = (dictEq) => (m1) => (m2) => all2((k) => (v) => _lookup(false, dictEq.eq(v), k, m2))(m1);
var isEmpty = /* @__PURE__ */ all2((v) => (v1) => false);
var insert = (k) => (v) => mutate(($0) => () => {
$0[k] = v;
return $0;
});
var functorObject = { map: (f) => (m) => _fmapObject(m, f) };
var functorWithIndexObject = { mapWithIndex: mapWithKey, Functor0: () => functorObject };
var fromFoldable = (dictFoldable) => {
const fromFoldable114 = fromFoldableImpl(dictFoldable.foldr);
return (l) => {
const s = {};
for (const v of fromFoldable114(l)) {
s[v._1] = v._2;
}
return s;
};
};
var foldM = (dictMonad) => {
const bind1 = dictMonad.Bind1().bind;
return (f) => (z) => _foldM(bind1)(f)(dictMonad.Applicative0().pure(z));
};
var foldM1 = /* @__PURE__ */ foldM(monadST);
var union = (m) => mutate((s) => foldM1((s$p) => (k) => (v) => () => {
s$p[k] = v;
return s$p;
})(s)(m));
var unionWith = (f) => (m1) => (m2) => mutate((s1) => foldM1((s2) => (k) => (v1) => {
const $0 = _lookup(v1, (v2) => f(v1)(v2), k, m2);
return () => {
s2[k] = $0;
return s2;
};
})(s1)(m1))(m2);
var fold = /* @__PURE__ */ _foldM(applyFlipped);
var foldMap = (dictMonoid) => {
const mempty = dictMonoid.mempty;
return (f) => fold((acc) => (k) => (v) => dictMonoid.Semigroup0().append(acc)(f(k)(v)))(mempty);
};
var foldableObject = {
foldl: (f) => fold((z) => (v) => f(z)),
foldr: (f) => (z) => (m) => foldrArray(f)(z)(values(m)),
foldMap: (dictMonoid) => {
const foldMap1 = foldMap(dictMonoid);
return (f) => foldMap1((v) => f);
}
};
var foldableWithIndexObject = {
foldlWithIndex: (f) => fold((b) => (a) => f(a)(b)),
foldrWithIndex: (f) => (z) => (m) => foldrArray((v) => f(v._1)(v._2))(z)(toArrayWithKey(Tuple)(m)),
foldMapWithIndex: (dictMonoid) => foldMap(dictMonoid),
Foldable0: () => foldableObject
};
var traversableWithIndexObject = {
traverseWithIndex: (dictApplicative) => {
const Apply0 = dictApplicative.Apply0();
return (f) => (ms) => fold((acc) => (k) => (v) => Apply0.apply(Apply0.Functor0().map((b) => (a) => mutate(($0) => () => {
$0[k] = a;
return $0;
})(b))(acc))(f(k)(v)))(dictApplicative.pure(empty))(ms);
},
FunctorWithIndex0: () => functorWithIndexObject,
FoldableWithIndex1: () => foldableWithIndexObject,
Traversable2: () => traversableObject
};
var traversableObject = {
traverse: (dictApplicative) => {
const $0 = traversableWithIndexObject.traverseWithIndex(dictApplicative);
return (x2) => $0((v) => x2);
},
sequence: (dictApplicative) => traversableObject.traverse(dictApplicative)(identity6),
Functor0: () => functorObject,
Foldable1: () => foldableObject
};
var filterWithKey = (predicate) => (m) => {
const m$p = {};
return foldM1((acc) => (k) => (v) => {
if (predicate(k)(v)) {
return () => {
acc[k] = v;
return acc;
};
}
return () => acc;
})(m$p)(m)();
};
var filterKeys = (predicate) => filterWithKey((x2) => {
const $0 = predicate(x2);
return (v) => $0;
});
var eqObject = (dictEq) => ({ eq: (m1) => (m2) => isSubmap(dictEq)(m1)(m2) && isSubmap(dictEq)(m2)(m1) });
var $$delete = (k) => mutate(($0) => () => {
delete $0[k];
return $0;
});
// output-es/Data.Argonaut.Core/foreign.js
function id(x2) {
return x2;
}
function stringify(j) {
return JSON.stringify(j);
}
function _caseJson(isNull2, isBool, isNum, isStr, isArr, isObj, j) {
if (j == null)
return isNull2();
else if (typeof j === "boolean")
return isBool(j);
else if (typeof j === "number")
return isNum(j);
else if (typeof j === "string")
return isStr(j);
else if (Object.prototype.toString.call(j) === "[object Array]")
return isArr(j);
else
return isObj(j);
}
// output-es/Data.Argonaut.Core/index.js
var jsonEmptyObject = /* @__PURE__ */ id(empty);
var caseJsonString = (d) => (f) => (j) => _caseJson((v) => d, (v) => d, (v) => d, f, (v) => d, (v) => d, j);
// output-es/Data.Argonaut.Parser/foreign.js
function _jsonParser(fail3, succ, s) {
try {
return succ(JSON.parse(s));
} catch (e) {
return fail3(e.message);
}
}
// output-es/Data.Semiring/foreign.js
var intAdd = function(x2) {
return function(y2) {
return x2 + y2 | 0;
};
};
var intMul = function(x2) {
return function(y2) {
return x2 * y2 | 0;
};
};
var numAdd = function(n1) {
return function(n2) {
return n1 + n2;
};
};
var numMul = function(n1) {
return function(n2) {
return n1 * n2;
};
};
// output-es/Data.Ring/foreign.js
var intSub = function(x2) {
return function(y2) {
return x2 - y2 | 0;
};
};
var numSub = function(n1) {
return function(n2) {
return n1 - n2;
};
};
// output-es/Data.EuclideanRing/foreign.js
var intDiv2 = function(x2) {
return function(y2) {
if (y2 === 0)
return 0;
return y2 > 0 ? Math.floor(x2 / y2) : -Math.floor(x2 / -y2);
};
};
var intMod = function(x2) {
return function(y2) {
if (y2 === 0)
return 0;
var yy = Math.abs(y2);
return (x2 % yy + yy) % yy;
};
};
var numDiv = function(n1) {
return function(n2) {
return n1 / n2;
};
};
// output-es/Data.Semigroup/foreign.js
var concatString = function(s1) {
return function(s2) {
return s1 + s2;
};
};
// 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(sep) {
return function(s) {
return s.split(sep);
};
};
var toLower = function(s) {
return s.toLowerCase();
};
var joinWith = function(s) {
return function(xs) {
return xs.join(s);
};
};
// output-es/JSURI/foreign.js
function toRFC3896(input) {
return input.replace(/[!'()*]/g, function(c) {
return "%" + c.charCodeAt(0).toString(16);
});
}
var _encodeFormURLComponent = function encode(fail3, succeed, input) {
try {
return succeed(toRFC3896(encodeURIComponent(input)).replace(/%20/g, "+"));
} catch (err) {
return fail3(err);
}
};
// output-es/Data.FormURLEncoded/index.js
var traverse = /* @__PURE__ */ (() => traversableArray.traverse(applicativeMaybe))();
var encode2 = /* @__PURE__ */ (() => {
const $0 = functorMaybe.map(joinWith("&"));
const $1 = traverse((v) => {
if (v._2.tag === "Nothing") {
return _encodeFormURLComponent((v$1) => Nothing, Just, v._1);
}
if (v._2.tag === "Just") {
return applyMaybe.apply((() => {
const $12 = _encodeFormURLComponent((v$1) => Nothing, Just, v._1);
if ($12.tag === "Just") {
return $Maybe(
"Just",
(() => {
const $2 = $12._1;
return (val) => $2 + "=" + val;
})()
);
}
return Nothing;
})())(_encodeFormURLComponent((v$1) => Nothing, Just, v._2._1));
}
fail();
});
return (x2) => $0($1(x2));
})();
// output-es/Data.HTTP.Method/index.js
var $Method = (tag) => tag;
var GET = /* @__PURE__ */ $Method("GET");
var HEAD = /* @__PURE__ */ $Method("HEAD");
var print = (v2) => {
if (v2.tag === "Left") {
if (v2._1 === "OPTIONS") {
return "OPTIONS";
}
if (v2._1 === "GET") {
return "GET";
}
if (v2._1 === "HEAD") {
return "HEAD";
}
if (v2._1 === "POST") {
return "POST";
}
if (v2._1 === "PUT") {
return "PUT";
}
if (v2._1 === "DELETE") {
return "DELETE";
}
if (v2._1 === "TRACE") {
return "TRACE";
}
if (v2._1 === "CONNECT") {
return "CONNECT";
}
if (v2._1 === "PROPFIND") {
return "PROPFIND";
}
if (v2._1 === "PROPPATCH") {
return "PROPPATCH";
}
if (v2._1 === "MKCOL") {
return "MKCOL";
}
if (v2._1 === "COPY") {
return "COPY";
}
if (v2._1 === "MOVE") {
return "MOVE";
}
if (v2._1 === "LOCK") {
return "LOCK";
}
if (v2._1 === "UNLOCK") {
return "UNLOCK";
}
if (v2._1 === "PATCH") {
return "PATCH";
}
fail();
}
if (v2.tag === "Right") {
return v2._1;
}
fail();
};
// output-es/Data.NonEmpty/index.js
var $NonEmpty = (_1, _2) => ({ tag: "NonEmpty", _1, _2 });
var NonEmpty = (value0) => (value1) => $NonEmpty(value0, value1);
var traversableNonEmpty = (dictTraversable) => {
const $0 = dictTraversable.Functor0();
const functorNonEmpty1 = { map: (f) => (m) => $NonEmpty(f(m._1), $0.map(f)(m._2)) };
const $1 = dictTraversable.Foldable1();
const foldableNonEmpty1 = {
foldMap: (dictMonoid) => {
const foldMap1 = $1.foldMap(dictMonoid);
return (f) => (v) => dictMonoid.Semigroup0().append(f(v._1))(foldMap1(f)(v._2));
},
foldl: (f) => (b) => (v) => $1.foldl(f)(f(b)(v._1))(v._2),
foldr: (f) => (b) => (v) => f(v._1)($1.foldr(f)(b)(v._2))
};
return {
sequence: (dictApplicative) => {
const Apply0 = dictApplicative.Apply0();
const sequence1 = dictTraversable.sequence(dictApplicative);
return (v) => Apply0.apply(Apply0.Functor0().map(NonEmpty)(v._1))(sequence1(v._2));
},
traverse: (dictApplicative) => {
const Apply0 = dictApplicative.Apply0();
const traverse1 = dictTraversable.traverse(dictApplicative);
return (f) => (v) => Apply0.apply(Apply0.Functor0().map(NonEmpty)(f(v._1)))(traverse1(f)(v._2));
},
Functor0: () => functorNonEmpty1,
Foldable1: () => foldableNonEmpty1
};
};
var foldable1NonEmpty = (dictFoldable) => {
const foldableNonEmpty1 = {
foldMap: (dictMonoid) => {
const foldMap1 = dictFoldable.foldMap(dictMonoid);
return (f) => (v) => dictMonoid.Semigroup0().append(f(v._1))(foldMap1(f)(v._2));
},
foldl: (f) => (b) => (v) => dictFoldable.foldl(f)(f(b)(v._1))(v._2),
foldr: (f) => (b) => (v) => f(v._1)(dictFoldable.foldr(f)(b)(v._2))
};
return {
foldMap1: (dictSemigroup) => (f) => (v) => dictFoldable.foldl((s) => (a1) => dictSemigroup.append(s)(f(a1)))(f(v._1))(v._2),
foldr1: (f) => (v) => {
const $0 = f(v._1);
const $1 = dictFoldable.foldr((a1) => {
const $12 = f(a1);
return (x2) => $Maybe(
"Just",
(() => {
if (x2.tag === "Nothing") {
return a1;
}
if (x2.tag === "Just") {
return $12(x2._1);
}
fail();
})()
);
})(Nothing)(v._2);
if ($1.tag === "Nothing") {
return v._1;
}
if ($1.tag === "Just") {
return $0($1._1);
}
fail();
},
foldl1: (f) => (v) => dictFoldable.foldl(f)(v._1)(v._2),
Foldable0: () => foldableNonEmpty1
};
};
// output-es/Data.List.Types/index.js
var $List = (tag, _1, _2) => ({ tag, _1, _2 });
var identity7 = (x2) => x2;
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 functorList = { map: listMap };
var functorNonEmptyList = { map: (f) => (m) => $NonEmpty(f(m._1), listMap(f)(m._2)) };
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 (x2) => $0($1(x2));
},
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 mempty = dictMonoid.mempty;
return (f) => foldableList.foldl((acc) => {
const $0 = dictMonoid.Semigroup0().append(acc);
return (x2) => $0(f(x2));
})(mempty);
}
};
var foldableNonEmptyList = {
foldMap: (dictMonoid) => {
const foldMap1 = foldableList.foldMap(dictMonoid);
return (f) => (v) => dictMonoid.Semigroup0().append(f(v._1))(foldMap1(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 semigroupNonEmptyList = { append: (v) => (as$p) => $NonEmpty(v._1, foldableList.foldr(Cons)($List("Cons", as$p._1, as$p._2))(v._2)) };
var showList = (dictShow) => {
const show4 = dictShow.show;
return {
show: (v) => {
if (v.tag === "Nil") {
return "Nil";
}
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$1 = go$a1;
if (v$1.tag === "Nil") {
go$c = false;
go$r = b;
continue;
}
if (v$1.tag === "Cons") {
go$a0 = b.init ? { init: false, acc: v$1._1 } : { init: false, acc: b.acc + " : " + v$1._1 };
go$a1 = v$1._2;
continue;
}
fail();
}
return go$r;
};
return "(" + go({ init: true, acc: "" })(listMap(show4)(v)).acc + " : Nil)";
}
};
};
var showNonEmptyList = (dictShow) => {
const $0 = showList(dictShow);
return { show: (v) => "(NonEmptyList (NonEmpty " + dictShow.show(v._1) + " " + $0.show(v._2) + "))" };
};
var traversableList = {
traverse: (dictApplicative) => {
const Apply0 = dictApplicative.Apply0();
return (f) => {
const $0 = Apply0.Functor0().map((() => {
const go2 = (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 = $List("Cons", v._1, b);
go$a1 = v._2;
continue;
}
fail();
}
return go$r;
};
return go2(Nil);
})());
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 = Apply0.apply(Apply0.Functor0().map((b$1) => (a) => $List("Cons", a, b$1))(b))(f(v._1));
go$a1 = v._2;
continue;
}
fail();
}
return go$r;
};
const $1 = go(dictApplicative.pure(Nil));