{"version":3,"file":"lambda.min.cjs","mappings":"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","sources":["webpack://L/webpack/universalModuleDefinition","webpack://L/webpack/bootstrap","webpack://L/webpack/runtime/define property getters","webpack://L/webpack/runtime/hasOwnProperty shorthand","webpack://L/webpack/runtime/make namespace object","webpack://L/./src/arity.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/iterableToArray.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack://L/./src/conditional.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack://L/./src/core.js","webpack://L/./src/utils.js","webpack://L/./src/string.js","webpack://L/./src/list.js","webpack://L/./src/Case.js","webpack://L/./src/AsyncEffect.js","webpack://L/./src/SyncEffect.js","webpack://L/./src/Either.js","webpack://L/./src/Maybe.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"L\"] = factory();\n\telse\n\t\troot[\"L\"] = factory();\n})(this, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/**\n * nary curried function and allows it to be called both as curried and n-ary.\n *\n * @HindleyMilner nary :: (a -> b) -> a -> b\n *\n * @pure\n * @param {function} fn\n * @return {function}\n *\n * @example\n * import {nary} from '@7urtle/lambda';\n *\n * const fn = nary(a => b => a + b);\n * fn('a')('b') === fn('a', 'b'); // => true\n */\nexport const nary = fn =>\n    (...args) => args.length === 0\n        ? fn()\n        : args.reduce(\n            (accumulator, current) => accumulator(current),\n            fn\n        );\n\n/**\n * curry takes n-ary function and allows it to be called both as curried and n-ary.\n *\n * @HindleyMilner curry :: (a -> b) -> a -> b\n *\n * @pure\n * @param {function} fn\n * @return {function}\n *\n * @example\n * import {curry} from '@7urtle/lambda';\n *\n * const fn = curry((a, b) => a + b);\n * fn('a')('b') === fn('a', 'b'); // => true\n */\nexport const curry = fn =>\n    (...args) => args.length >= fn.length\n        ? fn(...args)\n        : (...args2) => curry(fn)(...args, ...args2);","export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nexport default function _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}","export default function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","export default function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","export default function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}","import { typeOf, lengthOf, deepInspect } from \"./utils.js\";\nimport { everyOf, someOf } from './list.js';\nimport { nary } from \"./arity.js\";\n\n/**\n * and is a boolean-type function composition\n * where each boolean function is '&&'d together.\n * \n * The boolean functions may be entered in any order.\n * \n * and can be used together with or to encapsulate a predicate in a single function.\n * \n * @HindleyMilner and :: [(a -> boolean)] -> a -> boolean\n * \n * @pure\n * @param {function} predicates\n * @param {*} anything\n * @return {*}\n * \n * @example\n * import {and, isGreaterThan, isLessThan} from '@7urtle/lambda';\n * \n * const isEven = number => number % 2 === 0;\n * \n * const isSingleEvenDigit = and(isEven, isGreaterThan(-10), isLessThan(10));\n * isSingleEvenDigit(8)\n * // => true\n */\n export const and = (...predicates) => anything => everyOf(predicate => predicate(anything))(predicates);\n\n /**\n  * or is a boolean-type function composition\n  * where each boolean function is '||'d together.\n  * \n  * The boolean functions may be entered in any order.\n  * \n  * or can be used together with and to encapsulate a predicate in a single function.\n  * \n  * @HindleyMilner or :: [(a -> boolean)] -> a -> boolean\n  * \n  * @pure\n  * @param {function} predicates\n  * @param {*} anything\n  * @return {*}\n  * \n  * @example\n  * import {or} from '@7urtle/lambda';\n  * \n  * const isDivisibleBy = divisor => number => number % divisor === 0;\n  * const isFizzBuzzNumber = or(isDivisibleBy(3), isDivisibleBy(5));\n  * \n  * isFizzBuzzNumber(15)\n  * // => true\n  */\n export const or = (...predicates) => anything => someOf(predicate => predicate(anything))(predicates);\n\n/**\n * isEqual output is true if strict equality between a and b is true. isEqual output is always false for comparison\n * of objects and arrays.\n *\n * isEqual can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isEqual :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isEqual} from '@7urtle/lambda';\n *\n * isEqual('something')('something'); // => true\n * isEqual('something')('something else'); // => false\n * isEqual(['a'])(['a']); // => false\n * isEqual({a : 'something'})({a : 'something'}); // => false\n * isEqual([])([]); // => false\n * isEqual([])([]); // => false\n *\n * // isEqual can be called both as a curried unary function or as a standard binary function\n * isEqual('something')('something') === isEqual('something', 'something');\n */\nexport const isEqual = nary(a => b => a === b);\n\n/**\n * isNotEqual output is true if strict equality between a and b is false. isNotEqual output is always true for\n * comparison of objects and arrays.\n *\n * isEqual can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isNotEqual :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isNotEqual} from '@7urtle/lambda';\n *\n * isNotEqual('something')('something'); // => false\n * isNotEqual('something')('something else'); // => true\n * isNotEqual(['a'])(['a']); // => true\n * isNotEqual({a : 'something'})({a : 'something'}); // => true\n * isNotEqual([])([]); // => true\n * isNotEqual([])([]); // => true\n *\n * // isNotEqual can be called both as a curried unary function or as a standard binary function\n * isNotEqual('something')('something else') === isNotEqual('something', 'something else');\n */\nexport const isNotEqual = nary(a => b => a !== b);\n\n/**\n * isDeepEqual output is true if strict equality between the string conversion of a and the string conversion of b\n * is true including arrays and objects.\n *\n * isDeepEqual can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isDeepEqual :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isDeepEqual} from '@7urtle/lambda';\n *\n * isDeepEqual('something')('something'); // => true\n * isDeepEqual('something')('something else'); // => false\n * isDeepEqual(['a'])(['a']); // => true\n * isDeepEqual({a : 'something'})({a : 'something'}); // => true\n * isDeepEqual([])([]); // => true\n * isDeepEqual([])([]); // => true\n *\n * // isDeepEqual can be called both as a curried unary function or as a standard binary function\n * isDeepEqual('something')('something') === isDeepEqual('something', 'something');\n */\nexport const isDeepEqual = nary(a => b => isEqual(deepInspect(a))(deepInspect(b)));\n\n/**\n * isNotDeepEqual output is true if strict equality between the string conversion of a and the string conversion of b\n * is false including arrays and objects.\n *\n * isNotDeepEqual can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isNotDeepEqual :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isNotDeepEqual} from '@7urtle/lambda';\n *\n * isNotDeepEqual('something')('something'); // => false\n * isNotDeepEqual('something')('something else'); // => true\n * isNotDeepEqual(['a', 'b'])(['a']); // => true\n * isNotDeepEqual({a : 'something', b: c => c})({a : 'something'}); // => true\n * isNotDeepEqual([])([]); // => false\n * isNotDeepEqual([])([]); // => false\n *\n * // isNotDeepEqual can be called both as a curried unary function or as a standard binary function\n * isNotDeepEqual('something')('something else') === isNotDeepEqual('something', 'something else');\n */\nexport const isNotDeepEqual = nary(a => b => isNotEqual(deepInspect(a))(deepInspect(b)));\n\n/**\n * isTrue output is true if input is true.\n *\n * @HindleyMilner isTrue :: a -> boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import {isTrue} from '@7urtle/lambda';\n *\n * isTrue(true); // => true\n * isTrue(false); // => false\n */\nexport const isTrue = isEqual(true);\n\n/**\n * isFalse output is true if input is false.\n *\n * @HindleyMilner isFalse :: a -> Boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import {isFalse} from '@7urtle/lambda';\n *\n * isFalse(true); // => false\n * isFalse(false); // => true\n */\nexport const isFalse = isEqual(false);\n\n/**\n * isGreaterThan output is true if b is greater than a.\n *\n * isGreaterThan can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isGreaterThan :: a -> b -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isGreaterThan} from '@7urtle/lambda';\n *\n * isGreaterThan(1)(2); // => true\n * isGreaterThan(3)(2); // => false\n *\n * // isGreaterThan can be called both as a curried unary function or as a standard binary function\n * isGreaterThan(1)(2) === isGreaterThan(1, 2);\n */\nexport const isGreaterThan = nary(a => b => b > a);\n\n/**\n * isLessThan output is true if b is less than a.\n *\n * isLessThan can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isLessThan :: a -> b -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isLessThan} from '@7urtle/lambda';\n *\n * isLessThan(1)(2); // => false\n * isLessThan(3)(2); // => true\n *\n * // isLessThan can be called both as a curried unary function or as a standard binary function\n * isLessThan(3)(2) === isLessThan(3, 2);\n */\nexport const isLessThan = nary(a => b => b < a);\n\n/**\n * isAtLeast output is true if b is greater or equal to a.\n *\n * isAtLeast can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isAtLeast :: a -> b -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isAtLeast} from '@7urtle/lambda';\n *\n * isAtLeast(1)(2); // => true\n * isAtLeast(2)(2); // => true\n * isAtLeast(3)(2); // => false\n *\n * // isAtLeast can be called both as a curried unary function or as a standard binary function\n * isAtLeast(1)(2) === isAtLeast(1, 2);\n */\nexport const isAtLeast = nary(a => b => b >= a);\n\n/**\n * isAtMost output is true if b is less or equal to a.\n *\n * isAtMost can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isAtMost :: a -> b -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isAtMost} from '@7urtle/lambda';\n *\n * isAtMost(1)(2); // => false\n * isAtMost(2)(2); // => true\n * isAtMost(3)(2); // => true\n *\n * // isAtLeast can be called both as a curried unary function or as a standard binary function\n * isAtMost(3)(2) === isAtMost(31, 2);\n */\nexport const isAtMost = nary(a => b => b <= a);\n\n/**\n * isBetween output is true if c is between a and b.\n *\n * isBetween can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner isBetween :: a -> b -> c -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @param {number} c\n * @return {boolean}\n *\n * @example\n * import {isBetween} from '@7urtle/lambda';\n *\n * isBetween(1)(3)(2); // => true\n * isBetween(3)(1)(2); // => true\n * isBetween(1)(3)(3); // => false\n * isBetween(1)(3)(4); // => false\n *\n * // isBetween can be called both as a curried unary function or as a standard ternary function\n * isBetween(1)(3)(2) === isBetween(1, 3, 2);\n */\nexport const isBetween = nary(a => b => c =>\n    a > b\n    ? a > c && b < c\n    : a < c && b > c\n);\n\n/**\n * isInRange output is true if c is in range of a and b.\n *\n * isInRange can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner isInRange :: a -> b -> c -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @param {number} c\n * @return {boolean}\n *\n * @example\n * import {isInRange} from '@7urtle/lambda';\n *\n * isInRange(1)(3)(2); // => true\n * isInRange(3)(1)(2); // => true\n * isInRange(1)(3)(3); // => true\n * isInRange(1)(3)(4); // => false\n *\n * // isInRange can be called both as a curried unary function or as a standard ternary function\n * isInRange(1)(3)(2) === isInRange(1, 3, 2);\n */\n export const isInRange = nary(a => b => c =>\n    a > b\n    ? a >= c && b <= c\n    : a <= c && b >= c\n);\n\n/**\n * isTypeOf output is true if b is a type of a.\n *\n * isTypeOf can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isTypeOf :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isTypeOf} from '@7urtle/lambda';\n *\n * isTypeOf('number')(1); // => true\n * isTypeOf('string')(1); // => false\n *\n * // isTypeOf can be called both as a curried unary function or as a standard binary function\n * isTypeOf('number')(1) === isTypeOf('number', 1);\n */\nexport const isTypeOf = nary(a => b => isEqual(typeOf(b))(a));\n\n/**\n * isNotTypeOf output is true if b is not a type of a.\n *\n * isNotTypeOf can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isNotTypeOf :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isNotTypeOf} from '@7urtle/lambda';\n *\n * isNotTypeOf('number')(1); // => false\n * isNotTypeOf('string')(1); // => true\n *\n * // isNotTypeOf can be called both as a curried unary function or as a standard binary function\n * isNotTypeOf('string')(1) === isNotTypeOf('string', 1);\n */\nexport const isNotTypeOf = nary(a => b => isNotEqual(typeOf(b))(a));\n\n/**\n * isString output is true if input is a string.\n *\n * @HindleyMilner isString :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isString} from '@7urtle/lambda';\n *\n * isString('string'); // => true\n * isString(1); // => false\n */\nexport const isString = isTypeOf('string');\n\n/**\n * isNotString output is true if input is not a string.\n *\n * @HindleyMilner isNotString :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotString} from '@7urtle/lambda';\n *\n * isNotString('string'); // => false\n * isNotString(1); // => true\n */\nexport const isNotString = isNotTypeOf('string');\n\n/**\n * isBoolean output is true if input is a boolean.\n *\n * @HindleyMilner isBoolean :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isBoolean} from '@7urtle/lambda';\n *\n * isBoolean(false); // => true\n * isBoolean(1); // => false\n */\nexport const isBoolean = isTypeOf('boolean');\n\n/**\n * isNotBoolean output is true if input is not a boolean.\n *\n * @HindleyMilner isNotBoolean :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotBoolean} from '@7urtle/lambda';\n *\n * isNotBoolean(false); // => false\n * isNotBoolean(1); // => true\n */\nexport const isNotBoolean = isNotTypeOf('boolean');\n\n/**\n * isNull output is true if input is a null.\n *\n * @HindleyMilner isNull :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNull} from '@7urtle/lambda';\n *\n * isNull(null); // => true\n * isNull(1); // => false\n */\nexport const isNull = isEqual(null);\n\n/**\n * isNotNull output is true if input is not a null.\n *\n * @HindleyMilner isNotNull :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotNull} from '@7urtle/lambda';\n *\n * isNotNull(null); // => false\n * isNotNull(1); // => true\n */\nexport const isNotNull = isNotEqual(null);\n\n/**\n * isUndefined output is true if input is an undefined.\n *\n * @HindleyMilner isUndefined :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isUndefined} from '@7urtle/lambda';\n *\n * isUndefined(undefined); // => true\n * isUndefined(1); // => false\n */\nexport const isUndefined = isTypeOf('undefined');\n\n/**\n * isNotUndefined output is true if input is not an undefined.\n *\n * @HindleyMilner isNotUndefined :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotUndefined} from '@7urtle/lambda';\n *\n * isNotUndefined(undefined); // => false\n * isNotUndefined(1); // => true\n */\nexport const isNotUndefined = isNotTypeOf('undefined');\n\n/**\n * isNumber output is true if input is a number.\n *\n * @HindleyMilner isNumber :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNumber} from '@7urtle/lambda';\n *\n * isNumber(1); // => true\n * isNumber('string'); // => false\n */\nexport const isNumber = isTypeOf('number');\n\n/**\n * isNotNumber output is true if input is not a number.\n *\n * @HindleyMilner isNotNumber :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotNumber} from '@7urtle/lambda';\n *\n * isNotNumber(1); // => false\n * isNotNumber('string'); // => true\n */\nexport const isNotNumber = isNotTypeOf('number');\n\n/**\n * isObject output is true if b is an object, array, or null.\n *\n * @HindleyMilner isObject :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isObject} from '@7urtle/lambda';\n *\n * isObject({}); // => true\n * isObject([]); // => true\n * isObject(null); // => true\n * isObject(1); // => false\n */\nexport const isObject = isTypeOf('object');\n\n/**\n * isNotObject output is true if input is not an object, array, or null.\n *\n * @HindleyMilner isNotObject :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotObject} from '@7urtle/lambda';\n *\n * isNotObject({}); // => false\n * isNotObject([]); // => false\n * isNotObject(null); // => false\n * isNotObject(1); // => true\n */\nexport const isNotObject = isNotTypeOf('object');\n\n/**\n * isArray output is true if input is an array.\n *\n * @HindleyMilner isArray :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isArray} from '@7urtle/lambda';\n *\n * isArray([]); // => true\n * isArray({}); // => false\n */\nexport const isArray = Array.isArray;\n\n/**\n * isNotArray output is true if input is not an array.\n *\n * @HindleyMilner isNotArray :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotArray} from '@7urtle/lambda';\n *\n * isNotArray([]); // => false\n * isNotArray({}); // => true\n */\nexport const isNotArray = a => !Array.isArray(a);\n\n/**\n * isFunction output is true if input is a function.\n *\n * @HindleyMilner isFunction :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isFunction} from '@7urtle/lambda';\n *\n * isFunction(() => null); // => true\n * isFunction(1); // => false\n */\nexport const isFunction = isTypeOf('function');\n\n/**\n * isNotFunction output is true if input is not a function.\n *\n * @HindleyMilner isNotFunction :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotFunction} from '@7urtle/lambda';\n *\n * isNotFunction(() => null); // => false\n * isNotFunction(1); // => true\n */\nexport const isNotFunction = isNotTypeOf('function');\n\n/**\n * isLength output is true if b is a length of a.\n *\n * @HindleyMilner isLength :: (string|array) -> b -> boolean\n *\n * @pure\n * @param {string|array} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isLength} from '@7urtle/lambda';\n *\n * isLength(3)('abc'); // => true\n * isLength(3)([1,2,3]); // => true\n * isLength(3)('abc'); // => false\n */\nexport const isLength = nary(a => b => isEqual(lengthOf(b))(a));\n\n/**\n * isNotLength output is true if b is not a length of a.\n * \n * The function can be called both as a unary isNotLength(a)(b) and binary isNotLength(a, b).\n *\n * @HindleyMilner isNotLength :: (string|array) -> b -> boolean\n *\n * @pure\n * @param {string|array} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isNotLength} from '@7urtle/lambda';\n *\n * isNotLength(3)('abc'); // => false\n * isNotLength(3)([1,2,3]); // => false\n * isNotLength(3)('abce'); // => true\n * \n * isNotLength(3)('abcd') === isNotLength(3, 'abcd'); // => true\n */\nexport const isNotLength = nary(a => b => !isLength(a)(b));\n\n/**\n * isElement output is true if input is an HTML or SVG Element. Otherwise it is false.\n *\n * @HindleyMilner isElement :: a -> boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import {isElement} from '@7urtle/lambda';\n *\n * isElement(document.createElement('span')); // => true\n */\nexport const isElement = anything =>\n    (typeof Element !== 'undefined' && anything instanceof Element) ||\n    (typeof HTMLDocument !== 'undefined' && anything instanceof HTMLDocument);\n\n/**\n * isNotElement output is true if input is not an HTML or SVG Element. Otherwise it is false.\n *\n * @HindleyMilner isNotElement :: a -> boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import {isNotElement} from '@7urtle/lambda';\n *\n * isNotElement(document.createElement('span')); // => false\n */\nexport const isNotElement = anything => !isElement(anything);\n\n/**\n * isEmpty output is true if input is an empty string, array, or object. Otherwise it is false.\n *\n * @HindleyMilner isEmpty :: (string|array|Element) -> boolean\n *\n * @pure\n * @param {string|array|object} anything\n * @return {boolean}\n *\n * @example\n * import {isEmpty} from '@7urtle/lambda';\n *\n * isEmpty(''); // => true\n * isEmpty([]); // => true\n * isEmpty({}); // => true\n * isEmpty('abc'); // => false\n * isEmpty(document.getElementByID('image')); // => false\n */\nexport const isEmpty = anything =>\n    isLength(0)(anything) ||\n    isNotElement(anything) &&\n    (isObject(anything) ? isLength(0)(Object.getOwnPropertyNames(anything)) : false);\n\n/**\n * isNotEmpty output is false if input is an empty string, array, or object. Otherwise it is true.\n *\n * @HindleyMilner isNotEmpty :: (string|array|Element) -> boolean\n *\n * @pure\n * @param {string|array|object} anything\n * @return {boolean}\n *\n * @example\n * import {isNotEmpty} from '@7urtle/lambda';\n *\n * isNotEmpty(''); // => false\n * isNotEmpty([]); // => false\n * isNotEmpty('abc'); // => true\n * isNotEmpty({}); => true\n * isNotEmpty(document.getElementByID('image')); // => true\n */\nexport const isNotEmpty = anything => !isEmpty(anything);\n\n/**\n * isZero output is true if input is 0.\n *\n * @HindleyMilner isZero :: a -> boolean\n *\n * @pure\n * @param {number} a\n * @return {boolean}\n *\n * @example\n * import {isZero} from '@7urtle/lambda';\n *\n * isZero(0); // => true\n * isZero(1); // => false\n */\nexport const isZero = isEqual(0);\n\n/**\n * isNotZero output is true if input is not 0.\n *\n * @HindleyMilner isNotZero :: a -> boolean\n *\n * @pure\n * @param {number} a\n * @return {boolean}\n *\n * @example\n * import {isZero} from '@7urtle/lambda';\n *\n * isZero(0); // => false\n * isZero(1); // => true\n */\nexport const isNotZero = isNotEqual(0);\n\n/**\n * isNothing returns true if input is null, undefined or empty string or empty array or empty object or the monad Nothing.\n *\n * @HindleyMilner isNothing :: a -> boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import { isNothing, Maybe, Just, Nothing } from '@7urtle/lambda';\n *\n * isNothing(null); // => true\n * isNothing(undefined); // => true\n * isNothing(''); // => true\n * isNothing([]); // => true\n * isNothing({}); // => true\n * isNothing(Maybe.of('')); // => true\n * isNothing(Nothing); // => true\n * isNothing('7urtle'); // => false\n * isNothing(Maybe.of('7urtle')); // => false\n * isNothing(Just('7urtle')); // => false\n */\nexport const isNothing = anything =>\n    anything && anything.isNothing\n    ? anything.isNothing()\n    : isNull(anything) || isUndefined(anything) || isEmpty(anything);\n\n/**\n * isJust returns true if input is not null, undefined or empty string or empty array or empty object.\n *\n * @HindleyMilner isJust :: a -> boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import { isJust, Maybe, Just, Nothing } from '@7urtle/lambda';\n *\n * isJust(null); // => false\n * isJust(undefined); // => false\n * isJust(''); // => false\n * isJust([]); // => false\n * isJust({}); // => false\n * isJust(Nothing); // => false\n * isJust('7urtle'); // => true\n * isJust(Maybe.of('7urtle')); // => true\n * isJust(Just('7urtle')); // => true\n */\nexport const isJust = anything =>\n    !isNothing(anything);\n\n/**\n * when tests anything argument by passing it to predicate function. If the predicate function is true, when\n * will return the result of whenTrueFn function which receivs the same anything argument. If the predicate\n * is false, then the anything argument is returned unchanged.\n * \n * The function can be called both as a unary when(predicate)(whenTrueFn)(anything) and ternary when(predicate, whenTrueFn, anything).\n *\n * @HindleyMilner when :: (a -> Boolean) -> (a -> a) -> a -> a\n *\n * @pure\n * @param {function} predicate\n * @param {function} whenTrueFn\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {when} from '@7urtle/lambda';\n *\n * const predicate = a => a > 1;\n * const whenTrueFn = a => a * 2;\n * \n * when(predicate)(whenTrueFn)(2); // => 4\n * when(predicate)(whenTrueFn)(1); // => 1\n * \n * when(predicate)(whenTrueFn)(2) === when(predicate, whenTrueFn, 2); // => true\n */\nexport const when = nary(predicate => whenTrueFn => anything =>\n    predicate(anything)\n    ? whenTrueFn(anything)\n    : anything\n);\n\n/**\n * unless tests anything argument by passing it to predicate function. If the predicate function is false, unless\n * will return the result of whenFalseFn function which receivs the same anything argument. If the predicate\n * is true, then the anything argument is returned unchanged.\n * \n * The function can be called both as a unary unless(predicate)(whenFalseFn)(anything) and ternary unless(predicate, whenFalseFn, anything).\n *\n * @HindleyMilner unless :: (a -> Boolean) -> (a -> a) -> a -> a\n *\n * @pure\n * @param {function} predicate\n * @param {function} whenFalseFn\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {unless} from '@7urtle/lambda';\n *\n * const predicate = a => a > 1;\n * const whenFalseFn = a => a * 2;\n * \n * when(predicate)(whenFalseFn)(4); // => 4\n * when(predicate)(whenFalseFn)(1); // => 2\n * \n * when(predicate)(whenFalseFn)(1) === when(predicate, whenFalseFn, 1); // => true\n */\nexport const unless = nary(predicate => whenFalseFn => anything =>\n    predicate(anything)\n    ? anything\n    : whenFalseFn(anything)\n);\n\n/**\n * ifElse tests anything argument by passing it to predicate function. If the predicate function is true, ifElse\n * will return the result of whenTrueFn function which receivs the same anything argument. If the predicate\n * is false, then the anything argument is passed to the whenFalseFn function.\n * \n * The function can be called both as a unary ifElse(predicate)(whenTrueFn)(whenFalseFn)(anything) and quaternary\n * ifElse(predicate, whenTrueFn, whenFalseFn, anything).\n *\n * @HindleyMilner ifElse :: (a -> Boolean) -> (a -> a) -> (a -> a) a -> a\n *\n * @pure\n * @param {function} predicate\n * @param {function} whenTrueFn\n * @param {function} whenFalseFn\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {ifElse} from '@7urtle/lambda';\n *\n * const predicate = a => a > 1;\n * const whenTrueFn = a => a / 2;\n * const whenFalseFn = a => a * 2;\n * \n * ifElse(predicate)(whenTrueFn)(whenFalseFn)(4); // => 2\n * ifElse(predicate)(whenTrueFn)(whenFalseFn)(1); // => 2\n * \n * ifElse(predicate)(whenTrueFn)(whenFalseFn)(1) === ifElse(predicate, whenTrueFn, whenFalseFn, 1); // => true\n */\n export const ifElse = nary(predicate => whenTrueFn => whenFalseFn => anything =>\n    predicate(anything)\n    ? whenTrueFn(anything)\n    : whenFalseFn(anything)\n);","import toPropertyKey from \"./toPropertyKey.js\";\nexport default function _defineProperty(obj, key, value) {\n  key = toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : i + \"\";\n}","import _typeof from \"./typeof.js\";\nexport default function toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}","import { reduce, reduceRight } from './list.js';\nimport { isString, isArray, isObject } from './conditional.js';\nimport { minusOneToUndefined, passThrough } from './utils.js';\nimport { nary } from \"./arity.js\";\n\n/**\n * identity is a function that simply passes its input to its output without changing it.\n *\n * @HindleyMilner identity :: a -> a\n *\n * @pure\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {identity} from '@7urtle/lambda';\n *\n * identity('anything');\n * // => anything\n */\nexport const identity = anything => anything;\n\n/**\n * compose is a right-to-left function composition\n * where each function receives input and hands over its output to the next function.\n *\n * compose executes functions in reverse order to pipe.\n *\n * compose(f,g)(x) is equivalent to f(g(x)).\n *\n * @HindleyMilner compose :: [(a -> b)] -> a -> b\n *\n * @pure\n * @param {function} fns\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {compose} from '@7urtle/lambda';\n *\n * const addA = a => a + 'A';\n * const addB = a => a + 'B';\n * const addAB = value => compose(addA, addB)(value);\n *\n * addAB('Order: ');\n * // => Order: BA\n */\nexport const compose = (...fns) => anything => reduceRight(anything)((v, f) => f(v))(fns);\n\n/**\n * pipe output is a left-to-right function composition\n * where each function receives input and hands over its output to the next function.\n *\n * pipe executes functions in reverse order to compose.\n *\n * pipe(f,g)(x) is equivalent to g(f(x)).\n *\n * @HindleyMilner pipe :: [(a -> b)] -> a -> b\n *\n * @pure\n * @param {function} fns\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {pipe} from '@7urtle/lambda';\n *\n * const addA = a => a + 'A';\n * const addB = a => a + 'B';\n * const addAB = value => pipe(addA, addB)(value);\n *\n * addAB('Order: ');\n * // => Order: AB\n */\nexport const pipe = (...fns) => anything => reduce(anything)((v, f) => f(v))(fns);\n\n/**\n * map executes mapper function over input. If the input is array or monad, their map functions\n * are executed. If the input is anything else the mapper function is executed with the input\n * as its argument.\n *\n * In case of monads, you should use map when you want to work with functors using functions\n * and functional composition rather than calling Functor.map.\n *\n * If you need to both filter and map over an array, consider using the filterMap function.\n *\n * map can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner map :: (a -> b) -> a -> b\n *\n * @param {function} mapper\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {map, Maybe, upperCaseOf} from '@7urtle/lambda';\n *\n * const mapper = a => a + 'm';\n * const list = ['a', 'b', 'c'];\n *\n * // the function mapper is applied to each member of the array\n * map(mapper)(list); // => ['am', 'bm', 'cm']\n *\n * // the function upperCaseOf is applied to the value of the functor\n * map(upperCaseOf)(Maybe.of('something')); // => Just('SOMETHING')\n * \n * // the function upperCaseOf is applied to the input string\n * map(upperCaseOf)('turtle'); // => 'TURTLE'\n *\n * // use of map equals the use of map on the functor\n * map(upperCaseOf)(Maybe.of('something')).value === Maybe.of('something').map(upperCaseOf).value;\n *\n * // map can be called both as a curried unary function or as a standard binary function\n * map(upperCaseOf)(Maybe.of('something')).value === map(upperCaseOf, Maybe.of('something')).value;\n */\nexport const map = nary(mapper => anything =>\n    anything && anything.map\n    ? anything.map(mapper)\n    : mapper(anything)\n);\n\n/**\n * flatMap maps function over inputted functor outputting resulting flattened functor.\n *\n * You should use flatMap when you want to work with functors using functions\n * and functional composition rather than calling flatMaps.\n *\n * The function can be called both as a unary flatMap(fn)(functor) and binary flatMap(fn, functor).\n *\n * @HindleyMilner flatMap :: (a -> Functor) -> Functor -> Functor\n *\n * @param {function} fn\n * @param {functor} functor\n * @return {functor}\n *\n * @example\n * import {flatMap, map, Maybe} from '@7urtle/lambda';\n *\n * const maybePlus2 = number => Maybe.of(number + 2);\n *\n * // the function maybePlus2 is applied to the value of the functor\n * flatMap(maybePlus2)(Maybe.of(3)); // => Just(5)\n * map(maybePlus2)(Maybe.of(3)); // => Just(Just(5))\n *\n * // use of flatMap equals the use of flatMap on the functor\n * flatMap(maybePlus2)(Maybe.of(3)).value === Maybe.of(3).flatMap(maybePlus2).value;\n *\n * // flatMap can be called both as a curried unary function or as a standard binary function\n * flatMap(maybePlus2)(Maybe.of(3)).value === flatMap(maybePlus2, Maybe.of(3)).value;\n */\nexport const flatMap = nary(fn => functor => functor.flatMap(fn));\n\n/**\n * liftA2 provides point-free way of writing calls over applicative functors and functions expecting 2 inputs. It\n * applies input function over both functors values providing a resulting functor.\n *\n * The function can be called both as a unary liftA2(fn)(functor)(functor) and ternary liftA2(fn, functor, functor).\n *\n * @HindleyMilner liftA2 (a -> b -> c) -> Applicative a -> Applicative b -> Applicative c\n *\n * @pure\n * @param {function} fn\n * @param {functor} ap1\n * @param {functor} ap2\n * @return {functor}\n *\n * @example\n * import {liftA2, Maybe} from '@7urtle/lambda';\n *\n * const add = a => b => a + b;\n *\n * // function add which expects two inputs is applied to the values of two applicative functors Maybe\n * // the result is a Maybe functor with the internal value 5\n * liftA2(add)(Maybe.of(2))(Maybe.of(3)); // => Just(5)\n *\n * // an example of applying a function over a Maybe of undefined value to demonstrate continued safety of functors\n * liftA2(add)(Maybe.of(1))(Maybe.of(undefined)).isNothing(); // => true\n *\n * // liftA2 can be called both as a curried unary function or as a standard ternary function\n * liftA2(add)(Maybe.of(2))(Maybe.of(3)).value === liftA2(add, Maybe.of(2), Maybe.of(3)).value;\n */\nexport const liftA2 = nary(fn => ap1 => ap2 => ap1.map(fn).ap(ap2));\n\n/**\n * liftA3 provides point-free way of writing calls over applicative functors and functions expecting 3 inputs. It\n * applies input function over input functors values providing a resulting functor.\n *\n * The function can be called both as a unary liftA3(fn)(functor)(functor)(functor) and quaternary liftA2(fn, functor, functor, functor).\n *\n * @HindleyMilner liftA3 (a -> b -> c -> d) -> Applicative a -> Applicative b -> Applicative c -> Applicative d\n *\n * @pure\n * @param {function} fn\n * @param {functor} ap1\n * @param {functor} ap2\n * @param {functor} ap3\n * @return {functor}\n *\n * @example\n * import {liftA3, Maybe} from '@7urtle/lambda';\n *\n * const add = a => b => c => a + b + c;\n *\n * // function add which expects three inputs is applied to the values of three applicative functors Maybe\n * // the result is a Maybe functor with the internal value 9\n * liftA3(add)(Maybe.of(2))(Maybe.of(3))(Maybe.of(4)); // => Just(9)\n *\n * // an example of applying a function over a Maybe of undefined value to demonstrate continued safety of functors\n * liftA3(add)(Maybe.of(1))(Maybe.of(2))(Maybe.of(undefined)).isNothing(); // => true\n *\n * // liftA3 can be called both as a curried unary function or as a standard quaternary function\n * liftA3(add)(Maybe.of(2))(Maybe.of(3))(Maybe.of(4)).value === liftA3(add, Maybe.of(2), Maybe.of(3), Maybe.of(4)).value;\n */\nexport const liftA3 = nary(fn => ap1 => ap2 => ap3 => ap1.map(fn).ap(ap2).ap(ap3));\n\n/**\n * contact outputs concatenated inputs of strings, arrays and shallow objects or outputs undefined for other types.\n *\n * concat can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner concat :: a -> a|boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {*}\n *\n * @example\n * import {concat} from '@7urtle/lambda';\n *\n * concat('cd')('ab'); // => 'abcd'\n * concat([3, 4])([1,2]); // => [1, 2, 3, 4]\n * concat({here: {here: 'there'}})({hi: 'hello'}); // => {hi: 'hello', here: {here: 'there'}}\n * concat('cd')(1); // => undefined\n *\n * // concat can be called both as a curried unary function or as a standard binary function\n * concat('cd')('ab') === concat('cd', 'ab');\n */\nexport const concat = nary(a => b =>\n    isString(b) || isArray(b)\n        ? b.concat(a)\n        : isObject(b)\n            ? { ...b, ...a }\n            : undefined);\n\n/**\n * merge performs a deep merge on all input objects and arrays.\n *\n * @HindleyMilner merge :: [a] -> [b]\n *\n * @pure\n * @param {array|object} sources\n * @return {array|object}\n *\n * @example\n * import {merge} from '@7urtle/lambda';\n *\n * const obj1 = { a: 'a', c: ['a'] };\n * const obj2 = { b: a => a, d: ['a', 'b'] };\n * const obj3 = { a: 'c', c: ['c'] };\n *\n * merge(obj1, obj2, obj3));\n * // => {\"a\": \"c\", \"b\": a => a, \"c\": [\"a\", \"c\"], \"d\": [\"a\", \"b\"]}\n *\n * const list1 = ['a', 'b'];\n * const list2 = [1, 2];\n *\n * merge(list1,list2);\n * // => ['a', 'b', 1, 2]\n * \n * merge(list1, obj1)\n * // => {\"0\": \"a\", \"1\": \"b\", \"a\": \"a\", \"c\": [\"a\"]}\n */\nexport const merge = (...sources) =>\n    reduce\n        ([])\n        ((acc, current) =>\n            isArray(current)\n                ? [...acc, ...current]\n                : isObject(current)\n                    ? reduce\n                        (acc)\n                        ((a, c) =>\n                            isObject(current[c]) && c in acc\n                                ? { ...a, [c]: merge(acc[c], current[c]) }\n                                : { ...a, [c]: current[c] }\n                        )\n                        (Object.getOwnPropertyNames(current))\n                    : { ...acc, ...current }\n        )\n        (sources);\n\n/**\n * includes(a)(b) output is true if b includes a.\n *\n * includes can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner includes :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {*}\n *\n * @example\n * import {includes} from '@7urtle/lambda';\n *\n * includes('rt')('7urtle'); // => true\n * includes(1)([1, 2, 3]) // => true\n * includes('turtle')([1, 2, 3]) // => false\n *\n * // includes can be called both as a curried unary function or as a standard binary function\n * includes('rt')('7urtle') === includes('rt', '7urtle');\n */\nexport const includes = nary(a => b => b.includes(a));\n\n/**\n * indexOf(a)(b) outputs position of input a within input b or undefined if it is not found.\n *\n * indexOf can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner indexOf :: a -> b -> number\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {*}\n *\n * @example\n * import {indexOf} from '@7urtle/lambda';\n *\n * indexOf('7')('7urtle'); // => 0\n * indexOf(7)('7urtle'); // => 0\n * indexOf(2)([1, 2, 3]); // => 1\n * indexOf(4)([1, 2, 3]); // => undefined\n *\n * // indexOf can be called both as a curried unary function or as a standard binary function\n * indexOf('7')('7urtle') === indexOf('7', '7urtle');\n */\nexport const indexOf = nary(a => b => minusOneToUndefined(b.indexOf(a)));\n\n/**\n * lastIndexOf(a)(b) outputs position of input a withing input b looking from the end or it retuns undefined if it is not found.\n *\n * lastIndexOf can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner lastIndexOf :: a -> b -> number\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {*}\n *\n * @example\n * import {lastIndexOf} from '@7urtle/lambda';\n *\n * lastIndexOf('urtle')('7urtle'); // => 1\n * lastIndexOf(2)([1, 2, 3, 2]); // => 3\n * lastIndexOf('8')('7urtle'); // => undefined\n *\n * // lastIndexOf can be called both as a curried unary function or as a standard binary function\n * lastIndexOf('7')('7urtle') === lastIndexOf('7', '7urtle');\n */\nexport const lastIndexOf = nary(a => b => minusOneToUndefined(b.lastIndexOf(a)));\n\n/**\n * memoize uses input memory to save output of input function and then uses it to lookup the result on a repeated run. This\n * function is not pure because the input memory is modified in the process.\n *\n * The function can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner memoize :: object -> (a -> b) -> a -> b\n *\n * @param {object} memory\n * @param {function} fn\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {memoize} from '@7urtle/lambda';\n *\n * const addTwo = a => a + 2;\n * let memory = {};\n *\n * memoize(memory)(addTwo)(1); // => 3\n * memoize(memory)(addTwo)(1); // => 3\n * memory[1]; // => 3\n *\n * // lastIndexOf can be called both as a curried unary function or as a standard ternary function\n * memoize(memory)(addTwo)(1) === memoize(memory, addTwo, 1);\n */\nexport const memoize = nary(memory => fn => anything =>\n    anything in memory\n        ? memory[anything]\n        : passThrough(b => memory[anything] = b)(fn(anything))\n);\n\n/**\n * memo takes input function and returns it enhanced by memoization which ensures that each result is\n * always remembered internally and executed only once.\n *\n * @HindleyMilner memo :: (a -> b) -> (a -> b)\n *\n * @pure\n * @param {function} fn\n * @return {function}\n *\n * @example\n * import {memo} from '@7urtle/lambda';\n *\n * const addTwo = a => a + 2;\n * const memoAddTwo = memo(addTwo);\n * const memoAddThree = memo(a => a + 3);\n *\n * memoAddTwo(1); // => 3\n * memoAddThree(1); // => 4\n *\n * let count = 0;\n * const increaseCount = () => ++count;\n *\n * increaseCount(); // 1\n * increaseCount(); // 2\n *\n * const memoIncreaseCount = memo(increaseCount);\n *\n * memoIncreaseCount(); // 3\n * memoIncreaseCount(); // 3\n * memoIncreaseCount(); // 3\n */\nexport const memo = fn => memoize({})(fn);\n\n/**\n * fail throws the input error. It is just a function wrapped around JavaScript throw.\n *\n * @HindleyMilner fail :: a -> b -> number\n *\n * @impure\n * @param {string|Error} error\n * @return {null}\n *\n * @example\n * import { fail } from '@7urtle/lambda';\n *\n * fail('I am an error.'); // => throws 'I am an error.'\n * fail(new Error('something happend :(')); // => throws Error('something happened :('))\n */\nexport const fail = error => { throw error; };","import { isArray, isEqual, isString, isObject, isFunction, isNull, isUndefined } from \"./conditional.js\";\nimport {keysOf, join} from \"./list.js\";\nimport {map} from \"./core.js\";\nimport {nary} from \"./arity.js\";\n\n/**\n * typeOf outputs a type of its input.\n *\n * @HindleyMilner typeOf :: a -> string\n *\n * @pure\n * @param {*} a\n * @return {string}\n *\n * @example\n * import {typeOf} from '@7urtle/lambda';\n *\n * typeOf('7turtle'); // => 'string'\n */\nexport const typeOf = a => typeof a;\n\n/**\n * lengthOf outputs the length of an input.\n *\n * @HindleyMilner lengthOf :: (string|array) -> number\n *\n * @pure\n * @param {string|array} a\n * @return {number}\n *\n * @example\n * import {lengthOf} from '@7urtle/lambda';\n *\n * lengthOf('7turtle'); // => 7\n * lengthOf([1,2,3]); // => 3\n * lengthOf({}); // => undefined\n */\nexport const lengthOf = a => a.length;\n\n/**\n * passThrough output is the same as input a. passThrough executes function passed as first argument.\n *\n * passThrough can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner passThrough :: function -> a -> a\n *\n * @pure\n * @param {function} fn\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import {passThrough} from '@7urtle/lambda';\n *\n * passThrough(() => 'b')('a'); // => 'a'\n *\n * // isTypeOf can be called both as a curried unary function or as a standard binary function\n * passThrough(() => 'b')('a') === passThrough(() => 'b', 'a');\n */\nexport const passThrough = nary(fn => anything => {\n  fn(anything);\n  return anything;\n});\n\n/**\n * log output is the same as input and it logs the input value. log causes side effect of console.log.\n *\n * @HindleyMilner log :: a -> a\n *\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {log} from '@7urtle/lambda';\n *\n * log('anything'); // => 'anything'\n */\nexport const log = passThrough(console.log);\n\n/**\n * spy output is the same as input and it logs the deepInspect of the input. spy causes side effect of console.log.\n *\n * @HindleyMilner spy :: a -> a\n *\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {spy} from '@7urtle/lambda';\n *\n * spy([1, 'a']); // => \"[1, 'a']\"\n */\nexport const spy = passThrough(a => console.log(deepInspect(a)));\n\n/**\n * minusOneToUndefined output is the same as input or undefined if input is -1.\n *\n * Because some functions return -1 as error state, this function is created to change it into a more consistent\n * undefined output.\n *\n * @HindleyMilner minusOneToUndefined :: a -> a|boolean\n *\n * @pure\n * @param {*} anything\n * @return {*|boolean}\n *\n * @example\n * import {log} from '@7urtle/lambda';\n *\n * minusOneToUndefined(-1); // => undefined\n * minusOneToUndefined(0); // => 0\n * minusOneToUndefined('7urtle'); // => '7urtle'\n */\nexport const minusOneToUndefined = anything => isEqual(-1)(anything) ? undefined: anything;\n\n/**\n * inspectFunction outputs name of named function or its conversion to string.\n *\n * @HindleyMilner inspectFunction :: (a -> b) -> string\n *\n * @pure\n * @param {function} fn\n * @return {string}\n *\n * @example\n * import {inspectFunction} from '@7urtle/lambda';\n *\n * function namedFunction() {\n *   return null;\n * }\n *\n * inspectFunction(namedFunction); // => 'namedFunction'\n * inspectFunction(() => 'b');\n * // => `function () {\n * // =>     return 'b';\n * // => }`\n */\nexport const inspectFunction = fn => fn.name ? fn.name : String(fn);\n\n/**\n * inspectArray maps over input array [a] and outputs string representing it.\n *\n * @HindleyMilner inspectArray :: [a] -> string\n *\n * @pure\n * @param {array} a\n * @return {string}\n *\n * @example\n * import {inspectArray} from '@7urtle/lambda';\n *\n * function namedFunction() {\n *   return null;\n * }\n *\n * inspectArray([1, 'a']); // => \"[1, 'a']\"\n * inspectArray([namedFunction, 'a']); // => \"[namedFunction, 'a']\"\n */\nexport const inspectArray = a => `[${join(', ')(map(deepInspect)(a))}]`;\n\n/**\n * inspectString outputs string representing input.\n *\n * @HindleyMilner inspectString :: a -> string\n *\n * @pure\n * @param {*} a\n * @return {string}\n *\n * @example\n * import {inspectString} from '@7urtle/lambda';\n *\n * inspectString('my string'); // => \"'my string'\"\n */\nexport const inspectString = a => `'${a}'`;\n\n/**\n * inspectObject outputs string representing input.\n *\n * @HindleyMilner inspectObject :: a -> string\n *\n * @pure\n * @param {object} a\n * @return {string}\n *\n * @example\n * import {inspectObject} from '@7urtle/lambda';\n *\n * inspectObject({a: 'b'}); // => \"{a: 'b'}\"\n */\nexport const inspectObject = a =>\n  isFunction(a.inspect)\n    ? a.inspect()\n    : `{${join(', ')(map(join(': '))(map(k => [k, deepInspect(a[k])])(keysOf(a))))}}`\n\n/**\n * deepInspect runs recursively over input and outputs string representing the input.\n *\n * @HindleyMilner deepInspect :: a -> string\n *\n * @pure\n * @param {*} a\n * @return {string}\n *\n * @example\n * import {deepInspect} from '@7urtle/lambda';\n *\n * function namedFunction() {\n *   return null;\n * }\n *\n * deepInspect({a: 'b'}); // => \"{a: 'b'}\"\n * deepInspect(namedFunction); // => 'namedFunction'\n * deepInspect([1, 'a']); // => \"[1, 'a']\"\n * deepInspect('my string'); // => \"'my string'\"\n * deepInspect(undefined); // => 'undefined'\n */\nexport const deepInspect = a =>\n  isUndefined(a)\n    ? 'undefined'\n    : isNull(a)\n      ? 'null'\n      : isFunction(a)\n        ? inspectFunction(a)\n        : isArray(a)\n          ? inspectArray(a)\n          : isObject(a)\n            ? inspectObject(a)\n            : isString(a)\n              ? inspectString(a)\n              : String(a);","import {minusOneToUndefined} from './utils.js';\nimport {nary} from \"./arity.js\";\n\n/**\n * trim output is a string without white characters around it.\n *\n * @HindleyMilner trim :: string -> string\n *\n * @pure\n * @param {string} string\n * @return {string}\n *\n * @example\n * import {trim} from '@7urtle/lambda';\n *\n * trim(' a \\n '); // => 'a'\n */\nexport const trim = string => string.trim();\n\n/**\n * testRegEx outputs true if string b passes regular expression a.\n *\n * testRegEx can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner testRegEx :: regex -> string -> boolean\n *\n * @pure\n * @param {regex} regex\n * @param {string} string\n * @return {boolean}\n *\n * @example\n * import {testRegEx} from '@7urtle/lambda';\n *\n * testRegEx(/[a-z]/)('7urtle'); // => true\n * testRegEx(/[0-9]/)('1'); // => true\n * testRegEx(/[0-9]/)('abc'); // => false\n *\n * // testRegEx can be called both as a curried unary function or as a standard binary function\n * testRegEx(/[a-z]/)('7urtle') === testRegEx(/[a-z]/, '7urtle');\n */\nexport const testRegEx = nary(regex => string => regex.test(string));\n\n/**\n * substr outputs substring based on provided string, start and limit.\n *\n * substr can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner substr :: number -> number -> string -> string\n *\n * @pure\n * @param {number} limit\n * @param {number} start\n * @param {string} string\n * @return {string}\n *\n * @example\n * import {substr} from '@7urtle/lambda';\n *\n * substr(3)(1)('7urtle'); // => 'urt'\n * substr(1)(0)('7urtle'); // => '7'\n * substr(1)(-1)('7urtle'); // => 'e'\n *\n * // substr can be called both as a curried unary function or as a standard ternary function\n * substr(3)(1)('7urtle') === substr(3, 1, '7urtle');\n */\nexport const substr = nary(limit => start => string => string.substr(start, limit));\n\n/**\n * firstLetterOf outputs the first letter of a provided string.\n *\n * @HindleyMilner firstLetterOf :: string -> string\n *\n * @pure\n * @param {string} string\n * @return {string}\n *\n * @example\n * import {firstLetterOf} from '@7urtle/lambda';\n *\n * firstLetterOf('7urtle'); // => '7'\n */\nexport const firstLetterOf = string => string.substr(0, 1);\n\n/**\n * lastLetterOf outputs the last letter of a provided string.\n *\n * @HindleyMilner lastLetterOf :: string -> string\n *\n * @pure\n * @param {string} string\n * @return {string}\n *\n * @example\n * import {lastLetterOf} from '@7urtle/lambda';\n *\n * lastLetterOf('7urtle'); // => 'e'\n */\nexport const lastLetterOf = string => string.substr(-1, 1);\n\n/**\n * startsWith outputs true if an input string starts with provided string.\n *\n * startsWith can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner startsWith :: string -> string -> boolean\n *\n * @pure\n * @param {string} substring\n * @param {string} string\n * @return {boolean}\n *\n * @example\n * import {startsWith} from '@7urtle/lambda';\n *\n * startsWith('7')('7urtle'); // => true\n * startsWith('7urtl')('7urtle'); // => true\n * startsWith('8urtl')('7urtle'); // => false\n *\n * // startsWith can be called both as a curried unary function or as a standard binary function\n * startsWith('7')('7urtle') === startsWith('7', '7urtle');\n */\nexport const startsWith = nary(substring => string => string.startsWith(substring));\n\n/**\n * endsWith outputs true if an input string ends with provided string.\n *\n * endsWith can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner endsWith :: string -> string -> boolean\n *\n * @pure\n * @param {string} substring\n * @param {string} string\n * @return {boolean}\n *\n * @example\n * import {endsWith} from '@7urtle/lambda';\n *\n * endsWith('7e')('7urtle'); // => true\n * endsWith('urtle')('7urtle'); // => true\n * endsWith('urtls')('7urtle'); // => false\n *\n * // endsWith can be called both as a curried unary function or as a standard binary function\n * endsWith('e')('7urtle') === endsWith('e', '7urtle');\n */\nexport const endsWith = nary(substring => string => string.endsWith(substring));\n\n/**\n * repeat outputs new string repeating input string inputted count of times.\n *\n * repeat can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner repeat :: number -> string -> string\n *\n * @pure\n * @param {number} count\n * @param {string} string\n * @return {string}\n *\n * @example\n * import {repeat} from '@7urtle/lambda';\n *\n * repeat(2)('7urtle'); // => '7urtle7urtle'\n * repeat(0)('7urtle'); // => ''\n *\n * // repeat can be called both as a curried unary function or as a standard binary function\n * repeat(2)('7urtle') === repeat(2, '7urtle');\n */\nexport const repeat = nary(count => string => string.repeat(count));\n\n/**\n * replace outputs new string replacing input substring with input replacement string in input string.\n *\n * replace can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner replace :: string -> string -> string -> string\n *\n * @pure\n * @param {string} replacement\n * @param {string} substring\n * @param {string} string\n * @return {string}\n *\n * @example\n * import {replace} from '@7urtle/lambda';\n *\n * replace('8')('7')('7urtle'); // => '8urtle'\n * replace('7')('')('7urtle'); // => '77urtle'\n * replace('')('7')('7urtle'); // => 'urtle'\n *\n * // replace can be called both as a curried unary function or as a standard ternary function\n * replace('8')('7')('7urtle') === replace('8', '7', '7urtle');\n */\nexport const replace = nary(replacement => substring => string => string.replace(substring, replacement));\n\n/**\n * search outputs position of input substring or regular expression withing input string or undefined if it is not found.\n *\n * search can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner search :: string/regex -> string -> number\n *\n * @pure\n * @param {string|regex} substring\n * @param {string} string\n * @return {number}\n *\n * @example\n * import {search} from '@7urtle/lambda';\n *\n * search('7')('7urtle'); 0\n * search('e')('7urtle'); // => 5\n * search('rt')('7urtle'); // => 2\n * search(/URT/i)('7urtle'); // => 1\n * search('8')('7urtle'); => undefined\n *\n * // search can be called both as a curried unary function or as a standard binary function\n * search('7')('7urtle') === search('7', '7urtle');\n */\nexport const search = nary(substring => string => minusOneToUndefined(string.search(substring)));\n\n/**\n * split outputs and array of an input string split by the input substring.\n *\n * split can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner split :: string -> string -> array\n *\n * @pure\n * @param {string} substring\n * @param {string} string\n * @return {array}\n *\n * @example\n * import {split} from '@7urtle/lambda';\n *\n * split(' ')('7urtles are awesome'); // => ['7urtles', 'are', 'awesome']\n * split('/')('7urtles are awesome'); // => ['7urtles are awesome']\n *\n * // split can be called both as a curried unary function or as a standard binary function\n * split(' ')('7urtles are awesome') === split(' ', '7urtles are awesome');\n */\nexport const split = nary(substring => string => string.split(substring));\n\n/**\n * lowerCaseOf outputs the lower case version of input string.\n *\n * @HindleyMilner lowerCaseOf :: string -> string\n *\n * @pure\n * @param {string} string\n * @return {string}\n *\n * @example\n * import {lowerCaseOf} from '@7urtle/lambda';\n *\n * lowerCaseOf('PeTrA'); // => 'petra'\n * lowerCaseOf('PŘÍŠERNĚ ŽLUŤOUČKÝ KŮŇ ÚPĚL ĎÁBELSKÉ ÓDY'); // => 'příšerně žluťoučký kůň úpěl ďábelské ódy'\n */\nexport const lowerCaseOf = string => string.toLowerCase();\n\n/**\n * upperCaseOf outputs the upper case version of input string.\n *\n * @HindleyMilner upperCaseOf :: string -> string\n *\n * @pure\n * @param {string} string\n * @return {string}\n *\n * @example\n * import {upperCaseOf} from '@7urtle/lambda';\n *\n * upperCaseOf('PeTrA'); // => 'PETRA'\n * upperCaseOf('příšerně žluťoučký kůň úpěl ďábelské ódy'); // => 'PŘÍŠERNĚ ŽLUŤOUČKÝ KŮŇ ÚPĚL ĎÁBELSKÉ ÓDY'\n */\nexport const upperCaseOf = string => string.toUpperCase();","import {lengthOf, minusOneToUndefined} from './utils.js';\nimport {nary} from \"./arity.js\";\nimport {upperCaseOf} from \"./string.js\";\n\n/**\n * reduce executes input reducer function that over each member of input array [b] to output a single value. It is\n * the preferred way of working functionally with arrays as it is a pure function that does not cause mutations.\n *\n * reduce executes functions in reverse order to reduceRight.\n *\n * reduce can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner reduce :: a -> ((a, b) -> a) -> [b] -> a\n *\n * @pure\n * @param {*} initial\n * @param {function} reducer\n * @param {array} list\n * @return {*}\n *\n * @example\n * import {reduce} from '@7urtle/lambda';\n *\n * const reducer = (accumulator, currentValue) => accumulator + currentValue;\n * const list = ['a', 'b', 'c'];\n *\n * reduce('start')(reducer)(list); // => startabc\n *\n * // reduce can be called both as a curried unary function or as a standard ternary function\n * reduce('start')(reducer)(list) === reduce('start', reducer, list);\n */\nexport const reduce = nary(initial => reducer => list => list.reduce(reducer, initial));\n\n/**\n * reduceRight executes input reducer function that over each member of input array [b] to output a single value. It is\n * the preferred way of working functionally with arrays as it is a pure function that does not cause mutations.\n *\n * reduceRight executes functions in reverse order to reduce.\n *\n * reduceRight can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner reduceRight :: a -> ((a, b) -> a) -> [b] -> a\n *\n * @pure\n * @param {*} initial\n * @param {function} reducer\n * @param {array} list\n * @return {*}\n *\n * @example\n * import {reduceRight} from '@7urtle/lambda';\n *\n * const reducer = (accumulator, currentValue) => accumulator + currentValue;\n * const list = ['a', 'b', 'c'];\n *\n * reduceRight('start')(reducer)(list); // => startcba\n *\n * // reduceRight can be called both as a curried unary function or as a standard ternary function\n * reduceRight('start')(reducer)(list) === reduceRight('start', reducer, list);\n */\nexport const reduceRight = nary(initial => reducer => list => list.reduceRight(reducer, initial));\n\n/**\n * filter executes input checker over each member of input array [a] to filter and output filtered new array [b].\n *\n * If you need to both filter and map over an array, consider using the filterMap function.\n *\n * filter can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner filter :: (a -> boolean) -> [a] -> [b]\n *\n * @pure\n * @param {function} checker\n * @param {array} list\n * @return {*}\n *\n * @example\n * import {filter} from '@7urtle/lambda';\n *\n * const list = [0, 1, 2, 3]\n *\n * filter(a => a > 1)(list); // => [2, 3]\n *\n * // filter can be called both as a curried unary function or as a standard binary function\n * filter(a => a > 1)(list) === filter(a => a > 1, list);\n */\nexport const filter = nary(checker => list => list.filter(checker));\n\n/**\n * filterMap executes mapper function over filtered input array or monad and outputs the resulting array or monad.\n *\n * Only one pass through the array is executed unlike the use of map(mapper)(filter(checker)(list)).\n *\n * filterMap can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner filterMap :: (a -> boolean) -> (a -> b) -> [a] -> [b]\n *\n * @pure\n * @param {function} checker\n * @param {function} mapper\n * @param {array} list\n * @return {*}\n *\n * @example\n * import {filterMap} from '@7urtle/lambda';\n *\n * const list = [0, 1, 2, 3]\n * const mapper = a => a + 1;\n * const checker = a => a > 1;\n *\n * filterMap(checker)(mapper)(list);  // => [3, 4]\n * filterMap(a => a > 1)(a => a + 1)([0, 1, 2, 3]); // => [3, 4]\n *\n * const mapOverLargerThanOne = filterMap(checker);\n * mapOverLargerThanOne(mapper)(list); // => [3, 4]\n *\n * // filterMap can be called both as a curried unary function or as a standard ternary function\n * filterMap(a => a > 1)(a => a + 1)(list) === filterMap(a => a > 1, a => a + 1, list);\n */\nexport const filterMap = nary(checker => mapper => list =>\n    reduce([])((acc, current) => checker(current) ? acc.push(mapper(current)) && acc : acc)(list));\n\n/**\n * find executes input checker over each member of input array [a] and outputs the first array member that matches checker or undefined.\n *\n * find can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner find :: (a -> boolean) -> [a] -> [b]\n *\n * @pure\n * @param {function} checker\n * @param {array} list\n * @return {*}\n *\n * @example\n * import {find} from '@7urtle/lambda';\n *\n * const list = [0, 1, 2, 3]\n *\n * find(a => a > 1)(list); // => 2\n * find(a => a > 3)(list); // => undefined\n *\n * // find can be called both as a curried unary function or as a standard binary function\n * find(a => a > 1)(list) === find(a => a > 1, list);\n */\nexport const find = nary(checker => list => list.find(checker));\n\n/**\n * findIndex executes input checker over each member of input array [a] and outputs the index of first array member that matches checker or undefined.\n *\n * findIndex can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner findIndex :: (a -> boolean) -> [a] -> [b]\n *\n * @pure\n * @param {function} checker\n * @param {array} list\n * @return {*}\n *\n * @example\n * import {findIndex} from '@7urtle/lambda';\n *\n * const list = [2, 3, 4];\n *\n * findIndex(a => a > 2)(list); // => 1\n * findIndex(a => a > 4)(list); // => undefined\n *\n * // findIndex can be called both as a curried unary function or as a standard binary function\n * findIndex(a => a > 1)(list) === findIndex(a => a > 1, list);\n */\nexport const findIndex = nary(checker => list => minusOneToUndefined(list.findIndex(checker)));\n\n/**\n * join outputs a string created by joining input array members with input separator.\n *\n * join can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner join :: string -> [a] -> string\n *\n * @pure\n * @param {string} separator\n * @param {array} list\n * @return {*}\n *\n * @example\n * import {join} from '@7urtle/lambda';\n *\n * const list = [2, 3, 4];\n *\n * join('')(list); // => '234'\n * join(' and ')(list); // => '2 and 3 and 4'\n * join()(list); // => '2,3,4'\n *\n * // join can be called both as a curried unary function or as a standard binary function\n * join('')(list) === join('', list);\n */\nexport const join = nary(separator => list => list.join(separator));\n\n/**\n * keysOf outputs array of string keys of input array or object.\n *\n * @HindleyMilner keysOf :: object -> [string]\n *\n * @pure\n * @param {Object|array} list\n * @return {array}\n *\n * @example\n * import {keysOf} from '@7urtle/lambda';\n *\n * keysOf([2, 3, 4]); // => ['0', '1', '2']\n * keysOf({1: 2, 2: 3}); // => ['1', '2']\n */\nexport const keysOf = Object.keys;\n\n/**\n * entriesOf outputs array of arrays of string keys and raw values of input array or object.\n *\n * @HindleyMilner entriesOf :: object -> [[string, a]]\n *\n * @pure\n * @param {Object|array} list\n * @return {array}\n *\n * @example\n * import {entriesOf} from '@7urtle/lambda';\n *\n * entriesOf([2, 3, 4]); // => [['0', 2], ['1', 3], ['2', 4]]\n * entriesOf({1: 2, 2: 3}); // => [['1', 2],['2', 3]]\n */\nexport const entriesOf = Object.entries;\n\n/**\n * everyOf outputs true if every element of input array passes input checker function as true.\n *\n * everyOf can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner everyOf :: (a -> boolean) -> [a] -> boolean\n *\n * @pure\n * @param {function} checker\n * @param {array} list\n * @return {boolean}\n *\n * @example\n * import {everyOf} from '@7urtle/lambda';\n *\n * everyOf(a => a > 1)([2, 3, 4]); // => true\n * everyOf(a => a > 5)([2, 3, 4]); // => false\n *\n * // everyOf can be called both as a curried unary function or as a standard binary function\n * everyOf(a => a > 1)([2, 3, 4]) === everyOf(a => a > 1, [2, 3, 4]);\n */\nexport const everyOf = nary(checker => list => list.every(checker));\n\n/**\n * slice outputs selected array elements as an array based on input range. First argument end\n * represents the ending index (not length) and start represents the starting index in the input\n * array list.\n *\n * slice can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner slice :: number -> number -> [a] -> [a]\n *\n * @pure\n * @param {number} end\n * @param {number} start\n * @param {array} list\n * @return {array}\n *\n * @example\n * import {slice} from '@7urtle/lambda';\n *\n * slice(2)(1)([1, 2, 3, 4, 5]); // => [2]\n * slice(2)(0)([1, 2, 3, 4, 5]); // => [1, 2]\n * slice(8)(7)([1, 2, 3, 4, 5]); // => []\n *\n * // slice can be called both as a curried unary function or as a standard ternary function\n * slice(2)(1)([1, 2, 3, 4, 5]) === slice(2, 1, [1, 2, 3, 4, 5]);\n */\nexport const slice = nary(end => start => list => list.slice(start, end));\n\n/**\n * some outputs true if any element of input array passes input checker function as true.\n *\n * some can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner some :: (a -> boolean) -> [a] -> boolean\n *\n * @pure\n * @param {function} checker\n * @param {array} list\n * @return {boolean}\n *\n * @example\n * import {some} from '@7urtle/lambda';\n *\n * someOf(a => a > 1)([2, 3, 4]); // => true\n * someOf(a => a > 5)([2, 3, 4]); // => false\n *\n * // some can be called both as a curried unary function or as a standard binary function\n * someOf(a => a > 1)([2, 3, 4]) === someOf(a => a > 1, [2, 3, 4]);\n */\nexport const someOf = nary(checker => list => list.some(checker));\n\n/**\n * sort outputs an array sorted based on input compare function.\n *\n * sort can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner sort :: (a -> number) -> [a] -> [a]\n *\n * @pure\n * @param {function} compare\n * @param {array} list\n * @return {array}\n *\n * @example\n * import {sort} from '@7urtle/lambda';\n *\n * sort((a, b) => a < b ? -1 : a > b ? 1 : 0)(['a', 'd', 'c', 'd']); // => ['a', 'c', 'd', 'd']\n * sort((a, b) => a - b)([5, 3, 6]); // => [3, 5, 6]\n *\n * // sort can be called both as a curried unary function or as a standard binary function\n * sort((a, b) => a - b)([5, 3, 6]) === sort((a, b) => a - b, [5, 3, 6]);\n */\nexport const sort = nary(compare => list => [...list].sort(compare));\n\n/**\n * sortAlphabetically outputs an array sorted alphabetically from a to z.\n *\n * @HindleyMilner sortAlphabetically :: [string] -> [string]\n *\n * @pure\n * @param {array} list\n * @return {array}\n *\n * @example\n * import {sortAlphabetically} from '@7urtle/lambda';\n *\n * sortAlphabetically(['petra', 'Martin', 'Petra']); // => ['Martin', 'petra', 'Petra']\n */\nexport const sortAlphabetically = sort((a, b) => (a => b => a < b ? -1 : a > b ? 1 : 0)(upperCaseOf(a))(upperCaseOf(b)));\n\n/**\n * sortAlphabeticallyZA outputs an array sorted alphabetically from z to a.\n *\n * @HindleyMilner sortAlphabeticallyZA :: [string] -> [string]\n *\n * @pure\n * @param {array} list\n * @return {array}\n *\n * @example\n * import {sortAlphabeticallyZA} from '@7urtle/lambda';\n *\n * sortAlphabeticallyZA(['petra', 'Martin', 'Petra']); // => ['petra', 'Petra', 'Martin']\n */\nexport const sortAlphabeticallyZA = sort((a, b) => (a => b => a < b ? 1 : a > b ? -1 : 0)(upperCaseOf(a))(upperCaseOf(b)));\n\n/**\n * sortNumerically outputs an array sorted numerically from 1 to 2.\n *\n * @HindleyMilner sortNumerically :: [number] -> [number]\n *\n * @pure\n * @param {array} list\n * @return {array}\n *\n * @example\n * import {sortNumerically} from '@7urtle/lambda';\n *\n * sortNumerically([3, 4, 1, 3]); // => [1, 3, 3, 4]\n */\nexport const sortNumerically = sort((a, b) => a - b);\n\n/**\n * sortNumerically21 outputs an array sorted numerically from 2 to 1.\n *\n * @HindleyMilner sortNumerically21 :: [number] -> [number]\n *\n * @pure\n * @param {array} list\n * @return {array}\n *\n * @example\n * import {sortNumerically21} from '@7urtle/lambda';\n *\n * sortNumerically21([3, 4, 1, 3]); // => [4, 3, 3, 1]\n */\nexport const sortNumerically21 = sort((a, b) => b - a);\n\n/**\n * headOf outputs the first item (head) from the input array.\n *\n * @HindleyMilner headOf :: [a] -> a\n *\n * @pure\n * @param {array} list\n * @return {any}\n *\n * @example\n * import {headOf} from '@7urtle/lambda';\n *\n * headOf([3, 4, 1, 8]); // => 3\n * headOf([8]); // => 8\n * headOf([]); // => undefined\n */\nexport const headOf = list => list[0];\n\n/**\n * tailOf outputs the the input array without its first item.\n *\n * @HindleyMilner tailOf :: [a] -> []\n *\n * @pure\n * @param {array} list\n * @return {array}\n *\n * @example\n * import {tailOf} from '@7urtle/lambda';\n *\n * tailOf([3, 4, 1, 8]); // => [4, 1, 8]\n * tailOf([8]); // => []\n * tailOf([]); // => []\n */\nexport const tailOf = list => list.slice(1);\n\n/**\n * initOf outputs the the input array without its last item.\n *\n * @HindleyMilner initOf :: [a] -> []\n *\n * @pure\n * @param {array} list\n * @return {array}\n *\n * @example\n * import {initOf} from '@7urtle/lambda';\n *\n * initOf([3, 4, 1, 8]); // => [3, 4, 1]\n * initOf([8]); // => []\n * initOf([]); // => []\n */\nexport const initOf = list => slice(lengthOf(list) -1)(0)(list);\n\n/**\n * lastOf outputs the last item from the input array.\n *\n * @HindleyMilner lastOf :: [a] -> a\n *\n * @pure\n * @param {array} list\n * @return {any}\n *\n * @example\n * import {lastOf} from '@7urtle/lambda';\n *\n * lastOf([3, 4, 1, 8]); // => 8\n * lastOf([3]); // => 3\n * lastOf([]); // => undefined\n */\nexport const lastOf = list => list[lengthOf(list) -1];\n\n/**\n * groupBy outputs an objects with groups produced by an input function over input list.\n *\n * groupBy can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner groupBy :: (a -> b) -> [a] -> {b: a}\n *\n * @pure\n * @param {function} fn\n * @param {array} list\n * @return {object}\n *\n * @example\n * import {groupBy} from '@7urtle/lambda';\n *\n * groupBy(a => a.length)(['one', 'two', 'three']);\n * // => {\"3\": [\"one\", \"two\"], \"5\": [\"three\"]}\n *\n * groupBy(a => a % 2)([1, 2, 3]);\n * // =>  {\"0\": [2], \"1\": [1, 3]}\n *\n * // groupBy can be called both as a curried unary function or as a standard binary function\n * groupBy(a => a.length)(['one', 'two', 'three']) === groupBy(a => a.length, ['one', 'two', 'three'])\n */\nexport const groupBy = nary(fn => list =>\n    reduce\n    ({})\n    ((acc, current) =>\n        (acc[fn(current)] = acc[fn(current)] || []).push(current) && acc\n    )\n    (list));\n\n/**\n * randomOf outputs a random item from the input array.\n *\n * @HindleyMilner randomOf :: [a] -> a\n *\n * @pure\n * @param {array} list\n * @return {any}\n *\n * @example\n * import {randomOf} from '@7urtle/lambda';\n *\n * randomOf([3, 4, 1, 8]); // => 8\n * randomOf([3]); // => 3\n * randomOf([]); // => undefined\n */\nexport const randomOf = list => list[Math.floor(Math.random() * lengthOf(list))];","import {deepInspect} from \"./utils.js\";\nimport {isUndefined} from \"./conditional.js\";\n\n/**\n * Case is a monad that helps you with conditional processing.\n *\n * Case expects an array of key-value pairs as its input. Case.match then matches against a key to provide its value.\n *\n * Case is internally build on a JavaScript map and turns it into an applicative functor monad.\n *\n * @example\n * import {Case, upperCaseOf, liftA2} from '@7urtle/lambda';\n *\n * // in the example we define Case using key-value pairs. Case.of() outputs an instance of Case.\n * const myCase = Case.of([[1, 'one'], ['key', 'value'], ['_', 'fallback']]);\n *\n * // you reach a value by matching keys using Case.match\n * myCase.match(1); // => 'one'\n * myCase.match('key'); // => 'value'\n * myCase.match('nope'); // => 'fallback'\n *\n * // if no fallback is defined and no key is matched, we return undefined\n * Case.of([]).match('nope'); // => undefined\n *\n * // you can also inspect it by\n * myCase.inspect(); // => 'Case(...\n *\n * // as a functor the result is safely mappable (map doesn't execute over undefined matches)\n * myCase.map(value => upperCaseOf(value)).match('key'); // => 'VALUE'\n * Case.of([]).map(upperCaseOf).match('key'); // => undefined\n *\n * // as a monad Case can be safely flat mapped with other Cases (flatMap doesn't execute over undefined)\n * Case.of([[1, 'I am']]).flatMap(a => Case.of([[1, a + ' a turtle']]).match(1); // => 'I am a turtle'\n * Case.of([[1, 'I am']]).flatMap(a => Case.of([])).match(1); // => undefined\n *\n * // as an applicative functor you can apply Cases to each other especially using liftA2 or liftA3\n * const add = a => b => a + b;\n * liftA2(add)(Case.of([[1, 1]]))(Case.of([[1, 2]])).match(1); // => 3\n * Case.of([[1, add]]).ap(Case.of([[1, 'I am']])).ap(Case.of([[1, ' a turtle']])).match(1); // => 'I am a turtle'\n * Case.of([[1, add]]).ap(Case.of([])).ap(Case.of([[1, 'I am']])).match(1); // => undefined\n */\nexport const Case = {\n  of: match => getCase((match => a => match.get(a) || match.get('_') || undefined)(new Map(match)))\n};\n\nconst getCase = match => ({\n  match: match,\n  inspect: () => `Case(${deepInspect(match)})`,\n  map: fn => getCase(a => (result => isUndefined(result) ? result : fn(result))(match(a))),\n  flatMap: fn => getCase(a => (result => isUndefined(result) ? undefined : result.match(a))(getCase(match).map(fn).match(a))),\n  ap: f => getCase(match).flatMap(fn => f.map(fn))\n});","import { deepInspect } from \"./utils.js\";\nimport { nary } from \"./arity.js\";\nimport { isFunction } from \"./conditional.js\";\nimport { map } from \"./core.js\";\n\n/**\n * AsyncEffect is a monad that allows you to safely work with asynchronous side effects in JavaScript.\n *\n * AsyncEffect expects as its input a function that takes two inputs of a reject function, and a resolve\n * function. Reject function is called on failure and resolve function is called on success. It is similar\n * to using JavaScript Promise and AsyncEffect can be directly created from a Promise turning it into a monad.\n *\n * AsyncEffect is evaluated lazily and nothing is executed until a trigger function is called.\n *\n * AsyncEffect can also be called Future monad in other libraries or languages.\n *\n * @example\n * import {AsyncEffect, log, upperCaseOf, liftA2, liftA3} from '@7urtle/lambda';\n *\n * // we create AsyncEffect that expects a number from 0 to 1\n * // and based on that, it resolve or rejects 10 milliseconds after it is triggered\n * const myAsyncEffect = AsyncEffect\n * .of(reject => resolve =>\n *     setTimeout(() => Math.random() > 0.5 ? resolve('random success') : reject('random failure'), 10)\n * );\n *\n * // we could also create AsyncEffect from a function returning JavaScript Promise\n * const myPromise = () => new Promise((resolve, reject) =>\n *     setTimeout(() => Math.random() > 0.5 ? resolve('random success') : reject('random failure'), 10)\n * );\n * const promiseAsyncEffect = AsyncEffect.ofPromise(myPromise);\n *\n * // you can inspect AsyncEffect by\n * myAsyncEffect.inspect(); // => \"AsyncEffect(function...\n *\n * // when you are ready, you can call trigger to trigger the side effect\n * // nothing is executed until the trigger is called\n * myAsyncEffect\n * .trigger\n * (error => log(error))\n * (result => log(result));\n * // => logs 'random success' or 'random failure' depending on Math.random() value\n *\n * // you can also turn AsyncEffect into a JavaScript Promise\n * myAsyncEffect\n * .promise()\n * .then(result => log(result), error => log(error));\n * // => logs 'random success' or 'random failure' depending on Math.random() value\n *\n * // thrown exceptions lead AsyncEffect to reject\n * AsyncEffect\n * .of(() => {\n *     throw 'error';\n * })\n * .trigger(log)(log);\n * // => logs 'error'\n *\n * // as a functor the value inside is safely mappable\n * // map doesn't execute in case of an error and nothing executes until a trigger is called\n * myAsyncEffect\n * .map(value => upperCaseOf(value))\n * .trigger(log)(log);\n * // => logs 'RANDOM SUCCESS' or 'random failure' depending on Math.random() value\n *\n * // as a monad AsyncEffect can be safely flat mapped with other AsyncEffects\n * // flatMap doesn't execute in case of an error and nothing executes until a trigger is called\n * AsyncEffect\n * .of(reject => resolve => resolve('7urtle'))\n * .flatMap(a => AsyncEffect.of(reject => resolve => resolve(a + 's')))\n * .trigger(log)(log);\n * // => logs '7urtles'\n *\n * // as an applicative functor you can apply AsyncEffects to each other especially using liftA2 or liftA3\n * const add = a => b => a + b;\n * const AS1 = AsyncEffect.of(reject => resolve => resolve(1));\n * const AS2 = AsyncEffect.of(reject => resolve => resolve(2));\n * liftA2(add)(AS1)(AS2); // => resolve(3)\n *\n * const ASFail = AsyncEffect.of(() => {throw 'error'});\n * liftA3(add)(ASFail)(AS1)(AS2); // => reject('error')\n *\n * // AsyncEffect.of as well as AsyncEffect.trigger accept both curried and binary functions\n * AsyncEffect.of((reject, resolve) => resolve('7urtle')).trigger(log, log); // logs '7urtle'\n *\n * // as an example you can use AsyncEffect to help you work with axios or fs\n *\n * // axios example\n * import axios from 'axios';\n * const getFromURL = url => AsyncEffect.ofPromise(() => axios.get(url));\n *\n * getFromURL('/my/ajax/url')\n * .trigger\n * (error => log(error))\n * (result => log(result.data));\n *\n * // reading file example\n * import fs from 'fs';\n * const readFile => input =>\n *     AsyncEffect\n *     .of(reject => resolve =>\n *         fs.readFile(input, (err, data) =>\n *             err ? reject(err) : resolve(data)\n *         )\n *     );\n *\n * readFile('./file.txt')\n * .trigger\n * (error => log(error))\n * (result => log(result));;\n */\nexport const AsyncEffect = {\n  of: trigger => getAsyncEffect(nary(reject => resolve => {\n    try {\n      const result = trigger(reject, resolve);\n      return isFunction(result) ? result(resolve) : result;\n    } catch(error) {\n      reject(error);\n    }\n  })),\n  ofPromise: promise => AsyncEffect.of(reject => resolve =>\n      promise().then(resolve).catch(reject)\n  )\n};\n\nconst getAsyncEffect = trigger => ({\n  trigger: trigger,\n  inspect: () => `AsyncEffect(${deepInspect(trigger)})`,\n  promise: () => new Promise((resolve, reject) => trigger(reject)(resolve)),\n  map: fn => getAsyncEffect(nary(reject => resolve => trigger(reject)(a => resolve(fn(a))))),\n  flatMap: fn => getAsyncEffect(nary(reject => resolve => trigger(reject)(x => fn(x).trigger(reject)(resolve)))),\n  ap: f => getAsyncEffect(trigger).flatMap(fn => f.map(fn))\n});\n\n/**\n * mergeAsyncEffects outputs AsyncEffect which resolves with array of all input AsyncEffects or rejects with the first effect rejected.\n *\n * @HindleyMilner mergeAsyncEffects :: ([AsyncEffect]) -> AsyncEffect\n *\n * @pure\n * @param {AsyncEffect} asyncEffects\n * @return {AsyncEffect}\n *\n * @example\n * import { mergeAsyncEffects, AsyncEffect } from '@7urtle/lambda';\n * \n * const resolvingOne = AsyncEffect.of(_ => resolve => resolve('Resolving One'));\n * const resolvingTwo = AsyncEffect.of(_ => resolve => resolve('Resolving Two'));\n *\n * mergeAsyncEffects(resolvingOne, resolvingTwo)\n * .trigger(console.log)(console.log);\n * // => logs ['Resolving One', 'Resolving Two']\n * \n * const rejectingOne = AsyncEffect.of(reject => _ => reject('Rejecting One'));\n * const rejectingTwo = AsyncEffect.of(reject => _ => reject('Rejecting Two'));\n * \n * mergeAsyncEffects(resolvingOne, rejectingOne, rejectingTwo, resolvingTwo)\n * .trigger(console.log)(console.log);\n * // => logs 'Rejecting One'\n */\nexport const mergeAsyncEffects = (...asyncEffects) =>\n  AsyncEffect\n  .ofPromise(\n      () => Promise.all(map(a => a.promise())(asyncEffects))\n  );","import { deepInspect } from \"./utils.js\";\nimport { Maybe, Nothing } from './Maybe.js';\nimport { Either } from './Either.js';\nimport { AsyncEffect } from './AsyncEffect.js';\n\n/**\n * SyncEffect is a monad that allows you to safely work with synchronous side effects in JavaScript.\n *\n * SyncEffect expects as its input a function.\n *\n * SyncEffect is evaluated lazily and nothing is executed until a trigger function is called. It does not have any inner error/exception handling\n * mechanism for the effects of the trigger. Consider using the monads Maybe and Either for managing\n * the results of the trigger.\n *\n * In other languages and framework, SyncEffect can be also called the IO monad.\n *\n * @example\n * import {SyncEffect, log, upperCaseOf, liftA2, Either, isNull} from '@7urtle/lambda';\n *\n * // we create SyncEffect that expects a number from 0 to 1\n * // and based on that, it returns a value or throws an error\n * const throwError = () => {throw 'random failure'};\n * const dangerousFunction = value => value > 0.5 ? 'random success' : throwError();\n * const mySyncEffect = SyncEffect.of(dangerousFunction);\n *\n * // when you are ready, you can call trigger to trigger the side effect\n * // nothing is executed until the trigger is called\n * mySyncEffect.trigger(Math.random());\n * // => returns 'random success' or throws 'random failure' depending on Math.random() value\n *\n * // you can inspect SyncEffect by\n * mySyncEffect.inspect(); // => \"SyncEffect(function...\n *\n * // as a functor the value inside is safely mappable\n * // map doesn't execute in case of an error and nothing executes until a trigger is called\n * mySyncEffect\n * .map(value => upperCaseOf(value))\n * .trigger(Math.random());\n * // => returns 'RANDOM SUCCESS' or throws 'random failure' depending on Math.random() value\n *\n * // as a monad SyncEffect can be safely flat mapped with other SyncEffects\n * // flatMap doesn't execute in case of an error and nothing executes until a trigger is called\n * SyncEffect.of(() => '7turtle').flatMap(a => SyncEffect.of(() => a + 's')).trigger();\n * // => '7urtles'\n * SyncEffect.of(() => {throw 'error'}).flatMap(a => SyncEffect.of(() => a + 's')).trigger();\n * // => throws 'error'\n *\n * // as an applicative functor you can apply SyncEffects to each other especially using liftA2 or liftA3\n * const add = a => b => a + b;\n * liftA2(add)(SyncEffect.of(() => 1)(SyncEffect.of(() => 2)).trigger(); // => 3\n * SyncEffect.of(() => add).ap(SyncEffect.of(() => 1)).ap(SyncEffect.of(() => 2)).trigger(); // => 3\n *\n * // in practice you can use SyncEffect to work for example with DOM\n * const DOMSyncEffect = SyncEffect.of(targetID => document.querySelector(targetID));\n * const TopOffsetSyncEffect = DOMSyncEffect.map(a => a.offsetTop);\n * const ClientHeightSyncEffect = DOMSyncEffect.map(a => a.clientHeight);\n *\n * TopOffsetSyncEffect.trigger('article'); // 1280\n * Either.try(ClientHeightSyncEffect.trigger('#dontexist')); // Failure('Uncaught TypeError: Cannot read property 'offsetTop' of null')\n */\nexport const SyncEffect = {\n  of: trigger => getSyncEffect(trigger)\n};\n\nconst getSyncEffect = trigger => ({\n  trigger: trigger,\n  inspect: () => `SyncEffect(${deepInspect(trigger)})`,\n  map: fn => getSyncEffect(a => fn(trigger(a))),\n  flatMap: fn => getSyncEffect(() => getSyncEffect(trigger).map(fn).trigger().trigger()),\n  ap: f => getSyncEffect(trigger).flatMap(fn => f.map(fn))\n});\n\n/**\n * syncEffectToMaybe converts any SyncEffect monad to a Maybe monad with\n * Maybe Nothing if SyncEffect throws an error.\n *\n * @HindleyMilner syncEffectToMaybe :: SyncEffect -> Maybe\n *\n * @pure\n * @param {SyncEffect} syncEffectMonad\n * @return {Maybe}\n *\n * @example\n * import { syncEffectToMaybe, SyncEffect } from '@7urtle/lambda';\n *\n * eitherToMaybe(SyncEffect.of(() => '7urtle')); // => Just('7urtle')\n * eitherToMaybe(SyncEffect.of(() => undefined)); // => Nothing\n * eitherToMaybe(SyncEffect.of(() => { throw 'I am an error.'; }))); // => Nothing\n */\nexport const syncEffectToMaybe = syncEffectMonad => {\n  try {\n    return Maybe.of(syncEffectMonad.trigger());\n  } catch(error) {\n    return Nothing;\n  }\n};\n\n/**\n * syncEffectToEither converts any SyncEffect monad to an Either monad with\n * Either Failure containing SyncEffect thrown error.\n *\n * @HindleyMilner syncEffectToEither :: SyncEffect -> Either\n *\n * @pure\n * @param {SyncEffect} syncEffectMonad\n * @return {Either}\n *\n * @example\n * import { syncEffectToEither, SyncEffect } from '@7urtle/lambda';\n *\n * syncEffectToEither(SyncEffect.of(() => '7urtle')); // => Success('7urtle')\n * syncEffectToEither(SyncEffect.of(() => { throw 'I am an error.'; })); // => Failure('I am an error.')\n */\nexport const syncEffectToEither = syncEffectMonad => Either.try(syncEffectMonad.trigger);\n\n/**\n * syncEffectToAsyncEffect converts any SyncEffect monad to a AsyncEffect monad with\n * AsyncEffect rejecting thrown error.\n *\n * @HindleyMilner syncEffectToAsyncEffect :: SyncEffect -> AsyncEffect\n *\n * @pure\n * @param {SyncEffect} syncEffectMonad\n * @return {AsyncEffect}\n *\n * @example\n * import { syncEffectToAsyncEffect, SyncEffect } from '@7urtle/lambda';\n *\n * syncEffectToAsyncEffect(SyncEffect.of(() => '7urtle')); // resolves to '7urtle'\n * syncEffectToAsyncEffect(SyncEffect.of(() => { throw 'I am an error.'; })); // rejects 'I am an error.'\n */\n export const syncEffectToAsyncEffect = syncEffectMonad => \n  AsyncEffect\n  .of(_ => resolve =>\n    resolve(syncEffectMonad.trigger())\n  );","import { deepInspect } from './utils.js';\nimport { nary } from './arity.js';\nimport { reduce } from './list.js';\nimport { Maybe, Nothing } from './Maybe.js';\nimport { SyncEffect } from './SyncEffect.js';\nimport { AsyncEffect } from './AsyncEffect.js';\n\nexport const Failure = value => ({\n  value: value,\n  inspect: () => `Failure(${deepInspect(value)})`,\n  isFailure: () => true,\n  isSuccess: () => false,\n  map: () => Failure(value),\n  flatMap: () => Failure(value),\n  catchMap: fn => Failure(fn(value)),\n  bimap: nary(leftFn => _ => Failure(leftFn(value))),\n  ap: () => Failure(value),\n  orOf: a => Success(a),\n  orElse: fn => fn(),\n  orTry: fn => Either.try(fn)\n});\n\nexport const Success = value => ({\n  value: value,\n  inspect: () => `Success(${deepInspect(value)})`,\n  isFailure: () => false,\n  isSuccess: () => true,\n  map: fn => Success(fn(value)),\n  catchMap: () => Success(value),\n  bimap: nary(_ => rightFn => Success(rightFn(value))),\n  flatMap: fn => fn(value),\n  ap: m => m.map(value),\n  orOf: () => Success(value),\n  orElse: () => Success(value),\n  orTry: () => Success(value)\n});\n\n/**\n * Either is an excellent monad for handling error states and it is fairly similar to our monad Maybe. Either.Failure\n * represents an error state and Either.Success represents a success state.\n *\n * Either.of expects a value as its input. Either.of is the same as Either.Success. You can initiate Either\n * in its error state by Either.Failure.\n *\n * You can also initiate it using Either.try which expects a function as an input. It is Failure if an error\n * or exception is thrown. It is Success if there are no errors or exceptions.\n *\n * Either is called Either because it allows you to branch based on an error state. You want to use Either\n * for situations when you don't know whether there might be an error. It makes the very visible that an error\n * can occur and it forces the consumer to handle the situation.\n *\n * @example\n * import {either, Either, Success, Failure, upperCaseOf, liftA2} from '@7urtle/lambda';\n *\n * // in the example we randomly give Either a value or throw an error. Either.try() outputs an instance of Either.\n * const myEither = Either.try(() => Math.random() > 0.5 ? 'random success' : throw 'random failure');\n *\n * // you can also return Either.Failure or Either.Success based on a function logic\n * const myFunction = Math.random() > 0.5 ? Either.Success('random success') : Either.Failure('random failure');\n * \n * // Success and Failure can be called directly\n * Success('7urtle') === Either.Success('7urtle'); // => true\n * Success('7urtle') === Either.of('7urtle'); // => true\n * Failure('error') === Either.Failure('error'); // => true\n *\n * // you could access the actual value like this\n * myEither.value; // => 'random success' or 'random failure'\n *\n * // you can also inspect it by\n * myEither.inspect(); // => \"Success('random success')\" or Failure('random failure')\n *\n * // Either.of and Either.Success both represent success states\n * Either.of('some value').inspect() === Success('some value').inspect(); // => true\n *\n * // you can check if the value is Failure\n * myEither.isFailure(); // => true or false\n * Either.of('abc').isFailure(); // => false\n * Success('anything').isFailure(); // => false\n * Failure('anything').isFailure(); // => true\n * Either.try(() => {throw 'error'}).isFailure(); // => true\n *\n * // you can check if the value is Success\n * myEither.isSuccess(); // => true or false\n * Either.of('abc').isSuccess(); // => true\n * Success('anything').isSuccess(); // => true\n * Failure('anything').isSuccess(); // => false\n * Either.try(() => {throw 'error'}).isSuccess(); // => false\n *\n * // as a functor the value inside is safely mappable (map doesn't execute over Failure)\n * myEither.map(value => upperCaseOf(value));\n * myEither.inspect(); // => \"Success('RANDOM SUCCESS')\" or \"Failure('random failure')\"\n *\n * // as a monad Either can be safely flat mapped with other Eithers (flatMap doesn't execute over Failure)\n * Either.of(3).flatMap(a => Either.of(a + 2)).inspect(); // => 'Success(5)'\n * Failure(3).flatMap(a => Either.of(null)).inspect(); // => 'Failure(3)'\n * Either.of(3).flatMap(a => a + 2); // => 5\n * \n * // you can use catchMap if you want to map over Failure\n * Failure('error').catchMap(a => a + 's'); // => Failure('errors')\n * Success('7urtle').catchMap(a => a + 's'); // => Success('7urtle') \n * \n * // you can use bimap to map over both Success and Failure with different functions\n * Failure('error').bimap(a + ' is left')(a => a + ' is right');  // => Failure('error is left')\n * Succcess('7urtle').bimap(a + ' is left')(a => a + ' is right'); // => Success('7urtle is right')\n * \n * // orOf(a) replaces Failure with Success\n * Failure('error').orOf('7urtles'); // => Success('7urtle')\n * Success('7urtle').orOf('tortoise'); // => Success('7urtle')\n * \n * // orElse(a -> Either) replaces Failure with the output of orElse function\n * Failure('error').orElse(() => Success('7urtle')); // => Success('7urtle')\n * Success('7urtle').orElse(() => Success('tortoise')); // => Success('7urtle')\n * \n * // orTry(a -> b) replaces original Fairlure with Either.try\n * Failure('error').orTry(() => { throw 'i am an error'; }); // => Failure('i am an error')\n * Failure('error').orTry(() => '7urtle'); // => Success('7urtle')\n * Success('7urtle').orTry(() => { throw 'i am an error'; }); // => Success('7urtle')\n *\n * // as an applicative functor you can apply Eithers to each other especially using liftA2 or liftA3\n * const add = a => b => a + b;\n * liftA2(add)(Either.of(2))(Either.of(3)); // => Success(5)\n * Either.of(1).map(add).ap(Either.of(2)).inspect(); // => 'Success(3)'\n * Failure(1).map(add).ap(Either.of(2)).inspect(); // => 'Failure(1)'\n * Either.of(add).ap(Either.of(1)).ap(Either.of(2)).inspect(); // => 'Success(3)'\n */\nexport const Either = {\n  of: value => Success(value),\n  Success: value => Success(value),\n  Failure: value => Failure(value),\n  try: fn => {\n    try {\n      return Success(fn());\n    } catch(error) {\n      return Failure(error.message || error);\n    }\n  }\n};\n\n/**\n * either outputs result of a function onRight if input Either is Success or outputs result of a function onLeft if input Either is Failure.\n *\n * either can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner either :: (a -> b) -> (b -> c) -> Either\n *\n * @pure\n * @param {function} onFailure\n * @param {function} onSuccess\n * @param {Either} functorEither\n * @return {*}\n *\n * @example\n * import {either, Either} from '@7urtle/lambda';\n *\n * either(a => 'error ' + a)(a => 'success ' + a)(Either.of('abc')); // => 'success abc'\n * either(a => 'error ' + a)(a => 'success ' + a)(Either.Failure('failure')); // => 'error failure'\n * either(a => 'error ' + a)(a => 'success ' + a)(Either.try(() => throw 'failure')); // => 'error failure'\n *\n * // either can be called both as a curried unary function or as a standard ternary function\n * either(a => 'error ' + a)(a => 'success ' + a)(Either.of('abc')) === either(a => 'error ' + a, a => 'success ' + a, Either.of('abc'));\n */\nexport const either = nary(onFailure => onSuccess => functorEither =>\n  functorEither.isFailure()\n    ? onFailure(functorEither.value)\n    : onSuccess(functorEither.value)\n);\n\n/**\n * mergeEithers outputs Either of array with all Either values depending whether they are Success or Failure.\n *\n * @HindleyMilner mergeEithers :: ([Either]) -> Either\n *\n * @pure\n * @param {Either} eithers\n * @return {Either}\n *\n * @example\n * import { mergeEithers, Either } from '@7urtle/lambda';\n *\n * mergeEithers(Either.of('abc'), Either.of('def')); //  => Success(['abc', 'def'])\n * mergeEithers(Either.of('abc'), Either.Failure('def')); // => Failure(['def'])\n * mergeEithers(Either.Failure('abc'), Either.of('def')); // => Failure(['abc'])\n * mergeEithers(Either.Failure('abc'), Either.Failure('def')); // => Failure(['abc', 'def'])\n */\nexport const mergeEithers = (...eithers) =>\n  reduce\n  (Success([]))\n  ((accumulator, current) =>\n    current.isFailure()\n    ? accumulator.isFailure() // current Either is Failure\n      ? Failure([...accumulator.value, current.value]) // accumulator is Failure and current is Failure => update accumulator\n      : Failure([current.value]) // accumulator is Success and current is Failure => return first Failure\n    : accumulator.isFailure() // current Either is Success\n      ? accumulator // accumulator is Failure and current is Success => return accumulator\n      : Success([...accumulator.value, current.value]) // accumulator is Success and current is Success => update accumulator\n  )\n  (eithers);\n\n/**\n * validateEithers outputs Either of input value if all input functions returns Success or Failure\n * with array of error messages.\n *\n * @HindleyMilner validateEithers :: ([a -> b]) -> a -> Either\n *\n * @pure\n * @param {functions} fns\n * @param {*} input\n * @return {Either}\n *\n * @example\n * import { validateEithers, Either, isAtLeast, lengthOf } from '@7urtle/lambda';\n *\n * // mergeEithers is great to be used for validations\n * const isPasswordLongEnough = password =>\n *  isAtLeast(6)(lengthOf(password))\n *  ? Either.Success(password)\n *  : Either.Failure('Password must have more than 6 characters.');\n * \n * const isPasswordStrongEnough = password =>\n *  /[\\W]/.test(password)\n *  ? Either.Success(password)\n *  : Either.Failure('Password must contain special characters.');\n * \n * const validatePassword = validateEithers(isPasswordLongEnough, isPasswordStrongEnough);\n * \n * validatePassword('LongPa$$word'); // => Success('LongPa$$word')\n * validatePassword('Pa$$'); // => Failure(['Password must have more than 6 characters.'])\n * validatePassword('LongPassword'); // => Failure(['Password must contain special characters.'])\n * validatePassword('Pass'); // => Failure(['Password must have more than 6 characters.', 'Password must contain special characters.'])\n */\nexport const validateEithers = (...fns) => input =>\n  reduce\n  (Success(input))\n  ((accumulator, currentFn) =>\n    (currentResult =>\n      currentResult.isFailure()\n      ? accumulator.isFailure() // currentResult Either is Failure\n        ? Failure([...accumulator.value, currentResult.value]) // accumulator is Failure and currentResult is Failure => update accumulator\n        : Failure([currentResult.value]) // accumulator is Success and currentResult is Failure => return first Failure\n      : accumulator // currentResult Either is Success\n    )(currentFn(input))\n  )\n  (fns);\n\n/**\n * eitherToMaybe converts any Either monad to a Maybe monad with\n * Maybe Nothing if Either is Failure.\n *\n * @HindleyMilner eitherToMaybe :: Either -> Maybe\n *\n * @pure\n * @param {Either} eitherMonad\n * @return {Maybe}\n *\n * @example\n * import { eitherToMaybe, Either } from '@7urtle/lambda';\n *\n * eitherToMaybe(Either.Success('7urtle')); // => Just('7urtle')\n * eitherToMaybe(Either.Success(undefined)); // => Nothing\n * eitherToMaybe(Either.Failure('I am an error.')); // => Nothing\n * eitherToMaybe(Either.Failure('I am an error.')).value; // => 'I am an error.'\n */\nexport const eitherToMaybe = eitherMonad =>\n  either\n  (() => Nothing)\n  (value => Maybe.of(value))\n  (eitherMonad);\n\n/**\n * eitherToSyncEffect converts any Either monad to a SyncEffect monad with\n * error thrown on trigger if Either is Failure.\n *\n * @HindleyMilner eitherToSyncEffect :: Either -> SyncEffect\n *\n * @pure\n * @param {Either} eitherMonad\n * @return {SyncEffect}\n *\n * @example\n * import { eitherToSyncEffect, Either } from '@7urtle/lambda';\n *\n * eitherToSyncEffect(Either.Success('7urtle')).trigger(); // => '7urtle'\n * eitherToSyncEffect(Either.Failure('I am an error.')).trigger(); // throws 'I am an error.'\n */\nexport const eitherToSyncEffect = eitherMonad =>\n  either\n  (error => SyncEffect.of(() => { throw error; }))\n  (value => SyncEffect.of(() => value))\n  (eitherMonad);\n\n/**\n * eitherToAsyncEffect converts any Either monad to a AsyncEffect monad with\n * rejected error if Either is Failure.\n *\n * @HindleyMilner eitherToAsyncEffect :: Either -> AsyncEffect\n *\n * @pure\n * @param {Either} eitherMonad\n * @return {AsyncEffect}\n *\n * @example\n * import { eitherToAsyncEffect, Either } from '@7urtle/lambda';\n *\n * eitherToAsyncEffect(Either.Success('7urtle')); // resolves to '7urtle'\n * eitherToAsyncEffect(Either.Failure('I am an error.')); // rejects 'I am an error.'\n */\nexport const eitherToAsyncEffect = eitherMonad =>\n  either\n  (error => AsyncEffect.of(reject => _ => reject(error)))\n  (value => AsyncEffect.of(_ => resolve => resolve(value)))\n  (eitherMonad);","import { deepInspect } from './utils.js';\nimport { nary } from './arity.js';\nimport { isNothing } from './conditional.js';\nimport { reduce } from './list.js';\nimport { Failure, Success } from './Either.js';\nimport { SyncEffect } from './SyncEffect.js';\nimport { AsyncEffect } from './AsyncEffect.js';\n\nexport const Nothing = {\n  value: null,\n  inspect: () => 'Nothing',\n  isNothing: () => true,\n  isJust: () => false,\n  map: () => Nothing,\n  flatMap: () => Nothing,\n  ap: () => Nothing\n};\n\nexport const Just = value => ({\n  value: value,\n  inspect: () => `Just(${deepInspect(value)})`,\n  isNothing: () => false,\n  isJust: () => true,\n  map: fn => Maybe.of(fn(value)),\n  flatMap: fn => fn(value),\n  ap: f => f.map(value)\n});\n\n/**\n * Maybe is one of the simplest and well known monads. Maybe is also quite similar to our monad Either.\n *\n * Maybe expects a value as its input. It is Nothing if the value is null, undefined, or empty. It returns\n * Just for all other cases.\n *\n * Maybe is called Maybe because it maybe holds a value. You want to use Maybe for situations when you don't\n * know whether there is going to be an input. For example for your API endpoint, it makes it very obvious\n * that you service may not receive a value by mistake and forces the consumer of Maybe to safely deal with it.\n *\n * In other languages, Maybe monad can also be called Option monad or Nullable monad.\n *\n * @example\n * import {maybe, Maybe, Just, Nothing, upperCaseOf, liftA2, flatMap, compose, startsWith} from '@7urtle/lambda';\n *\n * // in the example we randomly give Maybe a value or undefined. Maybe.of() outputs an instance of Maybe.\n * const myMaybe = Maybe.of(Math.random() > 0.5 ? 'random success' : undefined);\n * \n * // you can use Just and Nothing directly\n * Just('7urtle') === Maybe.of('7urtle'); // => true\n * Just('7urte') === Maybe.Just('7urtle'); // => true\n * Nothing === Maybe.of(undefined); // => true\n * Nothing === Maybe.Nothing; // => true\n *\n * // you could access the actual value like this\n * myMaybe.value; // => 'random success' or undefined\n *\n * // you can also inspect it by\n * myMaybe.inspect(); // => \"Just('random success')\" or \"Nothing\"\n *\n * // you can check if the value is Nothing\n * myMaybe.isNothing(); // => true or false\n * Maybe.of('abc').isNothing(); // => false\n * Maybe.of([]).isNothing(); // => true\n * Just('7urtle').isNothing(); // => false\n * Nothing.isNothing(); // => true\n *\n * // you can check if the value is Just\n * myMaybe.isJust(); // => true or false\n * Maybe.of(123).isJust(); // => true\n * Maybe.of(null).isJust(); // => false\n * Just('7urtle').isJust(); // => true\n * Nothing.isJust(); // => false\n *\n * // as a functor the value inside is safely mappable (map doesn't execute over Nothing)\n * myMaybe.map(value => upperCaseOf(value));\n * myMaybe.inspect(); // => \"Just('RANDOM SUCCESS')\" or \"Nothing\"\n *\n * // as a monad Maybe can be safely flat mapped with other Maybes (flatMap doesn't execute over Nothing)\n * Maybe.of(3).flatMap(a => Maybe.of(a + 2)).inspect(); // => 'Just(5)'\n * Maybe.of(3).flatMap(a => Maybe.of(null)).inspect(); // => 'Nothing'\n * Maybe.of(3).flatMap(a => a + 2); // => 5\n *\n * // as an applicative functor you can apply Maybes to each other especially using liftA2 or liftA3\n * const add = a => b => a + b;\n * liftA2(add)(Maybe.of(2))(Maybe.of(3)); // => Just(5)\n * Maybe.of(1).map(add).ap(Maybe.of(2)).inspect(); // => 'Just(3)'\n * Maybe.of(1).map(add).ap(Maybe.of(null)).inspect(); // => 'Nothing'\n * Maybe.of(add).ap(Maybe.of(1)).ap(Maybe.of(2)).inspect(); // => 'Just(3)'\n *\n * // as an example you can use Maybe to help you work with DOM like this\n * Maybe.of(document.querySelector('#iexist')).map(a => a.offsetTop); // => Just(1240)\n * Maybe.of(document.querySelector('#idontexist')).map(a => a.offsetTop); // => Nothing\n * maybe\n * (() => 'error: the object doesnt exist')\n * (offsetTop => 'offset from top is ' + offsetTop)\n * (Maybe.of(document?.querySelector('#iexist')?.offsetTop));\n * \n * // to read API request you can use Maybe this way\n * const getQuery = body =>\n *   flatMap\n *   (a => Maybe.of(a.queryText))\n *   (Maybe.of(body.queryResult));\n * \n * // you can use Maybe, Just, and Nothing as output of your functions\n * const maybeGetEnvironmentVariable = key => Maybe.of(process?.env?[key]);\n * const maybeDIDKeyFromEnvironment =\n *   compose(\n *     flatMap(did => startsWith('did:key')(did) ? Just(did) : Nothing),\n *     maybeGetEnvironmentVariable\n *   );\n */\nexport const Maybe = {\n  of: value => isNothing(value) ? Nothing : Just(value),\n  Just: value => Just(value),\n  Nothing: Nothing\n};\n\n/**\n * maybe outputs result of a function onJust if input Maybe is Just or outputs input error if input Maybe is Nothing.\n *\n * maybe can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner maybe :: (a -> b) -> (c -> d) -> Maybe -> e\n *\n * @pure\n * @param {functioon} onNothing\n * @param {function} onJust\n * @param {Maybe} functorMaybe\n * @return {*}\n *\n * @example\n * import {maybe, Maybe} from '@7urtle/lambda';\n *\n * maybe(() => 'error')(value => value)(Maybe.of('abc')); // => 'abc'\n * maybe(() => 'error')(value => value)(Maybe.of(undefined)); // => 'error'\n * maybe(() => 'error')(() => 'not error)(Maybe.of(undefined)) === Maybe.of(undefined).isNothing() ? 'error' ? 'not error';\n *\n * // maybe can be called both as a curried unary function or as a standard ternary function\n * maybe(() => 'error')(value => value)(Maybe.of('abc')) === maybe('error', value => value, Maybe.of('abc'));\n */\nexport const maybe = nary(onNothing => onJust => functorMaybe =>\n  functorMaybe.isNothing()\n    ? onNothing()\n    : onJust(functorMaybe.value));\n\n/**\n * mergeMaybes outputs Maybe of array with all Maybe values depending whether they are Nothing or Just.\n *\n * @HindleyMilner mergeMaybes :: ([Maybe]) -> Maybe\n *\n * @pure\n * @param {Maybe} maybes\n * @return {Maybe}\n *\n * @example\n * import { mergeMaybes, Nothing, Just, Maybe } from '@7urtle/lambda';\n *\n * mergeMaybes(Maybe.of('abc'), Just('def')); //  => Just(['abc', 'def'])\n * mergeMaybes(Maybe.of('abc'), Nothing); // => Nothing\n * mergeMaybes(Nothing, Maybe.of('def')); // => Nothing\n * mergeMaybes(Nothing, Nothing); // => Nothing\n */\nexport const mergeMaybes = (...maybes) =>\n  reduce\n  (Just([]))\n  ((accumulator, current) =>\n    current.isNothing()\n    ? Nothing\n    : accumulator.isNothing()\n      ? Nothing\n      : Just([...accumulator.value, current.value])\n  )\n  (maybes);\n\n/**\n * maybeToEither converts any Maybe monad to an Either monad with\n * 'Maybe is Nothing.' Failure if the Maybe is Nothing.\n *\n * @HindleyMilner maybeToEither :: Maybe -> Either\n *\n * @pure\n * @param {Maybe} maybeMonad\n * @return {Either}\n *\n * @example\n * import { maybeToEither, Maybe } from '@7urtle/lambda';\n *\n * maybeToEither(Maybe.of('7urtle')); // => Success('7urtle')\n * maybeToEither(Maybe.of(undefined)); // => Failure('Maybe is Nothing.')\n */\nexport const maybeToEither = maybeMonad =>\n  maybe\n  (() => Failure('Maybe is Nothing.'))\n  (value => Success(value))\n  (maybeMonad);\n\n/**\n * maybeToSyncEffect converts any Maybe monad to an SyncEffect monad with\n * 'Maybe is Nothing.' thrown error if the Maybe is Nothing.\n *\n * @HindleyMilner maybeToSyncEffect :: Maybe -> SyncEffect\n *\n * @pure\n * @param {Maybe} maybeMonad\n * @return {SyncEffect}\n *\n * @example\n * import { maybeToSyncEffect, Maybe } from '@7urtle/lambda';\n *\n * maybeToSyncEffect(Maybe.of('7urtle')).trigger(); // => '7urtle'\n * maybeToSyncEffect(Maybe.of(undefined)).trigger(); // throws 'Maybe is Nothing.'\n */\nexport const maybeToSyncEffect = maybeMonad =>\n  maybe\n  (() => SyncEffect.of(() => { throw 'Maybe is Nothing.' }))\n  (value => SyncEffect.of(() => value))\n  (maybeMonad);\n\n/**\n * maybeToAsyncEffect converts any Maybe monad to an AsyncEffect monad with\n * 'Maybe is Nothing.' reject if the Maybe is Nothing.\n *\n * @HindleyMilner maybeToAsyncEffect :: Maybe -> AsyncEffect\n *\n * @pure\n * @param {Maybe} maybeMonad\n * @return {AsyncEffect}\n *\n * @example\n * import { maybeToAsyncEffect, Maybe } from '@7urtle/lambda';\n *\n * maybeToAsyncEffect(Maybe.of('7urtle')); // resolves to '7urtle'\n * maybeToAsyncEffect(Maybe.of(undefined)); // rejects 'Maybe is Nothing.'\n */\nexport const maybeToAsyncEffect = maybeMonad =>\n  maybe\n  (() => AsyncEffect.of(reject => _ => reject('Maybe is Nothing.')))\n  (value => AsyncEffect.of(_ => resolve => resolve(value)))\n  (maybeMonad);"],"names":["root","factory","exports","module","define","amd","this","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","value","nary","fn","_len","arguments","length","args","Array","_key","reduce","accumulator","current","curry","_len2","_key2","apply","_len3","args2","_key3","concat","_arrayLikeToArray","arr","len","i","arr2","_toConsumableArray","isArray","iter","iterator","from","minLen","n","toString","slice","constructor","name","test","TypeError","_typeof","and","predicates","anything","everyOf","predicate","or","someOf","isEqual","a","b","isNotEqual","isDeepEqual","deepInspect","isNotDeepEqual","isTrue","isFalse","isGreaterThan","isLessThan","isAtLeast","isAtMost","isBetween","c","isInRange","isTypeOf","typeOf","isNotTypeOf","isString","isNotString","isBoolean","isNotBoolean","isNull","isNotNull","isUndefined","isNotUndefined","isNumber","isNotNumber","isObject","isNotObject","isNotArray","isFunction","isNotFunction","isLength","lengthOf","isNotLength","isElement","Element","HTMLDocument","isNotElement","isEmpty","getOwnPropertyNames","isNotEmpty","isZero","isNotZero","isNothing","isJust","when","whenTrueFn","unless","whenFalseFn","ifElse","_defineProperty","t","r","e","toPrimitive","String","configurable","writable","identity","compose","fns","reduceRight","v","f","pipe","map","mapper","flatMap","functor","liftA2","ap1","ap2","ap","liftA3","ap3","_objectSpread","undefined","merge","sources","acc","includes","indexOf","minusOneToUndefined","lastIndexOf","memoize","memory","passThrough","memo","fail","error","log","console","spy","inspectFunction","inspectArray","join","inspectString","inspectObject","inspect","k","keysOf","trim","string","testRegEx","regex","substr","limit","start","firstLetterOf","lastLetterOf","startsWith","substring","endsWith","repeat","count","replace","replacement","search","split","lowerCaseOf","toLowerCase","upperCaseOf","toUpperCase","initial","reducer","list","filter","checker","filterMap","push","find","findIndex","separator","keys","entriesOf","entries","every","end","some","sort","compare","sortAlphabetically","sortAlphabeticallyZA","sortNumerically","sortNumerically21","headOf","tailOf","initOf","lastOf","groupBy","randomOf","Math","floor","random","Case","of","match","getCase","Map","result","AsyncEffect","trigger","getAsyncEffect","reject","resolve","ofPromise","promise","then","Promise","x","mergeAsyncEffects","asyncEffects","all","SyncEffect","getSyncEffect","syncEffectToMaybe","syncEffectMonad","Maybe","Nothing","syncEffectToEither","Either","syncEffectToAsyncEffect","_","Failure","isFailure","isSuccess","catchMap","bimap","leftFn","orOf","Success","orElse","orTry","rightFn","m","try","message","either","onFailure","onSuccess","functorEither","mergeEithers","eithers","validateEithers","input","currentFn","currentResult","eitherToMaybe","eitherMonad","eitherToSyncEffect","eitherToAsyncEffect","Just","maybe","onNothing","onJust","functorMaybe","mergeMaybes","maybes","maybeToEither","maybeMonad","maybeToSyncEffect","maybeToAsyncEffect"],"sourceRoot":""}