Skip to content

Instantly share code, notes, and snippets.

@arsdragonfly

arsdragonfly/log

Created January 4, 2020 03:59
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save arsdragonfly/e75cbe174ac35125ef1ab5ad21a40d61 to your computer and use it in GitHub Desktop.
Save arsdragonfly/e75cbe174ac35125ef1ab5ad21a40d61 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
log
[10:56:33 PM][spawn Spawn1]
[10:56:33 PM]room
[10:56:33 PM][room W4N8]
[10:56:33 PM]name
[10:56:33 PM]([(Right "Bella")] : Nil)
[10:56:33 PM][structure (controller) #946b07739d98cb7]
[10:56:33 PM]structureType
[10:56:33 PM][spawn Spawn1]
[10:56:33 PM]structureType
[10:56:33 PM][spawn Spawn1]
[10:56:33 PM]structureType
[10:56:33 PM][spawn Spawn1]
[10:56:33 PM]energy
[10:56:33 PM][spawn Spawn1]
[10:56:33 PM]energyCapacity
[10:56:33 PM][room W4N8]
[10:56:33 PM]controller
[10:56:33 PM][creep Bella]
[10:56:33 PM]room
[10:56:33 PM][creep Bella]
[10:56:33 PM]store
[10:56:33 PM]Error: This creep doesn't exist yet
at data (<runtime>:24497:19)
at Object.get [as store] (eval at <anonymous> (<runtime>:1093:9), <anonymous>:7:62)
at main:3433:17
at main:3774:92
at main:4415:84
at main:2253:38
at main:4472:86
at main:1093:31
at main:4474:22
Raw
main.js
// Generated by purs bundle 0.13.2
var PS = {};
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Alt"] = $PS["Control.Alt"] || {};
var exports = $PS["Control.Alt"];
var Alt = function (Functor0, alt) {
this.Functor0 = Functor0;
this.alt = alt;
};
var alt = function (dict) {
return dict.alt;
};
exports["Alt"] = Alt;
exports["alt"] = alt;
})(PS);
(function(exports) {
"use strict";
exports.arrayApply = function (fs) {
return function (xs) {
var l = fs.length;
var k = xs.length;
var result = new Array(l*k);
var n = 0;
for (var i = 0; i < l; i++) {
var f = fs[i];
for (var j = 0; j < k; j++) {
result[n++] = f(xs[j]);
}
}
return result;
};
};
})(PS["Control.Apply"] = PS["Control.Apply"] || {});
(function(exports) {
"use strict";
exports.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;
};
};
})(PS["Data.Functor"] = PS["Data.Functor"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Semigroupoid"] = $PS["Control.Semigroupoid"] || {};
var exports = $PS["Control.Semigroupoid"];
var Semigroupoid = function (compose) {
this.compose = compose;
};
var semigroupoidFn = new Semigroupoid(function (f) {
return function (g) {
return function (x) {
return f(g(x));
};
};
});
var compose = function (dict) {
return dict.compose;
};
exports["compose"] = compose;
exports["Semigroupoid"] = Semigroupoid;
exports["semigroupoidFn"] = semigroupoidFn;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Functor"] = $PS["Data.Functor"] || {};
var exports = $PS["Data.Functor"];
var $foreign = $PS["Data.Functor"];
var Control_Semigroupoid = $PS["Control.Semigroupoid"];
var Functor = function (map) {
this.map = map;
};
var map = function (dict) {
return dict.map;
};
var functorFn = new Functor(Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn));
var functorArray = new Functor($foreign.arrayMap);
exports["Functor"] = Functor;
exports["map"] = map;
exports["functorFn"] = functorFn;
exports["functorArray"] = functorArray;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Apply"] = $PS["Control.Apply"] || {};
var exports = $PS["Control.Apply"];
var $foreign = $PS["Control.Apply"];
var Data_Functor = $PS["Data.Functor"];
var Apply = function (Functor0, apply) {
this.Functor0 = Functor0;
this.apply = apply;
};
var applyArray = new Apply(function () {
return Data_Functor.functorArray;
}, $foreign.arrayApply);
var apply = function (dict) {
return dict.apply;
};
var lift2 = function (dictApply) {
return function (f) {
return function (a) {
return function (b) {
return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b);
};
};
};
};
exports["Apply"] = Apply;
exports["apply"] = apply;
exports["lift2"] = lift2;
exports["applyArray"] = applyArray;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Applicative"] = $PS["Control.Applicative"] || {};
var exports = $PS["Control.Applicative"];
var Control_Apply = $PS["Control.Apply"];
var Applicative = function (Apply0, pure) {
this.Apply0 = Apply0;
this.pure = pure;
};
var pure = function (dict) {
return dict.pure;
};
var liftA1 = function (dictApplicative) {
return function (f) {
return function (a) {
return Control_Apply.apply(dictApplicative.Apply0())(pure(dictApplicative)(f))(a);
};
};
};
exports["Applicative"] = Applicative;
exports["pure"] = pure;
exports["liftA1"] = liftA1;
})(PS);
(function(exports) {
"use strict";
exports.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;
};
};
})(PS["Control.Bind"] = PS["Control.Bind"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Bind"] = $PS["Control.Bind"] || {};
var exports = $PS["Control.Bind"];
var $foreign = $PS["Control.Bind"];
var Control_Apply = $PS["Control.Apply"];
var Bind = function (Apply0, bind) {
this.Apply0 = Apply0;
this.bind = bind;
};
var bindArray = new Bind(function () {
return Control_Apply.applyArray;
}, $foreign.arrayBind);
var bind = function (dict) {
return dict.bind;
};
exports["Bind"] = Bind;
exports["bind"] = bind;
exports["bindArray"] = bindArray;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Category"] = $PS["Control.Category"] || {};
var exports = $PS["Control.Category"];
var Control_Semigroupoid = $PS["Control.Semigroupoid"];
var Category = function (Semigroupoid0, identity) {
this.Semigroupoid0 = Semigroupoid0;
this.identity = identity;
};
var identity = function (dict) {
return dict.identity;
};
var categoryFn = new Category(function () {
return Control_Semigroupoid.semigroupoidFn;
}, function (x) {
return x;
});
exports["Category"] = Category;
exports["identity"] = identity;
exports["categoryFn"] = categoryFn;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Lazy"] = $PS["Control.Lazy"] || {};
var exports = $PS["Control.Lazy"];
var Lazy = function (defer) {
this.defer = defer;
};
var defer = function (dict) {
return dict.defer;
};
exports["defer"] = defer;
exports["Lazy"] = Lazy;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Monad"] = $PS["Control.Monad"] || {};
var exports = $PS["Control.Monad"];
var Control_Applicative = $PS["Control.Applicative"];
var Control_Bind = $PS["Control.Bind"];
var Monad = function (Applicative0, Bind1) {
this.Applicative0 = Applicative0;
this.Bind1 = Bind1;
};
var liftM1 = function (dictMonad) {
return function (f) {
return function (a) {
return Control_Bind.bind(dictMonad.Bind1())(a)(function (v) {
return Control_Applicative.pure(dictMonad.Applicative0())(f(v));
});
};
};
};
var ap = function (dictMonad) {
return function (f) {
return function (a) {
return Control_Bind.bind(dictMonad.Bind1())(f)(function (v) {
return Control_Bind.bind(dictMonad.Bind1())(a)(function (v1) {
return Control_Applicative.pure(dictMonad.Applicative0())(v(v1));
});
});
};
};
};
exports["Monad"] = Monad;
exports["liftM1"] = liftM1;
exports["ap"] = ap;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Monad.Error.Class"] = $PS["Control.Monad.Error.Class"] || {};
var exports = $PS["Control.Monad.Error.Class"];
var MonadThrow = function (Monad0, throwError) {
this.Monad0 = Monad0;
this.throwError = throwError;
};
var throwError = function (dict) {
return dict.throwError;
};
exports["throwError"] = throwError;
exports["MonadThrow"] = MonadThrow;
})(PS);
(function(exports) {
"use strict";
exports.showIntImpl = function (n) {
return n.toString();
};
exports.showStringImpl = function (s) {
var l = s.length;
return "\"" + s.replace(
/[\0-\x1F\x7F"\\]/g, // eslint-disable-line no-control-regex
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 "\t": return "\\t";
case "\v": return "\\v";
}
var k = i + 1;
var empty = k < l && s[k] >= "0" && s[k] <= "9" ? "\\&" : "";
return "\\" + c.charCodeAt(0).toString(10) + empty;
}
) + "\"";
};
exports.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(",") + "]";
};
};
exports.join = function (separator) {
return function (xs) {
return xs.join(separator);
};
};
})(PS["Data.Show"] = PS["Data.Show"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Show"] = $PS["Data.Show"] || {};
var exports = $PS["Data.Show"];
var $foreign = $PS["Data.Show"];
var Show = function (show) {
this.show = show;
};
var showString = new Show($foreign.showStringImpl);
var showInt = new Show($foreign.showIntImpl);
var show = function (dict) {
return dict.show;
};
var showArray = function (dictShow) {
return new Show($foreign.showArrayImpl(show(dictShow)));
};
exports["Show"] = Show;
exports["show"] = show;
exports["showInt"] = showInt;
exports["showString"] = showString;
exports["showArray"] = showArray;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Either"] = $PS["Data.Either"] || {};
var exports = $PS["Data.Either"];
var Data_Functor = $PS["Data.Functor"];
var Data_Show = $PS["Data.Show"];
var Left = (function () {
function Left(value0) {
this.value0 = value0;
};
Left.create = function (value0) {
return new Left(value0);
};
return Left;
})();
var Right = (function () {
function Right(value0) {
this.value0 = value0;
};
Right.create = function (value0) {
return new Right(value0);
};
return Right;
})();
var showEither = function (dictShow) {
return function (dictShow1) {
return new Data_Show.Show(function (v) {
if (v instanceof Left) {
return "(Left " + (Data_Show.show(dictShow)(v.value0) + ")");
};
if (v instanceof Right) {
return "(Right " + (Data_Show.show(dictShow1)(v.value0) + ")");
};
throw new Error("Failed pattern match at Data.Either (line 163, column 1 - line 165, column 46): " + [ v.constructor.name ]);
});
};
};
var functorEither = new Data_Functor.Functor(function (f) {
return function (m) {
if (m instanceof Left) {
return new Left(m.value0);
};
if (m instanceof Right) {
return new Right(f(m.value0));
};
throw new Error("Failed pattern match at Data.Either (line 38, column 1 - line 38, column 52): " + [ m.constructor.name ]);
};
});
var fromRight = function (dictPartial) {
return function (v) {
if (v instanceof Right) {
return v.value0;
};
throw new Error("Failed pattern match at Data.Either (line 261, column 1 - line 261, column 52): " + [ v.constructor.name ]);
};
};
var either = function (v) {
return function (v1) {
return function (v2) {
if (v2 instanceof Left) {
return v(v2.value0);
};
if (v2 instanceof Right) {
return v1(v2.value0);
};
throw new Error("Failed pattern match at Data.Either (line 238, column 1 - line 238, column 64): " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
};
};
};
exports["Left"] = Left;
exports["Right"] = Right;
exports["either"] = either;
exports["fromRight"] = fromRight;
exports["functorEither"] = functorEither;
exports["showEither"] = showEither;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Monad.Except.Trans"] = $PS["Control.Monad.Except.Trans"] || {};
var exports = $PS["Control.Monad.Except.Trans"];
var Control_Applicative = $PS["Control.Applicative"];
var Control_Apply = $PS["Control.Apply"];
var Control_Bind = $PS["Control.Bind"];
var Control_Monad = $PS["Control.Monad"];
var Control_Monad_Error_Class = $PS["Control.Monad.Error.Class"];
var Data_Either = $PS["Data.Either"];
var Data_Functor = $PS["Data.Functor"];
var ExceptT = function (x) {
return x;
};
var runExceptT = function (v) {
return v;
};
var mapExceptT = function (f) {
return function (v) {
return f(v);
};
};
var functorExceptT = function (dictFunctor) {
return new Data_Functor.Functor(function (f) {
return mapExceptT(Data_Functor.map(dictFunctor)(Data_Functor.map(Data_Either.functorEither)(f)));
});
};
var monadExceptT = function (dictMonad) {
return new Control_Monad.Monad(function () {
return applicativeExceptT(dictMonad);
}, function () {
return bindExceptT(dictMonad);
});
};
var bindExceptT = function (dictMonad) {
return new Control_Bind.Bind(function () {
return applyExceptT(dictMonad);
}, function (v) {
return function (k) {
return Control_Bind.bind(dictMonad.Bind1())(v)(Data_Either.either((function () {
var $98 = Control_Applicative.pure(dictMonad.Applicative0());
return function ($99) {
return $98(Data_Either.Left.create($99));
};
})())(function (a) {
var v1 = k(a);
return v1;
}));
};
});
};
var applyExceptT = function (dictMonad) {
return new Control_Apply.Apply(function () {
return functorExceptT(((dictMonad.Bind1()).Apply0()).Functor0());
}, Control_Monad.ap(monadExceptT(dictMonad)));
};
var applicativeExceptT = function (dictMonad) {
return new Control_Applicative.Applicative(function () {
return applyExceptT(dictMonad);
}, (function () {
var $100 = Control_Applicative.pure(dictMonad.Applicative0());
return function ($101) {
return ExceptT($100(Data_Either.Right.create($101)));
};
})());
};
var monadThrowExceptT = function (dictMonad) {
return new Control_Monad_Error_Class.MonadThrow(function () {
return monadExceptT(dictMonad);
}, (function () {
var $110 = Control_Applicative.pure(dictMonad.Applicative0());
return function ($111) {
return ExceptT($110(Data_Either.Left.create($111)));
};
})());
};
exports["ExceptT"] = ExceptT;
exports["runExceptT"] = runExceptT;
exports["mapExceptT"] = mapExceptT;
exports["functorExceptT"] = functorExceptT;
exports["applyExceptT"] = applyExceptT;
exports["applicativeExceptT"] = applicativeExceptT;
exports["bindExceptT"] = bindExceptT;
exports["monadExceptT"] = monadExceptT;
exports["monadThrowExceptT"] = monadThrowExceptT;
})(PS);
(function(exports) {
"use strict";
exports.boolConj = function (b1) {
return function (b2) {
return b1 && b2;
};
};
exports.boolDisj = function (b1) {
return function (b2) {
return b1 || b2;
};
};
exports.boolNot = function (b) {
return !b;
};
})(PS["Data.HeytingAlgebra"] = PS["Data.HeytingAlgebra"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.HeytingAlgebra"] = $PS["Data.HeytingAlgebra"] || {};
var exports = $PS["Data.HeytingAlgebra"];
var $foreign = $PS["Data.HeytingAlgebra"];
var HeytingAlgebra = function (conj, disj, ff, implies, not, tt) {
this.conj = conj;
this.disj = disj;
this.ff = ff;
this.implies = implies;
this.not = not;
this.tt = tt;
};
var tt = function (dict) {
return dict.tt;
};
var not = function (dict) {
return dict.not;
};
var implies = function (dict) {
return dict.implies;
};
var ff = function (dict) {
return dict.ff;
};
var disj = function (dict) {
return dict.disj;
};
var heytingAlgebraBoolean = new HeytingAlgebra($foreign.boolConj, $foreign.boolDisj, false, function (a) {
return function (b) {
return disj(heytingAlgebraBoolean)(not(heytingAlgebraBoolean)(a))(b);
};
}, $foreign.boolNot, true);
var conj = function (dict) {
return dict.conj;
};
exports["HeytingAlgebra"] = HeytingAlgebra;
exports["tt"] = tt;
exports["ff"] = ff;
exports["implies"] = implies;
exports["conj"] = conj;
exports["disj"] = disj;
exports["not"] = not;
exports["heytingAlgebraBoolean"] = heytingAlgebraBoolean;
})(PS);
(function(exports) {
"use strict";
exports.concatString = function (s1) {
return function (s2) {
return s1 + s2;
};
};
exports.concatArray = function (xs) {
return function (ys) {
if (xs.length === 0) return ys;
if (ys.length === 0) return xs;
return xs.concat(ys);
};
};
})(PS["Data.Semigroup"] = PS["Data.Semigroup"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Semigroup"] = $PS["Data.Semigroup"] || {};
var exports = $PS["Data.Semigroup"];
var $foreign = $PS["Data.Semigroup"];
var Semigroup = function (append) {
this.append = append;
};
var semigroupString = new Semigroup($foreign.concatString);
var semigroupArray = new Semigroup($foreign.concatArray);
var append = function (dict) {
return dict.append;
};
exports["Semigroup"] = Semigroup;
exports["append"] = append;
exports["semigroupString"] = semigroupString;
exports["semigroupArray"] = semigroupArray;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Monoid"] = $PS["Data.Monoid"] || {};
var exports = $PS["Data.Monoid"];
var Data_Semigroup = $PS["Data.Semigroup"];
var Monoid = function (Semigroup0, mempty) {
this.Semigroup0 = Semigroup0;
this.mempty = mempty;
};
var monoidString = new Monoid(function () {
return Data_Semigroup.semigroupString;
}, "");
var monoidArray = new Monoid(function () {
return Data_Semigroup.semigroupArray;
}, [ ]);
var mempty = function (dict) {
return dict.mempty;
};
exports["Monoid"] = Monoid;
exports["mempty"] = mempty;
exports["monoidString"] = monoidString;
exports["monoidArray"] = monoidArray;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Monoid.Disj"] = $PS["Data.Monoid.Disj"] || {};
var exports = $PS["Data.Monoid.Disj"];
var Data_HeytingAlgebra = $PS["Data.HeytingAlgebra"];
var Data_Monoid = $PS["Data.Monoid"];
var Data_Semigroup = $PS["Data.Semigroup"];
var Disj = function (x) {
return x;
};
var semigroupDisj = function (dictHeytingAlgebra) {
return new Data_Semigroup.Semigroup(function (v) {
return function (v1) {
return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);
};
});
};
var monoidDisj = function (dictHeytingAlgebra) {
return new Data_Monoid.Monoid(function () {
return semigroupDisj(dictHeytingAlgebra);
}, Data_HeytingAlgebra.ff(dictHeytingAlgebra));
};
exports["Disj"] = Disj;
exports["semigroupDisj"] = semigroupDisj;
exports["monoidDisj"] = monoidDisj;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Newtype"] = $PS["Data.Newtype"] || {};
var exports = $PS["Data.Newtype"];
var Data_Functor = $PS["Data.Functor"];
var Data_Monoid_Disj = $PS["Data.Monoid.Disj"];
var Newtype = function (unwrap, wrap) {
this.unwrap = unwrap;
this.wrap = wrap;
};
var wrap = function (dict) {
return dict.wrap;
};
var unwrap = function (dict) {
return dict.unwrap;
};
var newtypeDisj = new Newtype(function (v) {
return v;
}, Data_Monoid_Disj.Disj);
var alaF = function (dictFunctor) {
return function (dictFunctor1) {
return function (dictNewtype) {
return function (dictNewtype1) {
return function (v) {
return function (f) {
var $96 = Data_Functor.map(dictFunctor1)(unwrap(dictNewtype1));
var $97 = Data_Functor.map(dictFunctor)(wrap(dictNewtype));
return function ($98) {
return $96(f($97($98)));
};
};
};
};
};
};
};
exports["unwrap"] = unwrap;
exports["wrap"] = wrap;
exports["Newtype"] = Newtype;
exports["alaF"] = alaF;
exports["newtypeDisj"] = newtypeDisj;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Identity"] = $PS["Data.Identity"] || {};
var exports = $PS["Data.Identity"];
var Control_Applicative = $PS["Control.Applicative"];
var Control_Apply = $PS["Control.Apply"];
var Control_Bind = $PS["Control.Bind"];
var Control_Monad = $PS["Control.Monad"];
var Data_Functor = $PS["Data.Functor"];
var Data_Newtype = $PS["Data.Newtype"];
var Identity = function (x) {
return x;
};
var newtypeIdentity = new Data_Newtype.Newtype(function (n) {
return n;
}, Identity);
var functorIdentity = new Data_Functor.Functor(function (f) {
return function (m) {
return f(m);
};
});
var applyIdentity = new Control_Apply.Apply(function () {
return functorIdentity;
}, function (v) {
return function (v1) {
return v(v1);
};
});
var bindIdentity = new Control_Bind.Bind(function () {
return applyIdentity;
}, function (v) {
return function (f) {
return f(v);
};
});
var applicativeIdentity = new Control_Applicative.Applicative(function () {
return applyIdentity;
}, Identity);
var monadIdentity = new Control_Monad.Monad(function () {
return applicativeIdentity;
}, function () {
return bindIdentity;
});
exports["Identity"] = Identity;
exports["newtypeIdentity"] = newtypeIdentity;
exports["functorIdentity"] = functorIdentity;
exports["applyIdentity"] = applyIdentity;
exports["applicativeIdentity"] = applicativeIdentity;
exports["bindIdentity"] = bindIdentity;
exports["monadIdentity"] = monadIdentity;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Monad.Except"] = $PS["Control.Monad.Except"] || {};
var exports = $PS["Control.Monad.Except"];
var Control_Monad_Except_Trans = $PS["Control.Monad.Except.Trans"];
var Data_Identity = $PS["Data.Identity"];
var Data_Newtype = $PS["Data.Newtype"];
var runExcept = (function () {
var $0 = Data_Newtype.unwrap(Data_Identity.newtypeIdentity);
return function ($1) {
return $0(Control_Monad_Except_Trans.runExceptT($1));
};
})();
exports["runExcept"] = runExcept;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Control.Plus"] = $PS["Control.Plus"] || {};
var exports = $PS["Control.Plus"];
var Plus = function (Alt0, empty) {
this.Alt0 = Alt0;
this.empty = empty;
};
var empty = function (dict) {
return dict.empty;
};
exports["Plus"] = Plus;
exports["empty"] = empty;
})(PS);
(function(exports) {
"use strict";
function id(x) {
return x;
}
exports.fromString = id;
exports.fromObject = id;
function isArray(a) {
return Object.prototype.toString.call(a) === "[object Array]";
}
})(PS["Data.Argonaut.Core"] = PS["Data.Argonaut.Core"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Argonaut.Core"] = $PS["Data.Argonaut.Core"] || {};
var exports = $PS["Data.Argonaut.Core"];
var $foreign = $PS["Data.Argonaut.Core"];
exports["fromString"] = $foreign.fromString;
exports["fromObject"] = $foreign.fromObject;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Symbol"] = $PS["Data.Symbol"] || {};
var exports = $PS["Data.Symbol"];
var SProxy = (function () {
function SProxy() {
};
SProxy.value = new SProxy();
return SProxy;
})();
var IsSymbol = function (reflectSymbol) {
this.reflectSymbol = reflectSymbol;
};
var reflectSymbol = function (dict) {
return dict.reflectSymbol;
};
exports["IsSymbol"] = IsSymbol;
exports["reflectSymbol"] = reflectSymbol;
exports["SProxy"] = SProxy;
})(PS);
(function(exports) {
"use strict";
exports._copyST = function (m) {
return function () {
var r = {};
for (var k in m) {
if (hasOwnProperty.call(m, k)) {
r[k] = m[k];
}
}
return r;
};
};
exports.empty = {};
exports.runST = function (f) {
return f();
};
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;
};
}
})(PS["Foreign.Object"] = PS["Foreign.Object"] || {});
(function(exports) {
"use strict";
exports.poke = function (k) {
return function (v) {
return function (m) {
return function () {
m[k] = v;
return m;
};
};
};
};
})(PS["Foreign.Object.ST"] = PS["Foreign.Object.ST"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Foreign.Object.ST"] = $PS["Foreign.Object.ST"] || {};
var exports = $PS["Foreign.Object.ST"];
var $foreign = $PS["Foreign.Object.ST"];
exports["poke"] = $foreign.poke;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Foreign.Object"] = $PS["Foreign.Object"] || {};
var exports = $PS["Foreign.Object"];
var $foreign = $PS["Foreign.Object"];
var Foreign_Object_ST = $PS["Foreign.Object.ST"];
var thawST = $foreign["_copyST"];
var mutate = function (f) {
return function (m) {
return $foreign.runST(function __do() {
var v = thawST(m)();
var v1 = f(v)();
return v;
});
};
};
var insert = function (k) {
return function (v) {
return mutate(Foreign_Object_ST.poke(k)(v));
};
};
exports["insert"] = insert;
exports["thawST"] = thawST;
exports["empty"] = $foreign.empty;
})(PS);
(function(exports) {
"use strict";
exports.unsafeGet = function (label) {
return function (rec) {
return rec[label];
};
};
})(PS["Record.Unsafe"] = PS["Record.Unsafe"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Record.Unsafe"] = $PS["Record.Unsafe"] || {};
var exports = $PS["Record.Unsafe"];
var $foreign = $PS["Record.Unsafe"];
exports["unsafeGet"] = $foreign.unsafeGet;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Record"] = $PS["Record"] || {};
var exports = $PS["Record"];
var Data_Symbol = $PS["Data.Symbol"];
var Record_Unsafe = $PS["Record.Unsafe"];
var get = function (dictIsSymbol) {
return function (dictCons) {
return function (l) {
return function (r) {
return Record_Unsafe.unsafeGet(Data_Symbol.reflectSymbol(dictIsSymbol)(l))(r);
};
};
};
};
exports["get"] = get;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Type.Data.RowList"] = $PS["Type.Data.RowList"] || {};
var exports = $PS["Type.Data.RowList"];
var RLProxy = (function () {
function RLProxy() {
};
RLProxy.value = new RLProxy();
return RLProxy;
})();
exports["RLProxy"] = RLProxy;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Argonaut.Encode.Class"] = $PS["Data.Argonaut.Encode.Class"] || {};
var exports = $PS["Data.Argonaut.Encode.Class"];
var Data_Argonaut_Core = $PS["Data.Argonaut.Core"];
var Data_Symbol = $PS["Data.Symbol"];
var Foreign_Object = $PS["Foreign.Object"];
var Record = $PS["Record"];
var Type_Data_RowList = $PS["Type.Data.RowList"];
var GEncodeJson = function (gEncodeJson) {
this.gEncodeJson = gEncodeJson;
};
var EncodeJson = function (encodeJson) {
this.encodeJson = encodeJson;
};
var gEncodeJsonNil = new GEncodeJson(function (v) {
return function (v1) {
return Foreign_Object.empty;
};
});
var gEncodeJson = function (dict) {
return dict.gEncodeJson;
};
var encodeRecord = function (dictGEncodeJson) {
return function (dictRowToList) {
return new EncodeJson(function (rec) {
return Data_Argonaut_Core.fromObject(gEncodeJson(dictGEncodeJson)(rec)(Type_Data_RowList.RLProxy.value));
});
};
};
var encodeJsonJString = new EncodeJson(Data_Argonaut_Core.fromString);
var encodeJson = function (dict) {
return dict.encodeJson;
};
var gEncodeJsonCons = function (dictEncodeJson) {
return function (dictGEncodeJson) {
return function (dictIsSymbol) {
return function (dictCons) {
return new GEncodeJson(function (row) {
return function (v) {
return Foreign_Object.insert(Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value))(encodeJson(dictEncodeJson)(Record.get(dictIsSymbol)(dictCons)(Data_Symbol.SProxy.value)(row)))(gEncodeJson(dictGEncodeJson)(row)(Type_Data_RowList.RLProxy.value));
};
});
};
};
};
};
exports["encodeJson"] = encodeJson;
exports["gEncodeJson"] = gEncodeJson;
exports["EncodeJson"] = EncodeJson;
exports["GEncodeJson"] = GEncodeJson;
exports["encodeJsonJString"] = encodeJsonJString;
exports["encodeRecord"] = encodeRecord;
exports["gEncodeJsonNil"] = gEncodeJsonNil;
exports["gEncodeJsonCons"] = gEncodeJsonCons;
})(PS);
(function(exports) {
"use strict";
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;
};
};
// In browsers that have Array.prototype.fill we use it, as it's faster.
exports.replicate = typeof Array.prototype.fill === "function" ? replicateFill : replicatePolyfill;
//------------------------------------------------------------------------------
// Array size ------------------------------------------------------------------
//------------------------------------------------------------------------------
exports.length = function (xs) {
return xs.length;
};
//------------------------------------------------------------------------------
// Indexed operations ----------------------------------------------------------
//------------------------------------------------------------------------------
exports.indexImpl = function (just) {
return function (nothing) {
return function (xs) {
return function (i) {
return i < 0 || i >= xs.length ? nothing : just(xs[i]);
};
};
};
};
exports.concat = function (xss) {
if (xss.length <= 10000) {
// This method is faster, but it crashes on big arrays.
// So we use it when can and fallback to simple variant otherwise.
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;
};
exports.filter = function (f) {
return function (xs) {
return xs.filter(f);
};
};
//------------------------------------------------------------------------------
// Zipping ---------------------------------------------------------------------
//------------------------------------------------------------------------------
exports.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;
};
};
};
})(PS["Data.Array"] = PS["Data.Array"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Function"] = $PS["Data.Function"] || {};
var exports = $PS["Data.Function"];
var flip = function (f) {
return function (b) {
return function (a) {
return f(a)(b);
};
};
};
var $$const = function (a) {
return function (v) {
return a;
};
};
exports["flip"] = flip;
exports["const"] = $$const;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Maybe"] = $PS["Data.Maybe"] || {};
var exports = $PS["Data.Maybe"];
var Data_Function = $PS["Data.Function"];
var Nothing = (function () {
function Nothing() {
};
Nothing.value = new Nothing();
return Nothing;
})();
var Just = (function () {
function Just(value0) {
this.value0 = value0;
};
Just.create = function (value0) {
return new Just(value0);
};
return Just;
})();
var maybe = function (v) {
return function (v1) {
return function (v2) {
if (v2 instanceof Nothing) {
return v;
};
if (v2 instanceof Just) {
return v1(v2.value0);
};
throw new Error("Failed pattern match at Data.Maybe (line 217, column 1 - line 217, column 51): " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
};
};
};
var isNothing = maybe(true)(Data_Function["const"](false));
var isJust = maybe(false)(Data_Function["const"](true));
var fromJust = function (dictPartial) {
return function (v) {
if (v instanceof Just) {
return v.value0;
};
throw new Error("Failed pattern match at Data.Maybe (line 268, column 1 - line 268, column 46): " + [ v.constructor.name ]);
};
};
exports["Nothing"] = Nothing;
exports["Just"] = Just;
exports["maybe"] = maybe;
exports["isJust"] = isJust;
exports["isNothing"] = isNothing;
exports["fromJust"] = fromJust;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Array"] = $PS["Data.Array"] || {};
var exports = $PS["Data.Array"];
var $foreign = $PS["Data.Array"];
var Control_Bind = $PS["Control.Bind"];
var Control_Category = $PS["Control.Category"];
var Data_Function = $PS["Data.Function"];
var Data_Maybe = $PS["Data.Maybe"];
var singleton = function (a) {
return [ a ];
};
var $$null = function (xs) {
return $foreign.length(xs) === 0;
};
var index = $foreign.indexImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
var concatMap = Data_Function.flip(Control_Bind.bind(Control_Bind.bindArray));
var mapMaybe = function (f) {
return concatMap((function () {
var $123 = Data_Maybe.maybe([ ])(singleton);
return function ($124) {
return $123(f($124));
};
})());
};
var catMaybes = mapMaybe(Control_Category.identity(Control_Category.categoryFn));
exports["singleton"] = singleton;
exports["null"] = $$null;
exports["index"] = index;
exports["concatMap"] = concatMap;
exports["mapMaybe"] = mapMaybe;
exports["catMaybes"] = catMaybes;
exports["replicate"] = $foreign.replicate;
exports["length"] = $foreign.length;
exports["concat"] = $foreign.concat;
exports["filter"] = $foreign.filter;
exports["zipWith"] = $foreign.zipWith;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Boolean"] = $PS["Data.Boolean"] || {};
var exports = $PS["Data.Boolean"];
var otherwise = true;
exports["otherwise"] = otherwise;
})(PS);
(function(exports) {
"use strict";
exports.topInt = 2147483647;
exports.bottomInt = -2147483648;
exports.topChar = String.fromCharCode(65535);
exports.bottomChar = String.fromCharCode(0);
})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
(function(exports) {
"use strict";
var unsafeCompareImpl = function (lt) {
return function (eq) {
return function (gt) {
return function (x) {
return function (y) {
return x < y ? lt : x === y ? eq : gt;
};
};
};
};
};
exports.ordIntImpl = unsafeCompareImpl;
exports.ordStringImpl = unsafeCompareImpl;
exports.ordCharImpl = unsafeCompareImpl;
})(PS["Data.Ord"] = PS["Data.Ord"] || {});
(function(exports) {
"use strict";
var refEq = function (r1) {
return function (r2) {
return r1 === r2;
};
};
exports.eqIntImpl = refEq;
exports.eqCharImpl = refEq;
exports.eqStringImpl = refEq;
})(PS["Data.Eq"] = PS["Data.Eq"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Eq"] = $PS["Data.Eq"] || {};
var exports = $PS["Data.Eq"];
var $foreign = $PS["Data.Eq"];
var Eq = function (eq) {
this.eq = eq;
};
var eqString = new Eq($foreign.eqStringImpl);
var eqInt = new Eq($foreign.eqIntImpl);
var eqChar = new Eq($foreign.eqCharImpl);
var eq = function (dict) {
return dict.eq;
};
exports["Eq"] = Eq;
exports["eq"] = eq;
exports["eqInt"] = eqInt;
exports["eqChar"] = eqChar;
exports["eqString"] = eqString;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Ordering"] = $PS["Data.Ordering"] || {};
var exports = $PS["Data.Ordering"];
var LT = (function () {
function LT() {
};
LT.value = new LT();
return LT;
})();
var GT = (function () {
function GT() {
};
GT.value = new GT();
return GT;
})();
var EQ = (function () {
function EQ() {
};
EQ.value = new EQ();
return EQ;
})();
exports["LT"] = LT;
exports["GT"] = GT;
exports["EQ"] = EQ;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Ord"] = $PS["Data.Ord"] || {};
var exports = $PS["Data.Ord"];
var $foreign = $PS["Data.Ord"];
var Data_Eq = $PS["Data.Eq"];
var Data_Ordering = $PS["Data.Ordering"];
var Ord = function (Eq0, compare) {
this.Eq0 = Eq0;
this.compare = compare;
};
var ordString = new Ord(function () {
return Data_Eq.eqString;
}, $foreign.ordStringImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value));
var ordInt = new Ord(function () {
return Data_Eq.eqInt;
}, $foreign.ordIntImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value));
var ordChar = new Ord(function () {
return Data_Eq.eqChar;
}, $foreign.ordCharImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value));
var compare = function (dict) {
return dict.compare;
};
exports["Ord"] = Ord;
exports["compare"] = compare;
exports["ordInt"] = ordInt;
exports["ordString"] = ordString;
exports["ordChar"] = ordChar;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Bounded"] = $PS["Data.Bounded"] || {};
var exports = $PS["Data.Bounded"];
var $foreign = $PS["Data.Bounded"];
var Data_Ord = $PS["Data.Ord"];
var Bounded = function (Ord0, bottom, top) {
this.Ord0 = Ord0;
this.bottom = bottom;
this.top = top;
};
var top = function (dict) {
return dict.top;
};
var boundedInt = new Bounded(function () {
return Data_Ord.ordInt;
}, $foreign.bottomInt, $foreign.topInt);
var boundedChar = new Bounded(function () {
return Data_Ord.ordChar;
}, $foreign.bottomChar, $foreign.topChar);
var bottom = function (dict) {
return dict.bottom;
};
exports["Bounded"] = Bounded;
exports["bottom"] = bottom;
exports["top"] = top;
exports["boundedInt"] = boundedInt;
exports["boundedChar"] = boundedChar;
})(PS);
(function(exports) {
"use strict";
exports.toCharCode = function (c) {
return c.charCodeAt(0);
};
exports.fromCharCode = function (c) {
return String.fromCharCode(c);
};
})(PS["Data.Enum"] = PS["Data.Enum"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Enum"] = $PS["Data.Enum"] || {};
var exports = $PS["Data.Enum"];
var $foreign = $PS["Data.Enum"];
var Data_Bounded = $PS["Data.Bounded"];
var Data_Maybe = $PS["Data.Maybe"];
var Data_Ord = $PS["Data.Ord"];
var Enum = function (Ord0, pred, succ) {
this.Ord0 = Ord0;
this.pred = pred;
this.succ = succ;
};
var BoundedEnum = function (Bounded0, Enum1, cardinality, fromEnum, toEnum) {
this.Bounded0 = Bounded0;
this.Enum1 = Enum1;
this.cardinality = cardinality;
this.fromEnum = fromEnum;
this.toEnum = toEnum;
};
var toEnum = function (dict) {
return dict.toEnum;
};
var succ = function (dict) {
return dict.succ;
};
var pred = function (dict) {
return dict.pred;
};
var fromEnum = function (dict) {
return dict.fromEnum;
};
var defaultSucc = function (toEnum$prime) {
return function (fromEnum$prime) {
return function (a) {
return toEnum$prime(fromEnum$prime(a) + 1 | 0);
};
};
};
var defaultPred = function (toEnum$prime) {
return function (fromEnum$prime) {
return function (a) {
return toEnum$prime(fromEnum$prime(a) - 1 | 0);
};
};
};
var charToEnum = function (v) {
if (v >= Data_Bounded.bottom(Data_Bounded.boundedInt) && v <= Data_Bounded.top(Data_Bounded.boundedInt)) {
return new Data_Maybe.Just($foreign.fromCharCode(v));
};
return Data_Maybe.Nothing.value;
};
var enumChar = new Enum(function () {
return Data_Ord.ordChar;
}, defaultPred(charToEnum)($foreign.toCharCode), defaultSucc(charToEnum)($foreign.toCharCode));
var cardinality = function (dict) {
return dict.cardinality;
};
var boundedEnumChar = new BoundedEnum(function () {
return Data_Bounded.boundedChar;
}, function () {
return enumChar;
}, $foreign.toCharCode(Data_Bounded.top(Data_Bounded.boundedChar)) - $foreign.toCharCode(Data_Bounded.bottom(Data_Bounded.boundedChar)) | 0, $foreign.toCharCode, charToEnum);
exports["Enum"] = Enum;
exports["succ"] = succ;
exports["pred"] = pred;
exports["BoundedEnum"] = BoundedEnum;
exports["cardinality"] = cardinality;
exports["toEnum"] = toEnum;
exports["fromEnum"] = fromEnum;
exports["defaultSucc"] = defaultSucc;
exports["defaultPred"] = defaultPred;
exports["enumChar"] = enumChar;
exports["boundedEnumChar"] = boundedEnumChar;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Char"] = $PS["Data.Char"] || {};
var exports = $PS["Data.Char"];
var Data_Enum = $PS["Data.Enum"];
var toCharCode = Data_Enum.fromEnum(Data_Enum.boundedEnumChar);
exports["toCharCode"] = toCharCode;
})(PS);
(function(exports) {
"use strict";
exports.intSub = function (x) {
return function (y) {
/* jshint bitwise: false */
return x - y | 0;
};
};
})(PS["Data.Ring"] = PS["Data.Ring"] || {});
(function(exports) {
"use strict";
exports.intAdd = function (x) {
return function (y) {
/* jshint bitwise: false */
return x + y | 0;
};
};
exports.intMul = function (x) {
return function (y) {
/* jshint bitwise: false */
return x * y | 0;
};
};
})(PS["Data.Semiring"] = PS["Data.Semiring"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Semiring"] = $PS["Data.Semiring"] || {};
var exports = $PS["Data.Semiring"];
var $foreign = $PS["Data.Semiring"];
var Semiring = function (add, mul, one, zero) {
this.add = add;
this.mul = mul;
this.one = one;
this.zero = zero;
};
var zero = function (dict) {
return dict.zero;
};
var semiringInt = new Semiring($foreign.intAdd, $foreign.intMul, 1, 0);
var one = function (dict) {
return dict.one;
};
var mul = function (dict) {
return dict.mul;
};
var add = function (dict) {
return dict.add;
};
exports["Semiring"] = Semiring;
exports["add"] = add;
exports["zero"] = zero;
exports["mul"] = mul;
exports["one"] = one;
exports["semiringInt"] = semiringInt;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Ring"] = $PS["Data.Ring"] || {};
var exports = $PS["Data.Ring"];
var $foreign = $PS["Data.Ring"];
var Data_Semiring = $PS["Data.Semiring"];
var Ring = function (Semiring0, sub) {
this.Semiring0 = Semiring0;
this.sub = sub;
};
var sub = function (dict) {
return dict.sub;
};
var ringInt = new Ring(function () {
return Data_Semiring.semiringInt;
}, $foreign.intSub);
exports["Ring"] = Ring;
exports["sub"] = sub;
exports["ringInt"] = ringInt;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.CommutativeRing"] = $PS["Data.CommutativeRing"] || {};
var exports = $PS["Data.CommutativeRing"];
var Data_Ring = $PS["Data.Ring"];
var CommutativeRing = function (Ring0) {
this.Ring0 = Ring0;
};
var commutativeRingInt = new CommutativeRing(function () {
return Data_Ring.ringInt;
});
exports["CommutativeRing"] = CommutativeRing;
exports["commutativeRingInt"] = commutativeRingInt;
})(PS);
(function(exports) {
"use strict";
exports.intDegree = function (x) {
return Math.min(Math.abs(x), 2147483647);
};
// See the Euclidean definition in
// https://en.m.wikipedia.org/wiki/Modulo_operation.
exports.intDiv = function (x) {
return function (y) {
if (y === 0) return 0;
return y > 0 ? Math.floor(x / y) : -Math.floor(x / -y);
};
};
exports.intMod = function (x) {
return function (y) {
if (y === 0) return 0;
var yy = Math.abs(y);
return ((x % yy) + yy) % yy;
};
};
})(PS["Data.EuclideanRing"] = PS["Data.EuclideanRing"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.EuclideanRing"] = $PS["Data.EuclideanRing"] || {};
var exports = $PS["Data.EuclideanRing"];
var $foreign = $PS["Data.EuclideanRing"];
var Data_CommutativeRing = $PS["Data.CommutativeRing"];
var EuclideanRing = function (CommutativeRing0, degree, div, mod) {
this.CommutativeRing0 = CommutativeRing0;
this.degree = degree;
this.div = div;
this.mod = mod;
};
var mod = function (dict) {
return dict.mod;
};
var euclideanRingInt = new EuclideanRing(function () {
return Data_CommutativeRing.commutativeRingInt;
}, $foreign.intDegree, $foreign.intDiv, $foreign.intMod);
var div = function (dict) {
return dict.div;
};
var degree = function (dict) {
return dict.degree;
};
exports["EuclideanRing"] = EuclideanRing;
exports["degree"] = degree;
exports["div"] = div;
exports["mod"] = mod;
exports["euclideanRingInt"] = euclideanRingInt;
})(PS);
(function(exports) {
"use strict";
// module Unsafe.Coerce
exports.unsafeCoerce = function (x) {
return x;
};
})(PS["Unsafe.Coerce"] = PS["Unsafe.Coerce"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Unsafe.Coerce"] = $PS["Unsafe.Coerce"] || {};
var exports = $PS["Unsafe.Coerce"];
var $foreign = $PS["Unsafe.Coerce"];
exports["unsafeCoerce"] = $foreign.unsafeCoerce;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Exists"] = $PS["Data.Exists"] || {};
var exports = $PS["Data.Exists"];
var Unsafe_Coerce = $PS["Unsafe.Coerce"];
var runExists = Unsafe_Coerce.unsafeCoerce;
var mkExists = Unsafe_Coerce.unsafeCoerce;
exports["mkExists"] = mkExists;
exports["runExists"] = runExists;
})(PS);
(function(exports) {
"use strict";
exports.foldrArray = function (f) {
return function (init) {
return function (xs) {
var acc = init;
var len = xs.length;
for (var i = len - 1; i >= 0; i--) {
acc = f(xs[i])(acc);
}
return acc;
};
};
};
exports.foldlArray = function (f) {
return function (init) {
return function (xs) {
var acc = init;
var len = xs.length;
for (var i = 0; i < len; i++) {
acc = f(acc)(xs[i]);
}
return acc;
};
};
};
})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Foldable"] = $PS["Data.Foldable"] || {};
var exports = $PS["Data.Foldable"];
var $foreign = $PS["Data.Foldable"];
var Data_Eq = $PS["Data.Eq"];
var Data_Functor = $PS["Data.Functor"];
var Data_HeytingAlgebra = $PS["Data.HeytingAlgebra"];
var Data_Monoid = $PS["Data.Monoid"];
var Data_Monoid_Disj = $PS["Data.Monoid.Disj"];
var Data_Newtype = $PS["Data.Newtype"];
var Data_Semigroup = $PS["Data.Semigroup"];
var Data_Semiring = $PS["Data.Semiring"];
var Foldable = function (foldMap, foldl, foldr) {
this.foldMap = foldMap;
this.foldl = foldl;
this.foldr = foldr;
};
var foldr = function (dict) {
return dict.foldr;
};
var foldl = function (dict) {
return dict.foldl;
};
var intercalate = function (dictFoldable) {
return function (dictMonoid) {
return function (sep) {
return function (xs) {
var go = function (v) {
return function (x) {
if (v.init) {
return {
init: false,
acc: x
};
};
return {
init: false,
acc: Data_Semigroup.append(dictMonoid.Semigroup0())(v.acc)(Data_Semigroup.append(dictMonoid.Semigroup0())(sep)(x))
};
};
};
return (foldl(dictFoldable)(go)({
init: true,
acc: Data_Monoid.mempty(dictMonoid)
})(xs)).acc;
};
};
};
};
var length = function (dictFoldable) {
return function (dictSemiring) {
return foldl(dictFoldable)(function (c) {
return function (v) {
return Data_Semiring.add(dictSemiring)(Data_Semiring.one(dictSemiring))(c);
};
})(Data_Semiring.zero(dictSemiring));
};
};
var foldMapDefaultR = function (dictFoldable) {
return function (dictMonoid) {
return function (f) {
return foldr(dictFoldable)(function (x) {
return function (acc) {
return Data_Semigroup.append(dictMonoid.Semigroup0())(f(x))(acc);
};
})(Data_Monoid.mempty(dictMonoid));
};
};
};
var foldableArray = new Foldable(function (dictMonoid) {
return foldMapDefaultR(foldableArray)(dictMonoid);
}, $foreign.foldlArray, $foreign.foldrArray);
var foldMap = function (dict) {
return dict.foldMap;
};
var any = function (dictFoldable) {
return function (dictHeytingAlgebra) {
return Data_Newtype.alaF(Data_Functor.functorFn)(Data_Functor.functorFn)(Data_Newtype.newtypeDisj)(Data_Newtype.newtypeDisj)(Data_Monoid_Disj.Disj)(foldMap(dictFoldable)(Data_Monoid_Disj.monoidDisj(dictHeytingAlgebra)));
};
};
var elem = function (dictFoldable) {
return function (dictEq) {
var $204 = any(dictFoldable)(Data_HeytingAlgebra.heytingAlgebraBoolean);
var $205 = Data_Eq.eq(dictEq);
return function ($206) {
return $204($205($206));
};
};
};
exports["Foldable"] = Foldable;
exports["foldr"] = foldr;
exports["foldl"] = foldl;
exports["foldMap"] = foldMap;
exports["foldMapDefaultR"] = foldMapDefaultR;
exports["intercalate"] = intercalate;
exports["any"] = any;
exports["elem"] = elem;
exports["length"] = length;
exports["foldableArray"] = foldableArray;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Generic.Rep"] = $PS["Data.Generic.Rep"] || {};
var exports = $PS["Data.Generic.Rep"];
var Constructor = function (x) {
return x;
};
var Generic = function (from, to) {
this.from = from;
this.to = to;
};
var to = function (dict) {
return dict.to;
};
var from = function (dict) {
return dict.from;
};
exports["Generic"] = Generic;
exports["to"] = to;
exports["from"] = from;
exports["Constructor"] = Constructor;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Generic.Rep.Eq"] = $PS["Data.Generic.Rep.Eq"] || {};
var exports = $PS["Data.Generic.Rep.Eq"];
var Data_Eq = $PS["Data.Eq"];
var Data_Generic_Rep = $PS["Data.Generic.Rep"];
var GenericEq = function (genericEq$prime) {
this["genericEq'"] = genericEq$prime;
};
var genericEqArgument = function (dictEq) {
return new GenericEq(function (v) {
return function (v1) {
return Data_Eq.eq(dictEq)(v)(v1);
};
});
};
var genericEq$prime = function (dict) {
return dict["genericEq'"];
};
var genericEqConstructor = function (dictGenericEq) {
return new GenericEq(function (v) {
return function (v1) {
return genericEq$prime(dictGenericEq)(v)(v1);
};
});
};
var genericEq = function (dictGeneric) {
return function (dictGenericEq) {
return function (x) {
return function (y) {
return genericEq$prime(dictGenericEq)(Data_Generic_Rep.from(dictGeneric)(x))(Data_Generic_Rep.from(dictGeneric)(y));
};
};
};
};
exports["GenericEq"] = GenericEq;
exports["genericEq"] = genericEq;
exports["genericEqConstructor"] = genericEqConstructor;
exports["genericEqArgument"] = genericEqArgument;
})(PS);
(function(exports) {
"use strict";
exports.defer = function (thunk) {
var v = null;
return function() {
if (thunk === undefined) return v;
v = thunk();
thunk = undefined; // eslint-disable-line no-param-reassign
return v;
};
};
exports.force = function (l) {
return l();
};
})(PS["Data.Lazy"] = PS["Data.Lazy"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Lazy"] = $PS["Data.Lazy"] || {};
var exports = $PS["Data.Lazy"];
var $foreign = $PS["Data.Lazy"];
var Data_Functor = $PS["Data.Functor"];
var functorLazy = new Data_Functor.Functor(function (f) {
return function (l) {
return $foreign.defer(function (v) {
return f($foreign.force(l));
});
};
});
exports["functorLazy"] = functorLazy;
exports["defer"] = $foreign.defer;
exports["force"] = $foreign.force;
})(PS);
(function(exports) {
"use strict";
// jshint maxparams: 3
exports.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 (apply) {
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 apply(map(array2)(f(array[bot])))(f(array[bot + 1]));
case 3: return apply(apply(map(array3)(f(array[bot])))(f(array[bot + 1])))(f(array[bot + 2]));
default:
// This slightly tricky pivot selection aims to produce two
// even-length partitions where possible.
var pivot = bot + Math.floor((top - bot) / 4) * 2;
return apply(map(concat2)(go(bot, pivot)))(go(pivot, top));
}
}
return go(0, array.length);
};
};
};
};
};
}();
})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Traversable"] = $PS["Data.Traversable"] || {};
var exports = $PS["Data.Traversable"];
var $foreign = $PS["Data.Traversable"];
var Control_Applicative = $PS["Control.Applicative"];
var Control_Apply = $PS["Control.Apply"];
var Control_Category = $PS["Control.Category"];
var Data_Foldable = $PS["Data.Foldable"];
var Data_Functor = $PS["Data.Functor"];
var Traversable = function (Foldable1, Functor0, sequence, traverse) {
this.Foldable1 = Foldable1;
this.Functor0 = Functor0;
this.sequence = sequence;
this.traverse = traverse;
};
var traverse = function (dict) {
return dict.traverse;
};
var sequenceDefault = function (dictTraversable) {
return function (dictApplicative) {
return traverse(dictTraversable)(dictApplicative)(Control_Category.identity(Control_Category.categoryFn));
};
};
var traversableArray = new Traversable(function () {
return Data_Foldable.foldableArray;
}, function () {
return Data_Functor.functorArray;
}, function (dictApplicative) {
return sequenceDefault(traversableArray)(dictApplicative);
}, function (dictApplicative) {
return $foreign.traverseArrayImpl(Control_Apply.apply(dictApplicative.Apply0()))(Data_Functor.map((dictApplicative.Apply0()).Functor0()))(Control_Applicative.pure(dictApplicative));
});
var sequence = function (dict) {
return dict.sequence;
};
exports["Traversable"] = Traversable;
exports["traverse"] = traverse;
exports["sequence"] = sequence;
exports["sequenceDefault"] = sequenceDefault;
exports["traversableArray"] = traversableArray;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.List.Types"] = $PS["Data.List.Types"] || {};
var exports = $PS["Data.List.Types"];
var Control_Alt = $PS["Control.Alt"];
var Control_Applicative = $PS["Control.Applicative"];
var Control_Apply = $PS["Control.Apply"];
var Control_Category = $PS["Control.Category"];
var Control_Plus = $PS["Control.Plus"];
var Data_Foldable = $PS["Data.Foldable"];
var Data_Function = $PS["Data.Function"];
var Data_Functor = $PS["Data.Functor"];
var Data_Monoid = $PS["Data.Monoid"];
var Data_Semigroup = $PS["Data.Semigroup"];
var Data_Show = $PS["Data.Show"];
var Data_Traversable = $PS["Data.Traversable"];
var Nil = (function () {
function Nil() {
};
Nil.value = new Nil();
return Nil;
})();
var Cons = (function () {
function Cons(value0, value1) {
this.value0 = value0;
this.value1 = value1;
};
Cons.create = function (value0) {
return function (value1) {
return new Cons(value0, value1);
};
};
return Cons;
})();
var NonEmptyList = function (x) {
return x;
};
var listMap = function (f) {
var chunkedRevMap = function ($copy_chunksAcc) {
return function ($copy_v) {
var $tco_var_chunksAcc = $copy_chunksAcc;
var $tco_done = false;
var $tco_result;
function $tco_loop(chunksAcc, v) {
if (v instanceof Cons && (v.value1 instanceof Cons && v.value1.value1 instanceof Cons)) {
$tco_var_chunksAcc = new Cons(v, chunksAcc);
$copy_v = v.value1.value1.value1;
return;
};
var unrolledMap = function (v1) {
if (v1 instanceof Cons && (v1.value1 instanceof Cons && v1.value1.value1 instanceof Nil)) {
return new Cons(f(v1.value0), new Cons(f(v1.value1.value0), Nil.value));
};
if (v1 instanceof Cons && v1.value1 instanceof Nil) {
return new Cons(f(v1.value0), Nil.value);
};
return Nil.value;
};
var reverseUnrolledMap = function ($copy_v1) {
return function ($copy_acc) {
var $tco_var_v1 = $copy_v1;
var $tco_done = false;
var $tco_result;
function $tco_loop(v1, acc) {
if (v1 instanceof Cons && (v1.value0 instanceof Cons && (v1.value0.value1 instanceof Cons && v1.value0.value1.value1 instanceof Cons))) {
$tco_var_v1 = v1.value1;
$copy_acc = new Cons(f(v1.value0.value0), new Cons(f(v1.value0.value1.value0), new Cons(f(v1.value0.value1.value1.value0), acc)));
return;
};
$tco_done = true;
return acc;
};
while (!$tco_done) {
$tco_result = $tco_loop($tco_var_v1, $copy_acc);
};
return $tco_result;
};
};
$tco_done = true;
return reverseUnrolledMap(chunksAcc)(unrolledMap(v));
};
while (!$tco_done) {
$tco_result = $tco_loop($tco_var_chunksAcc, $copy_v);
};
return $tco_result;
};
};
return chunkedRevMap(Nil.value);
};
var functorList = new Data_Functor.Functor(listMap);
var foldableList = new Data_Foldable.Foldable(function (dictMonoid) {
return function (f) {
return Data_Foldable.foldl(foldableList)(function (acc) {
var $202 = Data_Semigroup.append(dictMonoid.Semigroup0())(acc);
return function ($203) {
return $202(f($203));
};
})(Data_Monoid.mempty(dictMonoid));
};
}, function (f) {
var go = function ($copy_b) {
return function ($copy_v) {
var $tco_var_b = $copy_b;
var $tco_done = false;
var $tco_result;
function $tco_loop(b, v) {
if (v instanceof Nil) {
$tco_done = true;
return b;
};
if (v instanceof Cons) {
$tco_var_b = f(b)(v.value0);
$copy_v = v.value1;
return;
};
throw new Error("Failed pattern match at Data.List.Types (line 109, column 12 - line 111, column 30): " + [ v.constructor.name ]);
};
while (!$tco_done) {
$tco_result = $tco_loop($tco_var_b, $copy_v);
};
return $tco_result;
};
};
return go;
}, function (f) {
return function (b) {
var rev = Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value);
var $204 = Data_Foldable.foldl(foldableList)(Data_Function.flip(f))(b);
return function ($205) {
return $204(rev($205));
};
};
});
var semigroupList = new Data_Semigroup.Semigroup(function (xs) {
return function (ys) {
return Data_Foldable.foldr(foldableList)(Cons.create)(ys)(xs);
};
});
var showList = function (dictShow) {
return new Data_Show.Show(function (v) {
if (v instanceof Nil) {
return "Nil";
};
return "(" + (Data_Foldable.intercalate(foldableList)(Data_Monoid.monoidString)(" : ")(Data_Functor.map(functorList)(Data_Show.show(dictShow))(v)) + " : Nil)");
});
};
var traversableList = new Data_Traversable.Traversable(function () {
return foldableList;
}, function () {
return functorList;
}, function (dictApplicative) {
return Data_Traversable.traverse(traversableList)(dictApplicative)(Control_Category.identity(Control_Category.categoryFn));
}, function (dictApplicative) {
return function (f) {
var $219 = Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value));
var $220 = Data_Foldable.foldl(foldableList)(function (acc) {
var $222 = Control_Apply.lift2(dictApplicative.Apply0())(Data_Function.flip(Cons.create))(acc);
return function ($223) {
return $222(f($223));
};
})(Control_Applicative.pure(dictApplicative)(Nil.value));
return function ($221) {
return $219($220($221));
};
};
});
var applyList = new Control_Apply.Apply(function () {
return functorList;
}, function (v) {
return function (v1) {
if (v instanceof Nil) {
return Nil.value;
};
if (v instanceof Cons) {
return Data_Semigroup.append(semigroupList)(Data_Functor.map(functorList)(v.value0)(v1))(Control_Apply.apply(applyList)(v.value1)(v1));
};
throw new Error("Failed pattern match at Data.List.Types (line 155, column 1 - line 157, column 48): " + [ v.constructor.name, v1.constructor.name ]);
};
});
var applicativeList = new Control_Applicative.Applicative(function () {
return applyList;
}, function (a) {
return new Cons(a, Nil.value);
});
var altList = new Control_Alt.Alt(function () {
return functorList;
}, Data_Semigroup.append(semigroupList));
var plusList = new Control_Plus.Plus(function () {
return altList;
}, Nil.value);
exports["Nil"] = Nil;
exports["Cons"] = Cons;
exports["NonEmptyList"] = NonEmptyList;
exports["showList"] = showList;
exports["semigroupList"] = semigroupList;
exports["functorList"] = functorList;
exports["foldableList"] = foldableList;
exports["traversableList"] = traversableList;
exports["applyList"] = applyList;
exports["applicativeList"] = applicativeList;
exports["altList"] = altList;
exports["plusList"] = plusList;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.List"] = $PS["Data.List"] || {};
var exports = $PS["Data.List"];
var Data_Foldable = $PS["Data.Foldable"];
var Data_List_Types = $PS["Data.List.Types"];
var fromFoldable = function (dictFoldable) {
return Data_Foldable.foldr(dictFoldable)(Data_List_Types.Cons.create)(Data_List_Types.Nil.value);
};
exports["fromFoldable"] = fromFoldable;
})(PS);
(function(exports) {
"use strict";
exports.unfoldrArrayImpl = function (isNothing) {
return function (fromJust) {
return function (fst) {
return function (snd) {
return function (f) {
return function (b) {
var result = [];
var value = b;
while (true) { // eslint-disable-line no-constant-condition
var maybe = f(value);
if (isNothing(maybe)) return result;
var tuple = fromJust(maybe);
result.push(fst(tuple));
value = snd(tuple);
}
};
};
};
};
};
};
})(PS["Data.Unfoldable"] = PS["Data.Unfoldable"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Tuple"] = $PS["Data.Tuple"] || {};
var exports = $PS["Data.Tuple"];
var Data_Foldable = $PS["Data.Foldable"];
var Data_Functor = $PS["Data.Functor"];
var Data_Show = $PS["Data.Show"];
var Data_Traversable = $PS["Data.Traversable"];
var Tuple = (function () {
function Tuple(value0, value1) {
this.value0 = value0;
this.value1 = value1;
};
Tuple.create = function (value0) {
return function (value1) {
return new Tuple(value0, value1);
};
};
return Tuple;
})();
var uncurry = function (f) {
return function (v) {
return f(v.value0)(v.value1);
};
};
var snd = function (v) {
return v.value1;
};
var showTuple = function (dictShow) {
return function (dictShow1) {
return new Data_Show.Show(function (v) {
return "(Tuple " + (Data_Show.show(dictShow)(v.value0) + (" " + (Data_Show.show(dictShow1)(v.value1) + ")")));
});
};
};
var functorTuple = new Data_Functor.Functor(function (f) {
return function (m) {
return new Tuple(m.value0, f(m.value1));
};
});
var fst = function (v) {
return v.value0;
};
var foldableTuple = new Data_Foldable.Foldable(function (dictMonoid) {
return function (f) {
return function (v) {
return f(v.value1);
};
};
}, function (f) {
return function (z) {
return function (v) {
return f(z)(v.value1);
};
};
}, function (f) {
return function (z) {
return function (v) {
return f(v.value1)(z);
};
};
});
var traversableTuple = new Data_Traversable.Traversable(function () {
return foldableTuple;
}, function () {
return functorTuple;
}, function (dictApplicative) {
return function (v) {
return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Tuple.create(v.value0))(v.value1);
};
}, function (dictApplicative) {
return function (f) {
return function (v) {
return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Tuple.create(v.value0))(f(v.value1));
};
};
});
exports["Tuple"] = Tuple;
exports["fst"] = fst;
exports["snd"] = snd;
exports["uncurry"] = uncurry;
exports["showTuple"] = showTuple;
exports["functorTuple"] = functorTuple;
exports["foldableTuple"] = foldableTuple;
exports["traversableTuple"] = traversableTuple;
})(PS);
(function(exports) {
"use strict";
exports.unfoldr1ArrayImpl = function (isNothing) {
return function (fromJust) {
return function (fst) {
return function (snd) {
return function (f) {
return function (b) {
var result = [];
var value = b;
while (true) { // eslint-disable-line no-constant-condition
var tuple = f(value);
result.push(fst(tuple));
var maybe = snd(tuple);
if (isNothing(maybe)) return result;
value = fromJust(maybe);
}
};
};
};
};
};
};
})(PS["Data.Unfoldable1"] = PS["Data.Unfoldable1"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Unfoldable1"] = $PS["Data.Unfoldable1"] || {};
var exports = $PS["Data.Unfoldable1"];
var $foreign = $PS["Data.Unfoldable1"];
var Data_Maybe = $PS["Data.Maybe"];
var Data_Tuple = $PS["Data.Tuple"];
var Unfoldable1 = function (unfoldr1) {
this.unfoldr1 = unfoldr1;
};
var unfoldr1 = function (dict) {
return dict.unfoldr1;
};
var unfoldable1Array = new Unfoldable1($foreign.unfoldr1ArrayImpl(Data_Maybe.isNothing)(Data_Maybe.fromJust())(Data_Tuple.fst)(Data_Tuple.snd));
exports["Unfoldable1"] = Unfoldable1;
exports["unfoldr1"] = unfoldr1;
exports["unfoldable1Array"] = unfoldable1Array;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Unfoldable"] = $PS["Data.Unfoldable"] || {};
var exports = $PS["Data.Unfoldable"];
var $foreign = $PS["Data.Unfoldable"];
var Data_Maybe = $PS["Data.Maybe"];
var Data_Tuple = $PS["Data.Tuple"];
var Data_Unfoldable1 = $PS["Data.Unfoldable1"];
var Unfoldable = function (Unfoldable10, unfoldr) {
this.Unfoldable10 = Unfoldable10;
this.unfoldr = unfoldr;
};
var unfoldr = function (dict) {
return dict.unfoldr;
};
var unfoldableArray = new Unfoldable(function () {
return Data_Unfoldable1.unfoldable1Array;
}, $foreign.unfoldrArrayImpl(Data_Maybe.isNothing)(Data_Maybe.fromJust())(Data_Tuple.fst)(Data_Tuple.snd));
exports["Unfoldable"] = Unfoldable;
exports["unfoldr"] = unfoldr;
exports["unfoldableArray"] = unfoldableArray;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.List.Lazy.Types"] = $PS["Data.List.Lazy.Types"] || {};
var exports = $PS["Data.List.Lazy.Types"];
var Control_Lazy = $PS["Control.Lazy"];
var Data_Foldable = $PS["Data.Foldable"];
var Data_Function = $PS["Data.Function"];
var Data_Lazy = $PS["Data.Lazy"];
var Data_Maybe = $PS["Data.Maybe"];
var Data_Monoid = $PS["Data.Monoid"];
var Data_Newtype = $PS["Data.Newtype"];
var Data_Semigroup = $PS["Data.Semigroup"];
var Data_Unfoldable = $PS["Data.Unfoldable"];
var Data_Unfoldable1 = $PS["Data.Unfoldable1"];
var List = function (x) {
return x;
};
var Nil = (function () {
function Nil() {
};
Nil.value = new Nil();
return Nil;
})();
var Cons = (function () {
function Cons(value0, value1) {
this.value0 = value0;
this.value1 = value1;
};
Cons.create = function (value0) {
return function (value1) {
return new Cons(value0, value1);
};
};
return Cons;
})();
var nil = List(Data_Lazy.defer(function (v) {
return Nil.value;
}));
var newtypeList = new Data_Newtype.Newtype(function (n) {
return n;
}, List);
var step = (function () {
var $215 = Data_Newtype.unwrap(newtypeList);
return function ($216) {
return Data_Lazy.force($215($216));
};
})();
var lazyList = new Control_Lazy.Lazy(function (f) {
return List(Data_Lazy.defer(function ($217) {
return step(f($217));
}));
});
var cons = function (x) {
return function (xs) {
return List(Data_Lazy.defer(function (v) {
return new Cons(x, xs);
}));
};
};
var foldableList = new Data_Foldable.Foldable(function (dictMonoid) {
return function (f) {
return Data_Foldable.foldl(foldableList)(function (b) {
return function (a) {
return Data_Semigroup.append(dictMonoid.Semigroup0())(b)(f(a));
};
})(Data_Monoid.mempty(dictMonoid));
};
}, function (op) {
var go = function ($copy_b) {
return function ($copy_xs) {
var $tco_var_b = $copy_b;
var $tco_done = false;
var $tco_result;
function $tco_loop(b, xs) {
var v = step(xs);
if (v instanceof Nil) {
$tco_done = true;
return b;
};
if (v instanceof Cons) {
$tco_var_b = op(b)(v.value0);
$copy_xs = v.value1;
return;
};
throw new Error("Failed pattern match at Data.List.Lazy.Types (line 122, column 7 - line 124, column 40): " + [ v.constructor.name ]);
};
while (!$tco_done) {
$tco_result = $tco_loop($tco_var_b, $copy_xs);
};
return $tco_result;
};
};
return go;
}, function (op) {
return function (z) {
return function (xs) {
var rev = Data_Foldable.foldl(foldableList)(Data_Function.flip(cons))(nil);
return Data_Foldable.foldl(foldableList)(Data_Function.flip(op))(z)(rev(xs));
};
};
});
var unfoldable1List = new Data_Unfoldable1.Unfoldable1((function () {
var go = function (f) {
return function (b) {
return Control_Lazy.defer(lazyList)(function (v) {
var v1 = f(b);
if (v1.value1 instanceof Data_Maybe.Just) {
return cons(v1.value0)(go(f)(v1.value1.value0));
};
if (v1.value1 instanceof Data_Maybe.Nothing) {
return cons(v1.value0)(nil);
};
throw new Error("Failed pattern match at Data.List.Lazy.Types (line 146, column 28 - line 148, column 33): " + [ v1.constructor.name ]);
});
};
};
return go;
})());
var unfoldableList = new Data_Unfoldable.Unfoldable(function () {
return unfoldable1List;
}, (function () {
var go = function (f) {
return function (b) {
return Control_Lazy.defer(lazyList)(function (v) {
var v1 = f(b);
if (v1 instanceof Data_Maybe.Nothing) {
return nil;
};
if (v1 instanceof Data_Maybe.Just) {
return cons(v1.value0.value0)(go(f)(v1.value0.value1));
};
throw new Error("Failed pattern match at Data.List.Lazy.Types (line 152, column 28 - line 154, column 39): " + [ v1.constructor.name ]);
});
};
};
return go;
})());
exports["List"] = List;
exports["Nil"] = Nil;
exports["Cons"] = Cons;
exports["step"] = step;
exports["nil"] = nil;
exports["cons"] = cons;
exports["newtypeList"] = newtypeList;
exports["lazyList"] = lazyList;
exports["foldableList"] = foldableList;
exports["unfoldable1List"] = unfoldable1List;
exports["unfoldableList"] = unfoldableList;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.List.Lazy"] = $PS["Data.List.Lazy"] || {};
var exports = $PS["Data.List.Lazy"];
var Data_Boolean = $PS["Data.Boolean"];
var Data_Functor = $PS["Data.Functor"];
var Data_Lazy = $PS["Data.Lazy"];
var Data_List_Lazy_Types = $PS["Data.List.Lazy.Types"];
var Data_Newtype = $PS["Data.Newtype"];
var filter = function (p) {
var go = function ($copy_v) {
var $tco_done = false;
var $tco_result;
function $tco_loop(v) {
if (v instanceof Data_List_Lazy_Types.Nil) {
$tco_done = true;
return Data_List_Lazy_Types.Nil.value;
};
if (v instanceof Data_List_Lazy_Types.Cons) {
if (p(v.value0)) {
$tco_done = true;
return new Data_List_Lazy_Types.Cons(v.value0, filter(p)(v.value1));
};
if (Data_Boolean.otherwise) {
$copy_v = Data_List_Lazy_Types.step(v.value1);
return;
};
};
throw new Error("Failed pattern match at Data.List.Lazy (line 428, column 3 - line 428, column 15): " + [ v.constructor.name ]);
};
while (!$tco_done) {
$tco_result = $tco_loop($copy_v);
};
return $tco_result;
};
var $266 = Data_Functor.map(Data_Lazy.functorLazy)(go);
var $267 = Data_Newtype.unwrap(Data_List_Lazy_Types.newtypeList);
return function ($268) {
return Data_List_Lazy_Types.List($266($267($268)));
};
};
exports["filter"] = filter;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.NonEmpty"] = $PS["Data.NonEmpty"] || {};
var exports = $PS["Data.NonEmpty"];
var Control_Plus = $PS["Control.Plus"];
var NonEmpty = (function () {
function NonEmpty(value0, value1) {
this.value0 = value0;
this.value1 = value1;
};
NonEmpty.create = function (value0) {
return function (value1) {
return new NonEmpty(value0, value1);
};
};
return NonEmpty;
})();
var singleton = function (dictPlus) {
return function (a) {
return new NonEmpty(a, Control_Plus.empty(dictPlus));
};
};
exports["NonEmpty"] = NonEmpty;
exports["singleton"] = singleton;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.List.NonEmpty"] = $PS["Data.List.NonEmpty"] || {};
var exports = $PS["Data.List.NonEmpty"];
var Data_List_Types = $PS["Data.List.Types"];
var Data_NonEmpty = $PS["Data.NonEmpty"];
var singleton = (function () {
var $168 = Data_NonEmpty.singleton(Data_List_Types.plusList);
return function ($169) {
return Data_List_Types.NonEmptyList($168($169));
};
})();
exports["singleton"] = singleton;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Map.Internal"] = $PS["Data.Map.Internal"] || {};
var exports = $PS["Data.Map.Internal"];
var Control_Applicative = $PS["Control.Applicative"];
var Data_Foldable = $PS["Data.Foldable"];
var Data_Function = $PS["Data.Function"];
var Data_Functor = $PS["Data.Functor"];
var Data_List_Lazy = $PS["Data.List.Lazy"];
var Data_List_Lazy_Types = $PS["Data.List.Lazy.Types"];
var Data_List_Types = $PS["Data.List.Types"];
var Data_Maybe = $PS["Data.Maybe"];
var Data_Ord = $PS["Data.Ord"];
var Data_Ordering = $PS["Data.Ordering"];
var Data_Semigroup = $PS["Data.Semigroup"];
var Data_Tuple = $PS["Data.Tuple"];
var Data_Unfoldable = $PS["Data.Unfoldable"];
var Leaf = (function () {
function Leaf() {
};
Leaf.value = new Leaf();
return Leaf;
})();
var Two = (function () {
function Two(value0, value1, value2, value3) {
this.value0 = value0;
this.value1 = value1;
this.value2 = value2;
this.value3 = value3;
};
Two.create = function (value0) {
return function (value1) {
return function (value2) {
return function (value3) {
return new Two(value0, value1, value2, value3);
};
};
};
};
return Two;
})();
var Three = (function () {
function Three(value0, value1, value2, value3, value4, value5, value6) {
this.value0 = value0;
this.value1 = value1;
this.value2 = value2;
this.value3 = value3;
this.value4 = value4;
this.value5 = value5;
this.value6 = value6;
};
Three.create = function (value0) {
return function (value1) {
return function (value2) {
return function (value3) {
return function (value4) {
return function (value5) {
return function (value6) {
return new Three(value0, value1, value2, value3, value4, value5, value6);
};
};
};
};
};
};
};
return Three;
})();
var TwoLeft = (function () {
function TwoLeft(value0, value1, value2) {
this.value0 = value0;
this.value1 = value1;
this.value2 = value2;
};
TwoLeft.create = function (value0) {
return function (value1) {
return function (value2) {
return new TwoLeft(value0, value1, value2);
};
};
};
return TwoLeft;
})();
var TwoRight = (function () {
function TwoRight(value0, value1, value2) {
this.value0 = value0;
this.value1 = value1;
this.value2 = value2;
};
TwoRight.create = function (value0) {
return function (value1) {
return function (value2) {
return new TwoRight(value0, value1, value2);
};
};
};
return TwoRight;
})();
var ThreeLeft = (function () {
function ThreeLeft(value0, value1, value2, value3, value4, value5) {
this.value0 = value0;
this.value1 = value1;
this.value2 = value2;
this.value3 = value3;
this.value4 = value4;
this.value5 = value5;
};
ThreeLeft.create = function (value0) {
return function (value1) {
return function (value2) {
return function (value3) {
return function (value4) {
return function (value5) {
return new ThreeLeft(value0, value1, value2, value3, value4, value5);
};
};
};
};
};
};
return ThreeLeft;
})();
var ThreeMiddle = (function () {
function ThreeMiddle(value0, value1, value2, value3, value4, value5) {
this.value0 = value0;
this.value1 = value1;
this.value2 = value2;
this.value3 = value3;
this.value4 = value4;
this.value5 = value5;
};
ThreeMiddle.create = function (value0) {
return function (value1) {
return function (value2) {
return function (value3) {
return function (value4) {
return function (value5) {
return new ThreeMiddle(value0, value1, value2, value3, value4, value5);
};
};
};
};
};
};
return ThreeMiddle;
})();
var ThreeRight = (function () {
function ThreeRight(value0, value1, value2, value3, value4, value5) {
this.value0 = value0;
this.value1 = value1;
this.value2 = value2;
this.value3 = value3;
this.value4 = value4;
this.value5 = value5;
};
ThreeRight.create = function (value0) {
return function (value1) {
return function (value2) {
return function (value3) {
return function (value4) {
return function (value5) {
return new ThreeRight(value0, value1, value2, value3, value4, value5);
};
};
};
};
};
};
return ThreeRight;
})();
var KickUp = (function () {
function KickUp(value0, value1, value2, value3) {
this.value0 = value0;
this.value1 = value1;
this.value2 = value2;
this.value3 = value3;
};
KickUp.create = function (value0) {
return function (value1) {
return function (value2) {
return function (value3) {
return new KickUp(value0, value1, value2, value3);
};
};
};
};
return KickUp;
})();
var values = function (v) {
if (v instanceof Leaf) {
return Data_List_Types.Nil.value;
};
if (v instanceof Two) {
return Data_Semigroup.append(Data_List_Types.semigroupList)(values(v.value0))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value2))(values(v.value3)));
};
if (v instanceof Three) {
return Data_Semigroup.append(Data_List_Types.semigroupList)(values(v.value0))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value2))(Data_Semigroup.append(Data_List_Types.semigroupList)(values(v.value3))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value5))(values(v.value6)))));
};
throw new Error("Failed pattern match at Data.Map.Internal (line 612, column 1 - line 612, column 40): " + [ v.constructor.name ]);
};
var singleton = function (k) {
return function (v) {
return new Two(Leaf.value, k, v, Leaf.value);
};
};
var toUnfoldable = function (dictUnfoldable) {
return function (m) {
var go = function ($copy_v) {
var $tco_done = false;
var $tco_result;
function $tco_loop(v) {
if (v instanceof Data_List_Types.Nil) {
$tco_done = true;
return Data_Maybe.Nothing.value;
};
if (v instanceof Data_List_Types.Cons) {
if (v.value0 instanceof Leaf) {
$copy_v = v.value1;
return;
};
if (v.value0 instanceof Two && (v.value0.value0 instanceof Leaf && v.value0.value3 instanceof Leaf)) {
$tco_done = true;
return Data_Maybe.Just.create(new Data_Tuple.Tuple(new Data_Tuple.Tuple(v.value0.value1, v.value0.value2), v.value1));
};
if (v.value0 instanceof Two && v.value0.value0 instanceof Leaf) {
$tco_done = true;
return Data_Maybe.Just.create(new Data_Tuple.Tuple(new Data_Tuple.Tuple(v.value0.value1, v.value0.value2), new Data_List_Types.Cons(v.value0.value3, v.value1)));
};
if (v.value0 instanceof Two) {
$copy_v = new Data_List_Types.Cons(v.value0.value0, new Data_List_Types.Cons(singleton(v.value0.value1)(v.value0.value2), new Data_List_Types.Cons(v.value0.value3, v.value1)));
return;
};
if (v.value0 instanceof Three) {
$copy_v = new Data_List_Types.Cons(v.value0.value0, new Data_List_Types.Cons(singleton(v.value0.value1)(v.value0.value2), new Data_List_Types.Cons(v.value0.value3, new Data_List_Types.Cons(singleton(v.value0.value4)(v.value0.value5), new Data_List_Types.Cons(v.value0.value6, v.value1)))));
return;
};
throw new Error("Failed pattern match at Data.Map.Internal (line 577, column 18 - line 586, column 71): " + [ v.value0.constructor.name ]);
};
throw new Error("Failed pattern match at Data.Map.Internal (line 576, column 3 - line 576, column 19): " + [ v.constructor.name ]);
};
while (!$tco_done) {
$tco_result = $tco_loop($copy_v);
};
return $tco_result;
};
return Data_Unfoldable.unfoldr(dictUnfoldable)(go)(new Data_List_Types.Cons(m, Data_List_Types.Nil.value));
};
};
var functorMap = new Data_Functor.Functor(function (v) {
return function (v1) {
if (v1 instanceof Leaf) {
return Leaf.value;
};
if (v1 instanceof Two) {
return new Two(Data_Functor.map(functorMap)(v)(v1.value0), v1.value1, v(v1.value2), Data_Functor.map(functorMap)(v)(v1.value3));
};
if (v1 instanceof Three) {
return new Three(Data_Functor.map(functorMap)(v)(v1.value0), v1.value1, v(v1.value2), Data_Functor.map(functorMap)(v)(v1.value3), v1.value4, v(v1.value5), Data_Functor.map(functorMap)(v)(v1.value6));
};
throw new Error("Failed pattern match at Data.Map.Internal (line 96, column 1 - line 99, column 110): " + [ v.constructor.name, v1.constructor.name ]);
};
});
var fromZipper = function ($copy_dictOrd) {
return function ($copy_v) {
return function ($copy_tree) {
var $tco_var_dictOrd = $copy_dictOrd;
var $tco_var_v = $copy_v;
var $tco_done = false;
var $tco_result;
function $tco_loop(dictOrd, v, tree) {
if (v instanceof Data_List_Types.Nil) {
$tco_done = true;
return tree;
};
if (v instanceof Data_List_Types.Cons) {
if (v.value0 instanceof TwoLeft) {
$tco_var_dictOrd = dictOrd;
$tco_var_v = v.value1;
$copy_tree = new Two(tree, v.value0.value0, v.value0.value1, v.value0.value2);
return;
};
if (v.value0 instanceof TwoRight) {
$tco_var_dictOrd = dictOrd;
$tco_var_v = v.value1;
$copy_tree = new Two(v.value0.value0, v.value0.value1, v.value0.value2, tree);
return;
};
if (v.value0 instanceof ThreeLeft) {
$tco_var_dictOrd = dictOrd;
$tco_var_v = v.value1;
$copy_tree = new Three(tree, v.value0.value0, v.value0.value1, v.value0.value2, v.value0.value3, v.value0.value4, v.value0.value5);
return;
};
if (v.value0 instanceof ThreeMiddle) {
$tco_var_dictOrd = dictOrd;
$tco_var_v = v.value1;
$copy_tree = new Three(v.value0.value0, v.value0.value1, v.value0.value2, tree, v.value0.value3, v.value0.value4, v.value0.value5);
return;
};
if (v.value0 instanceof ThreeRight) {
$tco_var_dictOrd = dictOrd;
$tco_var_v = v.value1;
$copy_tree = new Three(v.value0.value0, v.value0.value1, v.value0.value2, v.value0.value3, v.value0.value4, v.value0.value5, tree);
return;
};
throw new Error("Failed pattern match at Data.Map.Internal (line 418, column 3 - line 423, column 88): " + [ v.value0.constructor.name ]);
};
throw new Error("Failed pattern match at Data.Map.Internal (line 415, column 1 - line 415, column 80): " + [ v.constructor.name, tree.constructor.name ]);
};
while (!$tco_done) {
$tco_result = $tco_loop($tco_var_dictOrd, $tco_var_v, $copy_tree);
};
return $tco_result;
};
};
};
var insert = function (dictOrd) {
return function (k) {
return function (v) {
var up = function ($copy_v1) {
return function ($copy_v2) {
var $tco_var_v1 = $copy_v1;
var $tco_done = false;
var $tco_result;
function $tco_loop(v1, v2) {
if (v1 instanceof Data_List_Types.Nil) {
$tco_done = true;
return new Two(v2.value0, v2.value1, v2.value2, v2.value3);
};
if (v1 instanceof Data_List_Types.Cons) {
if (v1.value0 instanceof TwoLeft) {
$tco_done = true;
return fromZipper(dictOrd)(v1.value1)(new Three(v2.value0, v2.value1, v2.value2, v2.value3, v1.value0.value0, v1.value0.value1, v1.value0.value2));
};
if (v1.value0 instanceof TwoRight) {
$tco_done = true;
return fromZipper(dictOrd)(v1.value1)(new Three(v1.value0.value0, v1.value0.value1, v1.value0.value2, v2.value0, v2.value1, v2.value2, v2.value3));
};
if (v1.value0 instanceof ThreeLeft) {
$tco_var_v1 = v1.value1;
$copy_v2 = new KickUp(new Two(v2.value0, v2.value1, v2.value2, v2.value3), v1.value0.value0, v1.value0.value1, new Two(v1.value0.value2, v1.value0.value3, v1.value0.value4, v1.value0.value5));
return;
};
if (v1.value0 instanceof ThreeMiddle) {
$tco_var_v1 = v1.value1;
$copy_v2 = new KickUp(new Two(v1.value0.value0, v1.value0.value1, v1.value0.value2, v2.value0), v2.value1, v2.value2, new Two(v2.value3, v1.value0.value3, v1.value0.value4, v1.value0.value5));
return;
};
if (v1.value0 instanceof ThreeRight) {
$tco_var_v1 = v1.value1;
$copy_v2 = new KickUp(new Two(v1.value0.value0, v1.value0.value1, v1.value0.value2, v1.value0.value3), v1.value0.value4, v1.value0.value5, new Two(v2.value0, v2.value1, v2.value2, v2.value3));
return;
};
throw new Error("Failed pattern match at Data.Map.Internal (line 454, column 5 - line 459, column 108): " + [ v1.value0.constructor.name, v2.constructor.name ]);
};
throw new Error("Failed pattern match at Data.Map.Internal (line 451, column 3 - line 451, column 56): " + [ v1.constructor.name, v2.constructor.name ]);
};
while (!$tco_done) {
$tco_result = $tco_loop($tco_var_v1, $copy_v2);
};
return $tco_result;
};
};
var comp = Data_Ord.compare(dictOrd);
var down = function ($copy_ctx) {
return function ($copy_v1) {
var $tco_var_ctx = $copy_ctx;
var $tco_done = false;
var $tco_result;
function $tco_loop(ctx, v1) {
if (v1 instanceof Leaf) {
$tco_done = true;
return up(ctx)(new KickUp(Leaf.value, k, v, Leaf.value));
};
if (v1 instanceof Two) {
var v2 = comp(k)(v1.value1);
if (v2 instanceof Data_Ordering.EQ) {
$tco_done = true;
return fromZipper(dictOrd)(ctx)(new Two(v1.value0, k, v, v1.value3));
};
if (v2 instanceof Data_Ordering.LT) {
$tco_var_ctx = new Data_List_Types.Cons(new TwoLeft(v1.value1, v1.value2, v1.value3), ctx);
$copy_v1 = v1.value0;
return;
};
$tco_var_ctx = new Data_List_Types.Cons(new TwoRight(v1.value0, v1.value1, v1.value2), ctx);
$copy_v1 = v1.value3;
return;
};
if (v1 instanceof Three) {
var v3 = comp(k)(v1.value1);
if (v3 instanceof Data_Ordering.EQ) {
$tco_done = true;
return fromZipper(dictOrd)(ctx)(new Three(v1.value0, k, v, v1.value3, v1.value4, v1.value5, v1.value6));
};
var v4 = comp(k)(v1.value4);
if (v4 instanceof Data_Ordering.EQ) {
$tco_done = true;
return fromZipper(dictOrd)(ctx)(new Three(v1.value0, v1.value1, v1.value2, v1.value3, k, v, v1.value6));
};
if (v3 instanceof Data_Ordering.LT) {
$tco_var_ctx = new Data_List_Types.Cons(new ThreeLeft(v1.value1, v1.value2, v1.value3, v1.value4, v1.value5, v1.value6), ctx);
$copy_v1 = v1.value0;
return;
};
if (v3 instanceof Data_Ordering.GT && v4 instanceof Data_Ordering.LT) {
$tco_var_ctx = new Data_List_Types.Cons(new ThreeMiddle(v1.value0, v1.value1, v1.value2, v1.value4, v1.value5, v1.value6), ctx);
$copy_v1 = v1.value3;
return;
};
$tco_var_ctx = new Data_List_Types.Cons(new ThreeRight(v1.value0, v1.value1, v1.value2, v1.value3, v1.value4, v1.value5), ctx);
$copy_v1 = v1.value6;
return;
};
throw new Error("Failed pattern match at Data.Map.Internal (line 434, column 3 - line 434, column 55): " + [ ctx.constructor.name, v1.constructor.name ]);
};
while (!$tco_done) {
$tco_result = $tco_loop($tco_var_ctx, $copy_v1);
};
return $tco_result;
};
};
return down(Data_List_Types.Nil.value);
};
};
};
var foldableMap = new Data_Foldable.Foldable(function (dictMonoid) {
return function (f) {
return function (m) {
return Data_Foldable.foldMap(Data_List_Types.foldableList)(dictMonoid)(f)(values(m));
};
};
}, function (f) {
return function (z) {
return function (m) {
return Data_Foldable.foldl(Data_List_Types.foldableList)(f)(z)(values(m));
};
};
}, function (f) {
return function (z) {
return function (m) {
return Data_Foldable.foldr(Data_List_Types.foldableList)(f)(z)(values(m));
};
};
});
var empty = Leaf.value;
var fromFoldable = function (dictOrd) {
return function (dictFoldable) {
return Data_Foldable.foldl(dictFoldable)(function (m) {
return function (v) {
return insert(dictOrd)(v.value0)(v.value1)(m);
};
})(empty);
};
};
var filterWithKey = function (dictOrd) {
return function (predicate) {
var $758 = fromFoldable(dictOrd)(Data_List_Lazy_Types.foldableList);
var $759 = Data_List_Lazy.filter(Data_Tuple.uncurry(predicate));
var $760 = toUnfoldable(Data_List_Lazy_Types.unfoldableList);
return function ($761) {
return $758($759($760($761)));
};
};
};
var filter = function (dictOrd) {
return function (predicate) {
return filterWithKey(dictOrd)(Data_Function["const"](predicate));
};
};
exports["empty"] = empty;
exports["singleton"] = singleton;
exports["insert"] = insert;
exports["fromFoldable"] = fromFoldable;
exports["toUnfoldable"] = toUnfoldable;
exports["values"] = values;
exports["filterWithKey"] = filterWithKey;
exports["filter"] = filter;
exports["functorMap"] = functorMap;
exports["foldableMap"] = foldableMap;
})(PS);
(function(exports) {
"use strict";
exports.toCharArray = function (s) {
return s.split("");
};
})(PS["Data.String.CodeUnits"] = PS["Data.String.CodeUnits"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.String.CodeUnits"] = $PS["Data.String.CodeUnits"] || {};
var exports = $PS["Data.String.CodeUnits"];
var $foreign = $PS["Data.String.CodeUnits"];
exports["toCharArray"] = $foreign.toCharArray;
})(PS);
(function(exports) {
"use strict";
exports.unit = {};
})(PS["Data.Unit"] = PS["Data.Unit"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Data.Unit"] = $PS["Data.Unit"] || {};
var exports = $PS["Data.Unit"];
var $foreign = $PS["Data.Unit"];
var Data_Show = $PS["Data.Show"];
var showUnit = new Data_Show.Show(function (v) {
return "unit";
});
exports["showUnit"] = showUnit;
exports["unit"] = $foreign.unit;
})(PS);
(function(exports) {
"use strict";
exports.pureE = function (a) {
return function () {
return a;
};
};
exports.bindE = function (a) {
return function (f) {
return function () {
return f(a())();
};
};
};
})(PS["Effect"] = PS["Effect"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Effect"] = $PS["Effect"] || {};
var exports = $PS["Effect"];
var $foreign = $PS["Effect"];
var Control_Applicative = $PS["Control.Applicative"];
var Control_Apply = $PS["Control.Apply"];
var Control_Bind = $PS["Control.Bind"];
var Control_Monad = $PS["Control.Monad"];
var Data_Functor = $PS["Data.Functor"];
var monadEffect = new Control_Monad.Monad(function () {
return applicativeEffect;
}, function () {
return bindEffect;
});
var bindEffect = new Control_Bind.Bind(function () {
return applyEffect;
}, $foreign.bindE);
var applyEffect = new Control_Apply.Apply(function () {
return functorEffect;
}, Control_Monad.ap(monadEffect));
var applicativeEffect = new Control_Applicative.Applicative(function () {
return applyEffect;
}, $foreign.pureE);
var functorEffect = new Data_Functor.Functor(Control_Applicative.liftA1(applicativeEffect));
exports["functorEffect"] = functorEffect;
exports["applyEffect"] = applyEffect;
exports["applicativeEffect"] = applicativeEffect;
exports["bindEffect"] = bindEffect;
exports["monadEffect"] = monadEffect;
})(PS);
(function(exports) {
"use strict";
exports.log = function (s) {
return function () {
console.log(s);
return {};
};
};
})(PS["Effect.Console"] = PS["Effect.Console"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Effect.Console"] = $PS["Effect.Console"] || {};
var exports = $PS["Effect.Console"];
var $foreign = $PS["Effect.Console"];
var Data_Show = $PS["Data.Show"];
var logShow = function (dictShow) {
return function (a) {
return $foreign.log(Data_Show.show(dictShow)(a));
};
};
exports["logShow"] = logShow;
})(PS);
(function(exports) {
"use strict";
exports.unsafeFromForeign = function (value) {
return value;
};
exports.typeOf = function (value) {
return typeof value;
};
exports.isNull = function (value) {
return value === null;
};
exports.isUndefined = function (value) {
return value === undefined;
};
})(PS["Foreign"] = PS["Foreign"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Foreign"] = $PS["Foreign"] || {};
var exports = $PS["Foreign"];
var $foreign = $PS["Foreign"];
var Control_Monad_Error_Class = $PS["Control.Monad.Error.Class"];
var Control_Monad_Except_Trans = $PS["Control.Monad.Except.Trans"];
var Data_Identity = $PS["Data.Identity"];
var Data_List_NonEmpty = $PS["Data.List.NonEmpty"];
var TypeMismatch = (function () {
function TypeMismatch(value0, value1) {
this.value0 = value0;
this.value1 = value1;
};
TypeMismatch.create = function (value0) {
return function (value1) {
return new TypeMismatch(value0, value1);
};
};
return TypeMismatch;
})();
var ErrorAtProperty = (function () {
function ErrorAtProperty(value0, value1) {
this.value0 = value0;
this.value1 = value1;
};
ErrorAtProperty.create = function (value0) {
return function (value1) {
return new ErrorAtProperty(value0, value1);
};
};
return ErrorAtProperty;
})();
var fail = (function () {
var $107 = Control_Monad_Error_Class.throwError(Control_Monad_Except_Trans.monadThrowExceptT(Data_Identity.monadIdentity));
return function ($108) {
return $107(Data_List_NonEmpty.singleton($108));
};
})();
exports["TypeMismatch"] = TypeMismatch;
exports["ErrorAtProperty"] = ErrorAtProperty;
exports["fail"] = fail;
exports["unsafeFromForeign"] = $foreign.unsafeFromForeign;
exports["typeOf"] = $foreign.typeOf;
exports["isNull"] = $foreign.isNull;
exports["isUndefined"] = $foreign.isUndefined;
})(PS);
(function(exports) {
"use strict";
exports.unsafeReadPropImpl = function (f, s, key, value) {
return value == null ? f : s(value[key]);
};
exports.unsafeHasOwnProperty = function (prop, value) {
return Object.prototype.hasOwnProperty.call(value, prop);
};
exports.unsafeHasProperty = function (prop, value) {
return prop in value;
};
})(PS["Foreign.Index"] = PS["Foreign.Index"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Foreign.Index"] = $PS["Foreign.Index"] || {};
var exports = $PS["Foreign.Index"];
var $foreign = $PS["Foreign.Index"];
var Control_Applicative = $PS["Control.Applicative"];
var Control_Monad_Except_Trans = $PS["Control.Monad.Except.Trans"];
var Data_Function = $PS["Data.Function"];
var Data_Identity = $PS["Data.Identity"];
var Foreign = $PS["Foreign"];
var Indexable = function (ix) {
this.ix = ix;
};
var Index = function (errorAt, hasOwnProperty, hasProperty, index) {
this.errorAt = errorAt;
this.hasOwnProperty = hasOwnProperty;
this.hasProperty = hasProperty;
this.index = index;
};
var unsafeReadProp = function (k) {
return function (value) {
return $foreign.unsafeReadPropImpl(Foreign.fail(new Foreign.TypeMismatch("object", Foreign.typeOf(value))), Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity)), k, value);
};
};
var readProp = unsafeReadProp;
var ix = function (dict) {
return dict.ix;
};
var index = function (dict) {
return dict.index;
};
var indexableForeign = new Indexable(function (dictIndex) {
return index(dictIndex);
});
var hasPropertyImpl = function (v) {
return function (value) {
if (Foreign.isNull(value)) {
return false;
};
if (Foreign.isUndefined(value)) {
return false;
};
if (Foreign.typeOf(value) === "object" || Foreign.typeOf(value) === "function") {
return $foreign.unsafeHasProperty(v, value);
};
return false;
};
};
var hasProperty = function (dict) {
return dict.hasProperty;
};
var hasOwnPropertyImpl = function (v) {
return function (value) {
if (Foreign.isNull(value)) {
return false;
};
if (Foreign.isUndefined(value)) {
return false;
};
if (Foreign.typeOf(value) === "object" || Foreign.typeOf(value) === "function") {
return $foreign.unsafeHasOwnProperty(v, value);
};
return false;
};
};
var indexString = new Index(Foreign.ErrorAtProperty.create, hasOwnPropertyImpl, hasPropertyImpl, Data_Function.flip(readProp));
var hasOwnProperty = function (dict) {
return dict.hasOwnProperty;
};
var errorAt = function (dict) {
return dict.errorAt;
};
exports["Index"] = Index;
exports["Indexable"] = Indexable;
exports["readProp"] = readProp;
exports["ix"] = ix;
exports["index"] = index;
exports["hasProperty"] = hasProperty;
exports["hasOwnProperty"] = hasOwnProperty;
exports["errorAt"] = errorAt;
exports["indexString"] = indexString;
exports["indexableForeign"] = indexableForeign;
})(PS);
(function(exports) {
"use strict";
exports.unsafeKeys = Object.keys || function (value) {
var keys = [];
for (var prop in value) {
if (Object.prototype.hasOwnProperty.call(value, prop)) {
keys.push(prop);
}
}
return keys;
};
})(PS["Foreign.Keys"] = PS["Foreign.Keys"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Foreign.Keys"] = $PS["Foreign.Keys"] || {};
var exports = $PS["Foreign.Keys"];
var $foreign = $PS["Foreign.Keys"];
var Control_Applicative = $PS["Control.Applicative"];
var Control_Monad_Except_Trans = $PS["Control.Monad.Except.Trans"];
var Data_Boolean = $PS["Data.Boolean"];
var Data_Identity = $PS["Data.Identity"];
var Foreign = $PS["Foreign"];
var keys = function (value) {
if (Foreign.isNull(value)) {
return Foreign.fail(new Foreign.TypeMismatch("object", "null"));
};
if (Foreign.isUndefined(value)) {
return Foreign.fail(new Foreign.TypeMismatch("object", "undefined"));
};
if (Foreign.typeOf(value) === "object") {
return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))($foreign.unsafeKeys(value));
};
if (Data_Boolean.otherwise) {
return Foreign.fail(new Foreign.TypeMismatch("object", Foreign.typeOf(value)));
};
throw new Error("Failed pattern match at Foreign.Keys (line 15, column 1 - line 15, column 36): " + [ value.constructor.name ]);
};
exports["keys"] = keys;
})(PS);
(function(exports) {
"use strict";
exports.find_sources = FIND_SOURCES;
exports.find_structures = FIND_STRUCTURES;
exports.find_my_spawns = FIND_MY_SPAWNS;
})(PS["Screeps.FindType"] = PS["Screeps.FindType"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.FindType"] = $PS["Screeps.FindType"] || {};
var exports = $PS["Screeps.FindType"];
var $foreign = $PS["Screeps.FindType"];
exports["find_sources"] = $foreign.find_sources;
exports["find_structures"] = $foreign.find_structures;
exports["find_my_spawns"] = $foreign.find_my_spawns;
})(PS);
(function(exports) {
"use strict";
exports.unsafeGameField = function (fieldName) {
return function () { return Game[fieldName]; }
}
})(PS["Screeps.Game"] = PS["Screeps.Game"] || {});
(function(exports) {
"use strict";
// module Screeps.FFI
exports.unsafeField = function (key) {
return function (obj) {
console.log(obj);
console.log(key);
return obj[key];
}
}
exports.unsafeOptField_helper = function (Nothing) {
return function (Just) {
return function (key) {
return function (obj) {
var r = obj[key];
if (_.isUndefined(r)) {
return Nothing;
} else {
return Just(r);
}
}
}
}
}
exports.runThisEffectFn1 = function (key) {
return function (self) {
return function (a) {
return function () {
return self[key](a);
}
}
}
}
exports.runThisEffectFn2 = function (key) {
return function (self) {
return function (a) {
return function (b) {
return function () {
return self[key](a, b);
}
}
}
}
}
exports.runThisEffectFn3 = function (key) {
return function (self) {
return function (a) {
return function (b) {
return function (c) {
return function () {
return self[key](a, b, c);
}
}
}
}
}
}
exports.runThisFn0 = function (key) {
return function (self) {
return self[key]();
}
}
exports.runThisFn1 = function (key) {
return function (self) {
return function (a) {
return self[key](a);
}
}
}
exports.runThisFn2 = function (key) {
return function (self) {
return function (a) {
return function (b) {
return self[key](a, b);
}
}
}
}
exports.null = null;
exports.undefined = undefined;
exports.notNullOrUndefined = function (x) {
return x;
}
exports.isUndefined = function (x) {
return x === undefined;
}
exports.toMaybeImpl = function (val, nothing, just) {
if (val === null || val === undefined) {
return nothing;
} else {
return just(val);
}
}
exports.selectMaybesImpl = function (isJust) {
return function (fromJust) {
return function (obj) {
var newObj = {};
for (var key in obj) {
if (!obj.hasOwnProperty(key)) {
continue;
}
if (isJust(obj[key])) {
newObj[key] = fromJust(obj[key]);
}
}
return newObj;
}
}
}
exports.instanceOf = function (className) {
return function (object) {
var global = (1, eval)('this');
return object instanceof global[className];
}
}
})(PS["Screeps.FFI"] = PS["Screeps.FFI"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.FFI"] = $PS["Screeps.FFI"] || {};
var exports = $PS["Screeps.FFI"];
var $foreign = $PS["Screeps.FFI"];
var Control_Applicative = $PS["Control.Applicative"];
var Control_Apply = $PS["Control.Apply"];
var Control_Bind = $PS["Control.Bind"];
var Control_Monad_Except = $PS["Control.Monad.Except"];
var Control_Monad_Except_Trans = $PS["Control.Monad.Except.Trans"];
var Data_Either = $PS["Data.Either"];
var Data_Foldable = $PS["Data.Foldable"];
var Data_Function = $PS["Data.Function"];
var Data_Functor = $PS["Data.Functor"];
var Data_Identity = $PS["Data.Identity"];
var Data_Map_Internal = $PS["Data.Map.Internal"];
var Data_Maybe = $PS["Data.Maybe"];
var Data_Ord = $PS["Data.Ord"];
var Data_Traversable = $PS["Data.Traversable"];
var Data_Tuple = $PS["Data.Tuple"];
var Foreign = $PS["Foreign"];
var Foreign_Index = $PS["Foreign.Index"];
var Foreign_Keys = $PS["Foreign.Keys"];
var unsafeOptField = $foreign.unsafeOptField_helper(Data_Maybe.Nothing.value)(Data_Maybe.Just.create);
var unsafeObjectToStrMap = function (object) {
return Data_Either.fromRight()(Control_Monad_Except.runExcept(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Foreign_Keys.keys(object))(function (v) {
return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Data_Function.flip(Data_Traversable.traverse(Data_Traversable.traversableArray)(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity)))(v)(function (key) {
return Control_Apply.apply(Control_Monad_Except_Trans.applyExceptT(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Tuple.Tuple.create)(Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(key)))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Foreign.unsafeFromForeign)(Foreign_Index.ix(Foreign_Index.indexableForeign)(Foreign_Index.indexString)(object)(key)));
}))(function (v1) {
return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_Map_Internal.fromFoldable(Data_Ord.ordString)(Data_Foldable.foldableArray)(v1));
});
})));
};
var toNullable = Data_Maybe.maybe($foreign["null"])($foreign.notNullOrUndefined);
var toMaybe = function (n) {
return $foreign.toMaybeImpl(n, Data_Maybe.Nothing.value, Data_Maybe.Just.create);
};
var selectMaybes = function (obj) {
return $foreign.selectMaybesImpl(Data_Maybe.isJust)(Data_Maybe.fromJust())(obj);
};
exports["unsafeOptField"] = unsafeOptField;
exports["toMaybe"] = toMaybe;
exports["toNullable"] = toNullable;
exports["selectMaybes"] = selectMaybes;
exports["unsafeObjectToStrMap"] = unsafeObjectToStrMap;
exports["unsafeField"] = $foreign.unsafeField;
exports["runThisEffectFn1"] = $foreign.runThisEffectFn1;
exports["runThisEffectFn2"] = $foreign.runThisEffectFn2;
exports["runThisEffectFn3"] = $foreign.runThisEffectFn3;
exports["runThisFn0"] = $foreign.runThisFn0;
exports["runThisFn1"] = $foreign.runThisFn1;
exports["runThisFn2"] = $foreign.runThisFn2;
exports["instanceOf"] = $foreign.instanceOf;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Game"] = $PS["Screeps.Game"] || {};
var exports = $PS["Screeps.Game"];
var $foreign = $PS["Screeps.Game"];
var Data_Functor = $PS["Data.Functor"];
var Effect = $PS["Effect"];
var Screeps_FFI = $PS["Screeps.FFI"];
var rooms = Data_Functor.map(Effect.functorEffect)(Screeps_FFI.unsafeObjectToStrMap)($foreign.unsafeGameField("rooms"));
var creeps = Data_Functor.map(Effect.functorEffect)(Screeps_FFI.unsafeObjectToStrMap)($foreign.unsafeGameField("creeps"));
exports["creeps"] = creeps;
exports["rooms"] = rooms;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Room"] = $PS["Screeps.Room"] || {};
var exports = $PS["Screeps.Room"];
var Screeps_FFI = $PS["Screeps.FFI"];
var find$prime = function (room) {
return function (findType) {
return function (filter) {
return Screeps_FFI.runThisFn2("find")(room)(findType)({
filter: filter
});
};
};
};
var find = Screeps_FFI.runThisFn1("find");
var controller = function (room) {
return Screeps_FFI.toMaybe(Screeps_FFI.unsafeField("controller")(room));
};
exports["controller"] = controller;
exports["find"] = find;
exports["find'"] = find$prime;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Purescreeps.Colony"] = $PS["Purescreeps.Colony"] || {};
var exports = $PS["Purescreeps.Colony"];
var Data_Array = $PS["Data.Array"];
var Data_Functor = $PS["Data.Functor"];
var Data_List = $PS["Data.List"];
var Data_Map_Internal = $PS["Data.Map.Internal"];
var Data_Ord = $PS["Data.Ord"];
var Screeps_FindType = $PS["Screeps.FindType"];
var Screeps_Game = $PS["Screeps.Game"];
var Screeps_Room = $PS["Screeps.Room"];
var Colony = (function () {
function Colony(value0) {
this.value0 = value0;
};
Colony.create = function (value0) {
return new Colony(value0);
};
return Colony;
})();
var findColonies = function __do() {
var v = Screeps_Game.rooms();
var v1 = Data_Map_Internal.filter(Data_Ord.ordString)(function (r) {
return !Data_Array["null"](Screeps_Room.find(r)(Screeps_FindType.find_my_spawns));
})(v);
return Data_List.fromFoldable(Data_Map_Internal.foldableMap)(Data_Functor.map(Data_Map_Internal.functorMap)(Colony.create)(v1));
};
exports["Colony"] = Colony;
exports["findColonies"] = findColonies;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Purescreeps.Random"] = $PS["Purescreeps.Random"] || {};
var exports = $PS["Purescreeps.Random"];
var Data_Array = $PS["Data.Array"];
var Data_Char = $PS["Data.Char"];
var Data_EuclideanRing = $PS["Data.EuclideanRing"];
var Data_Foldable = $PS["Data.Foldable"];
var Data_Show = $PS["Data.Show"];
var Data_String_CodeUnits = $PS["Data.String.CodeUnits"];
var hashCode = function (s) {
return Data_Foldable.foldl(Data_Foldable.foldableArray)(function (hash) {
return function (c) {
return ((hash << 5) - hash | 0) + Data_Char.toCharCode(c) | 0;
};
})(0)(Data_String_CodeUnits.toCharArray(s));
};
var sampleByStringHash = function (dictShow) {
return function (str) {
return function (arr) {
return Data_Array.index(arr)(Data_EuclideanRing.mod(Data_EuclideanRing.euclideanRingInt)(hashCode(Data_Show.show(dictShow)(str)))(Data_Array.length(arr)));
};
};
};
exports["hashCode"] = hashCode;
exports["sampleByStringHash"] = sampleByStringHash;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Names"] = $PS["Screeps.Names"] || {};
var exports = $PS["Screeps.Names"];
var Data_Argonaut_Encode_Class = $PS["Data.Argonaut.Encode.Class"];
var Data_Show = $PS["Data.Show"];
var CreepName = function (x) {
return x;
};
var showCreepName = new Data_Show.Show(function (v) {
return v;
});
var encodeRoomName = new Data_Argonaut_Encode_Class.EncodeJson(function (v) {
return Data_Argonaut_Encode_Class.encodeJson(Data_Argonaut_Encode_Class.encodeJsonJString)(v);
});
var asCreepName = CreepName;
exports["asCreepName"] = asCreepName;
exports["encodeRoomName"] = encodeRoomName;
exports["showCreepName"] = showCreepName;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Owned"] = $PS["Screeps.Owned"] || {};
var exports = $PS["Screeps.Owned"];
var Screeps_FFI = $PS["Screeps.FFI"];
var owner = function (dictOwned) {
return function (struc) {
return Screeps_FFI.toMaybe(Screeps_FFI.unsafeField("owner")(struc));
};
};
exports["owner"] = owner;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.RoomObject"] = $PS["Screeps.RoomObject"] || {};
var exports = $PS["Screeps.RoomObject"];
var Data_Argonaut_Encode_Class = $PS["Data.Argonaut.Encode.Class"];
var Screeps_FFI = $PS["Screeps.FFI"];
var Screeps_Names = $PS["Screeps.Names"];
var RoomObject = {};
var room = function (dictRoomObject) {
return Screeps_FFI.unsafeField("room");
};
var name = Screeps_FFI.unsafeField("name");
var encodeJson = new Data_Argonaut_Encode_Class.EncodeJson((function () {
var $14 = Data_Argonaut_Encode_Class.encodeJson(Screeps_Names.encodeRoomName);
return function ($15) {
return $14(name($15));
};
})());
exports["RoomObject"] = RoomObject;
exports["name"] = name;
exports["room"] = room;
exports["encodeJson"] = encodeJson;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Stores"] = $PS["Screeps.Stores"] || {};
var exports = $PS["Screeps.Stores"];
var Screeps_FFI = $PS["Screeps.FFI"];
var Stores = {};
var storeTotalUsed = function (dictStores) {
return function (s) {
return Screeps_FFI.runThisFn0("getUsedCapacity")(Screeps_FFI.unsafeField("store")(s));
};
};
var storeTotalFree = function (dictStores) {
return function (s) {
return Screeps_FFI.runThisFn0("getFreeCapacity")(Screeps_FFI.unsafeField("store")(s));
};
};
exports["Stores"] = Stores;
exports["storeTotalUsed"] = storeTotalUsed;
exports["storeTotalFree"] = storeTotalFree;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Types"] = $PS["Screeps.Types"] || {};
var exports = $PS["Screeps.Types"];
var TargetPt = (function () {
function TargetPt(value0, value1) {
this.value0 = value0;
this.value1 = value1;
};
TargetPt.create = function (value0) {
return function (value1) {
return new TargetPt(value0, value1);
};
};
return TargetPt;
})();
var TargetObj = (function () {
function TargetObj(value0) {
this.value0 = value0;
};
TargetObj.create = function (value0) {
return new TargetObj(value0);
};
return TargetObj;
})();
var TargetPos = (function () {
function TargetPos(value0) {
this.value0 = value0;
};
TargetPos.create = function (value0) {
return new TargetPos(value0);
};
return TargetPos;
})();
var Owned = {};
exports["Owned"] = Owned;
exports["TargetPt"] = TargetPt;
exports["TargetObj"] = TargetObj;
exports["TargetPos"] = TargetPos;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Creep"] = $PS["Screeps.Creep"] || {};
var exports = $PS["Screeps.Creep"];
var Data_Maybe = $PS["Data.Maybe"];
var Screeps_FFI = $PS["Screeps.FFI"];
var Screeps_Names = $PS["Screeps.Names"];
var Screeps_Owned = $PS["Screeps.Owned"];
var Screeps_RoomObject = $PS["Screeps.RoomObject"];
var Screeps_Stores = $PS["Screeps.Stores"];
var Screeps_Types = $PS["Screeps.Types"];
var upgradeController = Screeps_FFI.runThisEffectFn1("upgradeController");
var transferToStructure = function (dictStructure) {
return Screeps_FFI.runThisEffectFn2("transfer");
};
var moveTo$prime = function (creep) {
return function (v) {
return function (opts) {
if (v instanceof Screeps_Types.TargetPt) {
return Screeps_FFI.runThisEffectFn3("moveTo")(creep)(v.value0)(v.value1)(Screeps_FFI.selectMaybes(opts));
};
if (v instanceof Screeps_Types.TargetPos) {
return Screeps_FFI.runThisEffectFn2("moveTo")(creep)(v.value0)(Screeps_FFI.selectMaybes(opts));
};
if (v instanceof Screeps_Types.TargetObj) {
return Screeps_FFI.runThisEffectFn2("moveTo")(creep)(v.value0)(Screeps_FFI.selectMaybes(opts));
};
throw new Error("Failed pattern match at Screeps.Creep (line 189, column 1 - line 189, column 83): " + [ creep.constructor.name, v.constructor.name, opts.constructor.name ]);
};
};
};
var moveOpts = {
ignoreCreeps: Data_Maybe.Nothing.value,
ignoreDestructibleStructures: Data_Maybe.Nothing.value,
ignoreRoads: Data_Maybe.Nothing.value,
ignore: Data_Maybe.Nothing.value,
avoid: Data_Maybe.Nothing.value,
maxOps: Data_Maybe.Nothing.value,
heuristicWeight: Data_Maybe.Nothing.value,
serialize: Data_Maybe.Nothing.value,
maxRooms: Data_Maybe.Nothing.value,
reusePath: Data_Maybe.Nothing.value,
serializeMemory: Data_Maybe.Nothing.value,
noPathFinding: Data_Maybe.Nothing.value,
visualizePathStyle: Data_Maybe.Nothing.value
};
var harvestSource = Screeps_FFI.runThisEffectFn1("harvest");
var creepStores = Screeps_Stores.Stores;
var creepIsRoomObject = Screeps_RoomObject.RoomObject;
var creepIsOwned = Screeps_Types.Owned;
var name = function (c) {
var showOwner = function (v) {
if (v instanceof Data_Maybe.Nothing) {
return "<unowned creep>";
};
if (v instanceof Data_Maybe.Just) {
return "<" + (v.value0.username + ">");
};
throw new Error("Failed pattern match at Screeps.Creep (line 114, column 3 - line 114, column 40): " + [ v.constructor.name ]);
};
var v = Screeps_FFI.unsafeOptField("name")(c);
if (v instanceof Data_Maybe.Nothing) {
return Screeps_Names.asCreepName(showOwner(Screeps_Owned.owner(creepIsOwned)(c)));
};
if (v instanceof Data_Maybe.Just) {
return v.value0;
};
throw new Error("Failed pattern match at Screeps.Creep (line 110, column 10 - line 112, column 14): " + [ v.constructor.name ]);
};
exports["moveOpts"] = moveOpts;
exports["name"] = name;
exports["harvestSource"] = harvestSource;
exports["moveTo'"] = moveTo$prime;
exports["transferToStructure"] = transferToStructure;
exports["upgradeController"] = upgradeController;
exports["creepIsRoomObject"] = creepIsRoomObject;
exports["creepIsOwned"] = creepIsOwned;
exports["creepStores"] = creepStores;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Purescreeps.Harvest"] = $PS["Purescreeps.Harvest"] || {};
var exports = $PS["Purescreeps.Harvest"];
var Purescreeps_Random = $PS["Purescreeps.Random"];
var Screeps_Creep = $PS["Screeps.Creep"];
var Screeps_FindType = $PS["Screeps.FindType"];
var Screeps_Names = $PS["Screeps.Names"];
var Screeps_Room = $PS["Screeps.Room"];
var Screeps_RoomObject = $PS["Screeps.RoomObject"];
var findCorrespondingSource = function (creep) {
return Purescreeps_Random.sampleByStringHash(Screeps_Names.showCreepName)(Screeps_Creep.name(creep))(Screeps_Room.find(Screeps_RoomObject.room(Screeps_Creep.creepIsRoomObject)(creep))(Screeps_FindType.find_sources));
};
exports["findCorrespondingSource"] = findCorrespondingSource;
})(PS);
(function(exports) {
'use strict';
exports.ok = OK;
exports.err_not_owner = ERR_NOT_OWNER;
exports.err_no_path = ERR_NO_PATH;
exports.err_name_exists = ERR_NAME_EXISTS;
exports.err_busy = ERR_BUSY;
exports.err_not_found = ERR_NOT_FOUND;
exports.err_not_enough_energy = ERR_NOT_ENOUGH_ENERGY;
exports.err_not_enough_resources = ERR_NOT_ENOUGH_RESOURCES;
exports.err_invalid_target = ERR_INVALID_TARGET;
exports.err_full = ERR_FULL;
exports.err_not_in_range = ERR_NOT_IN_RANGE;
exports.err_invalid_args = ERR_INVALID_ARGS;
exports.err_tired = ERR_TIRED;
exports.err_no_bodypart = ERR_NO_BODYPART;
exports.err_not_enough_extensions = ERR_NOT_ENOUGH_EXTENSIONS;
exports.err_rcl_not_enough = ERR_RCL_NOT_ENOUGH;
exports.err_gcl_not_enough = ERR_GCL_NOT_ENOUGH;
})(PS["Screeps.ReturnCode"] = PS["Screeps.ReturnCode"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.ReturnCode"] = $PS["Screeps.ReturnCode"] || {};
var exports = $PS["Screeps.ReturnCode"];
var $foreign = $PS["Screeps.ReturnCode"];
var Data_Eq = $PS["Data.Eq"];
var Data_Generic_Rep = $PS["Data.Generic.Rep"];
var Data_Generic_Rep_Eq = $PS["Data.Generic.Rep.Eq"];
var Data_Show = $PS["Data.Show"];
var genericReturnCode = new Data_Generic_Rep.Generic(function (v) {
return Data_Generic_Rep.Constructor(v);
}, function (v) {
return v;
});
var eqReturnCode = new Data_Eq.Eq(Data_Generic_Rep_Eq.genericEq(genericReturnCode)(Data_Generic_Rep_Eq.genericEqConstructor(Data_Generic_Rep_Eq.genericEqArgument(Data_Eq.eqInt))));
var showReturnCode = new Data_Show.Show(function (v) {
if (Data_Eq.eq(eqReturnCode)(v)($foreign.ok)) {
return "OK";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_not_owner)) {
return "ERR_NOT_OWNER";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_no_path)) {
return "ERR_NO_PATH";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_name_exists)) {
return "ERR_NAME_EXISTS";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_busy)) {
return "ERR_BUSY";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_not_found)) {
return "ERR_NOT_FOUND";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_not_enough_energy)) {
return "ERR_NOT_ENOUGH_ENERGY";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_not_enough_resources)) {
return "ERR_NOT_ENOUGH_RESOURCES";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_invalid_target)) {
return "ERR_INVALID_TARGET";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_full)) {
return "ERR_FULL";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_not_in_range)) {
return "ERR_NOT_IN_RANGE";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_invalid_args)) {
return "ERR_INVALID_ARGS";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_tired)) {
return "ERR_TIRED";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_no_bodypart)) {
return "ERR_NO_BODYPART";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_not_enough_extensions)) {
return "ERR_NOT_ENOUGH_EXTENSIONS";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_rcl_not_enough)) {
return "ERR_RCL_NOT_ENOUGH";
};
if (Data_Eq.eq(eqReturnCode)(v)($foreign.err_gcl_not_enough)) {
return "ERR_GCL_NOT_ENOUGH";
};
return Data_Show.show(Data_Show.showInt)(v);
});
exports["genericReturnCode"] = genericReturnCode;
exports["eqReturnCode"] = eqReturnCode;
exports["showReturnCode"] = showReturnCode;
exports["ok"] = $foreign.ok;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Purescreeps.ReturnCode"] = $PS["Purescreeps.ReturnCode"] || {};
var exports = $PS["Purescreeps.ReturnCode"];
var Control_Applicative = $PS["Control.Applicative"];
var Data_Either = $PS["Data.Either"];
var Data_Eq = $PS["Data.Eq"];
var Data_Show = $PS["Data.Show"];
var Data_Unit = $PS["Data.Unit"];
var Effect = $PS["Effect"];
var Screeps_ReturnCode = $PS["Screeps.ReturnCode"];
var toStatus = function (c) {
var $0 = Data_Eq.eq(Screeps_ReturnCode.eqReturnCode)(c)(Screeps_ReturnCode.ok);
if ($0) {
return new Data_Either.Right(Data_Unit.unit);
};
return new Data_Either.Left(Data_Show.show(Screeps_ReturnCode.showReturnCode)(c));
};
var orElse = function (eff) {
return function (status) {
return Data_Either.either(function (l) {
return eff;
})(function (r) {
return Control_Applicative.pure(Effect.applicativeEffect)(status);
})(status);
};
};
exports["toStatus"] = toStatus;
exports["orElse"] = orElse;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Id"] = $PS["Screeps.Id"] || {};
var exports = $PS["Screeps.Id"];
var HasId = function (validate) {
this.validate = validate;
};
var validate = function (dict) {
return dict.validate;
};
exports["HasId"] = HasId;
exports["validate"] = validate;
})(PS);
(function(exports) {
exports.structure_spawn = STRUCTURE_SPAWN;
exports.structure_extension = STRUCTURE_EXTENSION;
exports.structure_tower = STRUCTURE_TOWER;
})(PS["Screeps.Structure"] = PS["Screeps.Structure"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Type.Proxy"] = $PS["Type.Proxy"] || {};
var exports = $PS["Type.Proxy"];
var $$Proxy = (function () {
function $$Proxy() {
};
$$Proxy.value = new $$Proxy();
return $$Proxy;
})();
exports["Proxy"] = $$Proxy;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Structure"] = $PS["Screeps.Structure"] || {};
var exports = $PS["Screeps.Structure"];
var $foreign = $PS["Screeps.Structure"];
var Data_Boolean = $PS["Data.Boolean"];
var Data_Eq = $PS["Data.Eq"];
var Data_Maybe = $PS["Data.Maybe"];
var Screeps_FFI = $PS["Screeps.FFI"];
var Type_Proxy = $PS["Type.Proxy"];
var Structural = {};
var Structure = function (HasId2, RoomObject0, Structural1, _structureType) {
this.HasId2 = HasId2;
this.RoomObject0 = RoomObject0;
this.Structural1 = Structural1;
this["_structureType"] = _structureType;
};
var structureType = function (dictStructural) {
return Screeps_FFI.unsafeField("structureType");
};
var eqStructureType = Data_Eq.eqString;
var anyStructureIsStructural = Structural;
var unsafeCast = function (dictStructure) {
return function (t) {
return function (struc) {
if (Data_Eq.eq(eqStructureType)(structureType(anyStructureIsStructural)(struc))(t)) {
return Data_Maybe.Just.create(struc);
};
if (Data_Boolean.otherwise) {
return Data_Maybe.Nothing.value;
};
throw new Error("Failed pattern match at Screeps.Structure (line 121, column 1 - line 121, column 80): " + [ t.constructor.name, struc.constructor.name ]);
};
};
};
var _structureType = function (dict) {
return dict["_structureType"];
};
var fromAnyStructure = function (dictStructure) {
var from$prime = function (dictStructure1) {
return function (proxy) {
return unsafeCast(dictStructure)(_structureType(dictStructure)(proxy));
};
};
return from$prime(dictStructure)(Type_Proxy["Proxy"].value);
};
exports["_structureType"] = _structureType;
exports["Structural"] = Structural;
exports["Structure"] = Structure;
exports["structureType"] = structureType;
exports["unsafeCast"] = unsafeCast;
exports["fromAnyStructure"] = fromAnyStructure;
exports["eqStructureType"] = eqStructureType;
exports["anyStructureIsStructural"] = anyStructureIsStructural;
exports["structure_spawn"] = $foreign.structure_spawn;
exports["structure_extension"] = $foreign.structure_extension;
exports["structure_tower"] = $foreign.structure_tower;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Refillable"] = $PS["Screeps.Refillable"] || {};
var exports = $PS["Screeps.Refillable"];
var Data_Maybe = $PS["Data.Maybe"];
var Screeps_FFI = $PS["Screeps.FFI"];
var Screeps_Id = $PS["Screeps.Id"];
var Screeps_RoomObject = $PS["Screeps.RoomObject"];
var Screeps_Structure = $PS["Screeps.Structure"];
var Screeps_Types = $PS["Screeps.Types"];
var Refillable = function (Owned1, Structure0) {
this.Owned1 = Owned1;
this.Structure0 = Structure0;
};
var refillableIsStructural = Screeps_Structure.Structural;
var refillableIsOwned = Screeps_Types.Owned;
var energyCapacity = function (dictRefillable) {
return Screeps_FFI.unsafeField("energyCapacity");
};
var energy = function (dictRefillable) {
return Screeps_FFI.unsafeField("energy");
};
var isNotFull = function (dictRefillable) {
return function (x) {
return energy(dictRefillable)(x) < energyCapacity(dictRefillable)(x);
};
};
var anyRefillableIsRoomObject = Screeps_RoomObject.RoomObject;
var anyRefillableHasId = new Screeps_Id.HasId(function (o) {
return Screeps_FFI.instanceOf("StructureExtension")(o) || (Screeps_FFI.instanceOf("StructureSpawn")(o) || (Screeps_FFI.instanceOf("StructurePowerSpawn")(o) || (Screeps_FFI.instanceOf("StructureTower")(o) || (Screeps_FFI.instanceOf("StructureNuker")(o) || (Screeps_FFI.instanceOf("StructureLink")(o) || Screeps_FFI.instanceOf("StructureLab")(o))))));
});
var refillableIsStructure = new Screeps_Structure.Structure(function () {
return anyRefillableHasId;
}, function () {
return anyRefillableIsRoomObject;
}, function () {
return refillableIsStructural;
}, function (v) {
return "<refillable>";
});
var toRefillable = function (dictStructure) {
return function (r) {
var $6 = Screeps_Id.validate(anyRefillableHasId)(r);
if ($6) {
return new Data_Maybe.Just(r);
};
return Data_Maybe.Nothing.value;
};
};
var anyRefillable = new Refillable(function () {
return refillableIsOwned;
}, function () {
return refillableIsStructure;
});
exports["Refillable"] = Refillable;
exports["energy"] = energy;
exports["energyCapacity"] = energyCapacity;
exports["toRefillable"] = toRefillable;
exports["isNotFull"] = isNotFull;
exports["anyRefillableIsRoomObject"] = anyRefillableIsRoomObject;
exports["anyRefillableHasId"] = anyRefillableHasId;
exports["refillableIsStructural"] = refillableIsStructural;
exports["refillableIsOwned"] = refillableIsOwned;
exports["refillableIsStructure"] = refillableIsStructure;
exports["anyRefillable"] = anyRefillable;
})(PS);
(function(exports) {
"use strict";
exports.createCreepPrimeImpl = function (structure) {
return function (parts) {
return function (name) {
return function (memory) {
return function (left) {
return function (right) {
return function () {
var result = structure.createCreep(parts, name, memory);
if (typeof result === "string") {
return right(result);
} else {
return left(result);
}
}
}
}
}
}
}
}
})(PS["Screeps.Spawn"] = PS["Screeps.Spawn"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Spawn"] = $PS["Screeps.Spawn"] || {};
var exports = $PS["Screeps.Spawn"];
var $foreign = $PS["Screeps.Spawn"];
var Data_Argonaut_Encode_Class = $PS["Data.Argonaut.Encode.Class"];
var Data_Either = $PS["Data.Either"];
var Screeps_FFI = $PS["Screeps.FFI"];
var Screeps_Id = $PS["Screeps.Id"];
var Screeps_RoomObject = $PS["Screeps.RoomObject"];
var Screeps_Structure = $PS["Screeps.Structure"];
var structuralSpawn = Screeps_Structure.Structural;
var spawnHasId = new Screeps_Id.HasId(Screeps_FFI.instanceOf("StructureSpawn"));
var objectSpawn = Screeps_RoomObject.RoomObject;
var structureSpawn = new Screeps_Structure.Structure(function () {
return spawnHasId;
}, function () {
return objectSpawn;
}, function () {
return structuralSpawn;
}, function (v) {
return Screeps_Structure.structure_spawn;
});
var createCreep$prime = function (dictEncodeJson) {
return function (spawn) {
return function (parts) {
return function (name$prime) {
return function (mem) {
return $foreign.createCreepPrimeImpl(spawn)(parts)(Screeps_FFI.toNullable(name$prime))(Data_Argonaut_Encode_Class.encodeJson(dictEncodeJson)(mem))(Data_Either.Left.create)(Data_Either.Right.create);
};
};
};
};
};
exports["createCreep'"] = createCreep$prime;
exports["objectSpawn"] = objectSpawn;
exports["spawnHasId"] = spawnHasId;
exports["structuralSpawn"] = structuralSpawn;
exports["structureSpawn"] = structureSpawn;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Purescreeps.Work"] = $PS["Purescreeps.Work"] || {};
var exports = $PS["Purescreeps.Work"];
var Data_Array = $PS["Data.Array"];
var Data_Foldable = $PS["Data.Foldable"];
var Data_Functor = $PS["Data.Functor"];
var Screeps_FindType = $PS["Screeps.FindType"];
var Screeps_Refillable = $PS["Screeps.Refillable"];
var Screeps_Room = $PS["Screeps.Room"];
var Screeps_Spawn = $PS["Screeps.Spawn"];
var Screeps_Structure = $PS["Screeps.Structure"];
var findMyEmptySpawns = function (room) {
return Data_Array.filter(function (s) {
return Screeps_Refillable.isNotFull(Screeps_Refillable.anyRefillable)(s);
})(Data_Array.catMaybes(Data_Functor.map(Data_Functor.functorArray)(Screeps_Refillable.toRefillable(Screeps_Spawn.structureSpawn))(Data_Array.catMaybes(Data_Functor.map(Data_Functor.functorArray)(Screeps_Structure.fromAnyStructure(Screeps_Spawn.structureSpawn))(Screeps_Room["find'"](room)(Screeps_FindType.find_structures)(function (s) {
return Data_Foldable.elem(Data_Foldable.foldableArray)(Screeps_Structure.eqStructureType)(Screeps_Structure.structureType(Screeps_Structure.anyStructureIsStructural)(s))([ Screeps_Structure.structure_extension, Screeps_Structure.structure_spawn, Screeps_Structure.structure_tower ]);
}))))));
};
exports["findMyEmptySpawns"] = findMyEmptySpawns;
})(PS);
(function(exports) {
exports.part_move = MOVE;
exports.part_work = WORK;
exports.part_carry = CARRY;
})(PS["Screeps.BodyPartType"] = PS["Screeps.BodyPartType"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.BodyPartType"] = $PS["Screeps.BodyPartType"] || {};
var exports = $PS["Screeps.BodyPartType"];
var $foreign = $PS["Screeps.BodyPartType"];
exports["part_move"] = $foreign.part_move;
exports["part_work"] = $foreign.part_work;
exports["part_carry"] = $foreign.part_carry;
})(PS);
(function(exports) {
"use strict";
exports.resource_energy = RESOURCE_ENERGY;
})(PS["Screeps.Resource"] = PS["Screeps.Resource"] || {});
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Screeps.Resource"] = $PS["Screeps.Resource"] || {};
var exports = $PS["Screeps.Resource"];
var $foreign = $PS["Screeps.Resource"];
exports["resource_energy"] = $foreign.resource_energy;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Purescreeps.Creep"] = $PS["Purescreeps.Creep"] || {};
var exports = $PS["Purescreeps.Creep"];
var Control_Applicative = $PS["Control.Applicative"];
var Control_Bind = $PS["Control.Bind"];
var Control_Monad = $PS["Control.Monad"];
var Data_Array = $PS["Data.Array"];
var Data_Either = $PS["Data.Either"];
var Data_Exists = $PS["Data.Exists"];
var Data_Foldable = $PS["Data.Foldable"];
var Data_Functor = $PS["Data.Functor"];
var Data_List_Types = $PS["Data.List.Types"];
var Data_Map_Internal = $PS["Data.Map.Internal"];
var Data_Maybe = $PS["Data.Maybe"];
var Data_Monoid = $PS["Data.Monoid"];
var Data_Semigroup = $PS["Data.Semigroup"];
var Data_Semiring = $PS["Data.Semiring"];
var Data_Traversable = $PS["Data.Traversable"];
var Data_Tuple = $PS["Data.Tuple"];
var Effect = $PS["Effect"];
var Purescreeps_Harvest = $PS["Purescreeps.Harvest"];
var Purescreeps_ReturnCode = $PS["Purescreeps.ReturnCode"];
var Purescreeps_Work = $PS["Purescreeps.Work"];
var Screeps_BodyPartType = $PS["Screeps.BodyPartType"];
var Screeps_Creep = $PS["Screeps.Creep"];
var Screeps_Refillable = $PS["Screeps.Refillable"];
var Screeps_Resource = $PS["Screeps.Resource"];
var Screeps_Room = $PS["Screeps.Room"];
var Screeps_Stores = $PS["Screeps.Stores"];
var Screeps_Types = $PS["Screeps.Types"];
var TargetF = (function () {
function TargetF(value0, value1) {
this.value0 = value0;
this.value1 = value1;
};
TargetF.create = function (value0) {
return function (value1) {
return new TargetF(value0, value1);
};
};
return TargetF;
})();
var toTargetToJob = function (f) {
return function (target) {
return function (creep) {
return Control_Monad.liftM1(Effect.monadEffect)(Purescreeps_ReturnCode.toStatus)(f(creep)(target));
};
};
};
var transferEnergyToStructure$prime = function (dictStructure) {
return toTargetToJob(function (c) {
return function (t) {
return Screeps_Creep.transferToStructure(dictStructure)(c)(t)(Screeps_Resource.resource_energy);
};
});
};
var upgradeController$prime = toTargetToJob(Screeps_Creep.upgradeController);
var moveToAction = function (action) {
return function (target) {
return function (creep) {
return Control_Bind.bind(Effect.bindEffect)(action(target)(creep))(Purescreeps_ReturnCode.orElse(toTargetToJob(function (c) {
return function (t) {
return Screeps_Creep["moveTo'"](c)(new Screeps_Types.TargetObj(t))({
ignoreCreeps: Screeps_Creep.moveOpts.ignoreCreeps,
ignoreDestructibleStructures: Screeps_Creep.moveOpts.ignoreDestructibleStructures,
ignoreRoads: Screeps_Creep.moveOpts.ignoreRoads,
ignore: Screeps_Creep.moveOpts.ignore,
avoid: Screeps_Creep.moveOpts.avoid,
maxOps: Screeps_Creep.moveOpts.maxOps,
heuristicWeight: Screeps_Creep.moveOpts.heuristicWeight,
serialize: Screeps_Creep.moveOpts.serialize,
maxRooms: Screeps_Creep.moveOpts.maxRooms,
reusePath: Screeps_Creep.moveOpts.reusePath,
serializeMemory: Screeps_Creep.moveOpts.serializeMemory,
noPathFinding: Screeps_Creep.moveOpts.noPathFinding,
visualizePathStyle: new Data_Maybe.Just({})
});
};
})(target)(creep)));
};
};
};
var harvestSource$prime = toTargetToJob(Screeps_Creep.harvestSource);
var runTarget = (function () {
var runTarget$prime = function (v) {
return function (creep) {
var $6 = {
source: Purescreeps_Harvest.findCorrespondingSource(creep)
};
if ($6.source instanceof Data_Maybe.Just) {
var $7 = Screeps_Stores.storeTotalUsed(Screeps_Creep.creepStores)(creep) === 0;
if ($7) {
return moveToAction(harvestSource$prime)($6.source.value0)(creep);
};
var $8 = Screeps_Stores.storeTotalFree(Screeps_Creep.creepStores)(creep) === 0;
if ($8) {
return moveToAction(v.value0)(v.value1)(creep);
};
return Control_Bind.bind(Effect.bindEffect)(harvestSource$prime($6.source.value0)(creep))(Purescreeps_ReturnCode.orElse(moveToAction(v.value0)(v.value1)(creep)));
};
return Control_Applicative.pure(Effect.applicativeEffect)(new Data_Either.Left("No source/controller found"));
};
};
return Data_Exists.runExists(runTarget$prime);
})();
var genericCreep = function (capacity) {
if (capacity < 50) {
return [ ];
};
if (capacity < 100) {
return [ Screeps_BodyPartType.part_move ];
};
if (capacity < 150) {
return [ Screeps_BodyPartType.part_carry, Screeps_BodyPartType.part_move ];
};
if (capacity < 250) {
return [ Screeps_BodyPartType.part_work, Screeps_BodyPartType.part_carry, Screeps_BodyPartType.part_move ];
};
return Data_Array.concat([ genericCreep(capacity - 200 | 0), [ Screeps_BodyPartType.part_work, Screeps_BodyPartType.part_carry, Screeps_BodyPartType.part_move ] ]);
};
var generateFillStoreTargets = function (colonies) {
return function (creeps) {
return Data_Foldable.foldMap(Data_List_Types.foldableList)(Data_Monoid.monoidArray)(function (v) {
return Data_Functor.map(Data_Functor.functorArray)(function (store) {
return Data_Exists.mkExists(new TargetF(transferEnergyToStructure$prime(Screeps_Refillable.refillableIsStructure), store));
})(Purescreeps_Work.findMyEmptySpawns(v.value0));
})(colonies);
};
};
var generateControllerUpgradeTargets = function (colonies) {
return function (creeps) {
return Data_Foldable.foldMap(Data_List_Types.foldableList)(Data_Monoid.monoidArray)(function (v) {
return Data_Functor.map(Data_Functor.functorArray)(function (controller) {
return Data_Exists.mkExists(new TargetF(upgradeController$prime, controller));
})(Data_Array.catMaybes(Data_Array.replicate(Data_Foldable.length(Data_Map_Internal.foldableMap)(Data_Semiring.semiringInt)(creeps))(Screeps_Room.controller(v.value0))));
})(colonies);
};
};
var generateTargets = function (colonies) {
return function (creeps) {
return Data_Semigroup.append(Data_Semigroup.semigroupArray)(generateFillStoreTargets(colonies)(creeps))(generateControllerUpgradeTargets(colonies)(creeps));
};
};
var assignTargets = function (targets) {
return function (creeps) {
return Data_Traversable.traverse(Data_Traversable.traversableArray)(Effect.applicativeEffect)(Data_Traversable.sequence(Data_Tuple.traversableTuple)(Effect.applicativeEffect))(Data_Array.zipWith(function (target) {
return function (creep) {
return Data_Functor.map(Data_Tuple.functorTuple)(runTarget(target))(creep);
};
})(targets)(creeps));
};
};
exports["genericCreep"] = genericCreep;
exports["toTargetToJob"] = toTargetToJob;
exports["moveToAction"] = moveToAction;
exports["TargetF"] = TargetF;
exports["runTarget"] = runTarget;
exports["generateControllerUpgradeTargets"] = generateControllerUpgradeTargets;
exports["generateFillStoreTargets"] = generateFillStoreTargets;
exports["generateTargets"] = generateTargets;
exports["assignTargets"] = assignTargets;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Purescreeps.Spawn"] = $PS["Purescreeps.Spawn"] || {};
var exports = $PS["Purescreeps.Spawn"];
var Data_Argonaut_Encode_Class = $PS["Data.Argonaut.Encode.Class"];
var Data_Functor = $PS["Data.Functor"];
var Data_Maybe = $PS["Data.Maybe"];
var Data_Symbol = $PS["Data.Symbol"];
var Data_Traversable = $PS["Data.Traversable"];
var Effect = $PS["Effect"];
var Purescreeps_Creep = $PS["Purescreeps.Creep"];
var Screeps_FindType = $PS["Screeps.FindType"];
var Screeps_Room = $PS["Screeps.Room"];
var Screeps_RoomObject = $PS["Screeps.RoomObject"];
var Screeps_Spawn = $PS["Screeps.Spawn"];
var findSpawns = function (v) {
return Screeps_Room.find(v.value0)(Screeps_FindType.find_my_spawns);
};
var findCapacity = function (v) {
return 300;
};
var createSpecifiedCreep = function (spawn) {
return function (spec) {
return Screeps_Spawn["createCreep'"](Data_Argonaut_Encode_Class.encodeRecord(Data_Argonaut_Encode_Class.gEncodeJsonCons(Screeps_RoomObject.encodeJson)(Data_Argonaut_Encode_Class.gEncodeJsonNil)(new Data_Symbol.IsSymbol(function () {
return "colony";
}))())())(spawn)(spec)(Data_Maybe.Nothing.value)({
colony: Screeps_RoomObject.room(Screeps_Spawn.objectSpawn)(spawn)
});
};
};
var createCreeps = function (colony) {
return Data_Traversable.sequence(Data_Traversable.traversableArray)(Effect.applicativeEffect)(Data_Functor.map(Data_Functor.functorArray)(function (s) {
return createSpecifiedCreep(s)(Purescreeps_Creep.genericCreep(findCapacity(colony)));
})(findSpawns(colony)));
};
exports["createSpecifiedCreep"] = createSpecifiedCreep;
exports["findSpawns"] = findSpawns;
exports["findCapacity"] = findCapacity;
exports["createCreeps"] = createCreeps;
})(PS);
(function($PS) {
// Generated by purs version 0.13.2
"use strict";
$PS["Main"] = $PS["Main"] || {};
var exports = $PS["Main"];
var Control_Bind = $PS["Control.Bind"];
var Data_Either = $PS["Data.Either"];
var Data_Functor = $PS["Data.Functor"];
var Data_List_Types = $PS["Data.List.Types"];
var Data_Map_Internal = $PS["Data.Map.Internal"];
var Data_Show = $PS["Data.Show"];
var Data_Traversable = $PS["Data.Traversable"];
var Data_Tuple = $PS["Data.Tuple"];
var Data_Unfoldable = $PS["Data.Unfoldable"];
var Data_Unit = $PS["Data.Unit"];
var Effect = $PS["Effect"];
var Effect_Console = $PS["Effect.Console"];
var Purescreeps_Colony = $PS["Purescreeps.Colony"];
var Purescreeps_Creep = $PS["Purescreeps.Creep"];
var Purescreeps_Spawn = $PS["Purescreeps.Spawn"];
var Screeps_Game = $PS["Screeps.Game"];
var Screeps_ReturnCode = $PS["Screeps.ReturnCode"];
var main = function __do() {
var v = Purescreeps_Colony.findColonies();
Control_Bind.bind(Effect.bindEffect)(Data_Traversable.sequence(Data_List_Types.traversableList)(Effect.applicativeEffect)(Data_Functor.map(Data_List_Types.functorList)(Purescreeps_Spawn.createCreeps)(v)))(Effect_Console.logShow(Data_List_Types.showList(Data_Show.showArray(Data_Either.showEither(Screeps_ReturnCode.showReturnCode)(Data_Show.showString)))))();
var v1 = Screeps_Game.creeps();
return Control_Bind.bind(Effect.bindEffect)(Purescreeps_Creep.assignTargets(Purescreeps_Creep.generateTargets(v)(v1))(Data_Map_Internal.toUnfoldable(Data_Unfoldable.unfoldableArray)(v1)))(Effect_Console.logShow(Data_Show.showArray(Data_Tuple.showTuple(Data_Show.showString)(Data_Either.showEither(Data_Show.showString)(Data_Unit.showUnit)))))();
};
exports["main"] = main;
})(PS);module.exports.loop = PS["Main"].main
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment