{"version":3,"sources":["webpack:///./presentation/utils/createImageAlt.ts","webpack:///../node_modules/ramda/es/flip.js","webpack:///../node_modules/ramda/es/add.js","webpack:///../node_modules/ramda/es/divide.js","webpack:///../node_modules/ramda/es/sum.js","webpack:///../node_modules/ramda/es/mean.js","webpack:///../node_modules/ramda/es/median.js","webpack:///../node_modules/ramda/es/modulo.js","webpack:///../node_modules/ramda/es/multiply.js","webpack:///../node_modules/ramda/es/subtract.js","webpack:///../node_modules/ramda/es/gt.js","webpack:///../node_modules/ramda/es/gte.js","webpack:///../node_modules/ramda/es/lt.js","webpack:///../node_modules/ramda/es/lte.js","webpack:///../node_modules/ramda/es/internal/_xall.js","webpack:///../node_modules/ramda/es/all.js","webpack:///../node_modules/ramda/es/internal/_xany.js","webpack:///../node_modules/ramda/es/any.js","webpack:///../node_modules/ramda/es/times.js","webpack:///../node_modules/ramda/es/nthArg.js","webpack:///../node_modules/ramda/es/sort.js","webpack:///../node_modules/ramda-adjunct/es/stubNull.js","webpack:///../node_modules/ramda/es/identical.js","webpack:///../node_modules/ramda-adjunct/es/isTrue.js","webpack:///../node_modules/ramda-adjunct/es/isFalse.js","webpack:///../node_modules/ramda/es/addIndex.js","webpack:///../node_modules/ramda-adjunct/es/mapIndexed.js","webpack:///../node_modules/ramda-adjunct/es/lengthGt.js","webpack:///../node_modules/ramda/es/empty.js","webpack:///../node_modules/ramda/es/isEmpty.js","webpack:///../node_modules/ramda-adjunct/es/isNilOrEmpty.js","webpack:///../node_modules/@team-griffin/capra/dist/es/capra.js","webpack:///../node_modules/ramda/es/propSatisfies.js"],"names":["hasImage","r","isNotNilOrEmpty","str","image","match","replace","_curry1","fn","curryN","length","a","b","args","Array","prototype","slice","call","arguments","apply","this","_curry2","Number","reduce","list","len","NaN","width","idx","sort","XAll","f","xf","all","_xfBase","init","result","input","_reduced","_dispatchable","XAny","any","n","isNaN","RangeError","arity","nth","comparator","always","_objectIs","origFn","_concat","compareLength","x","constructor","empty","_isArray","_isString","_isObject","_isArguments","equals","either","isNil","curry2","isTrue$1","isFalse$1","complement","filterObjIndexed","ifElse","converge","pipe","obj","mapObjIndexed","v","k","reject","sortObj","keys$$1","keys","assoc","prop","_","aa","bb","propSatisfies","pred","name"],"mappings":"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","file":"pex-static/34/2.9023b7be6b6dd5d032a6.chunk.js","sourcesContent":["/*\n  createImageAlt({\n    illustration: ?String,\n    imageUrl: String,\n  });\n\n  Returns a relevant alt tag text from the URL path\n*/\n\nimport { isNotNilOrEmpty } from '@team-griffin/capra';\nimport * as r from 'ramda';\n\nconst hasImage = r.propSatisfies(isNotNilOrEmpty, 'imageUrl');\n\n/*\n  getImageName\n  From a URL like https://img1.wsimg.com/cdn/Image/All/Website/2/en-GB/ad586f1e-81a0-4a9d-a675-e266e25e965f/Christian_Jaroljmek.jpg\n  return the text between the final slash and dot (Christian_Jaroljmek)\n\n  If no regex match, return the string as is (this will capture illustrations)\n*/\nconst getImageName = (str: string) => {\n  if (typeof str !== 'string') {\n    return '';\n  }\n\n  const image = str.match(/\\/([^/]+?)\\.[a-zA-Z0-9]+$/);\n\n  if (image && image[1]) {\n    return image[1];\n  }\n\n  return str;\n};\n\n/*\n  formatName\n  Replace any underscores and hyphens with whitespace\n*/\nconst formatName = (str: string) => str.replace(/[-_]/g, ' ');\n\n// eslint-disable-next-line no-underscore-dangle\nexport const __test__ = {\n  getImageName,\n  formatName,\n};\n\nexport default r.ifElse(hasImage, r.pipe(r.prop('imageUrl'), getImageName, formatName), r.always(''));\n","import _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Returns a new function much like the supplied one, except that the first two\n * arguments' order is reversed.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((a, b, c, ...) -> z) -> (b -> a -> c -> ... -> z)\n * @param {Function} fn The function to invoke with its first two parameters reversed.\n * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n * @example\n *\n *      const mergeThree = (a, b, c) => [].concat(a, b, c);\n *\n *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n *\n *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n * @symb R.flip(f)(a, b, c) = f(b, a, c)\n */\n\nvar flip =\n/*#__PURE__*/\n_curry1(function flip(fn) {\n  return curryN(fn.length, function (a, b) {\n    var args = Array.prototype.slice.call(arguments, 0);\n    args[0] = b;\n    args[1] = a;\n    return fn.apply(this, args);\n  });\n});\n\nexport default flip;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Adds two values.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a\n * @param {Number} b\n * @return {Number}\n * @see R.subtract\n * @example\n *\n *      R.add(2, 3);       //=>  5\n *      R.add(7)(10);      //=> 17\n */\n\nvar add =\n/*#__PURE__*/\n_curry2(function add(a, b) {\n  return Number(a) + Number(b);\n});\n\nexport default add;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Divides two numbers. Equivalent to `a / b`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The first value.\n * @param {Number} b The second value.\n * @return {Number} The result of `a / b`.\n * @see R.multiply\n * @example\n *\n *      R.divide(71, 100); //=> 0.71\n *\n *      const half = R.divide(R.__, 2);\n *      half(42); //=> 21\n *\n *      const reciprocal = R.divide(1);\n *      reciprocal(4);   //=> 0.25\n */\n\nvar divide =\n/*#__PURE__*/\n_curry2(function divide(a, b) {\n  return a / b;\n});\n\nexport default divide;","import add from \"./add.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Adds together all the elements of a list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig [Number] -> Number\n * @param {Array} list An array of numbers\n * @return {Number} The sum of all the numbers in the list.\n * @see R.reduce\n * @example\n *\n *      R.sum([2,4,6,8,100,1]); //=> 121\n */\n\nvar sum =\n/*#__PURE__*/\nreduce(add, 0);\nexport default sum;","import _curry1 from \"./internal/_curry1.js\";\nimport sum from \"./sum.js\";\n/**\n * Returns the mean of the given list of numbers.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Math\n * @sig [Number] -> Number\n * @param {Array} list\n * @return {Number}\n * @see R.median\n * @example\n *\n *      R.mean([2, 7, 9]); //=> 6\n *      R.mean([]); //=> NaN\n */\n\nvar mean =\n/*#__PURE__*/\n_curry1(function mean(list) {\n  return sum(list) / list.length;\n});\n\nexport default mean;","import _curry1 from \"./internal/_curry1.js\";\nimport mean from \"./mean.js\";\n/**\n * Returns the median of the given list of numbers.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Math\n * @sig [Number] -> Number\n * @param {Array} list\n * @return {Number}\n * @see R.mean\n * @example\n *\n *      R.median([2, 9, 7]); //=> 7\n *      R.median([7, 2, 10, 9]); //=> 8\n *      R.median([]); //=> NaN\n */\n\nvar median =\n/*#__PURE__*/\n_curry1(function median(list) {\n  var len = list.length;\n\n  if (len === 0) {\n    return NaN;\n  }\n\n  var width = 2 - len % 2;\n  var idx = (len - width) / 2;\n  return mean(Array.prototype.slice.call(list, 0).sort(function (a, b) {\n    return a < b ? -1 : a > b ? 1 : 0;\n  }).slice(idx, idx + width));\n});\n\nexport default median;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Divides the first parameter by the second and returns the remainder. Note\n * that this function preserves the JavaScript-style behavior for modulo. For\n * mathematical modulo see [`mathMod`](#mathMod).\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The value to the divide.\n * @param {Number} b The pseudo-modulus\n * @return {Number} The result of `b % a`.\n * @see R.mathMod\n * @example\n *\n *      R.modulo(17, 3); //=> 2\n *      // JS behavior:\n *      R.modulo(-17, 3); //=> -2\n *      R.modulo(17, -3); //=> 2\n *\n *      const isOdd = R.modulo(R.__, 2);\n *      isOdd(42); //=> 0\n *      isOdd(21); //=> 1\n */\n\nvar modulo =\n/*#__PURE__*/\n_curry2(function modulo(a, b) {\n  return a % b;\n});\n\nexport default modulo;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Multiplies two numbers. Equivalent to `a * b` but curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The first value.\n * @param {Number} b The second value.\n * @return {Number} The result of `a * b`.\n * @see R.divide\n * @example\n *\n *      const double = R.multiply(2);\n *      const triple = R.multiply(3);\n *      double(3);       //=>  6\n *      triple(4);       //=> 12\n *      R.multiply(2, 5);  //=> 10\n */\n\nvar multiply =\n/*#__PURE__*/\n_curry2(function multiply(a, b) {\n  return a * b;\n});\n\nexport default multiply;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Subtracts its second argument from its first argument.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The first value.\n * @param {Number} b The second value.\n * @return {Number} The result of `a - b`.\n * @see R.add\n * @example\n *\n *      R.subtract(10, 8); //=> 2\n *\n *      const minus5 = R.subtract(R.__, 5);\n *      minus5(17); //=> 12\n *\n *      const complementaryAngle = R.subtract(90);\n *      complementaryAngle(30); //=> 60\n *      complementaryAngle(72); //=> 18\n */\n\nvar subtract =\n/*#__PURE__*/\n_curry2(function subtract(a, b) {\n  return Number(a) - Number(b);\n});\n\nexport default subtract;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the first argument is greater than the second; `false`\n * otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @see R.lt\n * @example\n *\n *      R.gt(2, 1); //=> true\n *      R.gt(2, 2); //=> false\n *      R.gt(2, 3); //=> false\n *      R.gt('a', 'z'); //=> false\n *      R.gt('z', 'a'); //=> true\n */\n\nvar gt =\n/*#__PURE__*/\n_curry2(function gt(a, b) {\n  return a > b;\n});\n\nexport default gt;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the first argument is greater than or equal to the second;\n * `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {Number} a\n * @param {Number} b\n * @return {Boolean}\n * @see R.lte\n * @example\n *\n *      R.gte(2, 1); //=> true\n *      R.gte(2, 2); //=> true\n *      R.gte(2, 3); //=> false\n *      R.gte('a', 'z'); //=> false\n *      R.gte('z', 'a'); //=> true\n */\n\nvar gte =\n/*#__PURE__*/\n_curry2(function gte(a, b) {\n  return a >= b;\n});\n\nexport default gte;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the first argument is less than the second; `false`\n * otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @see R.gt\n * @example\n *\n *      R.lt(2, 1); //=> false\n *      R.lt(2, 2); //=> false\n *      R.lt(2, 3); //=> true\n *      R.lt('a', 'z'); //=> true\n *      R.lt('z', 'a'); //=> false\n */\n\nvar lt =\n/*#__PURE__*/\n_curry2(function lt(a, b) {\n  return a < b;\n});\n\nexport default lt;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the first argument is less than or equal to the second;\n * `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {Number} a\n * @param {Number} b\n * @return {Boolean}\n * @see R.gte\n * @example\n *\n *      R.lte(2, 1); //=> false\n *      R.lte(2, 2); //=> true\n *      R.lte(2, 3); //=> true\n *      R.lte('a', 'z'); //=> true\n *      R.lte('z', 'a'); //=> false\n */\n\nvar lte =\n/*#__PURE__*/\n_curry2(function lte(a, b) {\n  return a <= b;\n});\n\nexport default lte;","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XAll =\n/*#__PURE__*/\nfunction () {\n  function XAll(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.all = true;\n  }\n\n  XAll.prototype['@@transducer/init'] = _xfBase.init;\n\n  XAll.prototype['@@transducer/result'] = function (result) {\n    if (this.all) {\n      result = this.xf['@@transducer/step'](result, true);\n    }\n\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XAll.prototype['@@transducer/step'] = function (result, input) {\n    if (!this.f(input)) {\n      this.all = false;\n      result = _reduced(this.xf['@@transducer/step'](result, false));\n    }\n\n    return result;\n  };\n\n  return XAll;\n}();\n\nvar _xall =\n/*#__PURE__*/\n_curry2(function _xall(f, xf) {\n  return new XAll(f, xf);\n});\n\nexport default _xall;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xall from \"./internal/_xall.js\";\n/**\n * Returns `true` if all elements of the list match the predicate, `false` if\n * there are any that don't.\n *\n * Dispatches to the `all` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> Boolean\n * @param {Function} fn The predicate function.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n *         otherwise.\n * @see R.any, R.none, R.transduce\n * @example\n *\n *      const equals3 = R.equals(3);\n *      R.all(equals3)([3, 3, 3, 3]); //=> true\n *      R.all(equals3)([3, 3, 1, 3]); //=> false\n */\n\nvar all =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['all'], _xall, function all(fn, list) {\n  var idx = 0;\n\n  while (idx < list.length) {\n    if (!fn(list[idx])) {\n      return false;\n    }\n\n    idx += 1;\n  }\n\n  return true;\n}));\n\nexport default all;","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XAny =\n/*#__PURE__*/\nfunction () {\n  function XAny(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.any = false;\n  }\n\n  XAny.prototype['@@transducer/init'] = _xfBase.init;\n\n  XAny.prototype['@@transducer/result'] = function (result) {\n    if (!this.any) {\n      result = this.xf['@@transducer/step'](result, false);\n    }\n\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XAny.prototype['@@transducer/step'] = function (result, input) {\n    if (this.f(input)) {\n      this.any = true;\n      result = _reduced(this.xf['@@transducer/step'](result, true));\n    }\n\n    return result;\n  };\n\n  return XAny;\n}();\n\nvar _xany =\n/*#__PURE__*/\n_curry2(function _xany(f, xf) {\n  return new XAny(f, xf);\n});\n\nexport default _xany;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xany from \"./internal/_xany.js\";\n/**\n * Returns `true` if at least one of the elements of the list match the predicate,\n * `false` otherwise.\n *\n * Dispatches to the `any` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> Boolean\n * @param {Function} fn The predicate function.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n *         otherwise.\n * @see R.all, R.none, R.transduce\n * @example\n *\n *      const lessThan0 = R.flip(R.lt)(0);\n *      const lessThan2 = R.flip(R.lt)(2);\n *      R.any(lessThan0)([1, 2]); //=> false\n *      R.any(lessThan2)([1, 2]); //=> true\n */\n\nvar any =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['any'], _xany, function any(fn, list) {\n  var idx = 0;\n\n  while (idx < list.length) {\n    if (fn(list[idx])) {\n      return true;\n    }\n\n    idx += 1;\n  }\n\n  return false;\n}));\n\nexport default any;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Calls an input function `n` times, returning an array containing the results\n * of those function calls.\n *\n * `fn` is passed one argument: The current value of `n`, which begins at `0`\n * and is gradually incremented to `n - 1`.\n *\n * @func\n * @memberOf R\n * @since v0.2.3\n * @category List\n * @sig (Number -> a) -> Number -> [a]\n * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n * @return {Array} An array containing the return values of all calls to `fn`.\n * @see R.repeat\n * @example\n *\n *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n * @symb R.times(f, 0) = []\n * @symb R.times(f, 1) = [f(0)]\n * @symb R.times(f, 2) = [f(0), f(1)]\n */\n\nvar times =\n/*#__PURE__*/\n_curry2(function times(fn, n) {\n  var len = Number(n);\n  var idx = 0;\n  var list;\n\n  if (len < 0 || isNaN(len)) {\n    throw new RangeError('n must be a non-negative number');\n  }\n\n  list = new Array(len);\n\n  while (idx < len) {\n    list[idx] = fn(idx);\n    idx += 1;\n  }\n\n  return list;\n});\n\nexport default times;","import _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\nimport nth from \"./nth.js\";\n/**\n * Returns a function which returns its nth argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig Number -> *... -> *\n * @param {Number} n\n * @return {Function}\n * @example\n *\n *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n * @symb R.nthArg(-1)(a, b, c) = c\n * @symb R.nthArg(0)(a, b, c) = a\n * @symb R.nthArg(1)(a, b, c) = b\n */\n\nvar nthArg =\n/*#__PURE__*/\n_curry1(function nthArg(n) {\n  var arity = n < 0 ? 1 : n + 1;\n  return curryN(arity, function () {\n    return nth(n, arguments);\n  });\n});\n\nexport default nthArg;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a copy of the list, sorted according to the comparator function,\n * which should accept two values at a time and return a negative number if the\n * first value is smaller, a positive number if it's larger, and zero if they\n * are equal. Please note that this is a **copy** of the list. It does not\n * modify the original.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, a) -> Number) -> [a] -> [a]\n * @param {Function} comparator A sorting function :: a -> b -> Int\n * @param {Array} list The list to sort\n * @return {Array} a new array with its elements sorted by the comparator function.\n * @example\n *\n *      const diff = function(a, b) { return a - b; };\n *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n */\n\nvar sort =\n/*#__PURE__*/\n_curry2(function sort(comparator, list) {\n  return Array.prototype.slice.call(list, 0).sort(comparator);\n});\n\nexport default sort;","import { always } from 'ramda';\n/**\n * A function that returns `null`.\n *\n * @func stubNull\n * @memberOf RA\n * @since {@link https://char0n.github.io/ramda-adjunct/1.6.0|v1.6.0}\n * @category Function\n * @sig ... -> null\n * @return {null}\n * @example\n *\n * RA.stubNull(); //=> null\n * RA.stubNull(1, 2, 3); //=> null\n */\n\nvar stubNull = always(null);\nexport default stubNull;","import _objectIs from \"./internal/_objectIs.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * Note this is merely a curried version of ES6 `Object.is`.\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      const o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\n\nvar identical =\n/*#__PURE__*/\n_curry2(_objectIs);\n\nexport default identical;","import { identical } from 'ramda';\n/**\n * Checks if input value is the Boolean primitive `true`. Will return false for Boolean objects\n * created using the `Boolean` function as a constructor.\n *\n * @func isTrue\n * @memberOf RA\n * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}\n * @category Type\n * @sig * -> Boolean\n * @param {*} val The value to test\n * @return {boolean}\n * @see {@link RA.isFalse|isFalse}, {@link RA.isTruthy|isTruthy}, {@link RA.isFalsy|isFalsy}\n * @example\n *\n * RA.isTrue(true); // => true\n * RA.isTrue(Boolean(true)); // => true\n * RA.isTrue(false); // => false\n * RA.isTrue(1); // => false\n * RA.isTrue('true'); // => false\n * RA.isTrue(new Boolean(true)); // => false\n */\n\nvar isTrue = identical(true);\nexport default isTrue;","import { identical } from 'ramda';\n/**\n * Checks if input value is the Boolean primitive `false`. Will return false for all values created\n * using the `Boolean` function as a constructor.\n *\n * @func isFalse\n * @memberOf RA\n * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}\n * @category Type\n * @sig * -> Boolean\n * @param {*} val The value to test\n * @return {boolean}\n * @see {@link RA.isTrue|isTrue}, {@link RA.isTruthy|isTruthy}, {@link RA.isFalsy|isFalsy}\n * @example\n *\n * RA.isFalse(false); // => true\n * RA.isFalse(Boolean(false)); // => true\n * RA.isFalse(true); // => false\n * RA.isFalse(0); // => false\n * RA.isFalse(''); // => false\n * RA.isFalse(null); // => false\n * RA.isFalse(undefined); // => false\n * RA.isFalse(NaN); // => false\n * RA.isFalse([]); // => false\n * RA.isFalse(new Boolean(false)); // => false\n */\n\nvar isFalse = identical(false);\nexport default isFalse;","import _concat from \"./internal/_concat.js\";\nimport _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Creates a new list iteration function from an existing one by adding two new\n * parameters to its callback function: the current index, and the entire list.\n *\n * This would turn, for instance, [`R.map`](#map) function into one that\n * more closely resembles `Array.prototype.map`. Note that this will only work\n * for functions in which the iteration callback function is the first\n * parameter, and where the list is the last parameter. (This latter might be\n * unimportant if the list parameter is not used.)\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Function\n * @category List\n * @sig ((a ... -> b) ... -> [a] -> *) -> ((a ..., Int, [a] -> b) ... -> [a] -> *)\n * @param {Function} fn A list iteration function that does not pass index or list to its callback\n * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n * @example\n *\n *      const mapIndexed = R.addIndex(R.map);\n *      mapIndexed((val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);\n *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n */\n\nvar addIndex =\n/*#__PURE__*/\n_curry1(function addIndex(fn) {\n  return curryN(fn.length, function () {\n    var idx = 0;\n    var origFn = arguments[0];\n    var list = arguments[arguments.length - 1];\n    var args = Array.prototype.slice.call(arguments, 0);\n\n    args[0] = function () {\n      var result = origFn.apply(this, _concat(arguments, [idx, list]));\n      idx += 1;\n      return result;\n    };\n\n    return fn.apply(this, args);\n  });\n});\n\nexport default addIndex;","import { addIndex, map } from 'ramda';\n/**\n * {@link http://ramdajs.com/docs/#map|R.map} function that more closely resembles Array.prototype.map.\n * It takes two new parameters to its callback function: the current index, and the entire list.\n *\n * `mapIndexed` implementation is simple : `\n * const mapIndexed = R.addIndex(R.map);\n * `\n * @func mapIndexed\n * @memberOf RA\n * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}\n * @category List\n * @typedef Idx = Number\n * @sig Functor f => ((a, Idx, f a) => b) => f a -> f b\n * @param {Function} fn The function to be called on every element of the input `list`\n * @param {Array} list The list to be iterated over\n * @return {Array} The new list\n * @see {@link http://ramdajs.com/docs/#addIndex|R.addIndex}, {@link http://ramdajs.com/docs/#map|R.map}\n * @example\n *\n * RA.mapIndexed((val, idx, list) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);\n * //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n */\n\nvar mapIndexed = addIndex(map);\nexport default mapIndexed;","import { flip, gt } from 'ramda';\nimport compareLength from './internal/compareLength';\n/**\n * Returns `true` if the supplied list or string has a length greater than `valueLength`.\n *\n * @func lengthGt\n * @memberOf RA\n * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}\n * @category List\n * @sig Number -> [*] -> Boolean\n * @param {number} valueLength The length of the list or string\n * @param {Array|string} value The list or string\n * @return {boolean}\n * @see {@link RA.lengthEq|lengthEq}, {@link RA.lengthNotEq|lengthNotEq}, {@link RA.lengthLt|lengthLt}, {@link RA.lengthLte|lengthLte}, {@link RA.lengthGte|lengthGte}, {@link http://ramdajs.com/docs/#gt|gt},  {@link http://ramdajs.com/docs/#length|length}\n * @example\n *\n * RA.lengthGt(3, [1,2,3,4]); //=> true\n * RA.lengthGt(3, [1,2,3]); //=> false\n */\n\nvar lengthGt = compareLength(flip(gt));\nexport default lengthGt;","import _curry1 from \"./internal/_curry1.js\";\nimport _isArguments from \"./internal/_isArguments.js\";\nimport _isArray from \"./internal/_isArray.js\";\nimport _isObject from \"./internal/_isObject.js\";\nimport _isString from \"./internal/_isString.js\";\n/**\n * Returns the empty value of its argument's type. Ramda defines the empty\n * value of Array (`[]`), Object (`{}`), String (`''`), and Arguments. Other\n * types are supported if they define `<Type>.empty`,\n * `<Type>.prototype.empty` or implement the\n * [FantasyLand Monoid spec](https://github.com/fantasyland/fantasy-land#monoid).\n *\n * Dispatches to the `empty` method of the first argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig a -> a\n * @param {*} x\n * @return {*}\n * @example\n *\n *      R.empty(Just(42));      //=> Nothing()\n *      R.empty([1, 2, 3]);     //=> []\n *      R.empty('unicorns');    //=> ''\n *      R.empty({x: 1, y: 2});  //=> {}\n */\n\nvar empty =\n/*#__PURE__*/\n_curry1(function empty(x) {\n  return x != null && typeof x['fantasy-land/empty'] === 'function' ? x['fantasy-land/empty']() : x != null && x.constructor != null && typeof x.constructor['fantasy-land/empty'] === 'function' ? x.constructor['fantasy-land/empty']() : x != null && typeof x.empty === 'function' ? x.empty() : x != null && x.constructor != null && typeof x.constructor.empty === 'function' ? x.constructor.empty() : _isArray(x) ? [] : _isString(x) ? '' : _isObject(x) ? {} : _isArguments(x) ? function () {\n    return arguments;\n  }() : void 0 // else\n  ;\n});\n\nexport default empty;","import _curry1 from \"./internal/_curry1.js\";\nimport empty from \"./empty.js\";\nimport equals from \"./equals.js\";\n/**\n * Returns `true` if the given value is its type's empty value; `false`\n * otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig a -> Boolean\n * @param {*} x\n * @return {Boolean}\n * @see R.empty\n * @example\n *\n *      R.isEmpty([1, 2, 3]);   //=> false\n *      R.isEmpty([]);          //=> true\n *      R.isEmpty('');          //=> true\n *      R.isEmpty(null);        //=> false\n *      R.isEmpty({});          //=> true\n *      R.isEmpty({length: 0}); //=> false\n */\n\nvar isEmpty =\n/*#__PURE__*/\n_curry1(function isEmpty(x) {\n  return x != null && equals(x, empty(x));\n});\n\nexport default isEmpty;","import { either, isEmpty, isNil, curryN } from 'ramda';\n/**\n * Returns `true` if the given value is its type's empty value, `null` or `undefined`.\n *\n * @func isNilOrEmpty\n * @memberOf RA\n * @since {@link https://char0n.github.io/ramda-adjunct/0.4.0|v0.4.0}\n * @category Type\n * @sig * -> Boolean\n * @param {*} val The value to test\n * @return {boolean}\n * @see {@link http://ramdajs.com/docs/#isEmpty|R.isEmpty}, {@link http://ramdajs.com/docs/#isNil|R.isNil}\n * @example\n *\n * RA.isNilOrEmpty([1, 2, 3]); //=> false\n * RA.isNilOrEmpty([]); //=> true\n * RA.isNilOrEmpty(''); //=> true\n * RA.isNilOrEmpty(null); //=> true\n * RA.isNilOrEmpty(undefined): //=> true\n * RA.isNilOrEmpty({}); //=> true\n * RA.isNilOrEmpty({length: 0}); //=> false\n */\n\nvar isNilOrEmpty = curryN(1, either(isNil, isEmpty));\nexport default isNilOrEmpty;","import { curryN, all, any, complement, ifElse, converge, times, always, nthArg, pipe, divide, multiply, mapObjIndexed, reject, equals, sort, keys, reduce, assoc, prop, __, flip, add, mean, median, modulo, subtract, gt, gte, lt, lte } from 'ramda';\nimport { stubNull, isTrue, isFalse, mapIndexed, lengthGt, isNilOrEmpty } from 'ramda-adjunct';\n\n// Ramdas math methods are not pipeable\n// i.e. r.subtract(1)(5) is not 4, it's -4\n// so we export some pipeable version of these methods\nvar add$1 = flip(add);\nvar divide$1 = flip(divide);\nvar mean$1 = flip(mean);\nvar median$1 = flip(median);\nvar modulo$1 = flip(modulo);\nvar multiply$1 = multiply;\nvar subtract$1 = flip(subtract);\nvar gt$1 = flip(gt);\nvar gte$1 = flip(gte);\nvar lt$1 = flip(lt);\nvar lte$1 = flip(lte);\n\nvar curry1 = curryN(1);\nvar curry2 = curryN(2);\nvar curry3 = curryN(3);\nvar curry4 = curryN(4);\n\nvar nuller = stubNull;\nvar isTrue$1 = isTrue;\nvar isFalse$1 = isFalse;\nvar mapIndexed$1 = mapIndexed;\n\nvar allTrue = all(isTrue$1);\n\nvar allFalse = all(isFalse$1);\n\nvar anyTrue = any(isTrue$1);\n\nvar anyFalse = any(isTrue$1);\n\nvar hasLength = lengthGt(0);\n\nvar isNotNilOrEmpty = complement(isNilOrEmpty);\n\nvar ifElseBool = ifElse(isTrue$1);\n\nvar arrayOf = curry2(converge(times, [always, nthArg(1)]));\n\nvar percentage = pipe(divide, multiply(100));\n\nvar filterObjIndexed = curry2(function (fn, obj) {\n  return pipe(mapObjIndexed(function (v, k) {\n    if (fn(v, k)) {\n      return v;\n    }\n    return '__@@tg/capra/REJECTED__';\n  }), reject(equals('__@@tg/capra/REJECTED__')))(obj);\n});\n\nvar rejectObjIndexed = curry2(function (fn, obj) {\n  return filterObjIndexed(complement(fn), obj);\n});\n\nvar sortObj = curry2(function (fn, obj) {\n  var keys$$1 = sort(fn, keys(obj));\n  return reduce(converge(assoc, [nthArg(1), pipe(nthArg(1), prop(__, obj)), nthArg(0)]), {}, keys$$1);\n});\n\nvar sortObjBy = curry2(function (fn, obj) {\n  var sortFn = function sortFn(a, b) {\n    var aa = fn(a);\n    var bb = fn(b);\n    if (aa < bb) {\n      return -1;\n    }\n    if (aa > bb) {\n      return 1;\n    }\n    return 0;\n  };\n  return sortObj(sortFn, obj);\n});\n\nexport { curry1, curry2, curry3, curry4, nuller, isTrue$1 as isTrue, isFalse$1 as isFalse, mapIndexed$1 as mapIndexed, allTrue, allFalse, anyTrue, anyFalse, hasLength, isNotNilOrEmpty, ifElseBool, arrayOf, percentage, filterObjIndexed, rejectObjIndexed, sortObj, sortObjBy, add$1 as add, divide$1 as divide, mean$1 as mean, median$1 as median, modulo$1 as modulo, multiply$1 as multiply, subtract$1 as subtract, gt$1 as gt, gte$1 as gte, lt$1 as lt, lte$1 as lte };\n","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Returns `true` if the specified object property satisfies the given\n * predicate; `false` otherwise. You can test multiple properties with\n * [`R.where`](#where).\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Logic\n * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n * @param {Function} pred\n * @param {String} name\n * @param {*} obj\n * @return {Boolean}\n * @see R.where, R.propEq, R.propIs\n * @example\n *\n *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n */\n\nvar propSatisfies =\n/*#__PURE__*/\n_curry3(function propSatisfies(pred, name, obj) {\n  return pred(obj[name]);\n});\n\nexport default propSatisfies;"],"sourceRoot":""}