{"version":3,"file":"static/js/315.923a3846.chunk.js","mappings":"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","sources":["../node_modules/ramda/es/F.js","../node_modules/ramda/es/T.js","../node_modules/ramda/es/__.js","../node_modules/ramda/es/internal/_isPlaceholder.js","../node_modules/ramda/es/internal/_curry1.js","../node_modules/ramda/es/internal/_curry2.js","../node_modules/ramda/es/add.js","../node_modules/ramda/es/internal/_concat.js","../node_modules/ramda/es/internal/_arity.js","../node_modules/ramda/es/internal/_curryN.js","../node_modules/ramda/es/curryN.js","../node_modules/ramda/es/addIndex.js","../node_modules/ramda/es/internal/_curry3.js","../node_modules/ramda/es/adjust.js","../node_modules/ramda/es/internal/_isArray.js","../node_modules/ramda/es/internal/_isTransformer.js","../node_modules/ramda/es/internal/_dispatchable.js","../node_modules/ramda/es/internal/_reduced.js","../node_modules/ramda/es/internal/_xfBase.js","../node_modules/ramda/es/internal/_xall.js","../node_modules/ramda/es/all.js","../node_modules/ramda/es/max.js","../node_modules/ramda/es/internal/_map.js","../node_modules/ramda/es/internal/_isString.js","../node_modules/ramda/es/internal/_isArrayLike.js","../node_modules/ramda/es/internal/_xwrap.js","../node_modules/ramda/es/bind.js","../node_modules/ramda/es/internal/_reduce.js","../node_modules/ramda/es/internal/_xmap.js","../node_modules/ramda/es/internal/_has.js","../node_modules/ramda/es/internal/_isArguments.js","../node_modules/ramda/es/keys.js","../node_modules/ramda/es/map.js","../node_modules/ramda/es/internal/_isInteger.js","../node_modules/ramda/es/nth.js","../node_modules/ramda/es/paths.js","../node_modules/ramda/es/path.js","../node_modules/ramda/es/prop.js","../node_modules/ramda/es/pluck.js","../node_modules/ramda/es/reduce.js","../node_modules/ramda/es/allPass.js","../node_modules/ramda/es/always.js","../node_modules/ramda/es/and.js","../node_modules/ramda/es/internal/_xany.js","../node_modules/ramda/es/any.js","../node_modules/ramda/es/anyPass.js","../node_modules/ramda/es/ap.js","../node_modules/ramda/es/internal/_aperture.js","../node_modules/ramda/es/internal/_xaperture.js","../node_modules/ramda/es/aperture.js","../node_modules/ramda/es/append.js","../node_modules/ramda/es/apply.js","../node_modules/ramda/es/values.js","../node_modules/ramda/es/applySpec.js","../node_modules/ramda/es/applyTo.js","../node_modules/ramda/es/ascend.js","../node_modules/ramda/es/assoc.js","../node_modules/ramda/es/isNil.js","../node_modules/ramda/es/assocPath.js","../node_modules/ramda/es/nAry.js","../node_modules/ramda/es/binary.js","../node_modules/ramda/es/internal/_isFunction.js","../node_modules/ramda/es/liftN.js","../node_modules/ramda/es/lift.js","../node_modules/ramda/es/both.js","../node_modules/ramda/es/curry.js","../node_modules/ramda/es/call.js","../node_modules/ramda/es/internal/_makeFlat.js","../node_modules/ramda/es/internal/_flatCat.js","../node_modules/ramda/es/internal/_forceReduced.js","../node_modules/ramda/es/chain.js","../node_modules/ramda/es/internal/_xchain.js","../node_modules/ramda/es/clamp.js","../node_modules/ramda/es/internal/_cloneRegExp.js","../node_modules/ramda/es/type.js","../node_modules/ramda/es/internal/_clone.js","../node_modules/ramda/es/clone.js","../node_modules/ramda/es/comparator.js","../node_modules/ramda/es/not.js","../node_modules/ramda/es/complement.js","../node_modules/ramda/es/internal/_pipe.js","../node_modules/ramda/es/internal/_checkForMethod.js","../node_modules/ramda/es/slice.js","../node_modules/ramda/es/tail.js","../node_modules/ramda/es/pipe.js","../node_modules/ramda/es/reverse.js","../node_modules/ramda/es/compose.js","../node_modules/ramda/es/composeK.js","../node_modules/ramda/es/internal/_pipeP.js","../node_modules/ramda/es/pipeP.js","../node_modules/ramda/es/composeP.js","../node_modules/ramda/es/head.js","../node_modules/ramda/es/internal/_identity.js","../node_modules/ramda/es/identity.js","../node_modules/ramda/es/pipeWith.js","../node_modules/ramda/es/composeWith.js","../node_modules/ramda/es/internal/_arrayFromIterator.js","../node_modules/ramda/es/internal/_includesWith.js","../node_modules/ramda/es/internal/_objectIs.js","../node_modules/ramda/es/internal/_equals.js","../node_modules/ramda/es/internal/_functionName.js","../node_modules/ramda/es/equals.js","../node_modules/ramda/es/internal/_indexOf.js","../node_modules/ramda/es/internal/_includes.js","../node_modules/ramda/es/internal/_quote.js","../node_modules/ramda/es/internal/_toISOString.js","../node_modules/ramda/es/internal/_complement.js","../node_modules/ramda/es/internal/_filter.js","../node_modules/ramda/es/internal/_isObject.js","../node_modules/ramda/es/internal/_xfilter.js","../node_modules/ramda/es/filter.js","../node_modules/ramda/es/reject.js","../node_modules/ramda/es/internal/_toString.js","../node_modules/ramda/es/toString.js","../node_modules/ramda/es/concat.js","../node_modules/ramda/es/cond.js","../node_modules/ramda/es/constructN.js","../node_modules/ramda/es/construct.js","../node_modules/ramda/es/contains.js","../node_modules/ramda/es/converge.js","../node_modules/ramda/es/internal/_xreduceBy.js","../node_modules/ramda/es/reduceBy.js","../node_modules/ramda/es/countBy.js","../node_modules/ramda/es/dec.js","../node_modules/ramda/es/defaultTo.js","../node_modules/ramda/es/descend.js","../node_modules/ramda/es/internal/_Set.js","../node_modules/ramda/es/difference.js","../node_modules/ramda/es/differenceWith.js","../node_modules/ramda/es/dissoc.js","../node_modules/ramda/es/remove.js","../node_modules/ramda/es/update.js","../node_modules/ramda/es/dissocPath.js","../node_modules/ramda/es/divide.js","../node_modules/ramda/es/internal/_xdrop.js","../node_modules/ramda/es/drop.js","../node_modules/ramda/es/internal/_xtake.js","../node_modules/ramda/es/take.js","../node_modules/ramda/es/internal/_dropLast.js","../node_modules/ramda/es/internal/_xdropLast.js","../node_modules/ramda/es/dropLast.js","../node_modules/ramda/es/internal/_dropLastWhile.js","../node_modules/ramda/es/internal/_xdropLastWhile.js","../node_modules/ramda/es/dropLastWhile.js","../node_modules/ramda/es/internal/_xdropRepeatsWith.js","../node_modules/ramda/es/last.js","../node_modules/ramda/es/dropRepeatsWith.js","../node_modules/ramda/es/dropRepeats.js","../node_modules/ramda/es/internal/_xdropWhile.js","../node_modules/ramda/es/dropWhile.js","../node_modules/ramda/es/or.js","../node_modules/ramda/es/either.js","../node_modules/ramda/es/empty.js","../node_modules/ramda/es/takeLast.js","../node_modules/ramda/es/endsWith.js","../node_modules/ramda/es/eqBy.js","../node_modules/ramda/es/eqProps.js","../node_modules/ramda/es/evolve.js","../node_modules/ramda/es/internal/_xfind.js","../node_modules/ramda/es/find.js","../node_modules/ramda/es/internal/_xfindIndex.js","../node_modules/ramda/es/findIndex.js","../node_modules/ramda/es/internal/_xfindLast.js","../node_modules/ramda/es/findLast.js","../node_modules/ramda/es/internal/_xfindLastIndex.js","../node_modules/ramda/es/findLastIndex.js","../node_modules/ramda/es/flatten.js","../node_modules/ramda/es/flip.js","../node_modules/ramda/es/forEach.js","../node_modules/ramda/es/forEachObjIndexed.js","../node_modules/ramda/es/fromPairs.js","../node_modules/ramda/es/groupBy.js","../node_modules/ramda/es/groupWith.js","../node_modules/ramda/es/gt.js","../node_modules/ramda/es/gte.js","../node_modules/ramda/es/hasPath.js","../node_modules/ramda/es/has.js","../node_modules/ramda/es/hasIn.js","../node_modules/ramda/es/identical.js","../node_modules/ramda/es/ifElse.js","../node_modules/ramda/es/inc.js","../node_modules/ramda/es/includes.js","../node_modules/ramda/es/indexBy.js","../node_modules/ramda/es/indexOf.js","../node_modules/ramda/es/init.js","../node_modules/ramda/es/innerJoin.js","../node_modules/ramda/es/insert.js","../node_modules/ramda/es/insertAll.js","../node_modules/ramda/es/uniqBy.js","../node_modules/ramda/es/uniq.js","../node_modules/ramda/es/intersection.js","../node_modules/ramda/es/intersperse.js","../node_modules/ramda/es/internal/_objectAssign.js","../node_modules/ramda/es/objOf.js","../node_modules/ramda/es/internal/_stepCat.js","../node_modules/ramda/es/into.js","../node_modules/ramda/es/invert.js","../node_modules/ramda/es/invertObj.js","../node_modules/ramda/es/invoker.js","../node_modules/ramda/es/is.js","../node_modules/ramda/es/isEmpty.js","../node_modules/ramda/es/join.js","../node_modules/ramda/es/juxt.js","../node_modules/ramda/es/keysIn.js","../node_modules/ramda/es/lastIndexOf.js","../node_modules/ramda/es/internal/_isNumber.js","../node_modules/ramda/es/length.js","../node_modules/ramda/es/lens.js","../node_modules/ramda/es/lensIndex.js","../node_modules/ramda/es/lensPath.js","../node_modules/ramda/es/lensProp.js","../node_modules/ramda/es/lt.js","../node_modules/ramda/es/lte.js","../node_modules/ramda/es/mapAccum.js","../node_modules/ramda/es/mapAccumRight.js","../node_modules/ramda/es/mapObjIndexed.js","../node_modules/ramda/es/match.js","../node_modules/ramda/es/mathMod.js","../node_modules/ramda/es/maxBy.js","../node_modules/ramda/es/sum.js","../node_modules/ramda/es/mean.js","../node_modules/ramda/es/median.js","../node_modules/ramda/es/memoizeWith.js","../node_modules/ramda/es/merge.js","../node_modules/ramda/es/mergeAll.js","../node_modules/ramda/es/mergeWithKey.js","../node_modules/ramda/es/mergeDeepWithKey.js","../node_modules/ramda/es/mergeDeepLeft.js","../node_modules/ramda/es/mergeDeepRight.js","../node_modules/ramda/es/mergeDeepWith.js","../node_modules/ramda/es/mergeLeft.js","../node_modules/ramda/es/mergeRight.js","../node_modules/ramda/es/mergeWith.js","../node_modules/ramda/es/min.js","../node_modules/ramda/es/minBy.js","../node_modules/ramda/es/modulo.js","../node_modules/ramda/es/move.js","../node_modules/ramda/es/multiply.js","../node_modules/ramda/es/negate.js","../node_modules/ramda/es/none.js","../node_modules/ramda/es/nthArg.js","../node_modules/ramda/es/o.js","../node_modules/ramda/es/internal/_of.js","../node_modules/ramda/es/of.js","../node_modules/ramda/es/omit.js","../node_modules/ramda/es/once.js","../node_modules/ramda/es/internal/_assertPromise.js","../node_modules/ramda/es/otherwise.js","../node_modules/ramda/es/over.js","../node_modules/ramda/es/pair.js","../node_modules/ramda/es/internal/_createPartialApplicator.js","../node_modules/ramda/es/partial.js","../node_modules/ramda/es/partialRight.js","../node_modules/ramda/es/partition.js","../node_modules/ramda/es/pathEq.js","../node_modules/ramda/es/pathOr.js","../node_modules/ramda/es/pathSatisfies.js","../node_modules/ramda/es/pick.js","../node_modules/ramda/es/pickAll.js","../node_modules/ramda/es/pickBy.js","../node_modules/ramda/es/pipeK.js","../node_modules/ramda/es/prepend.js","../node_modules/ramda/es/product.js","../node_modules/ramda/es/useWith.js","../node_modules/ramda/es/project.js","../node_modules/ramda/es/propEq.js","../node_modules/ramda/es/propIs.js","../node_modules/ramda/es/propOr.js","../node_modules/ramda/es/propSatisfies.js","../node_modules/ramda/es/props.js","../node_modules/ramda/es/range.js","../node_modules/ramda/es/reduceRight.js","../node_modules/ramda/es/reduceWhile.js","../node_modules/ramda/es/reduced.js","../node_modules/ramda/es/times.js","../node_modules/ramda/es/repeat.js","../node_modules/ramda/es/replace.js","../node_modules/ramda/es/scan.js","../node_modules/ramda/es/sequence.js","../node_modules/ramda/es/set.js","../node_modules/ramda/es/sort.js","../node_modules/ramda/es/sortBy.js","../node_modules/ramda/es/sortWith.js","../node_modules/ramda/es/split.js","../node_modules/ramda/es/splitAt.js","../node_modules/ramda/es/splitEvery.js","../node_modules/ramda/es/splitWhen.js","../node_modules/ramda/es/startsWith.js","../node_modules/ramda/es/subtract.js","../node_modules/ramda/es/symmetricDifference.js","../node_modules/ramda/es/symmetricDifferenceWith.js","../node_modules/ramda/es/takeLastWhile.js","../node_modules/ramda/es/internal/_xtakeWhile.js","../node_modules/ramda/es/takeWhile.js","../node_modules/ramda/es/internal/_xtap.js","../node_modules/ramda/es/tap.js","../node_modules/ramda/es/test.js","../node_modules/ramda/es/internal/_isRegExp.js","../node_modules/ramda/es/andThen.js","../node_modules/ramda/es/toLower.js","../node_modules/ramda/es/toPairs.js","../node_modules/ramda/es/toPairsIn.js","../node_modules/ramda/es/toUpper.js","../node_modules/ramda/es/transduce.js","../node_modules/ramda/es/transpose.js","../node_modules/ramda/es/traverse.js","../node_modules/ramda/es/trim.js","../node_modules/ramda/es/tryCatch.js","../node_modules/ramda/es/unapply.js","../node_modules/ramda/es/unary.js","../node_modules/ramda/es/uncurryN.js","../node_modules/ramda/es/unfold.js","../node_modules/ramda/es/union.js","../node_modules/ramda/es/uniqWith.js","../node_modules/ramda/es/unionWith.js","../node_modules/ramda/es/unless.js","../node_modules/ramda/es/unnest.js","../node_modules/ramda/es/until.js","../node_modules/ramda/es/valuesIn.js","../node_modules/ramda/es/view.js","../node_modules/ramda/es/when.js","../node_modules/ramda/es/where.js","../node_modules/ramda/es/whereEq.js","../node_modules/ramda/es/without.js","../node_modules/ramda/es/xor.js","../node_modules/ramda/es/xprod.js","../node_modules/ramda/es/zip.js","../node_modules/ramda/es/zipObj.js","../node_modules/ramda/es/zipWith.js","../node_modules/ramda/es/thunkify.js"],"sourcesContent":["/**\n * A function that always returns `false`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig * -> Boolean\n * @param {*}\n * @return {Boolean}\n * @see R.T\n * @example\n *\n * R.F(); //=> false\n */\nvar F = function () {\n return false;\n};\n\nexport default F;","/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig * -> Boolean\n * @param {*}\n * @return {Boolean}\n * @see R.F\n * @example\n *\n * R.T(); //=> true\n */\nvar T = function () {\n return true;\n};\n\nexport default T;","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments, regardless of\n * their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are\n * equivalent:\n *\n * - `g(1, 2, 3)`\n * - `g(_, 2, 3)(1)`\n * - `g(_, _, 3)(1)(2)`\n * - `g(_, _, 3)(1, 2)`\n * - `g(_, 2, _)(1, 3)`\n * - `g(_, 2)(1)(3)`\n * - `g(_, 2)(1, 3)`\n * - `g(_, 2)(_, 3)(1)`\n *\n * @name __\n * @constant\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @example\n *\n * const greet = R.replace('{name}', R.__, 'Hello, {name}!');\n * greet('Alice'); //=> 'Hello, Alice!'\n */\nexport default {\n '@@functional/placeholder': true\n};","export default function _isPlaceholder(a) {\n return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;\n}","import _isPlaceholder from \"./_isPlaceholder.js\";\n/**\n * Optimized internal one-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nexport default function _curry1(fn) {\n return function f1(a) {\n if (arguments.length === 0 || _isPlaceholder(a)) {\n return f1;\n } else {\n return fn.apply(this, arguments);\n }\n };\n}","import _curry1 from \"./_curry1.js\";\nimport _isPlaceholder from \"./_isPlaceholder.js\";\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nexport default function _curry2(fn) {\n return function f2(a, b) {\n switch (arguments.length) {\n case 0:\n return f2;\n\n case 1:\n return _isPlaceholder(a) ? f2 : _curry1(function (_b) {\n return fn(a, _b);\n });\n\n default:\n return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {\n return fn(_a, b);\n }) : _isPlaceholder(b) ? _curry1(function (_b) {\n return fn(a, _b);\n }) : fn(a, b);\n }\n };\n}","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;","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n * _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nexport default function _concat(set1, set2) {\n set1 = set1 || [];\n set2 = set2 || [];\n var idx;\n var len1 = set1.length;\n var len2 = set2.length;\n var result = [];\n idx = 0;\n\n while (idx < len1) {\n result[result.length] = set1[idx];\n idx += 1;\n }\n\n idx = 0;\n\n while (idx < len2) {\n result[result.length] = set2[idx];\n idx += 1;\n }\n\n return result;\n}","export default function _arity(n, fn) {\n /* eslint-disable no-unused-vars */\n switch (n) {\n case 0:\n return function () {\n return fn.apply(this, arguments);\n };\n\n case 1:\n return function (a0) {\n return fn.apply(this, arguments);\n };\n\n case 2:\n return function (a0, a1) {\n return fn.apply(this, arguments);\n };\n\n case 3:\n return function (a0, a1, a2) {\n return fn.apply(this, arguments);\n };\n\n case 4:\n return function (a0, a1, a2, a3) {\n return fn.apply(this, arguments);\n };\n\n case 5:\n return function (a0, a1, a2, a3, a4) {\n return fn.apply(this, arguments);\n };\n\n case 6:\n return function (a0, a1, a2, a3, a4, a5) {\n return fn.apply(this, arguments);\n };\n\n case 7:\n return function (a0, a1, a2, a3, a4, a5, a6) {\n return fn.apply(this, arguments);\n };\n\n case 8:\n return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n return fn.apply(this, arguments);\n };\n\n case 9:\n return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n return fn.apply(this, arguments);\n };\n\n case 10:\n return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n return fn.apply(this, arguments);\n };\n\n default:\n throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n }\n}","import _arity from \"./_arity.js\";\nimport _isPlaceholder from \"./_isPlaceholder.js\";\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @param {Array} received An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nexport default function _curryN(length, received, fn) {\n return function () {\n var combined = [];\n var argsIdx = 0;\n var left = length;\n var combinedIdx = 0;\n\n while (combinedIdx < received.length || argsIdx < arguments.length) {\n var result;\n\n if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {\n result = received[combinedIdx];\n } else {\n result = arguments[argsIdx];\n argsIdx += 1;\n }\n\n combined[combinedIdx] = result;\n\n if (!_isPlaceholder(result)) {\n left -= 1;\n }\n\n combinedIdx += 1;\n }\n\n return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n };\n}","import _arity from \"./internal/_arity.js\";\nimport _curry1 from \"./internal/_curry1.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _curryN from \"./internal/_curryN.js\";\n/**\n * Returns a curried equivalent of the provided function, with the specified\n * arity. The curried function has two unusual capabilities. First, its\n * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the\n * following are equivalent:\n *\n * - `g(1)(2)(3)`\n * - `g(1)(2, 3)`\n * - `g(1, 2)(3)`\n * - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value [`R.__`](#__) may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),\n * the following are equivalent:\n *\n * - `g(1, 2, 3)`\n * - `g(_, 2, 3)(1)`\n * - `g(_, _, 3)(1)(2)`\n * - `g(_, _, 3)(1, 2)`\n * - `g(_, 2)(1)(3)`\n * - `g(_, 2)(1, 3)`\n * - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n * const sumArgs = (...args) => R.sum(args);\n *\n * const curriedAddFourNumbers = R.curryN(4, sumArgs);\n * const f = curriedAddFourNumbers(1, 2);\n * const g = f(3);\n * g(4); //=> 10\n */\n\nvar curryN =\n/*#__PURE__*/\n_curry2(function curryN(length, fn) {\n if (length === 1) {\n return _curry1(fn);\n }\n\n return _arity(length, _curryN(length, [], fn));\n});\n\nexport default curryN;","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 _curry1 from \"./_curry1.js\";\nimport _curry2 from \"./_curry2.js\";\nimport _isPlaceholder from \"./_isPlaceholder.js\";\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nexport default function _curry3(fn) {\n return function f3(a, b, c) {\n switch (arguments.length) {\n case 0:\n return f3;\n\n case 1:\n return _isPlaceholder(a) ? f3 : _curry2(function (_b, _c) {\n return fn(a, _b, _c);\n });\n\n case 2:\n return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function (_a, _c) {\n return fn(_a, b, _c);\n }) : _isPlaceholder(b) ? _curry2(function (_b, _c) {\n return fn(a, _b, _c);\n }) : _curry1(function (_c) {\n return fn(a, b, _c);\n });\n\n default:\n return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function (_a, _b) {\n return fn(_a, _b, c);\n }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function (_a, _c) {\n return fn(_a, b, _c);\n }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function (_b, _c) {\n return fn(a, _b, _c);\n }) : _isPlaceholder(a) ? _curry1(function (_a) {\n return fn(_a, b, c);\n }) : _isPlaceholder(b) ? _curry1(function (_b) {\n return fn(a, _b, c);\n }) : _isPlaceholder(c) ? _curry1(function (_c) {\n return fn(a, b, _c);\n }) : fn(a, b, c);\n }\n };\n}","import _concat from \"./internal/_concat.js\";\nimport _curry3 from \"./internal/_curry3.js\";\n/**\n * Applies a function to the value at the given index of an array, returning a\n * new copy of the array with the element at the given index replaced with the\n * result of the function application.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig Number -> (a -> a) -> [a] -> [a]\n * @param {Number} idx The index.\n * @param {Function} fn The function to apply.\n * @param {Array|Arguments} list An array-like object whose value\n * at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n * the element at index `idx` replaced with the value\n * returned by applying `fn` to the existing element.\n * @see R.update\n * @example\n *\n * R.adjust(1, R.toUpper, ['a', 'b', 'c', 'd']); //=> ['a', 'B', 'c', 'd']\n * R.adjust(-1, R.toUpper, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c', 'D']\n * @symb R.adjust(-1, f, [a, b]) = [a, f(b)]\n * @symb R.adjust(0, f, [a, b]) = [f(a), b]\n */\n\nvar adjust =\n/*#__PURE__*/\n_curry3(function adjust(idx, fn, list) {\n if (idx >= list.length || idx < -list.length) {\n return list;\n }\n\n var start = idx < 0 ? list.length : 0;\n\n var _idx = start + idx;\n\n var _list = _concat(list);\n\n _list[_idx] = fn(list[_idx]);\n return _list;\n});\n\nexport default adjust;","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n * _isArray([]); //=> true\n * _isArray(null); //=> false\n * _isArray({}); //=> false\n */\nexport default Array.isArray || function _isArray(val) {\n return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n};","export default function _isTransformer(obj) {\n return obj != null && typeof obj['@@transducer/step'] === 'function';\n}","import _isArray from \"./_isArray.js\";\nimport _isTransformer from \"./_isTransformer.js\";\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a function with one of the given method names, it will\n * execute that function (functor case). Otherwise, if it is a transformer,\n * uses transducer [xf] to return a new transformer (transducer case).\n * Otherwise, it will default to executing [fn].\n *\n * @private\n * @param {Array} methodNames properties to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\n\nexport default function _dispatchable(methodNames, xf, fn) {\n return function () {\n if (arguments.length === 0) {\n return fn();\n }\n\n var args = Array.prototype.slice.call(arguments, 0);\n var obj = args.pop();\n\n if (!_isArray(obj)) {\n var idx = 0;\n\n while (idx < methodNames.length) {\n if (typeof obj[methodNames[idx]] === 'function') {\n return obj[methodNames[idx]].apply(obj, args);\n }\n\n idx += 1;\n }\n\n if (_isTransformer(obj)) {\n var transducer = xf.apply(null, args);\n return transducer(obj);\n }\n }\n\n return fn.apply(this, arguments);\n };\n}","export default function _reduced(x) {\n return x && x['@@transducer/reduced'] ? x : {\n '@@transducer/value': x,\n '@@transducer/reduced': true\n };\n}","export default {\n init: function () {\n return this.xf['@@transducer/init']();\n },\n result: function (result) {\n return this.xf['@@transducer/result'](result);\n }\n};","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 \"./internal/_curry2.js\";\n/**\n * Returns the larger of its two arguments.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> a\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.maxBy, R.min\n * @example\n *\n * R.max(789, 123); //=> 789\n * R.max('a', 'b'); //=> 'b'\n */\n\nvar max =\n/*#__PURE__*/\n_curry2(function max(a, b) {\n return b > a ? b : a;\n});\n\nexport default max;","export default function _map(fn, functor) {\n var idx = 0;\n var len = functor.length;\n var result = Array(len);\n\n while (idx < len) {\n result[idx] = fn(functor[idx]);\n idx += 1;\n }\n\n return result;\n}","export default function _isString(x) {\n return Object.prototype.toString.call(x) === '[object String]';\n}","import _curry1 from \"./_curry1.js\";\nimport _isArray from \"./_isArray.js\";\nimport _isString from \"./_isString.js\";\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @private\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n * _isArrayLike([]); //=> true\n * _isArrayLike(true); //=> false\n * _isArrayLike({}); //=> false\n * _isArrayLike({length: 10}); //=> false\n * _isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\n\nvar _isArrayLike =\n/*#__PURE__*/\n_curry1(function isArrayLike(x) {\n if (_isArray(x)) {\n return true;\n }\n\n if (!x) {\n return false;\n }\n\n if (typeof x !== 'object') {\n return false;\n }\n\n if (_isString(x)) {\n return false;\n }\n\n if (x.nodeType === 1) {\n return !!x.length;\n }\n\n if (x.length === 0) {\n return true;\n }\n\n if (x.length > 0) {\n return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n }\n\n return false;\n});\n\nexport default _isArrayLike;","var XWrap =\n/*#__PURE__*/\nfunction () {\n function XWrap(fn) {\n this.f = fn;\n }\n\n XWrap.prototype['@@transducer/init'] = function () {\n throw new Error('init not implemented on XWrap');\n };\n\n XWrap.prototype['@@transducer/result'] = function (acc) {\n return acc;\n };\n\n XWrap.prototype['@@transducer/step'] = function (acc, x) {\n return this.f(acc, x);\n };\n\n return XWrap;\n}();\n\nexport default function _xwrap(fn) {\n return new XWrap(fn);\n}","import _arity from \"./internal/_arity.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @category Object\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n * @see R.partial\n * @example\n *\n * const log = R.bind(console.log, console);\n * R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}\n * // logs {a: 2}\n * @symb R.bind(f, o)(a, b) = f.call(o, a, b)\n */\n\nvar bind =\n/*#__PURE__*/\n_curry2(function bind(fn, thisObj) {\n return _arity(fn.length, function () {\n return fn.apply(thisObj, arguments);\n });\n});\n\nexport default bind;","import _isArrayLike from \"./_isArrayLike.js\";\nimport _xwrap from \"./_xwrap.js\";\nimport bind from \"../bind.js\";\n\nfunction _arrayReduce(xf, acc, list) {\n var idx = 0;\n var len = list.length;\n\n while (idx < len) {\n acc = xf['@@transducer/step'](acc, list[idx]);\n\n if (acc && acc['@@transducer/reduced']) {\n acc = acc['@@transducer/value'];\n break;\n }\n\n idx += 1;\n }\n\n return xf['@@transducer/result'](acc);\n}\n\nfunction _iterableReduce(xf, acc, iter) {\n var step = iter.next();\n\n while (!step.done) {\n acc = xf['@@transducer/step'](acc, step.value);\n\n if (acc && acc['@@transducer/reduced']) {\n acc = acc['@@transducer/value'];\n break;\n }\n\n step = iter.next();\n }\n\n return xf['@@transducer/result'](acc);\n}\n\nfunction _methodReduce(xf, acc, obj, methodName) {\n return xf['@@transducer/result'](obj[methodName](bind(xf['@@transducer/step'], xf), acc));\n}\n\nvar symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\nexport default function _reduce(fn, acc, list) {\n if (typeof fn === 'function') {\n fn = _xwrap(fn);\n }\n\n if (_isArrayLike(list)) {\n return _arrayReduce(fn, acc, list);\n }\n\n if (typeof list['fantasy-land/reduce'] === 'function') {\n return _methodReduce(fn, acc, list, 'fantasy-land/reduce');\n }\n\n if (list[symIterator] != null) {\n return _iterableReduce(fn, acc, list[symIterator]());\n }\n\n if (typeof list.next === 'function') {\n return _iterableReduce(fn, acc, list);\n }\n\n if (typeof list.reduce === 'function') {\n return _methodReduce(fn, acc, list, 'reduce');\n }\n\n throw new TypeError('reduce: list must be array or iterable');\n}","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XMap =\n/*#__PURE__*/\nfunction () {\n function XMap(f, xf) {\n this.xf = xf;\n this.f = f;\n }\n\n XMap.prototype['@@transducer/init'] = _xfBase.init;\n XMap.prototype['@@transducer/result'] = _xfBase.result;\n\n XMap.prototype['@@transducer/step'] = function (result, input) {\n return this.xf['@@transducer/step'](result, this.f(input));\n };\n\n return XMap;\n}();\n\nvar _xmap =\n/*#__PURE__*/\n_curry2(function _xmap(f, xf) {\n return new XMap(f, xf);\n});\n\nexport default _xmap;","export default function _has(prop, obj) {\n return Object.prototype.hasOwnProperty.call(obj, prop);\n}","import _has from \"./_has.js\";\nvar toString = Object.prototype.toString;\n\nvar _isArguments =\n/*#__PURE__*/\nfunction () {\n return toString.call(arguments) === '[object Arguments]' ? function _isArguments(x) {\n return toString.call(x) === '[object Arguments]';\n } : function _isArguments(x) {\n return _has('callee', x);\n };\n}();\n\nexport default _isArguments;","import _curry1 from \"./internal/_curry1.js\";\nimport _has from \"./internal/_has.js\";\nimport _isArguments from \"./internal/_isArguments.js\"; // cover IE < 9 keys issues\n\nvar hasEnumBug = !\n/*#__PURE__*/\n{\n toString: null\n}.propertyIsEnumerable('toString');\nvar nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; // Safari bug\n\nvar hasArgsEnumBug =\n/*#__PURE__*/\nfunction () {\n 'use strict';\n\n return arguments.propertyIsEnumerable('length');\n}();\n\nvar contains = function contains(list, item) {\n var idx = 0;\n\n while (idx < list.length) {\n if (list[idx] === item) {\n return true;\n }\n\n idx += 1;\n }\n\n return false;\n};\n/**\n * Returns a list containing the names of all the enumerable own properties of\n * the supplied object.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @see R.keysIn, R.values\n * @example\n *\n * R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\n\n\nvar keys = typeof Object.keys === 'function' && !hasArgsEnumBug ?\n/*#__PURE__*/\n_curry1(function keys(obj) {\n return Object(obj) !== obj ? [] : Object.keys(obj);\n}) :\n/*#__PURE__*/\n_curry1(function keys(obj) {\n if (Object(obj) !== obj) {\n return [];\n }\n\n var prop, nIdx;\n var ks = [];\n\n var checkArgsLength = hasArgsEnumBug && _isArguments(obj);\n\n for (prop in obj) {\n if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {\n ks[ks.length] = prop;\n }\n }\n\n if (hasEnumBug) {\n nIdx = nonEnumerableProps.length - 1;\n\n while (nIdx >= 0) {\n prop = nonEnumerableProps[nIdx];\n\n if (_has(prop, obj) && !contains(ks, prop)) {\n ks[ks.length] = prop;\n }\n\n nIdx -= 1;\n }\n }\n\n return ks;\n});\nexport default keys;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _map from \"./internal/_map.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport _xmap from \"./internal/_xmap.js\";\nimport curryN from \"./curryN.js\";\nimport keys from \"./keys.js\";\n/**\n * Takes a function and\n * a [functor](https://github.com/fantasyland/fantasy-land#functor),\n * applies the function to each of the functor's values, and returns\n * a functor of the same shape.\n *\n * Ramda provides suitable `map` implementations for `Array` and `Object`,\n * so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.\n *\n * Dispatches to the `map` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * Also treats functions as functors and will compose them together.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Functor 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 R.transduce, R.addIndex\n * @example\n *\n * const double = x => x * 2;\n *\n * R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n *\n * R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}\n * @symb R.map(f, [a, b]) = [f(a), f(b)]\n * @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) }\n * @symb R.map(f, functor_o) = functor_o.map(f)\n */\n\nvar map =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['fantasy-land/map', 'map'], _xmap, function map(fn, functor) {\n switch (Object.prototype.toString.call(functor)) {\n case '[object Function]':\n return curryN(functor.length, function () {\n return fn.call(this, functor.apply(this, arguments));\n });\n\n case '[object Object]':\n return _reduce(function (acc, key) {\n acc[key] = fn(functor[key]);\n return acc;\n }, {}, keys(functor));\n\n default:\n return _map(fn, functor);\n }\n}));\n\nexport default map;","/**\n * Determine if the passed argument is an integer.\n *\n * @private\n * @param {*} n\n * @category Type\n * @return {Boolean}\n */\nexport default Number.isInteger || function _isInteger(n) {\n return n << 0 === n;\n};","import _curry2 from \"./internal/_curry2.js\";\nimport _isString from \"./internal/_isString.js\";\n/**\n * Returns the nth element of the given list or string. If n is negative the\n * element at index length + n is returned.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> [a] -> a | Undefined\n * @sig Number -> String -> String\n * @param {Number} offset\n * @param {*} list\n * @return {*}\n * @example\n *\n * const list = ['foo', 'bar', 'baz', 'quux'];\n * R.nth(1, list); //=> 'bar'\n * R.nth(-1, list); //=> 'quux'\n * R.nth(-99, list); //=> undefined\n *\n * R.nth(2, 'abc'); //=> 'c'\n * R.nth(3, 'abc'); //=> ''\n * @symb R.nth(-1, [a, b, c]) = c\n * @symb R.nth(0, [a, b, c]) = a\n * @symb R.nth(1, [a, b, c]) = b\n */\n\nvar nth =\n/*#__PURE__*/\n_curry2(function nth(offset, list) {\n var idx = offset < 0 ? list.length + offset : offset;\n return _isString(list) ? list.charAt(idx) : list[idx];\n});\n\nexport default nth;","import _curry2 from \"./internal/_curry2.js\";\nimport _isInteger from \"./internal/_isInteger.js\";\nimport nth from \"./nth.js\";\n/**\n * Retrieves the values at given paths of an object.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category Object\n * @typedefn Idx = [String | Int]\n * @sig [Idx] -> {a} -> [a | Undefined]\n * @param {Array} pathsArray The array of paths to be fetched.\n * @param {Object} obj The object to retrieve the nested properties from.\n * @return {Array} A list consisting of values at paths specified by \"pathsArray\".\n * @see R.path\n * @example\n *\n * R.paths([['a', 'b'], ['p', 0, 'q']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, 3]\n * R.paths([['a', 'b'], ['p', 'r']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, undefined]\n */\n\nvar paths =\n/*#__PURE__*/\n_curry2(function paths(pathsArray, obj) {\n return pathsArray.map(function (paths) {\n var val = obj;\n var idx = 0;\n var p;\n\n while (idx < paths.length) {\n if (val == null) {\n return;\n }\n\n p = paths[idx];\n val = _isInteger(p) ? nth(p, val) : val[p];\n idx += 1;\n }\n\n return val;\n });\n});\n\nexport default paths;","import _curry2 from \"./internal/_curry2.js\";\nimport paths from \"./paths.js\";\n/**\n * Retrieve the value at a given path.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig [Idx] -> {a} -> a | Undefined\n * @param {Array} path The path to use.\n * @param {Object} obj The object to retrieve the nested property from.\n * @return {*} The data at `path`.\n * @see R.prop, R.nth\n * @example\n *\n * R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n * R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n * R.path(['a', 'b', 0], {a: {b: [1, 2, 3]}}); //=> 1\n * R.path(['a', 'b', -2], {a: {b: [1, 2, 3]}}); //=> 2\n */\n\nvar path =\n/*#__PURE__*/\n_curry2(function path(pathAr, obj) {\n return paths([pathAr], obj)[0];\n});\n\nexport default path;","import _curry2 from \"./internal/_curry2.js\";\nimport path from \"./path.js\";\n/**\n * Returns a function that when supplied an object returns the indicated\n * property of that object, if it exists.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig Idx -> {s: a} -> a | Undefined\n * @param {String|Number} p The property name or array index\n * @param {Object} obj The object to query\n * @return {*} The value at `obj.p`.\n * @see R.path, R.nth\n * @example\n *\n * R.prop('x', {x: 100}); //=> 100\n * R.prop('x', {}); //=> undefined\n * R.prop(0, [100]); //=> 100\n * R.compose(R.inc, R.prop('x'))({ x: 3 }) //=> 4\n */\n\nvar prop =\n/*#__PURE__*/\n_curry2(function prop(p, obj) {\n return path([p], obj);\n});\n\nexport default prop;","import _curry2 from \"./internal/_curry2.js\";\nimport map from \"./map.js\";\nimport prop from \"./prop.js\";\n/**\n * Returns a new list by plucking the same named property off all objects in\n * the list supplied.\n *\n * `pluck` will work on\n * any [functor](https://github.com/fantasyland/fantasy-land#functor) in\n * addition to arrays, as it is equivalent to `R.map(R.prop(k), f)`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Functor f => k -> f {k: v} -> f v\n * @param {Number|String} key The key name to pluck off of each object.\n * @param {Array} f The array or functor to consider.\n * @return {Array} The list of values for the given key.\n * @see R.props\n * @example\n *\n * var getAges = R.pluck('age');\n * getAges([{name: 'fred', age: 29}, {name: 'wilma', age: 27}]); //=> [29, 27]\n *\n * R.pluck(0, [[1, 2], [3, 4]]); //=> [1, 3]\n * R.pluck('val', {a: {val: 3}, b: {val: 5}}); //=> {a: 3, b: 5}\n * @symb R.pluck('x', [{x: 1, y: 2}, {x: 3, y: 4}, {x: 5, y: 6}]) = [1, 3, 5]\n * @symb R.pluck(0, [[1, 2], [3, 4], [5, 6]]) = [1, 3, 5]\n */\n\nvar pluck =\n/*#__PURE__*/\n_curry2(function pluck(p, list) {\n return map(prop(p), list);\n});\n\nexport default pluck;","import _curry3 from \"./internal/_curry3.js\";\nimport _reduce from \"./internal/_reduce.js\";\n/**\n * Returns a single item by iterating through the list, successively calling\n * the iterator function and passing it an accumulator value and the current\n * value from the array, and then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*. It may use\n * [`R.reduced`](#reduced) to shortcut the iteration.\n *\n * The arguments' order of [`reduceRight`](#reduceRight)'s iterator function\n * is *(value, acc)*.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.reduce` method. For more details\n * on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n *\n * Dispatches to the `reduce` method of the third argument, if present. When\n * doing so, it is up to the user to handle the [`R.reduced`](#reduced)\n * shortcuting, as this is not implemented by `reduce`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n * current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduced, R.addIndex, R.reduceRight\n * @example\n *\n * R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10\n * // - -10\n * // / \\ / \\\n * // - 4 -6 4\n * // / \\ / \\\n * // - 3 ==> -3 3\n * // / \\ / \\\n * // - 2 -1 2\n * // / \\ / \\\n * // 0 1 0 1\n *\n * @symb R.reduce(f, a, [b, c, d]) = f(f(f(a, b), c), d)\n */\n\nvar reduce =\n/*#__PURE__*/\n_curry3(_reduce);\n\nexport default reduce;","import _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\nimport max from \"./max.js\";\nimport pluck from \"./pluck.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Takes a list of predicates and returns a predicate that returns true for a\n * given list of arguments if every one of the provided predicates is satisfied\n * by those arguments.\n *\n * The function returned is a curried function whose arity matches that of the\n * highest-arity predicate.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Logic\n * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n * @param {Array} predicates An array of predicates to check\n * @return {Function} The combined predicate\n * @see R.anyPass\n * @example\n *\n * const isQueen = R.propEq('rank', 'Q');\n * const isSpade = R.propEq('suit', '♠︎');\n * const isQueenOfSpades = R.allPass([isQueen, isSpade]);\n *\n * isQueenOfSpades({rank: 'Q', suit: '♣︎'}); //=> false\n * isQueenOfSpades({rank: 'Q', suit: '♠︎'}); //=> true\n */\n\nvar allPass =\n/*#__PURE__*/\n_curry1(function allPass(preds) {\n return curryN(reduce(max, 0, pluck('length', preds)), function () {\n var idx = 0;\n var len = preds.length;\n\n while (idx < len) {\n if (!preds[idx].apply(this, arguments)) {\n return false;\n }\n\n idx += 1;\n }\n\n return true;\n });\n});\n\nexport default allPass;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator) in\n * other languages and libraries.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n * const t = R.always('Tee');\n * t(); //=> 'Tee'\n */\n\nvar always =\n/*#__PURE__*/\n_curry1(function always(val) {\n return function () {\n return val;\n };\n});\n\nexport default always;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if both arguments are `true`; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig a -> b -> a | b\n * @param {Any} a\n * @param {Any} b\n * @return {Any} the first argument if it is falsy, otherwise the second argument.\n * @see R.both, R.xor\n * @example\n *\n * R.and(true, true); //=> true\n * R.and(true, false); //=> false\n * R.and(false, true); //=> false\n * R.and(false, false); //=> false\n */\n\nvar and =\n/*#__PURE__*/\n_curry2(function and(a, b) {\n return a && b;\n});\n\nexport default and;","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 _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\nimport max from \"./max.js\";\nimport pluck from \"./pluck.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Takes a list of predicates and returns a predicate that returns true for a\n * given list of arguments if at least one of the provided predicates is\n * satisfied by those arguments.\n *\n * The function returned is a curried function whose arity matches that of the\n * highest-arity predicate.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Logic\n * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n * @param {Array} predicates An array of predicates to check\n * @return {Function} The combined predicate\n * @see R.allPass\n * @example\n *\n * const isClub = R.propEq('suit', '♣');\n * const isSpade = R.propEq('suit', '♠');\n * const isBlackCard = R.anyPass([isClub, isSpade]);\n *\n * isBlackCard({rank: '10', suit: '♣'}); //=> true\n * isBlackCard({rank: 'Q', suit: '♠'}); //=> true\n * isBlackCard({rank: 'Q', suit: '♦'}); //=> false\n */\n\nvar anyPass =\n/*#__PURE__*/\n_curry1(function anyPass(preds) {\n return curryN(reduce(max, 0, pluck('length', preds)), function () {\n var idx = 0;\n var len = preds.length;\n\n while (idx < len) {\n if (preds[idx].apply(this, arguments)) {\n return true;\n }\n\n idx += 1;\n }\n\n return false;\n });\n});\n\nexport default anyPass;","import _concat from \"./internal/_concat.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport map from \"./map.js\";\n/**\n * ap applies a list of functions to a list of values.\n *\n * Dispatches to the `ap` method of the second argument, if present. Also\n * treats curried functions as applicatives.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig [a -> b] -> [a] -> [b]\n * @sig Apply f => f (a -> b) -> f a -> f b\n * @sig (r -> a -> b) -> (r -> a) -> (r -> b)\n * @param {*} applyF\n * @param {*} applyX\n * @return {*}\n * @example\n *\n * R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n * R.ap([R.concat('tasty '), R.toUpper], ['pizza', 'salad']); //=> [\"tasty pizza\", \"tasty salad\", \"PIZZA\", \"SALAD\"]\n *\n * // R.ap can also be used as S combinator\n * // when only two functions are passed\n * R.ap(R.concat, R.toUpper)('Ramda') //=> 'RamdaRAMDA'\n * @symb R.ap([f, g], [a, b]) = [f(a), f(b), g(a), g(b)]\n */\n\nvar ap =\n/*#__PURE__*/\n_curry2(function ap(applyF, applyX) {\n return typeof applyX['fantasy-land/ap'] === 'function' ? applyX['fantasy-land/ap'](applyF) : typeof applyF.ap === 'function' ? applyF.ap(applyX) : typeof applyF === 'function' ? function (x) {\n return applyF(x)(applyX(x));\n } : _reduce(function (acc, f) {\n return _concat(acc, map(f, applyX));\n }, [], applyF);\n});\n\nexport default ap;","export default function _aperture(n, list) {\n var idx = 0;\n var limit = list.length - (n - 1);\n var acc = new Array(limit >= 0 ? limit : 0);\n\n while (idx < limit) {\n acc[idx] = Array.prototype.slice.call(list, idx, idx + n);\n idx += 1;\n }\n\n return acc;\n}","import _concat from \"./_concat.js\";\nimport _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XAperture =\n/*#__PURE__*/\nfunction () {\n function XAperture(n, xf) {\n this.xf = xf;\n this.pos = 0;\n this.full = false;\n this.acc = new Array(n);\n }\n\n XAperture.prototype['@@transducer/init'] = _xfBase.init;\n\n XAperture.prototype['@@transducer/result'] = function (result) {\n this.acc = null;\n return this.xf['@@transducer/result'](result);\n };\n\n XAperture.prototype['@@transducer/step'] = function (result, input) {\n this.store(input);\n return this.full ? this.xf['@@transducer/step'](result, this.getCopy()) : result;\n };\n\n XAperture.prototype.store = function (input) {\n this.acc[this.pos] = input;\n this.pos += 1;\n\n if (this.pos === this.acc.length) {\n this.pos = 0;\n this.full = true;\n }\n };\n\n XAperture.prototype.getCopy = function () {\n return _concat(Array.prototype.slice.call(this.acc, this.pos), Array.prototype.slice.call(this.acc, 0, this.pos));\n };\n\n return XAperture;\n}();\n\nvar _xaperture =\n/*#__PURE__*/\n_curry2(function _xaperture(n, xf) {\n return new XAperture(n, xf);\n});\n\nexport default _xaperture;","import _aperture from \"./internal/_aperture.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xaperture from \"./internal/_xaperture.js\";\n/**\n * Returns a new list, composed of n-tuples of consecutive elements. If `n` is\n * greater than the length of the list, an empty list is returned.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category List\n * @sig Number -> [a] -> [[a]]\n * @param {Number} n The size of the tuples to create\n * @param {Array} list The list to split into `n`-length tuples\n * @return {Array} The resulting list of `n`-length tuples\n * @see R.transduce\n * @example\n *\n * R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n * R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n * R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n */\n\nvar aperture =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xaperture, _aperture));\n\nexport default aperture;","import _concat from \"./internal/_concat.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a new list containing the contents of the given list, followed by\n * the given element.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list of elements to add a new item to.\n * list.\n * @return {Array} A new list containing the elements of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n * R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n * R.append('tests', []); //=> ['tests']\n * R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\n\nvar append =\n/*#__PURE__*/\n_curry2(function append(el, list) {\n return _concat(list, [el]);\n});\n\nexport default append;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Applies function `fn` to the argument list `args`. This is useful for\n * creating a fixed-arity function from a variadic function. `fn` should be a\n * bound function if context is significant.\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Function\n * @sig (*... -> a) -> [*] -> a\n * @param {Function} fn The function which will be called with `args`\n * @param {Array} args The arguments to call `fn` with\n * @return {*} result The result, equivalent to `fn(...args)`\n * @see R.call, R.unapply\n * @example\n *\n * const nums = [1, 2, 3, -99, 42, 6, 7];\n * R.apply(Math.max, nums); //=> 42\n * @symb R.apply(f, [a, b, c]) = f(a, b, c)\n */\n\nvar apply =\n/*#__PURE__*/\n_curry2(function apply(fn, args) {\n return fn.apply(this, args);\n});\n\nexport default apply;","import _curry1 from \"./internal/_curry1.js\";\nimport keys from \"./keys.js\";\n/**\n * Returns a list of all the enumerable own properties of the supplied object.\n * Note that the order of the output array is not guaranteed across different\n * JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> [v]\n * @param {Object} obj The object to extract values from\n * @return {Array} An array of the values of the object's own properties.\n * @see R.valuesIn, R.keys\n * @example\n *\n * R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n */\n\nvar values =\n/*#__PURE__*/\n_curry1(function values(obj) {\n var props = keys(obj);\n var len = props.length;\n var vals = [];\n var idx = 0;\n\n while (idx < len) {\n vals[idx] = obj[props[idx]];\n idx += 1;\n }\n\n return vals;\n});\n\nexport default values;","import _curry1 from \"./internal/_curry1.js\";\nimport apply from \"./apply.js\";\nimport curryN from \"./curryN.js\";\nimport max from \"./max.js\";\nimport pluck from \"./pluck.js\";\nimport reduce from \"./reduce.js\";\nimport keys from \"./keys.js\";\nimport values from \"./values.js\"; // Use custom mapValues function to avoid issues with specs that include a \"map\" key and R.map\n// delegating calls to .map\n\nfunction mapValues(fn, obj) {\n return keys(obj).reduce(function (acc, key) {\n acc[key] = fn(obj[key]);\n return acc;\n }, {});\n}\n/**\n * Given a spec object recursively mapping properties to functions, creates a\n * function producing an object of the same structure, by mapping each property\n * to the result of calling its associated function with the supplied arguments.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Function\n * @sig {k: ((a, b, ..., m) -> v)} -> ((a, b, ..., m) -> {k: v})\n * @param {Object} spec an object recursively mapping properties to functions for\n * producing the values for these properties.\n * @return {Function} A function that returns an object of the same structure\n * as `spec', with each property set to the value returned by calling its\n * associated function with the supplied arguments.\n * @see R.converge, R.juxt\n * @example\n *\n * const getMetrics = R.applySpec({\n * sum: R.add,\n * nested: { mul: R.multiply }\n * });\n * getMetrics(2, 4); // => { sum: 6, nested: { mul: 8 } }\n * @symb R.applySpec({ x: f, y: { z: g } })(a, b) = { x: f(a, b), y: { z: g(a, b) } }\n */\n\n\nvar applySpec =\n/*#__PURE__*/\n_curry1(function applySpec(spec) {\n spec = mapValues(function (v) {\n return typeof v == 'function' ? v : applySpec(v);\n }, spec);\n return curryN(reduce(max, 0, pluck('length', values(spec))), function () {\n var args = arguments;\n return mapValues(function (f) {\n return apply(f, args);\n }, spec);\n });\n});\n\nexport default applySpec;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Takes a value and applies a function to it.\n *\n * This function is also known as the `thrush` combinator.\n *\n * @func\n * @memberOf R\n * @since v0.25.0\n * @category Function\n * @sig a -> (a -> b) -> b\n * @param {*} x The value\n * @param {Function} f The function to apply\n * @return {*} The result of applying `f` to `x`\n * @example\n *\n * const t42 = R.applyTo(42);\n * t42(R.identity); //=> 42\n * t42(R.add(1)); //=> 43\n */\n\nvar applyTo =\n/*#__PURE__*/\n_curry2(function applyTo(x, f) {\n return f(x);\n});\n\nexport default applyTo;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Makes an ascending comparator function out of a function that returns a value\n * that can be compared with `<` and `>`.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Function\n * @sig Ord b => (a -> b) -> a -> a -> Number\n * @param {Function} fn A function of arity one that returns a value that can be compared\n * @param {*} a The first item to be compared.\n * @param {*} b The second item to be compared.\n * @return {Number} `-1` if fn(a) < fn(b), `1` if fn(b) < fn(a), otherwise `0`\n * @see R.descend\n * @example\n *\n * const byAge = R.ascend(R.prop('age'));\n * const people = [\n * { name: 'Emma', age: 70 },\n * { name: 'Peter', age: 78 },\n * { name: 'Mikhail', age: 62 },\n * ];\n * const peopleByYoungestFirst = R.sort(byAge, people);\n * //=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }]\n */\n\nvar ascend =\n/*#__PURE__*/\n_curry3(function ascend(fn, a, b) {\n var aa = fn(a);\n var bb = fn(b);\n return aa < bb ? -1 : aa > bb ? 1 : 0;\n});\n\nexport default ascend;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value. Note that this copies and flattens prototype\n * properties onto the new object as well. All non-primitive properties are\n * copied by reference.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop The property name to set\n * @param {*} val The new value\n * @param {Object} obj The object to clone\n * @return {Object} A new object equivalent to the original except for the changed property.\n * @see R.dissoc, R.pick\n * @example\n *\n * R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\n\nvar assoc =\n/*#__PURE__*/\n_curry3(function assoc(prop, val, obj) {\n var result = {};\n\n for (var p in obj) {\n result[p] = obj[p];\n }\n\n result[prop] = val;\n return result;\n});\n\nexport default assoc;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Checks if the input value is `null` or `undefined`.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Type\n * @sig * -> Boolean\n * @param {*} x The value to test.\n * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n * @example\n *\n * R.isNil(null); //=> true\n * R.isNil(undefined); //=> true\n * R.isNil(0); //=> false\n * R.isNil([]); //=> false\n */\n\nvar isNil =\n/*#__PURE__*/\n_curry1(function isNil(x) {\n return x == null;\n});\n\nexport default isNil;","import _curry3 from \"./internal/_curry3.js\";\nimport _has from \"./internal/_has.js\";\nimport _isArray from \"./internal/_isArray.js\";\nimport _isInteger from \"./internal/_isInteger.js\";\nimport assoc from \"./assoc.js\";\nimport isNil from \"./isNil.js\";\n/**\n * Makes a shallow clone of an object, setting or overriding the nodes required\n * to create the given path, and placing the specific value at the tail end of\n * that path. Note that this copies and flattens prototype properties onto the\n * new object as well. All non-primitive properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig [Idx] -> a -> {a} -> {a}\n * @param {Array} path the path to set\n * @param {*} val The new value\n * @param {Object} obj The object to clone\n * @return {Object} A new object equivalent to the original except along the specified path.\n * @see R.dissocPath\n * @example\n *\n * R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n *\n * // Any missing or non-object keys in path will be overridden\n * R.assocPath(['a', 'b', 'c'], 42, {a: 5}); //=> {a: {b: {c: 42}}}\n */\n\nvar assocPath =\n/*#__PURE__*/\n_curry3(function assocPath(path, val, obj) {\n if (path.length === 0) {\n return val;\n }\n\n var idx = path[0];\n\n if (path.length > 1) {\n var nextObj = !isNil(obj) && _has(idx, obj) ? obj[idx] : _isInteger(path[1]) ? [] : {};\n val = assocPath(Array.prototype.slice.call(path, 1), val, nextObj);\n }\n\n if (_isInteger(idx) && _isArray(obj)) {\n var arr = [].concat(obj);\n arr[idx] = val;\n return arr;\n } else {\n return assoc(idx, val, obj);\n }\n});\n\nexport default assocPath;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts\n * exactly `n` parameters. Any extraneous parameters will not be passed to the\n * supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} n The desired arity of the new function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n * arity `n`.\n * @see R.binary, R.unary\n * @example\n *\n * const takesTwoArgs = (a, b) => [a, b];\n *\n * takesTwoArgs.length; //=> 2\n * takesTwoArgs(1, 2); //=> [1, 2]\n *\n * const takesOneArg = R.nAry(1, takesTwoArgs);\n * takesOneArg.length; //=> 1\n * // Only `n` arguments are passed to the wrapped function\n * takesOneArg(1, 2); //=> [1, undefined]\n * @symb R.nAry(0, f)(a, b) = f()\n * @symb R.nAry(1, f)(a, b) = f(a)\n * @symb R.nAry(2, f)(a, b) = f(a, b)\n */\n\nvar nAry =\n/*#__PURE__*/\n_curry2(function nAry(n, fn) {\n switch (n) {\n case 0:\n return function () {\n return fn.call(this);\n };\n\n case 1:\n return function (a0) {\n return fn.call(this, a0);\n };\n\n case 2:\n return function (a0, a1) {\n return fn.call(this, a0, a1);\n };\n\n case 3:\n return function (a0, a1, a2) {\n return fn.call(this, a0, a1, a2);\n };\n\n case 4:\n return function (a0, a1, a2, a3) {\n return fn.call(this, a0, a1, a2, a3);\n };\n\n case 5:\n return function (a0, a1, a2, a3, a4) {\n return fn.call(this, a0, a1, a2, a3, a4);\n };\n\n case 6:\n return function (a0, a1, a2, a3, a4, a5) {\n return fn.call(this, a0, a1, a2, a3, a4, a5);\n };\n\n case 7:\n return function (a0, a1, a2, a3, a4, a5, a6) {\n return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n };\n\n case 8:\n return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n };\n\n case 9:\n return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n };\n\n case 10:\n return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n };\n\n default:\n throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n }\n});\n\nexport default nAry;","import _curry1 from \"./internal/_curry1.js\";\nimport nAry from \"./nAry.js\";\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts\n * exactly 2 parameters. Any extraneous parameters will not be passed to the\n * supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Function\n * @sig (* -> c) -> (a, b -> c)\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n * arity 2.\n * @see R.nAry, R.unary\n * @example\n *\n * const takesThreeArgs = function(a, b, c) {\n * return [a, b, c];\n * };\n * takesThreeArgs.length; //=> 3\n * takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n *\n * const takesTwoArgs = R.binary(takesThreeArgs);\n * takesTwoArgs.length; //=> 2\n * // Only 2 arguments are passed to the wrapped function\n * takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n * @symb R.binary(f)(a, b, c) = f(a, b)\n */\n\nvar binary =\n/*#__PURE__*/\n_curry1(function binary(fn) {\n return nAry(2, fn);\n});\n\nexport default binary;","export default function _isFunction(x) {\n var type = Object.prototype.toString.call(x);\n return type === '[object Function]' || type === '[object AsyncFunction]' || type === '[object GeneratorFunction]' || type === '[object AsyncGeneratorFunction]';\n}","import _curry2 from \"./internal/_curry2.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport ap from \"./ap.js\";\nimport curryN from \"./curryN.js\";\nimport map from \"./map.js\";\n/**\n * \"lifts\" a function to be the specified arity, so that it may \"map over\" that\n * many lists, Functions or other objects that satisfy the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Function\n * @sig Number -> (*... -> *) -> ([*]... -> [*])\n * @param {Function} fn The function to lift into higher context\n * @return {Function} The lifted function.\n * @see R.lift, R.ap\n * @example\n *\n * const madd3 = R.liftN(3, (...args) => R.sum(args));\n * madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n */\n\nvar liftN =\n/*#__PURE__*/\n_curry2(function liftN(arity, fn) {\n var lifted = curryN(arity, fn);\n return curryN(arity, function () {\n return _reduce(ap, map(lifted, arguments[0]), Array.prototype.slice.call(arguments, 1));\n });\n});\n\nexport default liftN;","import _curry1 from \"./internal/_curry1.js\";\nimport liftN from \"./liftN.js\";\n/**\n * \"lifts\" a function of arity > 1 so that it may \"map over\" a list, Function or other\n * object that satisfies the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Function\n * @sig (*... -> *) -> ([*]... -> [*])\n * @param {Function} fn The function to lift into higher context\n * @return {Function} The lifted function.\n * @see R.liftN\n * @example\n *\n * const madd3 = R.lift((a, b, c) => a + b + c);\n *\n * madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n *\n * const madd5 = R.lift((a, b, c, d, e) => a + b + c + d + e);\n *\n * madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n */\n\nvar lift =\n/*#__PURE__*/\n_curry1(function lift(fn) {\n return liftN(fn.length, fn);\n});\n\nexport default lift;","import _curry2 from \"./internal/_curry2.js\";\nimport _isFunction from \"./internal/_isFunction.js\";\nimport and from \"./and.js\";\nimport lift from \"./lift.js\";\n/**\n * A function which calls the two provided functions and returns the `&&`\n * of the results.\n * It returns the result of the first function if it is false-y and the result\n * of the second function otherwise. Note that this is short-circuited,\n * meaning that the second function will not be invoked if the first returns a\n * false-y value.\n *\n * In addition to functions, `R.both` also accepts any fantasy-land compatible\n * applicative functor.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n * @param {Function} f A predicate\n * @param {Function} g Another predicate\n * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n * @see R.and\n * @example\n *\n * const gt10 = R.gt(R.__, 10)\n * const lt20 = R.lt(R.__, 20)\n * const f = R.both(gt10, lt20);\n * f(15); //=> true\n * f(30); //=> false\n *\n * R.both(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(false)\n * R.both([false, false, 'a'], [11]); //=> [false, false, 11]\n */\n\nvar both =\n/*#__PURE__*/\n_curry2(function both(f, g) {\n return _isFunction(f) ? function _both() {\n return f.apply(this, arguments) && g.apply(this, arguments);\n } : lift(and)(f, g);\n});\n\nexport default both;","import _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Returns a curried equivalent of the provided function. The curried function\n * has two unusual capabilities. First, its arguments needn't be provided one\n * at a time. If `f` is a ternary function and `g` is `R.curry(f)`, the\n * following are equivalent:\n *\n * - `g(1)(2)(3)`\n * - `g(1)(2, 3)`\n * - `g(1, 2)(3)`\n * - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value [`R.__`](#__) may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),\n * the following are equivalent:\n *\n * - `g(1, 2, 3)`\n * - `g(_, 2, 3)(1)`\n * - `g(_, _, 3)(1)(2)`\n * - `g(_, _, 3)(1, 2)`\n * - `g(_, 2)(1)(3)`\n * - `g(_, 2)(1, 3)`\n * - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN, R.partial\n * @example\n *\n * const addFourNumbers = (a, b, c, d) => a + b + c + d;\n *\n * const curriedAddFourNumbers = R.curry(addFourNumbers);\n * const f = curriedAddFourNumbers(1, 2);\n * const g = f(3);\n * g(4); //=> 10\n */\n\nvar curry =\n/*#__PURE__*/\n_curry1(function curry(fn) {\n return curryN(fn.length, fn);\n});\n\nexport default curry;","import curry from \"./curry.js\";\n/**\n * Returns the result of calling its first argument with the remaining\n * arguments. This is occasionally useful as a converging function for\n * [`R.converge`](#converge): the first branch can produce a function while the\n * remaining branches produce values to be passed to that function as its\n * arguments.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig (*... -> a),*... -> a\n * @param {Function} fn The function to apply to the remaining arguments.\n * @param {...*} args Any number of positional arguments.\n * @return {*}\n * @see R.apply\n * @example\n *\n * R.call(R.add, 1, 2); //=> 3\n *\n * const indentN = R.pipe(R.repeat(' '),\n * R.join(''),\n * R.replace(/^(?!$)/gm));\n *\n * const format = R.converge(R.call, [\n * R.pipe(R.prop('indent'), indentN),\n * R.prop('value')\n * ]);\n *\n * format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> ' foo\\n bar\\n baz\\n'\n * @symb R.call(f, a, b) = f(a, b)\n */\n\nvar call =\n/*#__PURE__*/\ncurry(function call(fn) {\n return fn.apply(this, Array.prototype.slice.call(arguments, 1));\n});\nexport default call;","import _isArrayLike from \"./_isArrayLike.js\";\n/**\n * `_makeFlat` is a helper function that returns a one-level or fully recursive\n * function based on the flag passed in.\n *\n * @private\n */\n\nexport default function _makeFlat(recursive) {\n return function flatt(list) {\n var value, jlen, j;\n var result = [];\n var idx = 0;\n var ilen = list.length;\n\n while (idx < ilen) {\n if (_isArrayLike(list[idx])) {\n value = recursive ? flatt(list[idx]) : list[idx];\n j = 0;\n jlen = value.length;\n\n while (j < jlen) {\n result[result.length] = value[j];\n j += 1;\n }\n } else {\n result[result.length] = list[idx];\n }\n\n idx += 1;\n }\n\n return result;\n };\n}","import _forceReduced from \"./_forceReduced.js\";\nimport _isArrayLike from \"./_isArrayLike.js\";\nimport _reduce from \"./_reduce.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar preservingReduced = function (xf) {\n return {\n '@@transducer/init': _xfBase.init,\n '@@transducer/result': function (result) {\n return xf['@@transducer/result'](result);\n },\n '@@transducer/step': function (result, input) {\n var ret = xf['@@transducer/step'](result, input);\n return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n }\n };\n};\n\nvar _flatCat = function _xcat(xf) {\n var rxf = preservingReduced(xf);\n return {\n '@@transducer/init': _xfBase.init,\n '@@transducer/result': function (result) {\n return rxf['@@transducer/result'](result);\n },\n '@@transducer/step': function (result, input) {\n return !_isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n }\n };\n};\n\nexport default _flatCat;","export default function _forceReduced(x) {\n return {\n '@@transducer/value': x,\n '@@transducer/reduced': true\n };\n}","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _makeFlat from \"./internal/_makeFlat.js\";\nimport _xchain from \"./internal/_xchain.js\";\nimport map from \"./map.js\";\n/**\n * `chain` maps a function over a list and concatenates the results. `chain`\n * is also known as `flatMap` in some libraries.\n *\n * Dispatches to the `chain` method of the second argument, if present,\n * according to the [FantasyLand Chain spec](https://github.com/fantasyland/fantasy-land#chain).\n *\n * If second argument is a function, `chain(f, g)(x)` is equivalent to `f(g(x), x)`.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig Chain m => (a -> m b) -> m a -> m b\n * @param {Function} fn The function to map with\n * @param {Array} list The list to map over\n * @return {Array} The result of flat-mapping `list` with `fn`\n * @example\n *\n * const duplicate = n => [n, n];\n * R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n *\n * R.chain(R.append, R.head)([1, 2, 3]); //=> [1, 2, 3, 1]\n */\n\nvar chain =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['fantasy-land/chain', 'chain'], _xchain, function chain(fn, monad) {\n if (typeof monad === 'function') {\n return function (x) {\n return fn(monad(x))(x);\n };\n }\n\n return _makeFlat(false)(map(fn, monad));\n}));\n\nexport default chain;","import _curry2 from \"./_curry2.js\";\nimport _flatCat from \"./_flatCat.js\";\nimport map from \"../map.js\";\n\nvar _xchain =\n/*#__PURE__*/\n_curry2(function _xchain(f, xf) {\n return map(f, _flatCat(xf));\n});\n\nexport default _xchain;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Restricts a number to be within a range.\n *\n * Also works for other ordered types such as Strings and Dates.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Relation\n * @sig Ord a => a -> a -> a -> a\n * @param {Number} minimum The lower limit of the clamp (inclusive)\n * @param {Number} maximum The upper limit of the clamp (inclusive)\n * @param {Number} value Value to be clamped\n * @return {Number} Returns `minimum` when `val < minimum`, `maximum` when `val > maximum`, returns `val` otherwise\n * @example\n *\n * R.clamp(1, 10, -5) // => 1\n * R.clamp(1, 10, 15) // => 10\n * R.clamp(1, 10, 4) // => 4\n */\n\nvar clamp =\n/*#__PURE__*/\n_curry3(function clamp(min, max, value) {\n if (min > max) {\n throw new Error('min must not be greater than max in clamp(min, max, value)');\n }\n\n return value < min ? min : value > max ? max : value;\n});\n\nexport default clamp;","export default function _cloneRegExp(pattern) {\n return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n}","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Gives a single-word string description of the (native) type of a value,\n * returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not\n * attempt to distinguish user Object types any further, reporting them all as\n * 'Object'.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n * R.type({}); //=> \"Object\"\n * R.type(1); //=> \"Number\"\n * R.type(false); //=> \"Boolean\"\n * R.type('s'); //=> \"String\"\n * R.type(null); //=> \"Null\"\n * R.type([]); //=> \"Array\"\n * R.type(/[A-z]/); //=> \"RegExp\"\n * R.type(() => {}); //=> \"Function\"\n * R.type(undefined); //=> \"Undefined\"\n */\n\nvar type =\n/*#__PURE__*/\n_curry1(function type(val) {\n return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n});\n\nexport default type;","import _cloneRegExp from \"./_cloneRegExp.js\";\nimport type from \"../type.js\";\n/**\n * Copies an object.\n *\n * @private\n * @param {*} value The value to be copied\n * @param {Array} refFrom Array containing the source references\n * @param {Array} refTo Array containing the copied source references\n * @param {Boolean} deep Whether or not to perform deep cloning.\n * @return {*} The copied value.\n */\n\nexport default function _clone(value, refFrom, refTo, deep) {\n var copy = function copy(copiedValue) {\n var len = refFrom.length;\n var idx = 0;\n\n while (idx < len) {\n if (value === refFrom[idx]) {\n return refTo[idx];\n }\n\n idx += 1;\n }\n\n refFrom[idx + 1] = value;\n refTo[idx + 1] = copiedValue;\n\n for (var key in value) {\n copiedValue[key] = deep ? _clone(value[key], refFrom, refTo, true) : value[key];\n }\n\n return copiedValue;\n };\n\n switch (type(value)) {\n case 'Object':\n return copy({});\n\n case 'Array':\n return copy([]);\n\n case 'Date':\n return new Date(value.valueOf());\n\n case 'RegExp':\n return _cloneRegExp(value);\n\n default:\n return value;\n }\n}","import _clone from \"./internal/_clone.js\";\nimport _curry1 from \"./internal/_curry1.js\";\n/**\n * Creates a deep copy of the value which may contain (nested) `Array`s and\n * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n * assigned by reference rather than copied\n *\n * Dispatches to a `clone` method if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {*} -> {*}\n * @param {*} value The object or array to clone\n * @return {*} A deeply cloned copy of `val`\n * @example\n *\n * const objects = [{}, {}, {}];\n * const objectsClone = R.clone(objects);\n * objects === objectsClone; //=> false\n * objects[0] === objectsClone[0]; //=> false\n */\n\nvar clone =\n/*#__PURE__*/\n_curry1(function clone(value) {\n return value != null && typeof value.clone === 'function' ? value.clone() : _clone(value, [], [], true);\n});\n\nexport default clone;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Makes a comparator function out of a function that reports whether the first\n * element is less than the second.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((a, b) -> Boolean) -> ((a, b) -> Number)\n * @param {Function} pred A predicate function of arity two which will return `true` if the first argument\n * is less than the second, `false` otherwise\n * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`\n * @example\n *\n * const byAge = R.comparator((a, b) => a.age < b.age);\n * const people = [\n * { name: 'Emma', age: 70 },\n * { name: 'Peter', age: 78 },\n * { name: 'Mikhail', age: 62 },\n * ];\n * const peopleByIncreasingAge = R.sort(byAge, people);\n * //=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }]\n */\n\nvar comparator =\n/*#__PURE__*/\n_curry1(function comparator(pred) {\n return function (a, b) {\n return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n };\n});\n\nexport default comparator;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * A function that returns the `!` of its argument. It will return `true` when\n * passed false-y value, and `false` when passed a truth-y one.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig * -> Boolean\n * @param {*} a any value\n * @return {Boolean} the logical inverse of passed argument.\n * @see R.complement\n * @example\n *\n * R.not(true); //=> false\n * R.not(false); //=> true\n * R.not(0); //=> true\n * R.not(1); //=> false\n */\n\nvar not =\n/*#__PURE__*/\n_curry1(function not(a) {\n return !a;\n});\n\nexport default not;","import lift from \"./lift.js\";\nimport not from \"./not.js\";\n/**\n * Takes a function `f` and returns a function `g` such that if called with the same arguments\n * when `f` returns a \"truthy\" value, `g` returns `false` and when `f` returns a \"falsy\" value `g` returns `true`.\n *\n * `R.complement` may be applied to any functor\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> *) -> (*... -> Boolean)\n * @param {Function} f\n * @return {Function}\n * @see R.not\n * @example\n *\n * const isNotNil = R.complement(R.isNil);\n * isNil(null); //=> true\n * isNotNil(null); //=> false\n * isNil(7); //=> false\n * isNotNil(7); //=> true\n */\n\nvar complement =\n/*#__PURE__*/\nlift(not);\nexport default complement;","export default function _pipe(f, g) {\n return function () {\n return g.call(this, f.apply(this, arguments));\n };\n}","import _isArray from \"./_isArray.js\";\n/**\n * This checks whether a function has a [methodname] function. If it isn't an\n * array it will execute that function otherwise it will default to the ramda\n * implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\n\nexport default function _checkForMethod(methodname, fn) {\n return function () {\n var length = arguments.length;\n\n if (length === 0) {\n return fn();\n }\n\n var obj = arguments[length - 1];\n return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));\n };\n}","import _checkForMethod from \"./internal/_checkForMethod.js\";\nimport _curry3 from \"./internal/_curry3.js\";\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * Dispatches to the `slice` method of the third argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n * R.slice(1, 3, ['a', 'b', 'c', 'd']); //=> ['b', 'c']\n * R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n * R.slice(0, -1, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c']\n * R.slice(-3, -1, ['a', 'b', 'c', 'd']); //=> ['b', 'c']\n * R.slice(0, 3, 'ramda'); //=> 'ram'\n */\n\nvar slice =\n/*#__PURE__*/\n_curry3(\n/*#__PURE__*/\n_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n\nexport default slice;","import _checkForMethod from \"./internal/_checkForMethod.js\";\nimport _curry1 from \"./internal/_curry1.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * Dispatches to the `slice` method of the first argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.head, R.init, R.last\n * @example\n *\n * R.tail([1, 2, 3]); //=> [2, 3]\n * R.tail([1, 2]); //=> [2]\n * R.tail([1]); //=> []\n * R.tail([]); //=> []\n *\n * R.tail('abc'); //=> 'bc'\n * R.tail('ab'); //=> 'b'\n * R.tail('a'); //=> ''\n * R.tail(''); //=> ''\n */\n\nvar tail =\n/*#__PURE__*/\n_curry1(\n/*#__PURE__*/\n_checkForMethod('tail',\n/*#__PURE__*/\nslice(1, Infinity)));\n\nexport default tail;","import _arity from \"./internal/_arity.js\";\nimport _pipe from \"./internal/_pipe.js\";\nimport reduce from \"./reduce.js\";\nimport tail from \"./tail.js\";\n/**\n * Performs left-to-right function composition. The first argument may have\n * any arity; the remaining arguments must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * **Note:** The result of pipe is not automatically curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n * const f = R.pipe(Math.pow, R.negate, R.inc);\n *\n * f(3, 4); // -(3^4) + 1\n * @symb R.pipe(f, g, h)(a, b) = h(g(f(a, b)))\n */\n\nexport default function pipe() {\n if (arguments.length === 0) {\n throw new Error('pipe requires at least one argument');\n }\n\n return _arity(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n}","import _curry1 from \"./internal/_curry1.js\";\nimport _isString from \"./internal/_isString.js\";\n/**\n * Returns a new list or string with the elements or characters in reverse\n * order.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {Array|String} list\n * @return {Array|String}\n * @example\n *\n * R.reverse([1, 2, 3]); //=> [3, 2, 1]\n * R.reverse([1, 2]); //=> [2, 1]\n * R.reverse([1]); //=> [1]\n * R.reverse([]); //=> []\n *\n * R.reverse('abc'); //=> 'cba'\n * R.reverse('ab'); //=> 'ba'\n * R.reverse('a'); //=> 'a'\n * R.reverse(''); //=> ''\n */\n\nvar reverse =\n/*#__PURE__*/\n_curry1(function reverse(list) {\n return _isString(list) ? list.split('').reverse().join('') : Array.prototype.slice.call(list, 0).reverse();\n});\n\nexport default reverse;","import pipe from \"./pipe.js\";\nimport reverse from \"./reverse.js\";\n/**\n * Performs right-to-left function composition. The last argument may have\n * any arity; the remaining arguments must be unary.\n *\n * **Note:** The result of compose is not automatically curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> ((a, b, ..., n) -> z)\n * @param {...Function} ...functions The functions to compose\n * @return {Function}\n * @see R.pipe\n * @example\n *\n * const classyGreeting = (firstName, lastName) => \"The name's \" + lastName + \", \" + firstName + \" \" + lastName\n * const yellGreeting = R.compose(R.toUpper, classyGreeting);\n * yellGreeting('James', 'Bond'); //=> \"THE NAME'S BOND, JAMES BOND\"\n *\n * R.compose(Math.abs, R.add(1), R.multiply(2))(-4) //=> 7\n *\n * @symb R.compose(f, g, h)(a, b) = f(g(h(a, b)))\n */\n\nexport default function compose() {\n if (arguments.length === 0) {\n throw new Error('compose requires at least one argument');\n }\n\n return pipe.apply(this, reverse(arguments));\n}","import chain from \"./chain.js\";\nimport compose from \"./compose.js\";\nimport map from \"./map.js\";\n/**\n * Returns the right-to-left Kleisli composition of the provided functions,\n * each of which must return a value of a type supported by [`chain`](#chain).\n *\n * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), f)`.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Function\n * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (a -> m z)\n * @param {...Function} ...functions The functions to compose\n * @return {Function}\n * @see R.pipeK\n * @deprecated since v0.26.0\n * @example\n *\n * // get :: String -> Object -> Maybe *\n * const get = R.curry((propName, obj) => Maybe(obj[propName]))\n *\n * // getStateCode :: Maybe String -> Maybe String\n * const getStateCode = R.composeK(\n * R.compose(Maybe.of, R.toUpper),\n * get('state'),\n * get('address'),\n * get('user'),\n * );\n * getStateCode({\"user\":{\"address\":{\"state\":\"ny\"}}}); //=> Maybe.Just(\"NY\")\n * getStateCode({}); //=> Maybe.Nothing()\n * @symb R.composeK(f, g, h)(a) = R.chain(f, R.chain(g, h(a)))\n */\n\nexport default function composeK() {\n if (arguments.length === 0) {\n throw new Error('composeK requires at least one argument');\n }\n\n var init = Array.prototype.slice.call(arguments);\n var last = init.pop();\n return compose(compose.apply(this, map(chain, init)), last);\n}","export default function _pipeP(f, g) {\n return function () {\n var ctx = this;\n return f.apply(ctx, arguments).then(function (x) {\n return g.call(ctx, x);\n });\n };\n}","import _arity from \"./internal/_arity.js\";\nimport _pipeP from \"./internal/_pipeP.js\";\nimport reduce from \"./reduce.js\";\nimport tail from \"./tail.js\";\n/**\n * Performs left-to-right composition of one or more Promise-returning\n * functions. The first argument may have any arity; the remaining arguments\n * must be unary.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Function\n * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.composeP\n * @deprecated since v0.26.0\n * @example\n *\n * // followersForUser :: String -> Promise [User]\n * const followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n */\n\nexport default function pipeP() {\n if (arguments.length === 0) {\n throw new Error('pipeP requires at least one argument');\n }\n\n return _arity(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n}","import pipeP from \"./pipeP.js\";\nimport reverse from \"./reverse.js\";\n/**\n * Performs right-to-left composition of one or more Promise-returning\n * functions. The last arguments may have any arity; the remaining\n * arguments must be unary.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Function\n * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n * @param {...Function} functions The functions to compose\n * @return {Function}\n * @see R.pipeP\n * @deprecated since v0.26.0\n * @example\n *\n * const db = {\n * users: {\n * JOE: {\n * name: 'Joe',\n * followers: ['STEVE', 'SUZY']\n * }\n * }\n * }\n *\n * // We'll pretend to do a db lookup which returns a promise\n * const lookupUser = (userId) => Promise.resolve(db.users[userId])\n * const lookupFollowers = (user) => Promise.resolve(user.followers)\n * lookupUser('JOE').then(lookupFollowers)\n *\n * // followersForUser :: String -> Promise [UserId]\n * const followersForUser = R.composeP(lookupFollowers, lookupUser);\n * followersForUser('JOE').then(followers => console.log('Followers:', followers))\n * // Followers: [\"STEVE\",\"SUZY\"]\n */\n\nexport default function composeP() {\n if (arguments.length === 0) {\n throw new Error('composeP requires at least one argument');\n }\n\n return pipeP.apply(this, reverse(arguments));\n}","import nth from \"./nth.js\";\n/**\n * Returns the first element of the given list or string. In some libraries\n * this function is named `first`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> a | Undefined\n * @sig String -> String\n * @param {Array|String} list\n * @return {*}\n * @see R.tail, R.init, R.last\n * @example\n *\n * R.head(['fi', 'fo', 'fum']); //=> 'fi'\n * R.head([]); //=> undefined\n *\n * R.head('abc'); //=> 'a'\n * R.head(''); //=> ''\n */\n\nvar head =\n/*#__PURE__*/\nnth(0);\nexport default head;","export default function _identity(x) {\n return x;\n}","import _curry1 from \"./internal/_curry1.js\";\nimport _identity from \"./internal/_identity.js\";\n/**\n * A function that does nothing but return the parameter supplied to it. Good\n * as a default or placeholder function.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig a -> a\n * @param {*} x The value to return.\n * @return {*} The input value, `x`.\n * @example\n *\n * R.identity(1); //=> 1\n *\n * const obj = {};\n * R.identity(obj) === obj; //=> true\n * @symb R.identity(a) = a\n */\n\nvar identity =\n/*#__PURE__*/\n_curry1(_identity);\n\nexport default identity;","import _arity from \"./internal/_arity.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport head from \"./head.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport tail from \"./tail.js\";\nimport identity from \"./identity.js\";\n/**\n * Performs left-to-right function composition using transforming function. The first argument may have\n * any arity; the remaining arguments must be unary.\n *\n * **Note:** The result of pipeWith is not automatically curried. Transforming function is not used on the\n * first argument.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Function\n * @sig ((* -> *), [((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)]) -> ((a, b, ..., n) -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.composeWith, R.pipe\n * @example\n *\n * const pipeWhileNotNil = R.pipeWith((f, res) => R.isNil(res) ? res : f(res));\n * const f = pipeWhileNotNil([Math.pow, R.negate, R.inc])\n *\n * f(3, 4); // -(3^4) + 1\n * @symb R.pipeWith(f)([g, h, i])(...args) = f(i, f(h, g(...args)))\n */\n\nvar pipeWith =\n/*#__PURE__*/\n_curry2(function pipeWith(xf, list) {\n if (list.length <= 0) {\n return identity;\n }\n\n var headList = head(list);\n var tailList = tail(list);\n return _arity(headList.length, function () {\n return _reduce(function (result, f) {\n return xf.call(this, f, result);\n }, headList.apply(this, arguments), tailList);\n });\n});\n\nexport default pipeWith;","import _curry2 from \"./internal/_curry2.js\";\nimport pipeWith from \"./pipeWith.js\";\nimport reverse from \"./reverse.js\";\n/**\n * Performs right-to-left function composition using transforming function. The last argument may have\n * any arity; the remaining arguments must be unary.\n *\n * **Note:** The result of compose is not automatically curried. Transforming function is not used on the\n * last argument.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Function\n * @sig ((* -> *), [(y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)]) -> ((a, b, ..., n) -> z)\n * @param {...Function} ...functions The functions to compose\n * @return {Function}\n * @see R.compose, R.pipeWith\n * @example\n *\n * const composeWhileNotNil = R.composeWith((f, res) => R.isNil(res) ? res : f(res));\n *\n * composeWhileNotNil([R.inc, R.prop('age')])({age: 1}) //=> 2\n * composeWhileNotNil([R.inc, R.prop('age')])({}) //=> undefined\n *\n * @symb R.composeWith(f)([g, h, i])(...args) = f(g, f(h, i(...args)))\n */\n\nvar composeWith =\n/*#__PURE__*/\n_curry2(function composeWith(xf, list) {\n return pipeWith.apply(this, [xf, reverse(list)]);\n});\n\nexport default composeWith;","export default function _arrayFromIterator(iter) {\n var list = [];\n var next;\n\n while (!(next = iter.next()).done) {\n list.push(next.value);\n }\n\n return list;\n}","export default function _includesWith(pred, x, list) {\n var idx = 0;\n var len = list.length;\n\n while (idx < len) {\n if (pred(x, list[idx])) {\n return true;\n }\n\n idx += 1;\n }\n\n return false;\n}","// Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\nfunction _objectIs(a, b) {\n // SameValue algorithm\n if (a === b) {\n // Steps 1-5, 7-10\n // Steps 6.b-6.e: +0 != -0\n return a !== 0 || 1 / a === 1 / b;\n } else {\n // Step 6.a: NaN == NaN\n return a !== a && b !== b;\n }\n}\n\nexport default typeof Object.is === 'function' ? Object.is : _objectIs;","import _arrayFromIterator from \"./_arrayFromIterator.js\";\nimport _includesWith from \"./_includesWith.js\";\nimport _functionName from \"./_functionName.js\";\nimport _has from \"./_has.js\";\nimport _objectIs from \"./_objectIs.js\";\nimport keys from \"../keys.js\";\nimport type from \"../type.js\";\n/**\n * private _uniqContentEquals function.\n * That function is checking equality of 2 iterator contents with 2 assumptions\n * - iterators lengths are the same\n * - iterators values are unique\n *\n * false-positive result will be returned for comparision of, e.g.\n * - [1,2,3] and [1,2,3,4]\n * - [1,1,1] and [1,2,3]\n * */\n\nfunction _uniqContentEquals(aIterator, bIterator, stackA, stackB) {\n var a = _arrayFromIterator(aIterator);\n\n var b = _arrayFromIterator(bIterator);\n\n function eq(_a, _b) {\n return _equals(_a, _b, stackA.slice(), stackB.slice());\n } // if *a* array contains any element that is not included in *b*\n\n\n return !_includesWith(function (b, aItem) {\n return !_includesWith(eq, aItem, b);\n }, b, a);\n}\n\nexport default function _equals(a, b, stackA, stackB) {\n if (_objectIs(a, b)) {\n return true;\n }\n\n var typeA = type(a);\n\n if (typeA !== type(b)) {\n return false;\n }\n\n if (a == null || b == null) {\n return false;\n }\n\n if (typeof a['fantasy-land/equals'] === 'function' || typeof b['fantasy-land/equals'] === 'function') {\n return typeof a['fantasy-land/equals'] === 'function' && a['fantasy-land/equals'](b) && typeof b['fantasy-land/equals'] === 'function' && b['fantasy-land/equals'](a);\n }\n\n if (typeof a.equals === 'function' || typeof b.equals === 'function') {\n return typeof a.equals === 'function' && a.equals(b) && typeof b.equals === 'function' && b.equals(a);\n }\n\n switch (typeA) {\n case 'Arguments':\n case 'Array':\n case 'Object':\n if (typeof a.constructor === 'function' && _functionName(a.constructor) === 'Promise') {\n return a === b;\n }\n\n break;\n\n case 'Boolean':\n case 'Number':\n case 'String':\n if (!(typeof a === typeof b && _objectIs(a.valueOf(), b.valueOf()))) {\n return false;\n }\n\n break;\n\n case 'Date':\n if (!_objectIs(a.valueOf(), b.valueOf())) {\n return false;\n }\n\n break;\n\n case 'Error':\n return a.name === b.name && a.message === b.message;\n\n case 'RegExp':\n if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) {\n return false;\n }\n\n break;\n }\n\n var idx = stackA.length - 1;\n\n while (idx >= 0) {\n if (stackA[idx] === a) {\n return stackB[idx] === b;\n }\n\n idx -= 1;\n }\n\n switch (typeA) {\n case 'Map':\n if (a.size !== b.size) {\n return false;\n }\n\n return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b]));\n\n case 'Set':\n if (a.size !== b.size) {\n return false;\n }\n\n return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b]));\n\n case 'Arguments':\n case 'Array':\n case 'Object':\n case 'Boolean':\n case 'Number':\n case 'String':\n case 'Date':\n case 'Error':\n case 'RegExp':\n case 'Int8Array':\n case 'Uint8Array':\n case 'Uint8ClampedArray':\n case 'Int16Array':\n case 'Uint16Array':\n case 'Int32Array':\n case 'Uint32Array':\n case 'Float32Array':\n case 'Float64Array':\n case 'ArrayBuffer':\n break;\n\n default:\n // Values of other types are only equal if identical.\n return false;\n }\n\n var keysA = keys(a);\n\n if (keysA.length !== keys(b).length) {\n return false;\n }\n\n var extendedStackA = stackA.concat([a]);\n var extendedStackB = stackB.concat([b]);\n idx = keysA.length - 1;\n\n while (idx >= 0) {\n var key = keysA[idx];\n\n if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) {\n return false;\n }\n\n idx -= 1;\n }\n\n return true;\n}","export default function _functionName(f) {\n // String(x => x) evaluates to \"x => x\", so the pattern may not match.\n var match = String(f).match(/^function (\\w*)/);\n return match == null ? '' : match[1];\n}","import _curry2 from \"./internal/_curry2.js\";\nimport _equals from \"./internal/_equals.js\";\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise. Handles\n * cyclical data structures.\n *\n * Dispatches symmetrically to the `equals` methods of both arguments, if\n * present.\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n * R.equals(1, 1); //=> true\n * R.equals(1, '1'); //=> false\n * R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n * const a = {}; a.v = a;\n * const b = {}; b.v = b;\n * R.equals(a, b); //=> true\n */\n\nvar equals =\n/*#__PURE__*/\n_curry2(function equals(a, b) {\n return _equals(a, b, [], []);\n});\n\nexport default equals;","import equals from \"../equals.js\";\nexport default function _indexOf(list, a, idx) {\n var inf, item; // Array.prototype.indexOf doesn't exist below IE9\n\n if (typeof list.indexOf === 'function') {\n switch (typeof a) {\n case 'number':\n if (a === 0) {\n // manually crawl the list to distinguish between +0 and -0\n inf = 1 / a;\n\n while (idx < list.length) {\n item = list[idx];\n\n if (item === 0 && 1 / item === inf) {\n return idx;\n }\n\n idx += 1;\n }\n\n return -1;\n } else if (a !== a) {\n // NaN\n while (idx < list.length) {\n item = list[idx];\n\n if (typeof item === 'number' && item !== item) {\n return idx;\n }\n\n idx += 1;\n }\n\n return -1;\n } // non-zero numbers can utilise Set\n\n\n return list.indexOf(a, idx);\n // all these types can utilise Set\n\n case 'string':\n case 'boolean':\n case 'function':\n case 'undefined':\n return list.indexOf(a, idx);\n\n case 'object':\n if (a === null) {\n // null can utilise Set\n return list.indexOf(a, idx);\n }\n\n }\n } // anything else not covered above, defer to R.equals\n\n\n while (idx < list.length) {\n if (equals(list[idx], a)) {\n return idx;\n }\n\n idx += 1;\n }\n\n return -1;\n}","import _indexOf from \"./_indexOf.js\";\nexport default function _includes(a, list) {\n return _indexOf(list, a, 0) >= 0;\n}","export default function _quote(s) {\n var escaped = s.replace(/\\\\/g, '\\\\\\\\').replace(/[\\b]/g, '\\\\b') // \\b matches word boundary; [\\b] matches backspace\n .replace(/\\f/g, '\\\\f').replace(/\\n/g, '\\\\n').replace(/\\r/g, '\\\\r').replace(/\\t/g, '\\\\t').replace(/\\v/g, '\\\\v').replace(/\\0/g, '\\\\0');\n return '\"' + escaped.replace(/\"/g, '\\\\\"') + '\"';\n}","/**\n * Polyfill from .\n */\nvar pad = function pad(n) {\n return (n < 10 ? '0' : '') + n;\n};\n\nvar _toISOString = typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n return d.toISOString();\n} : function _toISOString(d) {\n return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n};\n\nexport default _toISOString;","export default function _complement(f) {\n return function () {\n return !f.apply(this, arguments);\n };\n}","export default function _filter(fn, list) {\n var idx = 0;\n var len = list.length;\n var result = [];\n\n while (idx < len) {\n if (fn(list[idx])) {\n result[result.length] = list[idx];\n }\n\n idx += 1;\n }\n\n return result;\n}","export default function _isObject(x) {\n return Object.prototype.toString.call(x) === '[object Object]';\n}","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XFilter =\n/*#__PURE__*/\nfunction () {\n function XFilter(f, xf) {\n this.xf = xf;\n this.f = f;\n }\n\n XFilter.prototype['@@transducer/init'] = _xfBase.init;\n XFilter.prototype['@@transducer/result'] = _xfBase.result;\n\n XFilter.prototype['@@transducer/step'] = function (result, input) {\n return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n };\n\n return XFilter;\n}();\n\nvar _xfilter =\n/*#__PURE__*/\n_curry2(function _xfilter(f, xf) {\n return new XFilter(f, xf);\n});\n\nexport default _xfilter;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _filter from \"./internal/_filter.js\";\nimport _isObject from \"./internal/_isObject.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport _xfilter from \"./internal/_xfilter.js\";\nimport keys from \"./keys.js\";\n/**\n * Takes a predicate and a `Filterable`, and returns a new filterable of the\n * same type containing the members of the given filterable which satisfy the\n * given predicate. Filterable objects include plain objects or any object\n * that has a filter method such as `Array`.\n *\n * Dispatches to the `filter` 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 Filterable f => (a -> Boolean) -> f a -> f a\n * @param {Function} pred\n * @param {Array} filterable\n * @return {Array} Filterable\n * @see R.reject, R.transduce, R.addIndex\n * @example\n *\n * const isEven = n => n % 2 === 0;\n *\n * R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n *\n * R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}\n */\n\nvar filter =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['filter'], _xfilter, function (pred, filterable) {\n return _isObject(filterable) ? _reduce(function (acc, key) {\n if (pred(filterable[key])) {\n acc[key] = filterable[key];\n }\n\n return acc;\n }, {}, keys(filterable)) : // else\n _filter(pred, filterable);\n}));\n\nexport default filter;","import _complement from \"./internal/_complement.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport filter from \"./filter.js\";\n/**\n * The complement of [`filter`](#filter).\n *\n * Acts as a transducer if a transformer is given in list position. Filterable\n * objects include plain objects or any object that has a filter method such\n * as `Array`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> f a\n * @param {Function} pred\n * @param {Array} filterable\n * @return {Array}\n * @see R.filter, R.transduce, R.addIndex\n * @example\n *\n * const isOdd = (n) => n % 2 === 1;\n *\n * R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n *\n * R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}\n */\n\nvar reject =\n/*#__PURE__*/\n_curry2(function reject(pred, filterable) {\n return filter(_complement(pred), filterable);\n});\n\nexport default reject;","import _includes from \"./_includes.js\";\nimport _map from \"./_map.js\";\nimport _quote from \"./_quote.js\";\nimport _toISOString from \"./_toISOString.js\";\nimport keys from \"../keys.js\";\nimport reject from \"../reject.js\";\nexport default function _toString(x, seen) {\n var recur = function recur(y) {\n var xs = seen.concat([x]);\n return _includes(y, xs) ? '' : _toString(y, xs);\n }; // mapPairs :: (Object, [String]) -> [String]\n\n\n var mapPairs = function (obj, keys) {\n return _map(function (k) {\n return _quote(k) + ': ' + recur(obj[k]);\n }, keys.slice().sort());\n };\n\n switch (Object.prototype.toString.call(x)) {\n case '[object Arguments]':\n return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n\n case '[object Array]':\n return '[' + _map(recur, x).concat(mapPairs(x, reject(function (k) {\n return /^\\d+$/.test(k);\n }, keys(x)))).join(', ') + ']';\n\n case '[object Boolean]':\n return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n\n case '[object Date]':\n return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';\n\n case '[object Null]':\n return 'null';\n\n case '[object Number]':\n return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n\n case '[object String]':\n return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n\n case '[object Undefined]':\n return 'undefined';\n\n default:\n if (typeof x.toString === 'function') {\n var repr = x.toString();\n\n if (repr !== '[object Object]') {\n return repr;\n }\n }\n\n return '{' + mapPairs(x, keys(x)).join(', ') + '}';\n }\n}","import _curry1 from \"./internal/_curry1.js\";\nimport _toString from \"./internal/_toString.js\";\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n * function Point(x, y) {\n * this.x = x;\n * this.y = y;\n * }\n *\n * Point.prototype.toString = function() {\n * return 'new Point(' + this.x + ', ' + this.y + ')';\n * };\n *\n * R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n * R.toString(42); //=> '42'\n * R.toString('abc'); //=> '\"abc\"'\n * R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n * R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n * R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\n\nvar toString =\n/*#__PURE__*/\n_curry1(function toString(val) {\n return _toString(val, []);\n});\n\nexport default toString;","import _curry2 from \"./internal/_curry2.js\";\nimport _isArray from \"./internal/_isArray.js\";\nimport _isFunction from \"./internal/_isFunction.js\";\nimport _isString from \"./internal/_isString.js\";\nimport toString from \"./toString.js\";\n/**\n * Returns the result of concatenating the given lists or strings.\n *\n * Note: `R.concat` expects both arguments to be of the same type,\n * unlike the native `Array.prototype.concat` method. It will throw\n * an error if you `concat` an Array with a non-Array value.\n *\n * Dispatches to the `concat` method of the first argument, if present.\n * Can also concatenate two members of a [fantasy-land\n * compatible semigroup](https://github.com/fantasyland/fantasy-land#semigroup).\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a] -> [a]\n * @sig String -> String -> String\n * @param {Array|String} firstList The first list\n * @param {Array|String} secondList The second list\n * @return {Array|String} A list consisting of the elements of `firstList` followed by the elements of\n * `secondList`.\n *\n * @example\n *\n * R.concat('ABC', 'DEF'); // 'ABCDEF'\n * R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n * R.concat([], []); //=> []\n */\n\nvar concat =\n/*#__PURE__*/\n_curry2(function concat(a, b) {\n if (_isArray(a)) {\n if (_isArray(b)) {\n return a.concat(b);\n }\n\n throw new TypeError(toString(b) + ' is not an array');\n }\n\n if (_isString(a)) {\n if (_isString(b)) {\n return a + b;\n }\n\n throw new TypeError(toString(b) + ' is not a string');\n }\n\n if (a != null && _isFunction(a['fantasy-land/concat'])) {\n return a['fantasy-land/concat'](b);\n }\n\n if (a != null && _isFunction(a.concat)) {\n return a.concat(b);\n }\n\n throw new TypeError(toString(a) + ' does not have a method named \"concat\" or \"fantasy-land/concat\"');\n});\n\nexport default concat;","import _arity from \"./internal/_arity.js\";\nimport _curry1 from \"./internal/_curry1.js\";\nimport map from \"./map.js\";\nimport max from \"./max.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Returns a function, `fn`, which encapsulates `if/else, if/else, ...` logic.\n * `R.cond` takes a list of [predicate, transformer] pairs. All of the arguments\n * to `fn` are applied to each of the predicates in turn until one returns a\n * \"truthy\" value, at which point `fn` returns the result of applying its\n * arguments to the corresponding transformer. If none of the predicates\n * matches, `fn` returns undefined.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Logic\n * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n * @param {Array} pairs A list of [predicate, transformer]\n * @return {Function}\n * @see R.ifElse, R.unless, R.when\n * @example\n *\n * const fn = R.cond([\n * [R.equals(0), R.always('water freezes at 0°C')],\n * [R.equals(100), R.always('water boils at 100°C')],\n * [R.T, temp => 'nothing special happens at ' + temp + '°C']\n * ]);\n * fn(0); //=> 'water freezes at 0°C'\n * fn(50); //=> 'nothing special happens at 50°C'\n * fn(100); //=> 'water boils at 100°C'\n */\n\nvar cond =\n/*#__PURE__*/\n_curry1(function cond(pairs) {\n var arity = reduce(max, 0, map(function (pair) {\n return pair[0].length;\n }, pairs));\n return _arity(arity, function () {\n var idx = 0;\n\n while (idx < pairs.length) {\n if (pairs[idx][0].apply(this, arguments)) {\n return pairs[idx][1].apply(this, arguments);\n }\n\n idx += 1;\n }\n });\n});\n\nexport default cond;","import _curry2 from \"./internal/_curry2.js\";\nimport curry from \"./curry.js\";\nimport nAry from \"./nAry.js\";\n/**\n * Wraps a constructor function inside a curried function that can be called\n * with the same arguments and returns the same type. The arity of the function\n * returned is specified to allow using variadic constructor functions.\n *\n * @func\n * @memberOf R\n * @since v0.4.0\n * @category Function\n * @sig Number -> (* -> {*}) -> (* -> {*})\n * @param {Number} n The arity of the constructor function.\n * @param {Function} Fn The constructor function to wrap.\n * @return {Function} A wrapped, curried constructor function.\n * @example\n *\n * // Variadic Constructor function\n * function Salad() {\n * this.ingredients = arguments;\n * }\n *\n * Salad.prototype.recipe = function() {\n * const instructions = R.map(ingredient => 'Add a dollop of ' + ingredient, this.ingredients);\n * return R.join('\\n', instructions);\n * };\n *\n * const ThreeLayerSalad = R.constructN(3, Salad);\n *\n * // Notice we no longer need the 'new' keyword, and the constructor is curried for 3 arguments.\n * const salad = ThreeLayerSalad('Mayonnaise')('Potato Chips')('Ketchup');\n *\n * console.log(salad.recipe());\n * // Add a dollop of Mayonnaise\n * // Add a dollop of Potato Chips\n * // Add a dollop of Ketchup\n */\n\nvar constructN =\n/*#__PURE__*/\n_curry2(function constructN(n, Fn) {\n if (n > 10) {\n throw new Error('Constructor with greater than ten arguments');\n }\n\n if (n === 0) {\n return function () {\n return new Fn();\n };\n }\n\n return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n switch (arguments.length) {\n case 1:\n return new Fn($0);\n\n case 2:\n return new Fn($0, $1);\n\n case 3:\n return new Fn($0, $1, $2);\n\n case 4:\n return new Fn($0, $1, $2, $3);\n\n case 5:\n return new Fn($0, $1, $2, $3, $4);\n\n case 6:\n return new Fn($0, $1, $2, $3, $4, $5);\n\n case 7:\n return new Fn($0, $1, $2, $3, $4, $5, $6);\n\n case 8:\n return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n\n case 9:\n return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n\n case 10:\n return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n }\n }));\n});\n\nexport default constructN;","import _curry1 from \"./internal/_curry1.js\";\nimport constructN from \"./constructN.js\";\n/**\n * Wraps a constructor function inside a curried function that can be called\n * with the same arguments and returns the same type.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (* -> {*}) -> (* -> {*})\n * @param {Function} fn The constructor function to wrap.\n * @return {Function} A wrapped, curried constructor function.\n * @see R.invoker\n * @example\n *\n * // Constructor function\n * function Animal(kind) {\n * this.kind = kind;\n * };\n * Animal.prototype.sighting = function() {\n * return \"It's a \" + this.kind + \"!\";\n * }\n *\n * const AnimalConstructor = R.construct(Animal)\n *\n * // Notice we no longer need the 'new' keyword:\n * AnimalConstructor('Pig'); //=> {\"kind\": \"Pig\", \"sighting\": function (){...}};\n *\n * const animalTypes = [\"Lion\", \"Tiger\", \"Bear\"];\n * const animalSighting = R.invoker(0, 'sighting');\n * const sightNewAnimal = R.compose(animalSighting, AnimalConstructor);\n * R.map(sightNewAnimal, animalTypes); //=> [\"It's a Lion!\", \"It's a Tiger!\", \"It's a Bear!\"]\n */\n\nvar construct =\n/*#__PURE__*/\n_curry1(function construct(Fn) {\n return constructN(Fn.length, Fn);\n});\n\nexport default construct;","import _includes from \"./internal/_includes.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the specified value is equal, in [`R.equals`](#equals)\n * terms, to at least one element of the given list; `false` otherwise.\n * Works also with strings.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if an equivalent item is in the list, `false` otherwise.\n * @see R.includes\n * @deprecated since v0.26.0\n * @example\n *\n * R.contains(3, [1, 2, 3]); //=> true\n * R.contains(4, [1, 2, 3]); //=> false\n * R.contains({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true\n * R.contains([42], [[42]]); //=> true\n * R.contains('ba', 'banana'); //=>true\n */\n\nvar contains =\n/*#__PURE__*/\n_curry2(_includes);\n\nexport default contains;","import _curry2 from \"./internal/_curry2.js\";\nimport _map from \"./internal/_map.js\";\nimport curryN from \"./curryN.js\";\nimport max from \"./max.js\";\nimport pluck from \"./pluck.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Accepts a converging function and a list of branching functions and returns\n * a new function. The arity of the new function is the same as the arity of\n * the longest branching function. When invoked, this new function is applied\n * to some arguments, and each branching function is applied to those same\n * arguments. The results of each branching function are passed as arguments\n * to the converging function to produce the return value.\n *\n * @func\n * @memberOf R\n * @since v0.4.2\n * @category Function\n * @sig ((x1, x2, ...) -> z) -> [((a, b, ...) -> x1), ((a, b, ...) -> x2), ...] -> (a -> b -> ... -> z)\n * @param {Function} after A function. `after` will be invoked with the return values of\n * `fn1` and `fn2` as its arguments.\n * @param {Array} functions A list of functions.\n * @return {Function} A new function.\n * @see R.useWith\n * @example\n *\n * const average = R.converge(R.divide, [R.sum, R.length])\n * average([1, 2, 3, 4, 5, 6, 7]) //=> 4\n *\n * const strangeConcat = R.converge(R.concat, [R.toUpper, R.toLower])\n * strangeConcat(\"Yodel\") //=> \"YODELyodel\"\n *\n * @symb R.converge(f, [g, h])(a, b) = f(g(a, b), h(a, b))\n */\n\nvar converge =\n/*#__PURE__*/\n_curry2(function converge(after, fns) {\n return curryN(reduce(max, 0, pluck('length', fns)), function () {\n var args = arguments;\n var context = this;\n return after.apply(context, _map(function (fn) {\n return fn.apply(context, args);\n }, fns));\n });\n});\n\nexport default converge;","import _curryN from \"./_curryN.js\";\nimport _has from \"./_has.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XReduceBy =\n/*#__PURE__*/\nfunction () {\n function XReduceBy(valueFn, valueAcc, keyFn, xf) {\n this.valueFn = valueFn;\n this.valueAcc = valueAcc;\n this.keyFn = keyFn;\n this.xf = xf;\n this.inputs = {};\n }\n\n XReduceBy.prototype['@@transducer/init'] = _xfBase.init;\n\n XReduceBy.prototype['@@transducer/result'] = function (result) {\n var key;\n\n for (key in this.inputs) {\n if (_has(key, this.inputs)) {\n result = this.xf['@@transducer/step'](result, this.inputs[key]);\n\n if (result['@@transducer/reduced']) {\n result = result['@@transducer/value'];\n break;\n }\n }\n }\n\n this.inputs = null;\n return this.xf['@@transducer/result'](result);\n };\n\n XReduceBy.prototype['@@transducer/step'] = function (result, input) {\n var key = this.keyFn(input);\n this.inputs[key] = this.inputs[key] || [key, this.valueAcc];\n this.inputs[key][1] = this.valueFn(this.inputs[key][1], input);\n return result;\n };\n\n return XReduceBy;\n}();\n\nvar _xreduceBy =\n/*#__PURE__*/\n_curryN(4, [], function _xreduceBy(valueFn, valueAcc, keyFn, xf) {\n return new XReduceBy(valueFn, valueAcc, keyFn, xf);\n});\n\nexport default _xreduceBy;","import _clone from \"./internal/_clone.js\";\nimport _curryN from \"./internal/_curryN.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _has from \"./internal/_has.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport _xreduceBy from \"./internal/_xreduceBy.js\";\n/**\n * Groups the elements of the list according to the result of calling\n * the String-returning function `keyFn` on each element and reduces the elements\n * of each group to a single value via the reducer function `valueFn`.\n *\n * This function is basically a more general [`groupBy`](#groupBy) function.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category List\n * @sig ((a, b) -> a) -> a -> (b -> String) -> [b] -> {String: a}\n * @param {Function} valueFn The function that reduces the elements of each group to a single\n * value. Receives two values, accumulator for a particular group and the current element.\n * @param {*} acc The (initial) accumulator value for each group.\n * @param {Function} keyFn The function that maps the list's element into a key.\n * @param {Array} list The array to group.\n * @return {Object} An object with the output of `keyFn` for keys, mapped to the output of\n * `valueFn` for elements which produced that key when passed to `keyFn`.\n * @see R.groupBy, R.reduce\n * @example\n *\n * const groupNames = (acc, {name}) => acc.concat(name)\n * const toGrade = ({score}) =>\n * score < 65 ? 'F' :\n * score < 70 ? 'D' :\n * score < 80 ? 'C' :\n * score < 90 ? 'B' : 'A'\n *\n * var students = [\n * {name: 'Abby', score: 83},\n * {name: 'Bart', score: 62},\n * {name: 'Curt', score: 88},\n * {name: 'Dora', score: 92},\n * ]\n *\n * reduceBy(groupNames, [], toGrade, students)\n * //=> {\"A\": [\"Dora\"], \"B\": [\"Abby\", \"Curt\"], \"F\": [\"Bart\"]}\n */\n\nvar reduceBy =\n/*#__PURE__*/\n_curryN(4, [],\n/*#__PURE__*/\n_dispatchable([], _xreduceBy, function reduceBy(valueFn, valueAcc, keyFn, list) {\n return _reduce(function (acc, elt) {\n var key = keyFn(elt);\n acc[key] = valueFn(_has(key, acc) ? acc[key] : _clone(valueAcc, [], [], false), elt);\n return acc;\n }, {}, list);\n}));\n\nexport default reduceBy;","import reduceBy from \"./reduceBy.js\";\n/**\n * Counts the elements of a list according to how many match each value of a\n * key generated by the supplied function. Returns an object mapping the keys\n * produced by `fn` to the number of occurrences in the list. Note that all\n * keys are coerced to strings because of how JavaScript objects work.\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 Relation\n * @sig (a -> String) -> [a] -> {*}\n * @param {Function} fn The function used to map values to keys.\n * @param {Array} list The list to count elements from.\n * @return {Object} An object mapping keys to number of occurrences in the list.\n * @example\n *\n * const numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n * R.countBy(Math.floor)(numbers); //=> {'1': 3, '2': 2, '3': 1}\n *\n * const letters = ['a', 'b', 'A', 'a', 'B', 'c'];\n * R.countBy(R.toLower)(letters); //=> {'a': 3, 'b': 2, 'c': 1}\n */\n\nvar countBy =\n/*#__PURE__*/\nreduceBy(function (acc, elem) {\n return acc + 1;\n}, 0);\nexport default countBy;","import add from \"./add.js\";\n/**\n * Decrements its argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Math\n * @sig Number -> Number\n * @param {Number} n\n * @return {Number} n - 1\n * @see R.inc\n * @example\n *\n * R.dec(42); //=> 41\n */\n\nvar dec =\n/*#__PURE__*/\nadd(-1);\nexport default dec;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns the second argument if it is not `null`, `undefined` or `NaN`;\n * otherwise the first argument is returned.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Logic\n * @sig a -> b -> a | b\n * @param {a} default The default value.\n * @param {b} val `val` will be returned instead of `default` unless `val` is `null`, `undefined` or `NaN`.\n * @return {*} The second value if it is not `null`, `undefined` or `NaN`, otherwise the default value\n * @example\n *\n * const defaultTo42 = R.defaultTo(42);\n *\n * defaultTo42(null); //=> 42\n * defaultTo42(undefined); //=> 42\n * defaultTo42(false); //=> false\n * defaultTo42('Ramda'); //=> 'Ramda'\n * // parseInt('string') results in NaN\n * defaultTo42(parseInt('string')); //=> 42\n */\n\nvar defaultTo =\n/*#__PURE__*/\n_curry2(function defaultTo(d, v) {\n return v == null || v !== v ? d : v;\n});\n\nexport default defaultTo;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Makes a descending comparator function out of a function that returns a value\n * that can be compared with `<` and `>`.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Function\n * @sig Ord b => (a -> b) -> a -> a -> Number\n * @param {Function} fn A function of arity one that returns a value that can be compared\n * @param {*} a The first item to be compared.\n * @param {*} b The second item to be compared.\n * @return {Number} `-1` if fn(a) > fn(b), `1` if fn(b) > fn(a), otherwise `0`\n * @see R.ascend\n * @example\n *\n * const byAge = R.descend(R.prop('age'));\n * const people = [\n * { name: 'Emma', age: 70 },\n * { name: 'Peter', age: 78 },\n * { name: 'Mikhail', age: 62 },\n * ];\n * const peopleByOldestFirst = R.sort(byAge, people);\n * //=> [{ name: 'Peter', age: 78 }, { name: 'Emma', age: 70 }, { name: 'Mikhail', age: 62 }]\n */\n\nvar descend =\n/*#__PURE__*/\n_curry3(function descend(fn, a, b) {\n var aa = fn(a);\n var bb = fn(b);\n return aa > bb ? -1 : aa < bb ? 1 : 0;\n});\n\nexport default descend;","import _includes from \"./_includes.js\";\n\nvar _Set =\n/*#__PURE__*/\nfunction () {\n function _Set() {\n /* globals Set */\n this._nativeSet = typeof Set === 'function' ? new Set() : null;\n this._items = {};\n }\n\n // until we figure out why jsdoc chokes on this\n // @param item The item to add to the Set\n // @returns {boolean} true if the item did not exist prior, otherwise false\n //\n _Set.prototype.add = function (item) {\n return !hasOrAdd(item, true, this);\n }; //\n // @param item The item to check for existence in the Set\n // @returns {boolean} true if the item exists in the Set, otherwise false\n //\n\n\n _Set.prototype.has = function (item) {\n return hasOrAdd(item, false, this);\n }; //\n // Combines the logic for checking whether an item is a member of the set and\n // for adding a new item to the set.\n //\n // @param item The item to check or add to the Set instance.\n // @param shouldAdd If true, the item will be added to the set if it doesn't\n // already exist.\n // @param set The set instance to check or add to.\n // @return {boolean} true if the item already existed, otherwise false.\n //\n\n\n return _Set;\n}();\n\nfunction hasOrAdd(item, shouldAdd, set) {\n var type = typeof item;\n var prevSize, newSize;\n\n switch (type) {\n case 'string':\n case 'number':\n // distinguish between +0 and -0\n if (item === 0 && 1 / item === -Infinity) {\n if (set._items['-0']) {\n return true;\n } else {\n if (shouldAdd) {\n set._items['-0'] = true;\n }\n\n return false;\n }\n } // these types can all utilise the native Set\n\n\n if (set._nativeSet !== null) {\n if (shouldAdd) {\n prevSize = set._nativeSet.size;\n\n set._nativeSet.add(item);\n\n newSize = set._nativeSet.size;\n return newSize === prevSize;\n } else {\n return set._nativeSet.has(item);\n }\n } else {\n if (!(type in set._items)) {\n if (shouldAdd) {\n set._items[type] = {};\n set._items[type][item] = true;\n }\n\n return false;\n } else if (item in set._items[type]) {\n return true;\n } else {\n if (shouldAdd) {\n set._items[type][item] = true;\n }\n\n return false;\n }\n }\n\n case 'boolean':\n // set._items['boolean'] holds a two element array\n // representing [ falseExists, trueExists ]\n if (type in set._items) {\n var bIdx = item ? 1 : 0;\n\n if (set._items[type][bIdx]) {\n return true;\n } else {\n if (shouldAdd) {\n set._items[type][bIdx] = true;\n }\n\n return false;\n }\n } else {\n if (shouldAdd) {\n set._items[type] = item ? [false, true] : [true, false];\n }\n\n return false;\n }\n\n case 'function':\n // compare functions for reference equality\n if (set._nativeSet !== null) {\n if (shouldAdd) {\n prevSize = set._nativeSet.size;\n\n set._nativeSet.add(item);\n\n newSize = set._nativeSet.size;\n return newSize === prevSize;\n } else {\n return set._nativeSet.has(item);\n }\n } else {\n if (!(type in set._items)) {\n if (shouldAdd) {\n set._items[type] = [item];\n }\n\n return false;\n }\n\n if (!_includes(item, set._items[type])) {\n if (shouldAdd) {\n set._items[type].push(item);\n }\n\n return false;\n }\n\n return true;\n }\n\n case 'undefined':\n if (set._items[type]) {\n return true;\n } else {\n if (shouldAdd) {\n set._items[type] = true;\n }\n\n return false;\n }\n\n case 'object':\n if (item === null) {\n if (!set._items['null']) {\n if (shouldAdd) {\n set._items['null'] = true;\n }\n\n return false;\n }\n\n return true;\n }\n\n /* falls through */\n\n default:\n // reduce the search size of heterogeneous sets by creating buckets\n // for each type.\n type = Object.prototype.toString.call(item);\n\n if (!(type in set._items)) {\n if (shouldAdd) {\n set._items[type] = [item];\n }\n\n return false;\n } // scan through all previously applied items\n\n\n if (!_includes(item, set._items[type])) {\n if (shouldAdd) {\n set._items[type].push(item);\n }\n\n return false;\n }\n\n return true;\n }\n} // A simple Set type that honours R.equals semantics\n\n\nexport default _Set;","import _curry2 from \"./internal/_curry2.js\";\nimport _Set from \"./internal/_Set.js\";\n/**\n * Finds the set (i.e. no duplicates) of all elements in the first list not\n * contained in the second list. Objects and Arrays are compared in terms of\n * value equality, not reference equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` that are not in `list2`.\n * @see R.differenceWith, R.symmetricDifference, R.symmetricDifferenceWith, R.without\n * @example\n *\n * R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n * R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n * R.difference([{a: 1}, {b: 2}], [{a: 1}, {c: 3}]) //=> [{b: 2}]\n */\n\nvar difference =\n/*#__PURE__*/\n_curry2(function difference(first, second) {\n var out = [];\n var idx = 0;\n var firstLen = first.length;\n var secondLen = second.length;\n var toFilterOut = new _Set();\n\n for (var i = 0; i < secondLen; i += 1) {\n toFilterOut.add(second[i]);\n }\n\n while (idx < firstLen) {\n if (toFilterOut.add(first[idx])) {\n out[out.length] = first[idx];\n }\n\n idx += 1;\n }\n\n return out;\n});\n\nexport default difference;","import _includesWith from \"./internal/_includesWith.js\";\nimport _curry3 from \"./internal/_curry3.js\";\n/**\n * Finds the set (i.e. no duplicates) of all elements in the first list not\n * contained in the second list. Duplication is determined according to the\n * value returned by applying the supplied predicate to two list elements.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` that are not in `list2`.\n * @see R.difference, R.symmetricDifference, R.symmetricDifferenceWith\n * @example\n *\n * const cmp = (x, y) => x.a === y.a;\n * const l1 = [{a: 1}, {a: 2}, {a: 3}];\n * const l2 = [{a: 3}, {a: 4}];\n * R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n */\n\nvar differenceWith =\n/*#__PURE__*/\n_curry3(function differenceWith(pred, first, second) {\n var out = [];\n var idx = 0;\n var firstLen = first.length;\n\n while (idx < firstLen) {\n if (!_includesWith(pred, first[idx], second) && !_includesWith(pred, first[idx], out)) {\n out.push(first[idx]);\n }\n\n idx += 1;\n }\n\n return out;\n});\n\nexport default differenceWith;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop The name of the property to dissociate\n * @param {Object} obj The object to clone\n * @return {Object} A new object equivalent to the original but without the specified property\n * @see R.assoc, R.omit\n * @example\n *\n * R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\n\nvar dissoc =\n/*#__PURE__*/\n_curry2(function dissoc(prop, obj) {\n var result = {};\n\n for (var p in obj) {\n result[p] = obj[p];\n }\n\n delete result[prop];\n return result;\n});\n\nexport default dissoc;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Removes the sub-list of `list` starting at index `start` and containing\n * `count` elements. _Note that this is not destructive_: it returns a copy of\n * the list with the changes.\n * No lists have been harmed in the application of this function.\n *\n * @func\n * @memberOf R\n * @since v0.2.2\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @param {Number} start The position to start removing elements\n * @param {Number} count The number of elements to remove\n * @param {Array} list The list to remove from\n * @return {Array} A new Array with `count` elements from `start` removed.\n * @see R.without\n * @example\n *\n * R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n */\n\nvar remove =\n/*#__PURE__*/\n_curry3(function remove(start, count, list) {\n var result = Array.prototype.slice.call(list, 0);\n result.splice(start, count);\n return result;\n});\n\nexport default remove;","import _curry3 from \"./internal/_curry3.js\";\nimport adjust from \"./adjust.js\";\nimport always from \"./always.js\";\n/**\n * Returns a new copy of the array with the element at the provided index\n * replaced with the given value.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig Number -> a -> [a] -> [a]\n * @param {Number} idx The index to update.\n * @param {*} x The value to exist at the given index of the returned array.\n * @param {Array|Arguments} list The source array-like object to be updated.\n * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n * @see R.adjust\n * @example\n *\n * R.update(1, '_', ['a', 'b', 'c']); //=> ['a', '_', 'c']\n * R.update(-1, '_', ['a', 'b', 'c']); //=> ['a', 'b', '_']\n * @symb R.update(-1, a, [b, c]) = [b, a]\n * @symb R.update(0, a, [b, c]) = [a, c]\n * @symb R.update(1, a, [b, c]) = [b, a]\n */\n\nvar update =\n/*#__PURE__*/\n_curry3(function update(idx, x, list) {\n return adjust(idx, always(x), list);\n});\n\nexport default update;","import _curry2 from \"./internal/_curry2.js\";\nimport _isInteger from \"./internal/_isInteger.js\";\nimport _isArray from \"./internal/_isArray.js\";\nimport assoc from \"./assoc.js\";\nimport dissoc from \"./dissoc.js\";\nimport remove from \"./remove.js\";\nimport update from \"./update.js\";\n/**\n * Makes a shallow clone of an object, omitting the property at the given path.\n * Note that this copies and flattens prototype properties onto the new object\n * as well. All non-primitive properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @since v0.11.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig [Idx] -> {k: v} -> {k: v}\n * @param {Array} path The path to the value to omit\n * @param {Object} obj The object to clone\n * @return {Object} A new object without the property at path\n * @see R.assocPath\n * @example\n *\n * R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n */\n\nvar dissocPath =\n/*#__PURE__*/\n_curry2(function dissocPath(path, obj) {\n switch (path.length) {\n case 0:\n return obj;\n\n case 1:\n return _isInteger(path[0]) && _isArray(obj) ? remove(path[0], 1, obj) : dissoc(path[0], obj);\n\n default:\n var head = path[0];\n var tail = Array.prototype.slice.call(path, 1);\n\n if (obj[head] == null) {\n return obj;\n } else if (_isInteger(head) && _isArray(obj)) {\n return update(head, dissocPath(tail, obj[head]), obj);\n } else {\n return assoc(head, dissocPath(tail, obj[head]), obj);\n }\n\n }\n});\n\nexport default dissocPath;","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 _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XDrop =\n/*#__PURE__*/\nfunction () {\n function XDrop(n, xf) {\n this.xf = xf;\n this.n = n;\n }\n\n XDrop.prototype['@@transducer/init'] = _xfBase.init;\n XDrop.prototype['@@transducer/result'] = _xfBase.result;\n\n XDrop.prototype['@@transducer/step'] = function (result, input) {\n if (this.n > 0) {\n this.n -= 1;\n return result;\n }\n\n return this.xf['@@transducer/step'](result, input);\n };\n\n return XDrop;\n}();\n\nvar _xdrop =\n/*#__PURE__*/\n_curry2(function _xdrop(n, xf) {\n return new XDrop(n, xf);\n});\n\nexport default _xdrop;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xdrop from \"./internal/_xdrop.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns all but the first `n` elements of the given list, string, or\n * transducer/transformer (or object with a `drop` method).\n *\n * Dispatches to the `drop` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n\n * @param {*} list\n * @return {*} A copy of list without the first `n` elements\n * @see R.take, R.transduce, R.dropLast, R.dropWhile\n * @example\n *\n * R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n * R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n * R.drop(3, ['foo', 'bar', 'baz']); //=> []\n * R.drop(4, ['foo', 'bar', 'baz']); //=> []\n * R.drop(3, 'ramda'); //=> 'da'\n */\n\nvar drop =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['drop'], _xdrop, function drop(n, xs) {\n return slice(Math.max(0, n), Infinity, xs);\n}));\n\nexport default drop;","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XTake =\n/*#__PURE__*/\nfunction () {\n function XTake(n, xf) {\n this.xf = xf;\n this.n = n;\n this.i = 0;\n }\n\n XTake.prototype['@@transducer/init'] = _xfBase.init;\n XTake.prototype['@@transducer/result'] = _xfBase.result;\n\n XTake.prototype['@@transducer/step'] = function (result, input) {\n this.i += 1;\n var ret = this.n === 0 ? result : this.xf['@@transducer/step'](result, input);\n return this.n >= 0 && this.i >= this.n ? _reduced(ret) : ret;\n };\n\n return XTake;\n}();\n\nvar _xtake =\n/*#__PURE__*/\n_curry2(function _xtake(n, xf) {\n return new XTake(n, xf);\n});\n\nexport default _xtake;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xtake from \"./internal/_xtake.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns the first `n` elements of the given list, string, or\n * transducer/transformer (or object with a `take` method).\n *\n * Dispatches to the `take` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n\n * @param {*} list\n * @return {*}\n * @see R.drop\n * @example\n *\n * R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n * R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n * R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n * R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n * R.take(3, 'ramda'); //=> 'ram'\n *\n * const personnel = [\n * 'Dave Brubeck',\n * 'Paul Desmond',\n * 'Eugene Wright',\n * 'Joe Morello',\n * 'Gerry Mulligan',\n * 'Bob Bates',\n * 'Joe Dodge',\n * 'Ron Crotty'\n * ];\n *\n * const takeFive = R.take(5);\n * takeFive(personnel);\n * //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n * @symb R.take(-1, [a, b]) = [a, b]\n * @symb R.take(0, [a, b]) = []\n * @symb R.take(1, [a, b]) = [a]\n * @symb R.take(2, [a, b]) = [a, b]\n */\n\nvar take =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['take'], _xtake, function take(n, xs) {\n return slice(0, n < 0 ? Infinity : n, xs);\n}));\n\nexport default take;","import take from \"../take.js\";\nexport default function dropLast(n, xs) {\n return take(n < xs.length ? xs.length - n : 0, xs);\n}","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XDropLast =\n/*#__PURE__*/\nfunction () {\n function XDropLast(n, xf) {\n this.xf = xf;\n this.pos = 0;\n this.full = false;\n this.acc = new Array(n);\n }\n\n XDropLast.prototype['@@transducer/init'] = _xfBase.init;\n\n XDropLast.prototype['@@transducer/result'] = function (result) {\n this.acc = null;\n return this.xf['@@transducer/result'](result);\n };\n\n XDropLast.prototype['@@transducer/step'] = function (result, input) {\n if (this.full) {\n result = this.xf['@@transducer/step'](result, this.acc[this.pos]);\n }\n\n this.store(input);\n return result;\n };\n\n XDropLast.prototype.store = function (input) {\n this.acc[this.pos] = input;\n this.pos += 1;\n\n if (this.pos === this.acc.length) {\n this.pos = 0;\n this.full = true;\n }\n };\n\n return XDropLast;\n}();\n\nvar _xdropLast =\n/*#__PURE__*/\n_curry2(function _xdropLast(n, xf) {\n return new XDropLast(n, xf);\n});\n\nexport default _xdropLast;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _dropLast from \"./internal/_dropLast.js\";\nimport _xdropLast from \"./internal/_xdropLast.js\";\n/**\n * Returns a list containing all but the last `n` elements of the given `list`.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n The number of elements of `list` to skip.\n * @param {Array} list The list of elements to consider.\n * @return {Array} A copy of the list with only the first `list.length - n` elements\n * @see R.takeLast, R.drop, R.dropWhile, R.dropLastWhile\n * @example\n *\n * R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n * R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n * R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n * R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n * R.dropLast(3, 'ramda'); //=> 'ra'\n */\n\nvar dropLast =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xdropLast, _dropLast));\n\nexport default dropLast;","import slice from \"../slice.js\";\nexport default function dropLastWhile(pred, xs) {\n var idx = xs.length - 1;\n\n while (idx >= 0 && pred(xs[idx])) {\n idx -= 1;\n }\n\n return slice(0, idx + 1, xs);\n}","import _curry2 from \"./_curry2.js\";\nimport _reduce from \"./_reduce.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XDropLastWhile =\n/*#__PURE__*/\nfunction () {\n function XDropLastWhile(fn, xf) {\n this.f = fn;\n this.retained = [];\n this.xf = xf;\n }\n\n XDropLastWhile.prototype['@@transducer/init'] = _xfBase.init;\n\n XDropLastWhile.prototype['@@transducer/result'] = function (result) {\n this.retained = null;\n return this.xf['@@transducer/result'](result);\n };\n\n XDropLastWhile.prototype['@@transducer/step'] = function (result, input) {\n return this.f(input) ? this.retain(result, input) : this.flush(result, input);\n };\n\n XDropLastWhile.prototype.flush = function (result, input) {\n result = _reduce(this.xf['@@transducer/step'], result, this.retained);\n this.retained = [];\n return this.xf['@@transducer/step'](result, input);\n };\n\n XDropLastWhile.prototype.retain = function (result, input) {\n this.retained.push(input);\n return result;\n };\n\n return XDropLastWhile;\n}();\n\nvar _xdropLastWhile =\n/*#__PURE__*/\n_curry2(function _xdropLastWhile(fn, xf) {\n return new XDropLastWhile(fn, xf);\n});\n\nexport default _xdropLastWhile;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _dropLastWhile from \"./internal/_dropLastWhile.js\";\nimport _xdropLastWhile from \"./internal/_xdropLastWhile.js\";\n/**\n * Returns a new list excluding all the tailing elements of a given list which\n * satisfy the supplied predicate function. It passes each value from the right\n * to the supplied predicate function, skipping elements until the predicate\n * function returns a `falsy` value. The predicate function is applied to one argument:\n * *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} predicate The function to be called on each element\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array without any trailing elements that return `falsy` values from the `predicate`.\n * @see R.takeLastWhile, R.addIndex, R.drop, R.dropWhile\n * @example\n *\n * const lteThree = x => x <= 3;\n *\n * R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4]\n *\n * R.dropLastWhile(x => x !== 'd' , 'Ramda'); //=> 'Ramd'\n */\n\nvar dropLastWhile =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xdropLastWhile, _dropLastWhile));\n\nexport default dropLastWhile;","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XDropRepeatsWith =\n/*#__PURE__*/\nfunction () {\n function XDropRepeatsWith(pred, xf) {\n this.xf = xf;\n this.pred = pred;\n this.lastValue = undefined;\n this.seenFirstValue = false;\n }\n\n XDropRepeatsWith.prototype['@@transducer/init'] = _xfBase.init;\n XDropRepeatsWith.prototype['@@transducer/result'] = _xfBase.result;\n\n XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n var sameAsLast = false;\n\n if (!this.seenFirstValue) {\n this.seenFirstValue = true;\n } else if (this.pred(this.lastValue, input)) {\n sameAsLast = true;\n }\n\n this.lastValue = input;\n return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n };\n\n return XDropRepeatsWith;\n}();\n\nvar _xdropRepeatsWith =\n/*#__PURE__*/\n_curry2(function _xdropRepeatsWith(pred, xf) {\n return new XDropRepeatsWith(pred, xf);\n});\n\nexport default _xdropRepeatsWith;","import nth from \"./nth.js\";\n/**\n * Returns the last element of the given list or string.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig [a] -> a | Undefined\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.init, R.head, R.tail\n * @example\n *\n * R.last(['fi', 'fo', 'fum']); //=> 'fum'\n * R.last([]); //=> undefined\n *\n * R.last('abc'); //=> 'c'\n * R.last(''); //=> ''\n */\n\nvar last =\n/*#__PURE__*/\nnth(-1);\nexport default last;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xdropRepeatsWith from \"./internal/_xdropRepeatsWith.js\";\nimport last from \"./last.js\";\n/**\n * Returns a new list without any consecutively repeating elements. Equality is\n * determined by applying the supplied predicate to each pair of consecutive elements. The\n * first element in a series of equal elements will be preserved.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig ((a, a) -> Boolean) -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list The array to consider.\n * @return {Array} `list` without repeating elements.\n * @see R.transduce\n * @example\n *\n * const l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n * R.dropRepeatsWith(R.eqBy(Math.abs), l); //=> [1, 3, 4, -5, 3]\n */\n\nvar dropRepeatsWith =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n var result = [];\n var idx = 1;\n var len = list.length;\n\n if (len !== 0) {\n result[0] = list[0];\n\n while (idx < len) {\n if (!pred(last(result), list[idx])) {\n result[result.length] = list[idx];\n }\n\n idx += 1;\n }\n }\n\n return result;\n}));\n\nexport default dropRepeatsWith;","import _curry1 from \"./internal/_curry1.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xdropRepeatsWith from \"./internal/_xdropRepeatsWith.js\";\nimport dropRepeatsWith from \"./dropRepeatsWith.js\";\nimport equals from \"./equals.js\";\n/**\n * Returns a new list without any consecutively repeating elements.\n * [`R.equals`](#equals) is used to determine equality.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The array to consider.\n * @return {Array} `list` without repeating elements.\n * @see R.transduce\n * @example\n *\n * R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n */\n\nvar dropRepeats =\n/*#__PURE__*/\n_curry1(\n/*#__PURE__*/\n_dispatchable([],\n/*#__PURE__*/\n_xdropRepeatsWith(equals),\n/*#__PURE__*/\ndropRepeatsWith(equals)));\n\nexport default dropRepeats;","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XDropWhile =\n/*#__PURE__*/\nfunction () {\n function XDropWhile(f, xf) {\n this.xf = xf;\n this.f = f;\n }\n\n XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n\n XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n if (this.f) {\n if (this.f(input)) {\n return result;\n }\n\n this.f = null;\n }\n\n return this.xf['@@transducer/step'](result, input);\n };\n\n return XDropWhile;\n}();\n\nvar _xdropWhile =\n/*#__PURE__*/\n_curry2(function _xdropWhile(f, xf) {\n return new XDropWhile(f, xf);\n});\n\nexport default _xdropWhile;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xdropWhile from \"./internal/_xdropWhile.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns a new list excluding the leading elements of a given list which\n * satisfy the supplied predicate function. It passes each value to the supplied\n * predicate function, skipping elements while the predicate function returns\n * `true`. The predicate function is applied to one argument: *(value)*.\n *\n * Dispatches to the `dropWhile` 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.9.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} fn The function called per iteration.\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array.\n * @see R.takeWhile, R.transduce, R.addIndex\n * @example\n *\n * const lteTwo = x => x <= 2;\n *\n * R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n *\n * R.dropWhile(x => x !== 'd' , 'Ramda'); //=> 'da'\n */\n\nvar dropWhile =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['dropWhile'], _xdropWhile, function dropWhile(pred, xs) {\n var idx = 0;\n var len = xs.length;\n\n while (idx < len && pred(xs[idx])) {\n idx += 1;\n }\n\n return slice(idx, Infinity, xs);\n}));\n\nexport default dropWhile;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if one or both of its arguments are `true`. Returns `false`\n * if both arguments are `false`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig a -> b -> a | b\n * @param {Any} a\n * @param {Any} b\n * @return {Any} the first argument if truthy, otherwise the second argument.\n * @see R.either, R.xor\n * @example\n *\n * R.or(true, true); //=> true\n * R.or(true, false); //=> true\n * R.or(false, true); //=> true\n * R.or(false, false); //=> false\n */\n\nvar or =\n/*#__PURE__*/\n_curry2(function or(a, b) {\n return a || b;\n});\n\nexport default or;","import _curry2 from \"./internal/_curry2.js\";\nimport _isFunction from \"./internal/_isFunction.js\";\nimport lift from \"./lift.js\";\nimport or from \"./or.js\";\n/**\n * A function wrapping calls to the two functions in an `||` operation,\n * returning the result of the first function if it is truth-y and the result\n * of the second function otherwise. Note that this is short-circuited,\n * meaning that the second function will not be invoked if the first returns a\n * truth-y value.\n *\n * In addition to functions, `R.either` also accepts any fantasy-land compatible\n * applicative functor.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n * @param {Function} f a predicate\n * @param {Function} g another predicate\n * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n * @see R.or\n * @example\n *\n * const gt10 = x => x > 10;\n * const even = x => x % 2 === 0;\n * const f = R.either(gt10, even);\n * f(101); //=> true\n * f(8); //=> true\n *\n * R.either(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(55)\n * R.either([false, false, 'a'], [11]) // => [11, 11, \"a\"]\n */\n\nvar either =\n/*#__PURE__*/\n_curry2(function either(f, g) {\n return _isFunction(f) ? function _either() {\n return f.apply(this, arguments) || g.apply(this, arguments);\n } : lift(or)(f, g);\n});\n\nexport default either;","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 `.empty`,\n * `.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 _curry2 from \"./internal/_curry2.js\";\nimport drop from \"./drop.js\";\n/**\n * Returns a new list containing the last `n` elements of the given list.\n * If `n > list.length`, returns a list of `list.length` elements.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n The number of elements to return.\n * @param {Array} xs The collection to consider.\n * @return {Array}\n * @see R.dropLast\n * @example\n *\n * R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n * R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n * R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n * R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n * R.takeLast(3, 'ramda'); //=> 'mda'\n */\n\nvar takeLast =\n/*#__PURE__*/\n_curry2(function takeLast(n, xs) {\n return drop(n >= 0 ? xs.length - n : 0, xs);\n});\n\nexport default takeLast;","import _curry2 from \"./internal/_curry2.js\";\nimport equals from \"./equals.js\";\nimport takeLast from \"./takeLast.js\";\n/**\n * Checks if a list ends with the provided sublist.\n *\n * Similarly, checks if a string ends with the provided substring.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category List\n * @sig [a] -> [a] -> Boolean\n * @sig String -> String -> Boolean\n * @param {*} suffix\n * @param {*} list\n * @return {Boolean}\n * @see R.startsWith\n * @example\n *\n * R.endsWith('c', 'abc') //=> true\n * R.endsWith('b', 'abc') //=> false\n * R.endsWith(['c'], ['a', 'b', 'c']) //=> true\n * R.endsWith(['b'], ['a', 'b', 'c']) //=> false\n */\n\nvar endsWith =\n/*#__PURE__*/\n_curry2(function (suffix, list) {\n return equals(takeLast(suffix.length, list), suffix);\n});\n\nexport default endsWith;","import _curry3 from \"./internal/_curry3.js\";\nimport equals from \"./equals.js\";\n/**\n * Takes a function and two values in its domain and returns `true` if the\n * values map to the same value in the codomain; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Relation\n * @sig (a -> b) -> a -> a -> Boolean\n * @param {Function} f\n * @param {*} x\n * @param {*} y\n * @return {Boolean}\n * @example\n *\n * R.eqBy(Math.abs, 5, -5); //=> true\n */\n\nvar eqBy =\n/*#__PURE__*/\n_curry3(function eqBy(f, x, y) {\n return equals(f(x), f(y));\n});\n\nexport default eqBy;","import _curry3 from \"./internal/_curry3.js\";\nimport equals from \"./equals.js\";\n/**\n * Reports whether two objects have the same value, in [`R.equals`](#equals)\n * terms, for the specified property. Useful as a curried predicate.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig k -> {k: v} -> {k: v} -> Boolean\n * @param {String} prop The name of the property to compare\n * @param {Object} obj1\n * @param {Object} obj2\n * @return {Boolean}\n *\n * @example\n *\n * const o1 = { a: 1, b: 2, c: 3, d: 4 };\n * const o2 = { a: 10, b: 20, c: 3, d: 40 };\n * R.eqProps('a', o1, o2); //=> false\n * R.eqProps('c', o1, o2); //=> true\n */\n\nvar eqProps =\n/*#__PURE__*/\n_curry3(function eqProps(prop, obj1, obj2) {\n return equals(obj1[prop], obj2[prop]);\n});\n\nexport default eqProps;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`,\n * according to the `transformation` functions. All non-primitive properties\n * are copied by reference.\n *\n * A `transformation` function will not be invoked if its corresponding key\n * does not exist in the evolved object.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n * to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n * const tomato = {firstName: ' Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n * const transformations = {\n * firstName: R.trim,\n * lastName: R.trim, // Will not get invoked.\n * data: {elapsed: R.add(1), remaining: R.add(-1)}\n * };\n * R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\n\nvar evolve =\n/*#__PURE__*/\n_curry2(function evolve(transformations, object) {\n var result = object instanceof Array ? [] : {};\n var transformation, key, type;\n\n for (key in object) {\n transformation = transformations[key];\n type = typeof transformation;\n result[key] = type === 'function' ? transformation(object[key]) : transformation && type === 'object' ? evolve(transformation, object[key]) : object[key];\n }\n\n return result;\n});\n\nexport default evolve;","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XFind =\n/*#__PURE__*/\nfunction () {\n function XFind(f, xf) {\n this.xf = xf;\n this.f = f;\n this.found = false;\n }\n\n XFind.prototype['@@transducer/init'] = _xfBase.init;\n\n XFind.prototype['@@transducer/result'] = function (result) {\n if (!this.found) {\n result = this.xf['@@transducer/step'](result, void 0);\n }\n\n return this.xf['@@transducer/result'](result);\n };\n\n XFind.prototype['@@transducer/step'] = function (result, input) {\n if (this.f(input)) {\n this.found = true;\n result = _reduced(this.xf['@@transducer/step'](result, input));\n }\n\n return result;\n };\n\n return XFind;\n}();\n\nvar _xfind =\n/*#__PURE__*/\n_curry2(function _xfind(f, xf) {\n return new XFind(f, xf);\n});\n\nexport default _xfind;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xfind from \"./internal/_xfind.js\";\n/**\n * Returns the first element of the list which matches the predicate, or\n * `undefined` if no element matches.\n *\n * Dispatches to the `find` 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] -> a | undefined\n * @param {Function} fn The predicate function used to determine if the element is the\n * desired one.\n * @param {Array} list The array to consider.\n * @return {Object} The element found, or `undefined`.\n * @see R.transduce\n * @example\n *\n * const xs = [{a: 1}, {a: 2}, {a: 3}];\n * R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n * R.find(R.propEq('a', 4))(xs); //=> undefined\n */\n\nvar find =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['find'], _xfind, function find(fn, list) {\n var idx = 0;\n var len = list.length;\n\n while (idx < len) {\n if (fn(list[idx])) {\n return list[idx];\n }\n\n idx += 1;\n }\n}));\n\nexport default find;","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XFindIndex =\n/*#__PURE__*/\nfunction () {\n function XFindIndex(f, xf) {\n this.xf = xf;\n this.f = f;\n this.idx = -1;\n this.found = false;\n }\n\n XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n\n XFindIndex.prototype['@@transducer/result'] = function (result) {\n if (!this.found) {\n result = this.xf['@@transducer/step'](result, -1);\n }\n\n return this.xf['@@transducer/result'](result);\n };\n\n XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n this.idx += 1;\n\n if (this.f(input)) {\n this.found = true;\n result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n }\n\n return result;\n };\n\n return XFindIndex;\n}();\n\nvar _xfindIndex =\n/*#__PURE__*/\n_curry2(function _xfindIndex(f, xf) {\n return new XFindIndex(f, xf);\n});\n\nexport default _xfindIndex;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xfindIndex from \"./internal/_xfindIndex.js\";\n/**\n * Returns the index of the first element of the list which matches the\n * predicate, or `-1` if no element matches.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> Boolean) -> [a] -> Number\n * @param {Function} fn The predicate function used to determine if the element is the\n * desired one.\n * @param {Array} list The array to consider.\n * @return {Number} The index of the element found, or `-1`.\n * @see R.transduce\n * @example\n *\n * const xs = [{a: 1}, {a: 2}, {a: 3}];\n * R.findIndex(R.propEq('a', 2))(xs); //=> 1\n * R.findIndex(R.propEq('a', 4))(xs); //=> -1\n */\n\nvar findIndex =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xfindIndex, function findIndex(fn, list) {\n var idx = 0;\n var len = list.length;\n\n while (idx < len) {\n if (fn(list[idx])) {\n return idx;\n }\n\n idx += 1;\n }\n\n return -1;\n}));\n\nexport default findIndex;","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XFindLast =\n/*#__PURE__*/\nfunction () {\n function XFindLast(f, xf) {\n this.xf = xf;\n this.f = f;\n }\n\n XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n\n XFindLast.prototype['@@transducer/result'] = function (result) {\n return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n };\n\n XFindLast.prototype['@@transducer/step'] = function (result, input) {\n if (this.f(input)) {\n this.last = input;\n }\n\n return result;\n };\n\n return XFindLast;\n}();\n\nvar _xfindLast =\n/*#__PURE__*/\n_curry2(function _xfindLast(f, xf) {\n return new XFindLast(f, xf);\n});\n\nexport default _xfindLast;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xfindLast from \"./internal/_xfindLast.js\";\n/**\n * Returns the last element of the list which matches the predicate, or\n * `undefined` if no element matches.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> Boolean) -> [a] -> a | undefined\n * @param {Function} fn The predicate function used to determine if the element is the\n * desired one.\n * @param {Array} list The array to consider.\n * @return {Object} The element found, or `undefined`.\n * @see R.transduce\n * @example\n *\n * const xs = [{a: 1, b: 0}, {a:1, b: 1}];\n * R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n * R.findLast(R.propEq('a', 4))(xs); //=> undefined\n */\n\nvar findLast =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xfindLast, function findLast(fn, list) {\n var idx = list.length - 1;\n\n while (idx >= 0) {\n if (fn(list[idx])) {\n return list[idx];\n }\n\n idx -= 1;\n }\n}));\n\nexport default findLast;","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XFindLastIndex =\n/*#__PURE__*/\nfunction () {\n function XFindLastIndex(f, xf) {\n this.xf = xf;\n this.f = f;\n this.idx = -1;\n this.lastIdx = -1;\n }\n\n XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n\n XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n };\n\n XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n this.idx += 1;\n\n if (this.f(input)) {\n this.lastIdx = this.idx;\n }\n\n return result;\n };\n\n return XFindLastIndex;\n}();\n\nvar _xfindLastIndex =\n/*#__PURE__*/\n_curry2(function _xfindLastIndex(f, xf) {\n return new XFindLastIndex(f, xf);\n});\n\nexport default _xfindLastIndex;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xfindLastIndex from \"./internal/_xfindLastIndex.js\";\n/**\n * Returns the index of the last element of the list which matches the\n * predicate, or `-1` if no element matches.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> Boolean) -> [a] -> Number\n * @param {Function} fn The predicate function used to determine if the element is the\n * desired one.\n * @param {Array} list The array to consider.\n * @return {Number} The index of the element found, or `-1`.\n * @see R.transduce\n * @example\n *\n * const xs = [{a: 1, b: 0}, {a:1, b: 1}];\n * R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n * R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n */\n\nvar findLastIndex =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xfindLastIndex, function findLastIndex(fn, list) {\n var idx = list.length - 1;\n\n while (idx >= 0) {\n if (fn(list[idx])) {\n return idx;\n }\n\n idx -= 1;\n }\n\n return -1;\n}));\n\nexport default findLastIndex;","import _curry1 from \"./internal/_curry1.js\";\nimport _makeFlat from \"./internal/_makeFlat.js\";\n/**\n * Returns a new list by pulling every item out of it (and all its sub-arrays)\n * and putting them in a new array, depth-first.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [b]\n * @param {Array} list The array to consider.\n * @return {Array} The flattened list.\n * @see R.unnest\n * @example\n *\n * R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n * //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n */\n\nvar flatten =\n/*#__PURE__*/\n_curry1(\n/*#__PURE__*/\n_makeFlat(true));\n\nexport default flatten;","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 _checkForMethod from \"./internal/_checkForMethod.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Iterate over an input `list`, calling a provided function `fn` for each\n * element in the list.\n *\n * `fn` receives one argument: *(value)*.\n *\n * Note: `R.forEach` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.forEach` method. For more\n * details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n *\n * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns\n * the original array. In some libraries this function is named `each`.\n *\n * Dispatches to the `forEach` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> *) -> [a] -> [a]\n * @param {Function} fn The function to invoke. Receives one argument, `value`.\n * @param {Array} list The list to iterate over.\n * @return {Array} The original list.\n * @see R.addIndex\n * @example\n *\n * const printXPlusFive = x => console.log(x + 5);\n * R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n * // logs 6\n * // logs 7\n * // logs 8\n * @symb R.forEach(f, [a, b, c]) = [a, b, c]\n */\n\nvar forEach =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_checkForMethod('forEach', function forEach(fn, list) {\n var len = list.length;\n var idx = 0;\n\n while (idx < len) {\n fn(list[idx]);\n idx += 1;\n }\n\n return list;\n}));\n\nexport default forEach;","import _curry2 from \"./internal/_curry2.js\";\nimport keys from \"./keys.js\";\n/**\n * Iterate over an input `object`, calling a provided function `fn` for each\n * key and value in the object.\n *\n * `fn` receives three argument: *(value, key, obj)*.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Object\n * @sig ((a, String, StrMap a) -> Any) -> StrMap a -> StrMap a\n * @param {Function} fn The function to invoke. Receives three argument, `value`, `key`, `obj`.\n * @param {Object} obj The object to iterate over.\n * @return {Object} The original object.\n * @example\n *\n * const printKeyConcatValue = (value, key) => console.log(key + ':' + value);\n * R.forEachObjIndexed(printKeyConcatValue, {x: 1, y: 2}); //=> {x: 1, y: 2}\n * // logs x:1\n * // logs y:2\n * @symb R.forEachObjIndexed(f, {x: a, y: b}) = {x: a, y: b}\n */\n\nvar forEachObjIndexed =\n/*#__PURE__*/\n_curry2(function forEachObjIndexed(fn, obj) {\n var keyList = keys(obj);\n var idx = 0;\n\n while (idx < keyList.length) {\n var key = keyList[idx];\n fn(obj[key], key, obj);\n idx += 1;\n }\n\n return obj;\n});\n\nexport default forEachObjIndexed;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Creates a new object from a list key-value pairs. If a key appears in\n * multiple pairs, the rightmost pair is included in the object.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig [[k,v]] -> {k: v}\n * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n * @return {Object} The object made by pairing up `keys` and `values`.\n * @see R.toPairs, R.pair\n * @example\n *\n * R.fromPairs([['a', 1], ['b', 2], ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n */\n\nvar fromPairs =\n/*#__PURE__*/\n_curry1(function fromPairs(pairs) {\n var result = {};\n var idx = 0;\n\n while (idx < pairs.length) {\n result[pairs[idx][0]] = pairs[idx][1];\n idx += 1;\n }\n\n return result;\n});\n\nexport default fromPairs;","import _checkForMethod from \"./internal/_checkForMethod.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport reduceBy from \"./reduceBy.js\";\n/**\n * Splits a list into sub-lists stored in an object, based on the result of\n * calling a String-returning function on each element, and grouping the\n * results according to values returned.\n *\n * Dispatches to the `groupBy` 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 -> String) -> [a] -> {String: [a]}\n * @param {Function} fn Function :: a -> String\n * @param {Array} list The array to group\n * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n * that produced that key when passed to `fn`.\n * @see R.reduceBy, R.transduce\n * @example\n *\n * const byGrade = R.groupBy(function(student) {\n * const score = student.score;\n * return score < 65 ? 'F' :\n * score < 70 ? 'D' :\n * score < 80 ? 'C' :\n * score < 90 ? 'B' : 'A';\n * });\n * const students = [{name: 'Abby', score: 84},\n * {name: 'Eddy', score: 58},\n * // ...\n * {name: 'Jack', score: 69}];\n * byGrade(students);\n * // {\n * // 'A': [{name: 'Dianne', score: 99}],\n * // 'B': [{name: 'Abby', score: 84}]\n * // // ...,\n * // 'F': [{name: 'Eddy', score: 58}]\n * // }\n */\n\nvar groupBy =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_checkForMethod('groupBy',\n/*#__PURE__*/\nreduceBy(function (acc, item) {\n if (acc == null) {\n acc = [];\n }\n\n acc.push(item);\n return acc;\n}, null)));\n\nexport default groupBy;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Takes a list and returns a list of lists where each sublist's elements are\n * all satisfied pairwise comparison according to the provided function.\n * Only adjacent elements are passed to the comparison function.\n *\n * @func\n * @memberOf R\n * @since v0.21.0\n * @category List\n * @sig ((a, a) → Boolean) → [a] → [[a]]\n * @param {Function} fn Function for determining whether two given (adjacent)\n * elements should be in the same group\n * @param {Array} list The array to group. Also accepts a string, which will be\n * treated as a list of characters.\n * @return {List} A list that contains sublists of elements,\n * whose concatenations are equal to the original list.\n * @example\n *\n * R.groupWith(R.equals, [0, 1, 1, 2, 3, 5, 8, 13, 21])\n * //=> [[0], [1, 1], [2], [3], [5], [8], [13], [21]]\n *\n * R.groupWith((a, b) => a + 1 === b, [0, 1, 1, 2, 3, 5, 8, 13, 21])\n * //=> [[0, 1], [1, 2, 3], [5], [8], [13], [21]]\n *\n * R.groupWith((a, b) => a % 2 === b % 2, [0, 1, 1, 2, 3, 5, 8, 13, 21])\n * //=> [[0], [1, 1], [2], [3, 5], [8], [13, 21]]\n *\n * R.groupWith(R.eqBy(isVowel), 'aestiou')\n * //=> ['ae', 'st', 'iou']\n */\n\nvar groupWith =\n/*#__PURE__*/\n_curry2(function (fn, list) {\n var res = [];\n var idx = 0;\n var len = list.length;\n\n while (idx < len) {\n var nextidx = idx + 1;\n\n while (nextidx < len && fn(list[nextidx - 1], list[nextidx])) {\n nextidx += 1;\n }\n\n res.push(list.slice(idx, nextidx));\n idx = nextidx;\n }\n\n return res;\n});\n\nexport default groupWith;","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\";\nimport _has from \"./internal/_has.js\";\nimport isNil from \"./isNil.js\";\n/**\n * Returns whether or not a path exists in an object. Only the object's\n * own properties are checked.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig [Idx] -> {a} -> Boolean\n * @param {Array} path The path to use.\n * @param {Object} obj The object to check the path in.\n * @return {Boolean} Whether the path exists.\n * @see R.has\n * @example\n *\n * R.hasPath(['a', 'b'], {a: {b: 2}}); // => true\n * R.hasPath(['a', 'b'], {a: {b: undefined}}); // => true\n * R.hasPath(['a', 'b'], {a: {c: 2}}); // => false\n * R.hasPath(['a', 'b'], {}); // => false\n */\n\nvar hasPath =\n/*#__PURE__*/\n_curry2(function hasPath(_path, obj) {\n if (_path.length === 0 || isNil(obj)) {\n return false;\n }\n\n var val = obj;\n var idx = 0;\n\n while (idx < _path.length) {\n if (!isNil(val) && _has(_path[idx], val)) {\n val = val[_path[idx]];\n idx += 1;\n } else {\n return false;\n }\n }\n\n return true;\n});\n\nexport default hasPath;","import _curry2 from \"./internal/_curry2.js\";\nimport hasPath from \"./hasPath.js\";\n/**\n * Returns whether or not an object has an own property with the specified name\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Object\n * @sig s -> {s: x} -> Boolean\n * @param {String} prop The name of the property to check for.\n * @param {Object} obj The object to query.\n * @return {Boolean} Whether the property exists.\n * @example\n *\n * const hasName = R.has('name');\n * hasName({name: 'alice'}); //=> true\n * hasName({name: 'bob'}); //=> true\n * hasName({}); //=> false\n *\n * const point = {x: 0, y: 0};\n * const pointHas = R.has(R.__, point);\n * pointHas('x'); //=> true\n * pointHas('y'); //=> true\n * pointHas('z'); //=> false\n */\n\nvar has =\n/*#__PURE__*/\n_curry2(function has(prop, obj) {\n return hasPath([prop], obj);\n});\n\nexport default has;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns whether or not an object or its prototype chain has a property with\n * the specified name\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Object\n * @sig s -> {s: x} -> Boolean\n * @param {String} prop The name of the property to check for.\n * @param {Object} obj The object to query.\n * @return {Boolean} Whether the property exists.\n * @example\n *\n * function Rectangle(width, height) {\n * this.width = width;\n * this.height = height;\n * }\n * Rectangle.prototype.area = function() {\n * return this.width * this.height;\n * };\n *\n * const square = new Rectangle(2, 2);\n * R.hasIn('width', square); //=> true\n * R.hasIn('area', square); //=> true\n */\n\nvar hasIn =\n/*#__PURE__*/\n_curry2(function hasIn(prop, obj) {\n return prop in obj;\n});\n\nexport default hasIn;","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 _curry3 from \"./internal/_curry3.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Creates a function that will process either the `onTrue` or the `onFalse`\n * function depending upon the result of the `condition` predicate.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Logic\n * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n * @param {Function} condition A predicate function\n * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n * @return {Function} A new function that will process either the `onTrue` or the `onFalse`\n * function depending upon the result of the `condition` predicate.\n * @see R.unless, R.when, R.cond\n * @example\n *\n * const incCount = R.ifElse(\n * R.has('count'),\n * R.over(R.lensProp('count'), R.inc),\n * R.assoc('count', 1)\n * );\n * incCount({}); //=> { count: 1 }\n * incCount({ count: 1 }); //=> { count: 2 }\n */\n\nvar ifElse =\n/*#__PURE__*/\n_curry3(function ifElse(condition, onTrue, onFalse) {\n return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n });\n});\n\nexport default ifElse;","import add from \"./add.js\";\n/**\n * Increments its argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Math\n * @sig Number -> Number\n * @param {Number} n\n * @return {Number} n + 1\n * @see R.dec\n * @example\n *\n * R.inc(42); //=> 43\n */\n\nvar inc =\n/*#__PURE__*/\nadd(1);\nexport default inc;","import _includes from \"./internal/_includes.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the specified value is equal, in [`R.equals`](#equals)\n * terms, to at least one element of the given list; `false` otherwise.\n * Works also with strings.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if an equivalent item is in the list, `false` otherwise.\n * @see R.any\n * @example\n *\n * R.includes(3, [1, 2, 3]); //=> true\n * R.includes(4, [1, 2, 3]); //=> false\n * R.includes({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true\n * R.includes([42], [[42]]); //=> true\n * R.includes('ba', 'banana'); //=>true\n */\n\nvar includes =\n/*#__PURE__*/\n_curry2(_includes);\n\nexport default includes;","import reduceBy from \"./reduceBy.js\";\n/**\n * Given a function that generates a key, turns a list of objects into an\n * object indexing the objects by the given key. Note that if multiple\n * objects generate the same value for the indexing key only the last value\n * will be included in the generated object.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig (a -> String) -> [{k: v}] -> {k: {k: v}}\n * @param {Function} fn Function :: a -> String\n * @param {Array} array The array of objects to index\n * @return {Object} An object indexing each array element by the given property.\n * @example\n *\n * const list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}];\n * R.indexBy(R.prop('id'), list);\n * //=> {abc: {id: 'abc', title: 'B'}, xyz: {id: 'xyz', title: 'A'}}\n */\n\nvar indexBy =\n/*#__PURE__*/\nreduceBy(function (acc, elem) {\n return elem;\n}, null);\nexport default indexBy;","import _curry2 from \"./internal/_curry2.js\";\nimport _indexOf from \"./internal/_indexOf.js\";\nimport _isArray from \"./internal/_isArray.js\";\n/**\n * Returns the position of the first occurrence of an item in an array, or -1\n * if the item is not included in the array. [`R.equals`](#equals) is used to\n * determine equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> Number\n * @param {*} target The item to find.\n * @param {Array} xs The array to search in.\n * @return {Number} the index of the target, or -1 if the target is not found.\n * @see R.lastIndexOf\n * @example\n *\n * R.indexOf(3, [1,2,3,4]); //=> 2\n * R.indexOf(10, [1,2,3,4]); //=> -1\n */\n\nvar indexOf =\n/*#__PURE__*/\n_curry2(function indexOf(target, xs) {\n return typeof xs.indexOf === 'function' && !_isArray(xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n});\n\nexport default indexOf;","import slice from \"./slice.js\";\n/**\n * Returns all but the last element of the given list or string.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category List\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.last, R.head, R.tail\n * @example\n *\n * R.init([1, 2, 3]); //=> [1, 2]\n * R.init([1, 2]); //=> [1]\n * R.init([1]); //=> []\n * R.init([]); //=> []\n *\n * R.init('abc'); //=> 'ab'\n * R.init('ab'); //=> 'a'\n * R.init('a'); //=> ''\n * R.init(''); //=> ''\n */\n\nvar init =\n/*#__PURE__*/\nslice(0, -1);\nexport default init;","import _includesWith from \"./internal/_includesWith.js\";\nimport _curry3 from \"./internal/_curry3.js\";\nimport _filter from \"./internal/_filter.js\";\n/**\n * Takes a predicate `pred`, a list `xs`, and a list `ys`, and returns a list\n * `xs'` comprising each of the elements of `xs` which is equal to one or more\n * elements of `ys` according to `pred`.\n *\n * `pred` must be a binary function expecting an element from each list.\n *\n * `xs`, `ys`, and `xs'` are treated as sets, semantically, so ordering should\n * not be significant, but since `xs'` is ordered the implementation guarantees\n * that its values are in the same order as they appear in `xs`. Duplicates are\n * not removed, so `xs'` may contain duplicates if `xs` contains duplicates.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Relation\n * @sig ((a, b) -> Boolean) -> [a] -> [b] -> [a]\n * @param {Function} pred\n * @param {Array} xs\n * @param {Array} ys\n * @return {Array}\n * @see R.intersection\n * @example\n *\n * R.innerJoin(\n * (record, id) => record.id === id,\n * [{id: 824, name: 'Richie Furay'},\n * {id: 956, name: 'Dewey Martin'},\n * {id: 313, name: 'Bruce Palmer'},\n * {id: 456, name: 'Stephen Stills'},\n * {id: 177, name: 'Neil Young'}],\n * [177, 456, 999]\n * );\n * //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n */\n\nvar innerJoin =\n/*#__PURE__*/\n_curry3(function innerJoin(pred, xs, ys) {\n return _filter(function (x) {\n return _includesWith(pred, x, ys);\n }, xs);\n});\n\nexport default innerJoin;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Inserts the supplied element into the list, at the specified `index`. _Note that\n\n * this is not destructive_: it returns a copy of the list with the changes.\n * No lists have been harmed in the application of this function.\n *\n * @func\n * @memberOf R\n * @since v0.2.2\n * @category List\n * @sig Number -> a -> [a] -> [a]\n * @param {Number} index The position to insert the element\n * @param {*} elt The element to insert into the Array\n * @param {Array} list The list to insert into\n * @return {Array} A new Array with `elt` inserted at `index`.\n * @example\n *\n * R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n */\n\nvar insert =\n/*#__PURE__*/\n_curry3(function insert(idx, elt, list) {\n idx = idx < list.length && idx >= 0 ? idx : list.length;\n var result = Array.prototype.slice.call(list, 0);\n result.splice(idx, 0, elt);\n return result;\n});\n\nexport default insert;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Inserts the sub-list into the list, at the specified `index`. _Note that this is not\n * destructive_: it returns a copy of the list with the changes.\n * No lists have been harmed in the application of this function.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category List\n * @sig Number -> [a] -> [a] -> [a]\n * @param {Number} index The position to insert the sub-list\n * @param {Array} elts The sub-list to insert into the Array\n * @param {Array} list The list to insert the sub-list into\n * @return {Array} A new Array with `elts` inserted starting at `index`.\n * @example\n *\n * R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n */\n\nvar insertAll =\n/*#__PURE__*/\n_curry3(function insertAll(idx, elts, list) {\n idx = idx < list.length && idx >= 0 ? idx : list.length;\n return [].concat(Array.prototype.slice.call(list, 0, idx), elts, Array.prototype.slice.call(list, idx));\n});\n\nexport default insertAll;","import _Set from \"./internal/_Set.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a new list containing only one copy of each element in the original\n * list, based upon the value returned by applying the supplied function to\n * each list element. Prefers the first item if the supplied function produces\n * the same value on two items. [`R.equals`](#equals) is used for comparison.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig (a -> b) -> [a] -> [a]\n * @param {Function} fn A function used to produce a value to use during comparisons.\n * @param {Array} list The array to consider.\n * @return {Array} The list of unique items.\n * @example\n *\n * R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n */\n\nvar uniqBy =\n/*#__PURE__*/\n_curry2(function uniqBy(fn, list) {\n var set = new _Set();\n var result = [];\n var idx = 0;\n var appliedItem, item;\n\n while (idx < list.length) {\n item = list[idx];\n appliedItem = fn(item);\n\n if (set.add(appliedItem)) {\n result.push(item);\n }\n\n idx += 1;\n }\n\n return result;\n});\n\nexport default uniqBy;","import identity from \"./identity.js\";\nimport uniqBy from \"./uniqBy.js\";\n/**\n * Returns a new list containing only one copy of each element in the original\n * list. [`R.equals`](#equals) is used to determine equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The array to consider.\n * @return {Array} The list of unique items.\n * @example\n *\n * R.uniq([1, 1, 2, 1]); //=> [1, 2]\n * R.uniq([1, '1']); //=> [1, '1']\n * R.uniq([[42], [42]]); //=> [[42]]\n */\n\nvar uniq =\n/*#__PURE__*/\nuniqBy(identity);\nexport default uniq;","import _includes from \"./internal/_includes.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _filter from \"./internal/_filter.js\";\nimport flip from \"./flip.js\";\nimport uniq from \"./uniq.js\";\n/**\n * Combines two lists into a set (i.e. no duplicates) composed of those\n * elements common to both lists.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The list of elements found in both `list1` and `list2`.\n * @see R.innerJoin\n * @example\n *\n * R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n */\n\nvar intersection =\n/*#__PURE__*/\n_curry2(function intersection(list1, list2) {\n var lookupList, filteredList;\n\n if (list1.length > list2.length) {\n lookupList = list1;\n filteredList = list2;\n } else {\n lookupList = list2;\n filteredList = list1;\n }\n\n return uniq(_filter(flip(_includes)(lookupList), filteredList));\n});\n\nexport default intersection;","import _checkForMethod from \"./internal/_checkForMethod.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a new list with the separator interposed between elements.\n *\n * Dispatches to the `intersperse` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} separator The element to add to the list.\n * @param {Array} list The list to be interposed.\n * @return {Array} The new list.\n * @example\n *\n * R.intersperse('a', ['b', 'n', 'n', 's']); //=> ['b', 'a', 'n', 'a', 'n', 'a', 's']\n */\n\nvar intersperse =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_checkForMethod('intersperse', function intersperse(separator, list) {\n var out = [];\n var idx = 0;\n var length = list.length;\n\n while (idx < length) {\n if (idx === length - 1) {\n out.push(list[idx]);\n } else {\n out.push(list[idx], separator);\n }\n\n idx += 1;\n }\n\n return out;\n}));\n\nexport default intersperse;","import _has from \"./_has.js\"; // Based on https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\n\nfunction _objectAssign(target) {\n if (target == null) {\n throw new TypeError('Cannot convert undefined or null to object');\n }\n\n var output = Object(target);\n var idx = 1;\n var length = arguments.length;\n\n while (idx < length) {\n var source = arguments[idx];\n\n if (source != null) {\n for (var nextKey in source) {\n if (_has(nextKey, source)) {\n output[nextKey] = source[nextKey];\n }\n }\n }\n\n idx += 1;\n }\n\n return output;\n}\n\nexport default typeof Object.assign === 'function' ? Object.assign : _objectAssign;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates an object containing a single key:value pair.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Object\n * @sig String -> a -> {String:a}\n * @param {String} key\n * @param {*} val\n * @return {Object}\n * @see R.pair\n * @example\n *\n * const matchPhrases = R.compose(\n * R.objOf('must'),\n * R.map(R.objOf('match_phrase'))\n * );\n * matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n */\n\nvar objOf =\n/*#__PURE__*/\n_curry2(function objOf(key, val) {\n var obj = {};\n obj[key] = val;\n return obj;\n});\n\nexport default objOf;","import _objectAssign from \"./_objectAssign.js\";\nimport _identity from \"./_identity.js\";\nimport _isArrayLike from \"./_isArrayLike.js\";\nimport _isTransformer from \"./_isTransformer.js\";\nimport objOf from \"../objOf.js\";\nvar _stepCatArray = {\n '@@transducer/init': Array,\n '@@transducer/step': function (xs, x) {\n xs.push(x);\n return xs;\n },\n '@@transducer/result': _identity\n};\nvar _stepCatString = {\n '@@transducer/init': String,\n '@@transducer/step': function (a, b) {\n return a + b;\n },\n '@@transducer/result': _identity\n};\nvar _stepCatObject = {\n '@@transducer/init': Object,\n '@@transducer/step': function (result, input) {\n return _objectAssign(result, _isArrayLike(input) ? objOf(input[0], input[1]) : input);\n },\n '@@transducer/result': _identity\n};\nexport default function _stepCat(obj) {\n if (_isTransformer(obj)) {\n return obj;\n }\n\n if (_isArrayLike(obj)) {\n return _stepCatArray;\n }\n\n if (typeof obj === 'string') {\n return _stepCatString;\n }\n\n if (typeof obj === 'object') {\n return _stepCatObject;\n }\n\n throw new Error('Cannot create transformer for ' + obj);\n}","import _clone from \"./internal/_clone.js\";\nimport _curry3 from \"./internal/_curry3.js\";\nimport _isTransformer from \"./internal/_isTransformer.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport _stepCat from \"./internal/_stepCat.js\";\n/**\n * Transforms the items of the list with the transducer and appends the\n * transformed items to the accumulator using an appropriate iterator function\n * based on the accumulator type.\n *\n * The accumulator can be an array, string, object or a transformer. Iterated\n * items will be appended to arrays and concatenated to strings. Objects will\n * be merged directly or 2-item arrays will be merged as key, value pairs.\n *\n * The accumulator can also be a transformer object that provides a 2-arity\n * reducing iterator function, step, 0-arity initial value function, init, and\n * 1-arity result extraction function result. The step function is used as the\n * iterator function in reduce. The result function is used to convert the\n * final accumulator into the return type and in most cases is R.identity. The\n * init function is used to provide the initial accumulator.\n *\n * The iteration is performed with [`R.reduce`](#reduce) after initializing the\n * transducer.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category List\n * @sig a -> (b -> b) -> [c] -> a\n * @param {*} acc The initial accumulator value.\n * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.transduce\n * @example\n *\n * const numbers = [1, 2, 3, 4];\n * const transducer = R.compose(R.map(R.add(1)), R.take(2));\n *\n * R.into([], transducer, numbers); //=> [2, 3]\n *\n * const intoArray = R.into([]);\n * intoArray(transducer, numbers); //=> [2, 3]\n */\n\nvar into =\n/*#__PURE__*/\n_curry3(function into(acc, xf, list) {\n return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), _clone(acc, [], [], false), list);\n});\n\nexport default into;","import _curry1 from \"./internal/_curry1.js\";\nimport _has from \"./internal/_has.js\";\nimport keys from \"./keys.js\";\n/**\n * Same as [`R.invertObj`](#invertObj), however this accounts for objects with\n * duplicate values by putting the values into an array.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig {s: x} -> {x: [ s, ... ]}\n * @param {Object} obj The object or array to invert\n * @return {Object} out A new object with keys in an array.\n * @see R.invertObj\n * @example\n *\n * const raceResultsByFirstName = {\n * first: 'alice',\n * second: 'jake',\n * third: 'alice',\n * };\n * R.invert(raceResultsByFirstName);\n * //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n */\n\nvar invert =\n/*#__PURE__*/\n_curry1(function invert(obj) {\n var props = keys(obj);\n var len = props.length;\n var idx = 0;\n var out = {};\n\n while (idx < len) {\n var key = props[idx];\n var val = obj[key];\n var list = _has(val, out) ? out[val] : out[val] = [];\n list[list.length] = key;\n idx += 1;\n }\n\n return out;\n});\n\nexport default invert;","import _curry1 from \"./internal/_curry1.js\";\nimport keys from \"./keys.js\";\n/**\n * Returns a new object with the keys of the given object as values, and the\n * values of the given object, which are coerced to strings, as keys. Note\n * that the last key found is preferred when handling the same value.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig {s: x} -> {x: s}\n * @param {Object} obj The object or array to invert\n * @return {Object} out A new object\n * @see R.invert\n * @example\n *\n * const raceResults = {\n * first: 'alice',\n * second: 'jake'\n * };\n * R.invertObj(raceResults);\n * //=> { 'alice': 'first', 'jake':'second' }\n *\n * // Alternatively:\n * const raceResults = ['alice', 'jake'];\n * R.invertObj(raceResults);\n * //=> { 'alice': '0', 'jake':'1' }\n */\n\nvar invertObj =\n/*#__PURE__*/\n_curry1(function invertObj(obj) {\n var props = keys(obj);\n var len = props.length;\n var idx = 0;\n var out = {};\n\n while (idx < len) {\n var key = props[idx];\n out[obj[key]] = key;\n idx += 1;\n }\n\n return out;\n});\n\nexport default invertObj;","import _curry2 from \"./internal/_curry2.js\";\nimport _isFunction from \"./internal/_isFunction.js\";\nimport curryN from \"./curryN.js\";\nimport toString from \"./toString.js\";\n/**\n * Turns a named method with a specified arity into a function that can be\n * called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n * before the target object.\n * @param {String} method Name of any of the target object's methods to call.\n * @return {Function} A new curried function.\n * @see R.construct\n * @example\n *\n * const sliceFrom = R.invoker(1, 'slice');\n * sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n * const sliceFrom6 = R.invoker(2, 'slice')(6);\n * sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n *\n * const dog = {\n * speak: async () => 'Woof!'\n * };\n * const speak = R.invoker(0, 'speak');\n * speak(dog).then(console.log) //~> 'Woof!'\n *\n * @symb R.invoker(0, 'method')(o) = o['method']()\n * @symb R.invoker(1, 'method')(a, o) = o['method'](a)\n * @symb R.invoker(2, 'method')(a, b, o) = o['method'](a, b)\n */\n\nvar invoker =\n/*#__PURE__*/\n_curry2(function invoker(arity, method) {\n return curryN(arity + 1, function () {\n var target = arguments[arity];\n\n if (target != null && _isFunction(target[method])) {\n return target[method].apply(target, Array.prototype.slice.call(arguments, 0, arity));\n }\n\n throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n });\n});\n\nexport default invoker;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * See if an object (`val`) is an instance of the supplied constructor. This\n * function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n * R.is(Object, {}); //=> true\n * R.is(Number, 1); //=> true\n * R.is(Object, 1); //=> false\n * R.is(String, 's'); //=> true\n * R.is(String, new String('')); //=> true\n * R.is(Object, new String('')); //=> true\n * R.is(Object, 's'); //=> false\n * R.is(Number, {}); //=> false\n */\n\nvar is =\n/*#__PURE__*/\n_curry2(function is(Ctor, val) {\n return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n\nexport default is;","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 invoker from \"./invoker.js\";\n/**\n * Returns a string made by inserting the `separator` between each element and\n * concatenating all the elements into a single string.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig String -> [a] -> String\n * @param {Number|String} separator The string used to separate the elements.\n * @param {Array} xs The elements to join into a string.\n * @return {String} str The string made by concatenating `xs` with `separator`.\n * @see R.split\n * @example\n *\n * const spacer = R.join(' ');\n * spacer(['a', 2, 3.4]); //=> 'a 2 3.4'\n * R.join('|', [1, 2, 3]); //=> '1|2|3'\n */\n\nvar join =\n/*#__PURE__*/\ninvoker(1, 'join');\nexport default join;","import _curry1 from \"./internal/_curry1.js\";\nimport converge from \"./converge.js\";\n/**\n * juxt applies a list of functions to a list of values.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Function\n * @sig [(a, b, ..., m) -> n] -> ((a, b, ..., m) -> [n])\n * @param {Array} fns An array of functions\n * @return {Function} A function that returns a list of values after applying each of the original `fns` to its parameters.\n * @see R.applySpec\n * @example\n *\n * const getRange = R.juxt([Math.min, Math.max]);\n * getRange(3, 4, 9, -3); //=> [-3, 9]\n * @symb R.juxt([f, g, h])(a, b) = [f(a, b), g(a, b), h(a, b)]\n */\n\nvar juxt =\n/*#__PURE__*/\n_curry1(function juxt(fns) {\n return converge(function () {\n return Array.prototype.slice.call(arguments, 0);\n }, fns);\n});\n\nexport default juxt;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Returns a list containing the names of all the properties of the supplied\n * object, including prototype properties.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own and prototype properties.\n * @see R.keys, R.valuesIn\n * @example\n *\n * const F = function() { this.x = 'X'; };\n * F.prototype.y = 'Y';\n * const f = new F();\n * R.keysIn(f); //=> ['x', 'y']\n */\n\nvar keysIn =\n/*#__PURE__*/\n_curry1(function keysIn(obj) {\n var prop;\n var ks = [];\n\n for (prop in obj) {\n ks[ks.length] = prop;\n }\n\n return ks;\n});\n\nexport default keysIn;","import _curry2 from \"./internal/_curry2.js\";\nimport _isArray from \"./internal/_isArray.js\";\nimport equals from \"./equals.js\";\n/**\n * Returns the position of the last occurrence of an item in an array, or -1 if\n * the item is not included in the array. [`R.equals`](#equals) is used to\n * determine equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> Number\n * @param {*} target The item to find.\n * @param {Array} xs The array to search in.\n * @return {Number} the index of the target, or -1 if the target is not found.\n * @see R.indexOf\n * @example\n *\n * R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n * R.lastIndexOf(10, [1,2,3,4]); //=> -1\n */\n\nvar lastIndexOf =\n/*#__PURE__*/\n_curry2(function lastIndexOf(target, xs) {\n if (typeof xs.lastIndexOf === 'function' && !_isArray(xs)) {\n return xs.lastIndexOf(target);\n } else {\n var idx = xs.length - 1;\n\n while (idx >= 0) {\n if (equals(xs[idx], target)) {\n return idx;\n }\n\n idx -= 1;\n }\n\n return -1;\n }\n});\n\nexport default lastIndexOf;","export default function _isNumber(x) {\n return Object.prototype.toString.call(x) === '[object Number]';\n}","import _curry1 from \"./internal/_curry1.js\";\nimport _isNumber from \"./internal/_isNumber.js\";\n/**\n * Returns the number of elements in the array by returning `list.length`.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig [a] -> Number\n * @param {Array} list The array to inspect.\n * @return {Number} The length of the array.\n * @example\n *\n * R.length([]); //=> 0\n * R.length([1, 2, 3]); //=> 3\n */\n\nvar length =\n/*#__PURE__*/\n_curry1(function length(list) {\n return list != null && _isNumber(list.length) ? list.length : NaN;\n});\n\nexport default length;","import _curry2 from \"./internal/_curry2.js\";\nimport map from \"./map.js\";\n/**\n * Returns a lens for the given getter and setter functions. The getter \"gets\"\n * the value of the focus; the setter \"sets\" the value of the focus. The setter\n * should not mutate the data structure.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n * @param {Function} getter\n * @param {Function} setter\n * @return {Lens}\n * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n * @example\n *\n * const xLens = R.lens(R.prop('x'), R.assoc('x'));\n *\n * R.view(xLens, {x: 1, y: 2}); //=> 1\n * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}\n * R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2}\n */\n\nvar lens =\n/*#__PURE__*/\n_curry2(function lens(getter, setter) {\n return function (toFunctorFn) {\n return function (target) {\n return map(function (focus) {\n return setter(focus, target);\n }, toFunctorFn(getter(target)));\n };\n };\n});\n\nexport default lens;","import _curry1 from \"./internal/_curry1.js\";\nimport lens from \"./lens.js\";\nimport nth from \"./nth.js\";\nimport update from \"./update.js\";\n/**\n * Returns a lens whose focus is the specified index.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Number -> Lens s a\n * @param {Number} n\n * @return {Lens}\n * @see R.view, R.set, R.over, R.nth\n * @example\n *\n * const headLens = R.lensIndex(0);\n *\n * R.view(headLens, ['a', 'b', 'c']); //=> 'a'\n * R.set(headLens, 'x', ['a', 'b', 'c']); //=> ['x', 'b', 'c']\n * R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n */\n\nvar lensIndex =\n/*#__PURE__*/\n_curry1(function lensIndex(n) {\n return lens(nth(n), update(n));\n});\n\nexport default lensIndex;","import _curry1 from \"./internal/_curry1.js\";\nimport assocPath from \"./assocPath.js\";\nimport lens from \"./lens.js\";\nimport path from \"./path.js\";\n/**\n * Returns a lens whose focus is the specified path.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Object\n * @typedefn Idx = String | Int\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig [Idx] -> Lens s a\n * @param {Array} path The path to use.\n * @return {Lens}\n * @see R.view, R.set, R.over\n * @example\n *\n * const xHeadYLens = R.lensPath(['x', 0, 'y']);\n *\n * R.view(xHeadYLens, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});\n * //=> 2\n * R.set(xHeadYLens, 1, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});\n * //=> {x: [{y: 1, z: 3}, {y: 4, z: 5}]}\n * R.over(xHeadYLens, R.negate, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});\n * //=> {x: [{y: -2, z: 3}, {y: 4, z: 5}]}\n */\n\nvar lensPath =\n/*#__PURE__*/\n_curry1(function lensPath(p) {\n return lens(path(p), assocPath(p));\n});\n\nexport default lensPath;","import _curry1 from \"./internal/_curry1.js\";\nimport assoc from \"./assoc.js\";\nimport lens from \"./lens.js\";\nimport prop from \"./prop.js\";\n/**\n * Returns a lens whose focus is the specified property.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig String -> Lens s a\n * @param {String} k\n * @return {Lens}\n * @see R.view, R.set, R.over\n * @example\n *\n * const xLens = R.lensProp('x');\n *\n * R.view(xLens, {x: 1, y: 2}); //=> 1\n * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}\n * R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2}\n */\n\nvar lensProp =\n/*#__PURE__*/\n_curry1(function lensProp(k) {\n return lens(prop(k), assoc(k));\n});\n\nexport default lensProp;","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 _curry3 from \"./internal/_curry3.js\";\n/**\n * The `mapAccum` function behaves like a combination of map and reduce; it\n * applies a function to each element of a list, passing an accumulating\n * parameter from left to right, and returning a final value of this\n * accumulator together with the new list.\n *\n * The iterator function receives two arguments, *acc* and *value*, and should\n * return a tuple *[acc, value]*.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig ((acc, x) -> (acc, y)) -> acc -> [x] -> (acc, [y])\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.scan, R.addIndex, R.mapAccumRight\n * @example\n *\n * const digits = ['1', '2', '3', '4'];\n * const appender = (a, b) => [a + b, a + b];\n *\n * R.mapAccum(appender, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n * @symb R.mapAccum(f, a, [b, c, d]) = [\n * f(f(f(a, b)[0], c)[0], d)[0],\n * [\n * f(a, b)[1],\n * f(f(a, b)[0], c)[1],\n * f(f(f(a, b)[0], c)[0], d)[1]\n * ]\n * ]\n */\n\nvar mapAccum =\n/*#__PURE__*/\n_curry3(function mapAccum(fn, acc, list) {\n var idx = 0;\n var len = list.length;\n var result = [];\n var tuple = [acc];\n\n while (idx < len) {\n tuple = fn(tuple[0], list[idx]);\n result[idx] = tuple[1];\n idx += 1;\n }\n\n return [tuple[0], result];\n});\n\nexport default mapAccum;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * The `mapAccumRight` function behaves like a combination of map and reduce; it\n * applies a function to each element of a list, passing an accumulating\n * parameter from right to left, and returning a final value of this\n * accumulator together with the new list.\n *\n * Similar to [`mapAccum`](#mapAccum), except moves through the input list from\n * the right to the left.\n *\n * The iterator function receives two arguments, *acc* and *value*, and should\n * return a tuple *[acc, value]*.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig ((acc, x) -> (acc, y)) -> acc -> [x] -> (acc, [y])\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.addIndex, R.mapAccum\n * @example\n *\n * const digits = ['1', '2', '3', '4'];\n * const appender = (a, b) => [b + a, b + a];\n *\n * R.mapAccumRight(appender, 5, digits); //=> ['12345', ['12345', '2345', '345', '45']]\n * @symb R.mapAccumRight(f, a, [b, c, d]) = [\n * f(f(f(a, d)[0], c)[0], b)[0],\n * [\n * f(a, d)[1],\n * f(f(a, d)[0], c)[1],\n * f(f(f(a, d)[0], c)[0], b)[1]\n * ]\n * ]\n */\n\nvar mapAccumRight =\n/*#__PURE__*/\n_curry3(function mapAccumRight(fn, acc, list) {\n var idx = list.length - 1;\n var result = [];\n var tuple = [acc];\n\n while (idx >= 0) {\n tuple = fn(tuple[0], list[idx]);\n result[idx] = tuple[1];\n idx -= 1;\n }\n\n return [tuple[0], result];\n});\n\nexport default mapAccumRight;","import _curry2 from \"./internal/_curry2.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport keys from \"./keys.js\";\n/**\n * An Object-specific version of [`map`](#map). The function is applied to three\n * arguments: *(value, key, obj)*. If only the value is significant, use\n * [`map`](#map) instead.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig ((*, String, Object) -> *) -> Object -> Object\n * @param {Function} fn\n * @param {Object} obj\n * @return {Object}\n * @see R.map\n * @example\n *\n * const xyz = { x: 1, y: 2, z: 3 };\n * const prependKeyAndDouble = (num, key, obj) => key + (num * 2);\n *\n * R.mapObjIndexed(prependKeyAndDouble, xyz); //=> { x: 'x2', y: 'y4', z: 'z6' }\n */\n\nvar mapObjIndexed =\n/*#__PURE__*/\n_curry2(function mapObjIndexed(fn, obj) {\n return _reduce(function (acc, key) {\n acc[key] = fn(obj[key], key, obj);\n return acc;\n }, {}, keys(obj));\n});\n\nexport default mapObjIndexed;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Tests a regular expression against a String. Note that this function will\n * return an empty array when there are no matches. This differs from\n * [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n * which returns `null` when there are no matches.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category String\n * @sig RegExp -> String -> [String | Undefined]\n * @param {RegExp} rx A regular expression.\n * @param {String} str The string to match against\n * @return {Array} The list of matches or empty array.\n * @see R.test\n * @example\n *\n * R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n * R.match(/a/, 'b'); //=> []\n * R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n */\n\nvar match =\n/*#__PURE__*/\n_curry2(function match(rx, str) {\n return str.match(rx) || [];\n});\n\nexport default match;","import _curry2 from \"./internal/_curry2.js\";\nimport _isInteger from \"./internal/_isInteger.js\";\n/**\n * `mathMod` behaves like the modulo operator should mathematically, unlike the\n * `%` operator (and by extension, [`R.modulo`](#modulo)). So while\n * `-17 % 5` is `-2`, `mathMod(-17, 5)` is `3`. `mathMod` requires Integer\n * arguments, and returns NaN when the modulus is zero or negative.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} m The dividend.\n * @param {Number} p the modulus.\n * @return {Number} The result of `b mod a`.\n * @see R.modulo\n * @example\n *\n * R.mathMod(-17, 5); //=> 3\n * R.mathMod(17, 5); //=> 2\n * R.mathMod(17, -5); //=> NaN\n * R.mathMod(17, 0); //=> NaN\n * R.mathMod(17.2, 5); //=> NaN\n * R.mathMod(17, 5.3); //=> NaN\n *\n * const clock = R.mathMod(R.__, 12);\n * clock(15); //=> 3\n * clock(24); //=> 0\n *\n * const seventeenMod = R.mathMod(17);\n * seventeenMod(3); //=> 2\n * seventeenMod(4); //=> 1\n * seventeenMod(10); //=> 7\n */\n\nvar mathMod =\n/*#__PURE__*/\n_curry2(function mathMod(m, p) {\n if (!_isInteger(m)) {\n return NaN;\n }\n\n if (!_isInteger(p) || p < 1) {\n return NaN;\n }\n\n return (m % p + p) % p;\n});\n\nexport default mathMod;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Takes a function and two values, and returns whichever value produces the\n * larger result when passed to the provided function.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Relation\n * @sig Ord b => (a -> b) -> a -> a -> a\n * @param {Function} f\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.max, R.minBy\n * @example\n *\n * // square :: Number -> Number\n * const square = n => n * n;\n *\n * R.maxBy(square, -3, 2); //=> -3\n *\n * R.reduce(R.maxBy(square), 0, [3, -5, 4, 1, -2]); //=> -5\n * R.reduce(R.maxBy(square), 0, []); //=> 0\n */\n\nvar maxBy =\n/*#__PURE__*/\n_curry3(function maxBy(f, a, b) {\n return f(b) > f(a) ? b : a;\n});\n\nexport default maxBy;","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 _arity from \"./internal/_arity.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _has from \"./internal/_has.js\";\n/**\n * Creates a new function that, when invoked, caches the result of calling `fn`\n * for a given argument set and returns the result. Subsequent calls to the\n * memoized `fn` with the same argument set will not result in an additional\n * call to `fn`; instead, the cached result for that set of arguments will be\n * returned.\n *\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Function\n * @sig (*... -> String) -> (*... -> a) -> (*... -> a)\n * @param {Function} fn The function to generate the cache key.\n * @param {Function} fn The function to memoize.\n * @return {Function} Memoized version of `fn`.\n * @example\n *\n * let count = 0;\n * const factorial = R.memoizeWith(R.identity, n => {\n * count += 1;\n * return R.product(R.range(1, n + 1));\n * });\n * factorial(5); //=> 120\n * factorial(5); //=> 120\n * factorial(5); //=> 120\n * count; //=> 1\n */\n\nvar memoizeWith =\n/*#__PURE__*/\n_curry2(function memoizeWith(mFn, fn) {\n var cache = {};\n return _arity(fn.length, function () {\n var key = mFn.apply(this, arguments);\n\n if (!_has(key, cache)) {\n cache[key] = fn.apply(this, arguments);\n }\n\n return cache[key];\n });\n});\n\nexport default memoizeWith;","import _objectAssign from \"./internal/_objectAssign.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Create a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects,\n * the value from the second object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeRight, R.mergeDeepRight, R.mergeWith, R.mergeWithKey\n * @deprecated since v0.26.0\n * @example\n *\n * R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n * //=> { 'name': 'fred', 'age': 40 }\n *\n * const withDefaults = R.merge({x: 0, y: 0});\n * withDefaults({y: 2}); //=> {x: 0, y: 2}\n * @symb R.merge(a, b) = {...a, ...b}\n */\n\nvar merge =\n/*#__PURE__*/\n_curry2(function merge(l, r) {\n return _objectAssign({}, l, r);\n});\n\nexport default merge;","import _objectAssign from \"./internal/_objectAssign.js\";\nimport _curry1 from \"./internal/_curry1.js\";\n/**\n * Merges a list of objects together into one object.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig [{k: v}] -> {k: v}\n * @param {Array} list An array of objects\n * @return {Object} A merged object.\n * @see R.reduce\n * @example\n *\n * R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n * R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n * @symb R.mergeAll([{ x: 1 }, { y: 2 }, { z: 3 }]) = { x: 1, y: 2, z: 3 }\n */\n\nvar mergeAll =\n/*#__PURE__*/\n_curry1(function mergeAll(list) {\n return _objectAssign.apply(null, [{}].concat(list));\n});\n\nexport default mergeAll;","import _curry3 from \"./internal/_curry3.js\";\nimport _has from \"./internal/_has.js\";\n/**\n * Creates a new object with the own properties of the two provided objects. If\n * a key exists in both objects, the provided function is applied to the key\n * and the values associated with the key in each object, with the result being\n * used as the value associated with the key in the returned object.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Object\n * @sig ((String, a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeDeepWithKey, R.merge, R.mergeWith\n * @example\n *\n * let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r\n * R.mergeWithKey(concatValues,\n * { a: true, thing: 'foo', values: [10, 20] },\n * { b: true, thing: 'bar', values: [15, 35] });\n * //=> { a: true, b: true, thing: 'bar', values: [10, 20, 15, 35] }\n * @symb R.mergeWithKey(f, { x: 1, y: 2 }, { y: 5, z: 3 }) = { x: 1, y: f('y', 2, 5), z: 3 }\n */\n\nvar mergeWithKey =\n/*#__PURE__*/\n_curry3(function mergeWithKey(fn, l, r) {\n var result = {};\n var k;\n\n for (k in l) {\n if (_has(k, l)) {\n result[k] = _has(k, r) ? fn(k, l[k], r[k]) : l[k];\n }\n }\n\n for (k in r) {\n if (_has(k, r) && !_has(k, result)) {\n result[k] = r[k];\n }\n }\n\n return result;\n});\n\nexport default mergeWithKey;","import _curry3 from \"./internal/_curry3.js\";\nimport _isObject from \"./internal/_isObject.js\";\nimport mergeWithKey from \"./mergeWithKey.js\";\n/**\n * Creates a new object with the own properties of the two provided objects.\n * If a key exists in both objects:\n * - and both associated values are also objects then the values will be\n * recursively merged.\n * - otherwise the provided function is applied to the key and associated values\n * using the resulting value as the new value associated with the key.\n * If a key only exists in one object, the value will be associated with the key\n * of the resulting object.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig ((String, a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.mergeWithKey, R.mergeDeepWith\n * @example\n *\n * let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r\n * R.mergeDeepWithKey(concatValues,\n * { a: true, c: { thing: 'foo', values: [10, 20] }},\n * { b: true, c: { thing: 'bar', values: [15, 35] }});\n * //=> { a: true, b: true, c: { thing: 'bar', values: [10, 20, 15, 35] }}\n */\n\nvar mergeDeepWithKey =\n/*#__PURE__*/\n_curry3(function mergeDeepWithKey(fn, lObj, rObj) {\n return mergeWithKey(function (k, lVal, rVal) {\n if (_isObject(lVal) && _isObject(rVal)) {\n return mergeDeepWithKey(fn, lVal, rVal);\n } else {\n return fn(k, lVal, rVal);\n }\n }, lObj, rObj);\n});\n\nexport default mergeDeepWithKey;","import _curry2 from \"./internal/_curry2.js\";\nimport mergeDeepWithKey from \"./mergeDeepWithKey.js\";\n/**\n * Creates a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects:\n * - and both values are objects, the two values will be recursively merged\n * - otherwise the value from the first object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig {a} -> {a} -> {a}\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.merge, R.mergeDeepRight, R.mergeDeepWith, R.mergeDeepWithKey\n * @example\n *\n * R.mergeDeepLeft({ name: 'fred', age: 10, contact: { email: 'moo@example.com' }},\n * { age: 40, contact: { email: 'baa@example.com' }});\n * //=> { name: 'fred', age: 10, contact: { email: 'moo@example.com' }}\n */\n\nvar mergeDeepLeft =\n/*#__PURE__*/\n_curry2(function mergeDeepLeft(lObj, rObj) {\n return mergeDeepWithKey(function (k, lVal, rVal) {\n return lVal;\n }, lObj, rObj);\n});\n\nexport default mergeDeepLeft;","import _curry2 from \"./internal/_curry2.js\";\nimport mergeDeepWithKey from \"./mergeDeepWithKey.js\";\n/**\n * Creates a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects:\n * - and both values are objects, the two values will be recursively merged\n * - otherwise the value from the second object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig {a} -> {a} -> {a}\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.merge, R.mergeDeepLeft, R.mergeDeepWith, R.mergeDeepWithKey\n * @example\n *\n * R.mergeDeepRight({ name: 'fred', age: 10, contact: { email: 'moo@example.com' }},\n * { age: 40, contact: { email: 'baa@example.com' }});\n * //=> { name: 'fred', age: 40, contact: { email: 'baa@example.com' }}\n */\n\nvar mergeDeepRight =\n/*#__PURE__*/\n_curry2(function mergeDeepRight(lObj, rObj) {\n return mergeDeepWithKey(function (k, lVal, rVal) {\n return rVal;\n }, lObj, rObj);\n});\n\nexport default mergeDeepRight;","import _curry3 from \"./internal/_curry3.js\";\nimport mergeDeepWithKey from \"./mergeDeepWithKey.js\";\n/**\n * Creates a new object with the own properties of the two provided objects.\n * If a key exists in both objects:\n * - and both associated values are also objects then the values will be\n * recursively merged.\n * - otherwise the provided function is applied to associated values using the\n * resulting value as the new value associated with the key.\n * If a key only exists in one object, the value will be associated with the key\n * of the resulting object.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig ((a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.mergeWith, R.mergeDeepWithKey\n * @example\n *\n * R.mergeDeepWith(R.concat,\n * { a: true, c: { values: [10, 20] }},\n * { b: true, c: { values: [15, 35] }});\n * //=> { a: true, b: true, c: { values: [10, 20, 15, 35] }}\n */\n\nvar mergeDeepWith =\n/*#__PURE__*/\n_curry3(function mergeDeepWith(fn, lObj, rObj) {\n return mergeDeepWithKey(function (k, lVal, rVal) {\n return fn(lVal, rVal);\n }, lObj, rObj);\n});\n\nexport default mergeDeepWith;","import _objectAssign from \"./internal/_objectAssign.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Create a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects,\n * the value from the first object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeRight, R.mergeDeepLeft, R.mergeWith, R.mergeWithKey\n * @example\n *\n * R.mergeLeft({ 'age': 40 }, { 'name': 'fred', 'age': 10 });\n * //=> { 'name': 'fred', 'age': 40 }\n *\n * const resetToDefault = R.mergeLeft({x: 0});\n * resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n * @symb R.mergeLeft(a, b) = {...b, ...a}\n */\n\nvar mergeLeft =\n/*#__PURE__*/\n_curry2(function mergeLeft(l, r) {\n return _objectAssign({}, r, l);\n});\n\nexport default mergeLeft;","import _objectAssign from \"./internal/_objectAssign.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Create a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects,\n * the value from the second object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeLeft, R.mergeDeepRight, R.mergeWith, R.mergeWithKey\n * @example\n *\n * R.mergeRight({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n * //=> { 'name': 'fred', 'age': 40 }\n *\n * const withDefaults = R.mergeRight({x: 0, y: 0});\n * withDefaults({y: 2}); //=> {x: 0, y: 2}\n * @symb R.mergeRight(a, b) = {...a, ...b}\n */\n\nvar mergeRight =\n/*#__PURE__*/\n_curry2(function mergeRight(l, r) {\n return _objectAssign({}, l, r);\n});\n\nexport default mergeRight;","import _curry3 from \"./internal/_curry3.js\";\nimport mergeWithKey from \"./mergeWithKey.js\";\n/**\n * Creates a new object with the own properties of the two provided objects. If\n * a key exists in both objects, the provided function is applied to the values\n * associated with the key in each object, with the result being used as the\n * value associated with the key in the returned object.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Object\n * @sig ((a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeDeepWith, R.merge, R.mergeWithKey\n * @example\n *\n * R.mergeWith(R.concat,\n * { a: true, values: [10, 20] },\n * { b: true, values: [15, 35] });\n * //=> { a: true, b: true, values: [10, 20, 15, 35] }\n */\n\nvar mergeWith =\n/*#__PURE__*/\n_curry3(function mergeWith(fn, l, r) {\n return mergeWithKey(function (_, _l, _r) {\n return fn(_l, _r);\n }, l, r);\n});\n\nexport default mergeWith;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns the smaller of its two arguments.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> a\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.minBy, R.max\n * @example\n *\n * R.min(789, 123); //=> 123\n * R.min('a', 'b'); //=> 'a'\n */\n\nvar min =\n/*#__PURE__*/\n_curry2(function min(a, b) {\n return b < a ? b : a;\n});\n\nexport default min;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Takes a function and two values, and returns whichever value produces the\n * smaller result when passed to the provided function.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Relation\n * @sig Ord b => (a -> b) -> a -> a -> a\n * @param {Function} f\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.min, R.maxBy\n * @example\n *\n * // square :: Number -> Number\n * const square = n => n * n;\n *\n * R.minBy(square, -3, 2); //=> 2\n *\n * R.reduce(R.minBy(square), Infinity, [3, -5, 4, 1, -2]); //=> 1\n * R.reduce(R.minBy(square), Infinity, []); //=> Infinity\n */\n\nvar minBy =\n/*#__PURE__*/\n_curry3(function minBy(f, a, b) {\n return f(b) < f(a) ? b : a;\n});\n\nexport default minBy;","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 _curry3 from \"./internal/_curry3.js\";\n/**\n * Move an item, at index `from`, to index `to`, in a list of elements.\n * A new list will be created containing the new elements order.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @param {Number} from The source index\n * @param {Number} to The destination index\n * @param {Array} list The list which will serve to realise the move\n * @return {Array} The new list reordered\n * @example\n *\n * R.move(0, 2, ['a', 'b', 'c', 'd', 'e', 'f']); //=> ['b', 'c', 'a', 'd', 'e', 'f']\n * R.move(-1, 0, ['a', 'b', 'c', 'd', 'e', 'f']); //=> ['f', 'a', 'b', 'c', 'd', 'e'] list rotation\n */\n\nvar move =\n/*#__PURE__*/\n_curry3(function (from, to, list) {\n var length = list.length;\n var result = list.slice();\n var positiveFrom = from < 0 ? length + from : from;\n var positiveTo = to < 0 ? length + to : to;\n var item = result.splice(positiveFrom, 1);\n return positiveFrom < 0 || positiveFrom >= list.length || positiveTo < 0 || positiveTo >= list.length ? list : [].concat(result.slice(0, positiveTo)).concat(item).concat(result.slice(positiveTo, list.length));\n});\n\nexport default move;","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 _curry1 from \"./internal/_curry1.js\";\n/**\n * Negates its argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Math\n * @sig Number -> Number\n * @param {Number} n\n * @return {Number}\n * @example\n *\n * R.negate(42); //=> -42\n */\n\nvar negate =\n/*#__PURE__*/\n_curry1(function negate(n) {\n return -n;\n});\n\nexport default negate;","import _complement from \"./internal/_complement.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport all from \"./all.js\";\n/**\n * Returns `true` if no elements of the list match the predicate, `false`\n * otherwise.\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.12.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 not satisfied by every element, `false` otherwise.\n * @see R.all, R.any\n * @example\n *\n * const isEven = n => n % 2 === 0;\n * const isOdd = n => n % 2 === 1;\n *\n * R.none(isEven, [1, 3, 5, 7, 9, 11]); //=> true\n * R.none(isOdd, [1, 3, 5, 7, 8, 11]); //=> false\n */\n\nvar none =\n/*#__PURE__*/\n_curry2(function none(fn, input) {\n return all(_complement(fn), input);\n});\n\nexport default none;","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 _curry3 from \"./internal/_curry3.js\";\n/**\n * `o` is a curried composition function that returns a unary function.\n * Like [`compose`](#compose), `o` performs right-to-left function composition.\n * Unlike [`compose`](#compose), the rightmost function passed to `o` will be\n * invoked with only one argument. Also, unlike [`compose`](#compose), `o` is\n * limited to accepting only 2 unary functions. The name o was chosen because\n * of its similarity to the mathematical composition operator ∘.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Function\n * @sig (b -> c) -> (a -> b) -> a -> c\n * @param {Function} f\n * @param {Function} g\n * @return {Function}\n * @see R.compose, R.pipe\n * @example\n *\n * const classyGreeting = name => \"The name's \" + name.last + \", \" + name.first + \" \" + name.last\n * const yellGreeting = R.o(R.toUpper, classyGreeting);\n * yellGreeting({first: 'James', last: 'Bond'}); //=> \"THE NAME'S BOND, JAMES BOND\"\n *\n * R.o(R.multiply(10), R.add(10))(-4) //=> 60\n *\n * @symb R.o(f, g, x) = f(g(x))\n */\n\nvar o =\n/*#__PURE__*/\n_curry3(function o(f, g, x) {\n return f(g(x));\n});\n\nexport default o;","export default function _of(x) {\n return [x];\n}","import _curry1 from \"./internal/_curry1.js\";\nimport _of from \"./internal/_of.js\";\n/**\n * Returns a singleton array containing the value provided.\n *\n * Note this `of` is different from the ES6 `of`; See\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig a -> [a]\n * @param {*} x any value\n * @return {Array} An array wrapping `x`.\n * @example\n *\n * R.of(null); //=> [null]\n * R.of([42]); //=> [[42]]\n */\n\nvar of =\n/*#__PURE__*/\n_curry1(_of);\n\nexport default of;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [String] -> {String: *} -> {String: *}\n * @param {Array} names an array of String property names to omit from the new object\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with properties from `names` not on it.\n * @see R.pick\n * @example\n *\n * R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n */\n\nvar omit =\n/*#__PURE__*/\n_curry2(function omit(names, obj) {\n var result = {};\n var index = {};\n var idx = 0;\n var len = names.length;\n\n while (idx < len) {\n index[names[idx]] = 1;\n idx += 1;\n }\n\n for (var prop in obj) {\n if (!index.hasOwnProperty(prop)) {\n result[prop] = obj[prop];\n }\n }\n\n return result;\n});\n\nexport default omit;","import _arity from \"./internal/_arity.js\";\nimport _curry1 from \"./internal/_curry1.js\";\n/**\n * Accepts a function `fn` and returns a function that guards invocation of\n * `fn` such that `fn` can only ever be called once, no matter how many times\n * the returned function is invoked. The first value calculated is returned in\n * subsequent invocations.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (a... -> b) -> (a... -> b)\n * @param {Function} fn The function to wrap in a call-only-once wrapper.\n * @return {Function} The wrapped function.\n * @example\n *\n * const addOneOnce = R.once(x => x + 1);\n * addOneOnce(10); //=> 11\n * addOneOnce(addOneOnce(50)); //=> 11\n */\n\nvar once =\n/*#__PURE__*/\n_curry1(function once(fn) {\n var called = false;\n var result;\n return _arity(fn.length, function () {\n if (called) {\n return result;\n }\n\n called = true;\n result = fn.apply(this, arguments);\n return result;\n });\n});\n\nexport default once;","import _isFunction from \"./_isFunction.js\";\nimport _toString from \"./_toString.js\";\nexport default function _assertPromise(name, p) {\n if (p == null || !_isFunction(p.then)) {\n throw new TypeError('`' + name + '` expected a Promise, received ' + _toString(p, []));\n }\n}","import _curry2 from \"./internal/_curry2.js\";\nimport _assertPromise from \"./internal/_assertPromise.js\";\n/**\n * Returns the result of applying the onFailure function to the value inside\n * a failed promise. This is useful for handling rejected promises\n * inside function compositions.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Function\n * @sig (e -> b) -> (Promise e a) -> (Promise e b)\n * @sig (e -> (Promise f b)) -> (Promise e a) -> (Promise f b)\n * @param {Function} onFailure The function to apply. Can return a value or a promise of a value.\n * @param {Promise} p\n * @return {Promise} The result of calling `p.then(null, onFailure)`\n * @see R.then\n * @example\n *\n * var failedFetch = (id) => Promise.reject('bad ID');\n * var useDefault = () => ({ firstName: 'Bob', lastName: 'Loblaw' })\n *\n * //recoverFromFailure :: String -> Promise ({firstName, lastName})\n * var recoverFromFailure = R.pipe(\n * failedFetch,\n * R.otherwise(useDefault),\n * R.then(R.pick(['firstName', 'lastName'])),\n * );\n * recoverFromFailure(12345).then(console.log)\n */\n\nvar otherwise =\n/*#__PURE__*/\n_curry2(function otherwise(f, p) {\n _assertPromise('otherwise', p);\n\n return p.then(null, f);\n});\n\nexport default otherwise;","import _curry3 from \"./internal/_curry3.js\"; // `Identity` is a functor that holds a single value, where `map` simply\n// transforms the held value with the provided function.\n\nvar Identity = function (x) {\n return {\n value: x,\n map: function (f) {\n return Identity(f(x));\n }\n };\n};\n/**\n * Returns the result of \"setting\" the portion of the given data structure\n * focused by the given lens to the result of applying the given function to\n * the focused value.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Lens s a -> (a -> a) -> s -> s\n * @param {Lens} lens\n * @param {*} v\n * @param {*} x\n * @return {*}\n * @see R.prop, R.lensIndex, R.lensProp\n * @example\n *\n * const headLens = R.lensIndex(0);\n *\n * R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n */\n\n\nvar over =\n/*#__PURE__*/\n_curry3(function over(lens, f, x) {\n // The value returned by the getter function is first transformed with `f`,\n // then set as the value of an `Identity`. This is then mapped over with the\n // setter function of the lens.\n return lens(function (y) {\n return Identity(f(y));\n })(x).value;\n});\n\nexport default over;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Takes two arguments, `fst` and `snd`, and returns `[fst, snd]`.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category List\n * @sig a -> b -> (a,b)\n * @param {*} fst\n * @param {*} snd\n * @return {Array}\n * @see R.objOf, R.of\n * @example\n *\n * R.pair('foo', 'bar'); //=> ['foo', 'bar']\n */\n\nvar pair =\n/*#__PURE__*/\n_curry2(function pair(fst, snd) {\n return [fst, snd];\n});\n\nexport default pair;","import _arity from \"./_arity.js\";\nimport _curry2 from \"./_curry2.js\";\nexport default function _createPartialApplicator(concat) {\n return _curry2(function (fn, args) {\n return _arity(Math.max(0, fn.length - args.length), function () {\n return fn.apply(this, concat(args, arguments));\n });\n });\n}","import _concat from \"./internal/_concat.js\";\nimport _createPartialApplicator from \"./internal/_createPartialApplicator.js\";\n/**\n * Takes a function `f` and a list of arguments, and returns a function `g`.\n * When applied, `g` returns the result of applying `f` to the arguments\n * provided initially followed by the arguments provided to `g`.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Function\n * @sig ((a, b, c, ..., n) -> x) -> [a, b, c, ...] -> ((d, e, f, ..., n) -> x)\n * @param {Function} f\n * @param {Array} args\n * @return {Function}\n * @see R.partialRight, R.curry\n * @example\n *\n * const multiply2 = (a, b) => a * b;\n * const double = R.partial(multiply2, [2]);\n * double(2); //=> 4\n *\n * const greet = (salutation, title, firstName, lastName) =>\n * salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n *\n * const sayHello = R.partial(greet, ['Hello']);\n * const sayHelloToMs = R.partial(sayHello, ['Ms.']);\n * sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n * @symb R.partial(f, [a, b])(c, d) = f(a, b, c, d)\n */\n\nvar partial =\n/*#__PURE__*/\n_createPartialApplicator(_concat);\n\nexport default partial;","import _concat from \"./internal/_concat.js\";\nimport _createPartialApplicator from \"./internal/_createPartialApplicator.js\";\nimport flip from \"./flip.js\";\n/**\n * Takes a function `f` and a list of arguments, and returns a function `g`.\n * When applied, `g` returns the result of applying `f` to the arguments\n * provided to `g` followed by the arguments provided initially.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Function\n * @sig ((a, b, c, ..., n) -> x) -> [d, e, f, ..., n] -> ((a, b, c, ...) -> x)\n * @param {Function} f\n * @param {Array} args\n * @return {Function}\n * @see R.partial\n * @example\n *\n * const greet = (salutation, title, firstName, lastName) =>\n * salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n *\n * const greetMsJaneJones = R.partialRight(greet, ['Ms.', 'Jane', 'Jones']);\n *\n * greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n * @symb R.partialRight(f, [a, b])(c, d) = f(c, d, a, b)\n */\n\nvar partialRight =\n/*#__PURE__*/\n_createPartialApplicator(\n/*#__PURE__*/\nflip(_concat));\n\nexport default partialRight;","import filter from \"./filter.js\";\nimport juxt from \"./juxt.js\";\nimport reject from \"./reject.js\";\n/**\n * Takes a predicate and a list or other `Filterable` object and returns the\n * pair of filterable objects of the same type of elements which do and do not\n * satisfy, the predicate, respectively. Filterable objects include plain objects or any object\n * that has a filter method such as `Array`.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> [f a, f a]\n * @param {Function} pred A predicate to determine which side the element belongs to.\n * @param {Array} filterable the list (or other filterable) to partition.\n * @return {Array} An array, containing first the subset of elements that satisfy the\n * predicate, and second the subset of elements that do not satisfy.\n * @see R.filter, R.reject\n * @example\n *\n * R.partition(R.includes('s'), ['sss', 'ttt', 'foo', 'bars']);\n * // => [ [ 'sss', 'bars' ], [ 'ttt', 'foo' ] ]\n *\n * R.partition(R.includes('s'), { a: 'sss', b: 'ttt', foo: 'bars' });\n * // => [ { a: 'sss', foo: 'bars' }, { b: 'ttt' } ]\n */\n\nvar partition =\n/*#__PURE__*/\njuxt([filter, reject]);\nexport default partition;","import _curry3 from \"./internal/_curry3.js\";\nimport equals from \"./equals.js\";\nimport path from \"./path.js\";\n/**\n * Determines whether a nested path on an object has a specific value, in\n * [`R.equals`](#equals) terms. Most likely used to filter a list.\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Relation\n * @typedefn Idx = String | Int\n * @sig [Idx] -> a -> {a} -> Boolean\n * @param {Array} path The path of the nested property to use\n * @param {*} val The value to compare the nested property with\n * @param {Object} obj The object to check the nested property in\n * @return {Boolean} `true` if the value equals the nested object property,\n * `false` otherwise.\n * @example\n *\n * const user1 = { address: { zipCode: 90210 } };\n * const user2 = { address: { zipCode: 55555 } };\n * const user3 = { name: 'Bob' };\n * const users = [ user1, user2, user3 ];\n * const isFamous = R.pathEq(['address', 'zipCode'], 90210);\n * R.filter(isFamous, users); //=> [ user1 ]\n */\n\nvar pathEq =\n/*#__PURE__*/\n_curry3(function pathEq(_path, val, obj) {\n return equals(path(_path, obj), val);\n});\n\nexport default pathEq;","import _curry3 from \"./internal/_curry3.js\";\nimport defaultTo from \"./defaultTo.js\";\nimport path from \"./path.js\";\n/**\n * If the given, non-null object has a value at the given path, returns the\n * value at that path. Otherwise returns the provided default value.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig a -> [Idx] -> {a} -> a\n * @param {*} d The default value.\n * @param {Array} p The path to use.\n * @param {Object} obj The object to retrieve the nested property from.\n * @return {*} The data at `path` of the supplied object or the default value.\n * @example\n *\n * R.pathOr('N/A', ['a', 'b'], {a: {b: 2}}); //=> 2\n * R.pathOr('N/A', ['a', 'b'], {c: {b: 2}}); //=> \"N/A\"\n */\n\nvar pathOr =\n/*#__PURE__*/\n_curry3(function pathOr(d, p, obj) {\n return defaultTo(d, path(p, obj));\n});\n\nexport default pathOr;","import _curry3 from \"./internal/_curry3.js\";\nimport path from \"./path.js\";\n/**\n * Returns `true` if the specified object property at given path satisfies the\n * given predicate; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Logic\n * @typedefn Idx = String | Int\n * @sig (a -> Boolean) -> [Idx] -> {a} -> Boolean\n * @param {Function} pred\n * @param {Array} propPath\n * @param {*} obj\n * @return {Boolean}\n * @see R.propSatisfies, R.path\n * @example\n *\n * R.pathSatisfies(y => y > 0, ['x', 'y'], {x: {y: 2}}); //=> true\n * R.pathSatisfies(R.is(Object), [], {x: {y: 2}}); //=> true\n */\n\nvar pathSatisfies =\n/*#__PURE__*/\n_curry3(function pathSatisfies(pred, propPath, obj) {\n return pred(path(propPath, obj));\n});\n\nexport default pathSatisfies;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a partial copy of an object containing only the keys specified. If\n * the key does not exist, the property is ignored.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [k] -> {k: v} -> {k: v}\n * @param {Array} names an array of String property names to copy onto a new object\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with only properties from `names` on it.\n * @see R.omit, R.props\n * @example\n *\n * R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n * R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n */\n\nvar pick =\n/*#__PURE__*/\n_curry2(function pick(names, obj) {\n var result = {};\n var idx = 0;\n\n while (idx < names.length) {\n if (names[idx] in obj) {\n result[names[idx]] = obj[names[idx]];\n }\n\n idx += 1;\n }\n\n return result;\n});\n\nexport default pick;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Similar to `pick` except that this one includes a `key: undefined` pair for\n * properties that don't exist.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [k] -> {k: v} -> {k: v}\n * @param {Array} names an array of String property names to copy onto a new object\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with only properties from `names` on it.\n * @see R.pick\n * @example\n *\n * R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n * R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n */\n\nvar pickAll =\n/*#__PURE__*/\n_curry2(function pickAll(names, obj) {\n var result = {};\n var idx = 0;\n var len = names.length;\n\n while (idx < len) {\n var name = names[idx];\n result[name] = obj[name];\n idx += 1;\n }\n\n return result;\n});\n\nexport default pickAll;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a partial copy of an object containing only the keys that satisfy\n * the supplied predicate.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @sig ((v, k) -> Boolean) -> {k: v} -> {k: v}\n * @param {Function} pred A predicate to determine whether or not a key\n * should be included on the output object.\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with only properties that satisfy `pred`\n * on it.\n * @see R.pick, R.filter\n * @example\n *\n * const isUpperCase = (val, key) => key.toUpperCase() === key;\n * R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n */\n\nvar pickBy =\n/*#__PURE__*/\n_curry2(function pickBy(test, obj) {\n var result = {};\n\n for (var prop in obj) {\n if (test(obj[prop], prop, obj)) {\n result[prop] = obj[prop];\n }\n }\n\n return result;\n});\n\nexport default pickBy;","import composeK from \"./composeK.js\";\nimport reverse from \"./reverse.js\";\n/**\n * Returns the left-to-right Kleisli composition of the provided functions,\n * each of which must return a value of a type supported by [`chain`](#chain).\n *\n * `R.pipeK(f, g, h)` is equivalent to `R.pipe(f, R.chain(g), R.chain(h))`.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Function\n * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (a -> m z)\n * @param {...Function}\n * @return {Function}\n * @see R.composeK\n * @deprecated since v0.26.0\n * @example\n *\n * // parseJson :: String -> Maybe *\n * // get :: String -> Object -> Maybe *\n *\n * // getStateCode :: Maybe String -> Maybe String\n * const getStateCode = R.pipeK(\n * parseJson,\n * get('user'),\n * get('address'),\n * get('state'),\n * R.compose(Maybe.of, R.toUpper)\n * );\n *\n * getStateCode('{\"user\":{\"address\":{\"state\":\"ny\"}}}');\n * //=> Just('NY')\n * getStateCode('[Invalid JSON]');\n * //=> Nothing()\n * @symb R.pipeK(f, g, h)(a) = R.chain(h, R.chain(g, f(a)))\n */\n\nexport default function pipeK() {\n if (arguments.length === 0) {\n throw new Error('pipeK requires at least one argument');\n }\n\n return composeK.apply(this, reverse(arguments));\n}","import _concat from \"./internal/_concat.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a new list with the given element at the front, followed by the\n * contents of the list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The item to add to the head of the output list.\n * @param {Array} list The array to add to the tail of the output list.\n * @return {Array} A new array.\n * @see R.append\n * @example\n *\n * R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n */\n\nvar prepend =\n/*#__PURE__*/\n_curry2(function prepend(el, list) {\n return _concat([el], list);\n});\n\nexport default prepend;","import multiply from \"./multiply.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Multiplies 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 product of all the numbers in the list.\n * @see R.reduce\n * @example\n *\n * R.product([2,4,6,8,100,1]); //=> 38400\n */\n\nvar product =\n/*#__PURE__*/\nreduce(multiply, 1);\nexport default product;","import _curry2 from \"./internal/_curry2.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Accepts a function `fn` and a list of transformer functions and returns a\n * new curried function. When the new function is invoked, it calls the\n * function `fn` with parameters consisting of the result of calling each\n * supplied handler on successive arguments to the new function.\n *\n * If more arguments are passed to the returned function than transformer\n * functions, those arguments are passed directly to `fn` as additional\n * parameters. If you expect additional arguments that don't need to be\n * transformed, although you can ignore them, it's best to pass an identity\n * function so that the new function reports the correct arity.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((x1, x2, ...) -> z) -> [(a -> x1), (b -> x2), ...] -> (a -> b -> ... -> z)\n * @param {Function} fn The function to wrap.\n * @param {Array} transformers A list of transformer functions\n * @return {Function} The wrapped function.\n * @see R.converge\n * @example\n *\n * R.useWith(Math.pow, [R.identity, R.identity])(3, 4); //=> 81\n * R.useWith(Math.pow, [R.identity, R.identity])(3)(4); //=> 81\n * R.useWith(Math.pow, [R.dec, R.inc])(3, 4); //=> 32\n * R.useWith(Math.pow, [R.dec, R.inc])(3)(4); //=> 32\n * @symb R.useWith(f, [g, h])(a, b) = f(g(a), h(b))\n */\n\nvar useWith =\n/*#__PURE__*/\n_curry2(function useWith(fn, transformers) {\n return curryN(transformers.length, function () {\n var args = [];\n var idx = 0;\n\n while (idx < transformers.length) {\n args.push(transformers[idx].call(this, arguments[idx]));\n idx += 1;\n }\n\n return fn.apply(this, args.concat(Array.prototype.slice.call(arguments, transformers.length)));\n });\n});\n\nexport default useWith;","import _map from \"./internal/_map.js\";\nimport identity from \"./identity.js\";\nimport pickAll from \"./pickAll.js\";\nimport useWith from \"./useWith.js\";\n/**\n * Reasonable analog to SQL `select` statement.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @category Relation\n * @sig [k] -> [{k: v}] -> [{k: v}]\n * @param {Array} props The property names to project\n * @param {Array} objs The objects to query\n * @return {Array} An array of objects with just the `props` properties.\n * @example\n *\n * const abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n * const fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n * const kids = [abby, fred];\n * R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n */\n\nvar project =\n/*#__PURE__*/\nuseWith(_map, [pickAll, identity]); // passing `identity` gives correct arity\n\nexport default project;","import _curry3 from \"./internal/_curry3.js\";\nimport equals from \"./equals.js\";\n/**\n * Returns `true` if the specified object property is equal, in\n * [`R.equals`](#equals) terms, to the given value; `false` otherwise.\n * You can test multiple properties with [`R.whereEq`](#whereEq).\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig String -> a -> Object -> Boolean\n * @param {String} name\n * @param {*} val\n * @param {*} obj\n * @return {Boolean}\n * @see R.whereEq, R.propSatisfies, R.equals\n * @example\n *\n * const abby = {name: 'Abby', age: 7, hair: 'blond'};\n * const fred = {name: 'Fred', age: 12, hair: 'brown'};\n * const rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n * const alois = {name: 'Alois', age: 15, disposition: 'surly'};\n * const kids = [abby, fred, rusty, alois];\n * const hasBrownHair = R.propEq('hair', 'brown');\n * R.filter(hasBrownHair, kids); //=> [fred, rusty]\n */\n\nvar propEq =\n/*#__PURE__*/\n_curry3(function propEq(name, val, obj) {\n return equals(val, obj[name]);\n});\n\nexport default propEq;","import _curry3 from \"./internal/_curry3.js\";\nimport is from \"./is.js\";\n/**\n * Returns `true` if the specified object property is of the given type;\n * `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Type\n * @sig Type -> String -> Object -> Boolean\n * @param {Function} type\n * @param {String} name\n * @param {*} obj\n * @return {Boolean}\n * @see R.is, R.propSatisfies\n * @example\n *\n * R.propIs(Number, 'x', {x: 1, y: 2}); //=> true\n * R.propIs(Number, 'x', {x: 'foo'}); //=> false\n * R.propIs(Number, 'x', {}); //=> false\n */\n\nvar propIs =\n/*#__PURE__*/\n_curry3(function propIs(type, name, obj) {\n return is(type, obj[name]);\n});\n\nexport default propIs;","import _curry3 from \"./internal/_curry3.js\";\nimport pathOr from \"./pathOr.js\";\n/**\n * If the given, non-null object has an own property with the specified name,\n * returns the value of that property. Otherwise returns the provided default\n * value.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Object\n * @sig a -> String -> Object -> a\n * @param {*} val The default value.\n * @param {String} p The name of the property to return.\n * @param {Object} obj The object to query.\n * @return {*} The value of given property of the supplied object or the default value.\n * @example\n *\n * const alice = {\n * name: 'ALICE',\n * age: 101\n * };\n * const favorite = R.prop('favoriteLibrary');\n * const favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n *\n * favorite(alice); //=> undefined\n * favoriteWithDefault(alice); //=> 'Ramda'\n */\n\nvar propOr =\n/*#__PURE__*/\n_curry3(function propOr(val, p, obj) {\n return pathOr(val, [p], obj);\n});\n\nexport default propOr;","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;","import _curry2 from \"./internal/_curry2.js\";\nimport path from \"./path.js\";\n/**\n * Acts as multiple `prop`: array of keys in, array of values out. Preserves\n * order.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [k] -> {k: v} -> [v]\n * @param {Array} ps The property names to fetch\n * @param {Object} obj The object to query\n * @return {Array} The corresponding values or partially applied function.\n * @example\n *\n * R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n * R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n *\n * const fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n * fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n */\n\nvar props =\n/*#__PURE__*/\n_curry2(function props(ps, obj) {\n return ps.map(function (p) {\n return path([p], obj);\n });\n});\n\nexport default props;","import _curry2 from \"./internal/_curry2.js\";\nimport _isNumber from \"./internal/_isNumber.js\";\n/**\n * Returns a list of numbers from `from` (inclusive) to `to` (exclusive).\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> Number -> [Number]\n * @param {Number} from The first number in the list.\n * @param {Number} to One more than the last number in the list.\n * @return {Array} The list of numbers in the set `[a, b)`.\n * @example\n *\n * R.range(1, 5); //=> [1, 2, 3, 4]\n * R.range(50, 53); //=> [50, 51, 52]\n */\n\nvar range =\n/*#__PURE__*/\n_curry2(function range(from, to) {\n if (!(_isNumber(from) && _isNumber(to))) {\n throw new TypeError('Both arguments to range must be numbers');\n }\n\n var result = [];\n var n = from;\n\n while (n < to) {\n result.push(n);\n n += 1;\n }\n\n return result;\n});\n\nexport default range;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Returns a single item by iterating through the list, successively calling\n * the iterator function and passing it an accumulator value and the current\n * value from the array, and then passing the result to the next call.\n *\n * Similar to [`reduce`](#reduce), except moves through the input list from the\n * right to the left.\n *\n * The iterator function receives two values: *(value, acc)*, while the arguments'\n * order of `reduce`'s iterator function is *(acc, value)*.\n *\n * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.reduceRight` method. For more details\n * on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, b) -> b) -> b -> [a] -> b\n * @param {Function} fn The iterator function. Receives two values, the current element from the array\n * and the accumulator.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduce, R.addIndex\n * @example\n *\n * R.reduceRight(R.subtract, 0, [1, 2, 3, 4]) // => (1 - (2 - (3 - (4 - 0)))) = -2\n * // - -2\n * // / \\ / \\\n * // 1 - 1 3\n * // / \\ / \\\n * // 2 - ==> 2 -1\n * // / \\ / \\\n * // 3 - 3 4\n * // / \\ / \\\n * // 4 0 4 0\n *\n * @symb R.reduceRight(f, a, [b, c, d]) = f(b, f(c, f(d, a)))\n */\n\nvar reduceRight =\n/*#__PURE__*/\n_curry3(function reduceRight(fn, acc, list) {\n var idx = list.length - 1;\n\n while (idx >= 0) {\n acc = fn(list[idx], acc);\n idx -= 1;\n }\n\n return acc;\n});\n\nexport default reduceRight;","import _curryN from \"./internal/_curryN.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport _reduced from \"./internal/_reduced.js\";\n/**\n * Like [`reduce`](#reduce), `reduceWhile` returns a single item by iterating\n * through the list, successively calling the iterator function. `reduceWhile`\n * also takes a predicate that is evaluated before each step. If the predicate\n * returns `false`, it \"short-circuits\" the iteration and returns the current\n * value of the accumulator.\n *\n * @func\n * @memberOf R\n * @since v0.22.0\n * @category List\n * @sig ((a, b) -> Boolean) -> ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} pred The predicate. It is passed the accumulator and the\n * current element.\n * @param {Function} fn The iterator function. Receives two values, the\n * accumulator and the current element.\n * @param {*} a The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduce, R.reduced\n * @example\n *\n * const isOdd = (acc, x) => x % 2 === 1;\n * const xs = [1, 3, 5, 60, 777, 800];\n * R.reduceWhile(isOdd, R.add, 0, xs); //=> 9\n *\n * const ys = [2, 4, 6]\n * R.reduceWhile(isOdd, R.add, 111, ys); //=> 111\n */\n\nvar reduceWhile =\n/*#__PURE__*/\n_curryN(4, [], function _reduceWhile(pred, fn, a, list) {\n return _reduce(function (acc, x) {\n return pred(acc, x) ? fn(acc, x) : _reduced(acc);\n }, a, list);\n});\n\nexport default reduceWhile;","import _curry1 from \"./internal/_curry1.js\";\nimport _reduced from \"./internal/_reduced.js\";\n/**\n * Returns a value wrapped to indicate that it is the final value of the reduce\n * and transduce functions. The returned value should be considered a black\n * box: the internal structure is not guaranteed to be stable.\n *\n * Note: this optimization is only available to the below functions:\n * - [`reduce`](#reduce)\n * - [`reduceWhile`](#reduceWhile)\n * - [`transduce`](#transduce)\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category List\n * @sig a -> *\n * @param {*} x The final value of the reduce.\n * @return {*} The wrapped value.\n * @see R.reduce, R.reduceWhile, R.transduce\n * @example\n *\n * R.reduce(\n * (acc, item) => item > 3 ? R.reduced(acc) : acc.concat(item),\n * [],\n * [1, 2, 3, 4, 5]) // [1, 2, 3]\n */\n\nvar reduced =\n/*#__PURE__*/\n_curry1(_reduced);\n\nexport default reduced;","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 _curry2 from \"./internal/_curry2.js\";\nimport always from \"./always.js\";\nimport times from \"./times.js\";\n/**\n * Returns a fixed list of size `n` containing a specified identical value.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig a -> n -> [a]\n * @param {*} value The value to repeat.\n * @param {Number} n The desired size of the output list.\n * @return {Array} A new array containing `n` `value`s.\n * @see R.times\n * @example\n *\n * R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n *\n * const obj = {};\n * const repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n * repeatedObjs[0] === repeatedObjs[1]; //=> true\n * @symb R.repeat(a, 0) = []\n * @symb R.repeat(a, 1) = [a]\n * @symb R.repeat(a, 2) = [a, a]\n */\n\nvar repeat =\n/*#__PURE__*/\n_curry2(function repeat(value, n) {\n return times(always(value), n);\n});\n\nexport default repeat;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Replace a substring or regex match in a string with a replacement.\n *\n * The first two parameters correspond to the parameters of the\n * `String.prototype.replace()` function, so the second parameter can also be a\n * function.\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category String\n * @sig RegExp|String -> String -> String -> String\n * @param {RegExp|String} pattern A regular expression or a substring to match.\n * @param {String} replacement The string to replace the matches with.\n * @param {String} str The String to do the search and replacement in.\n * @return {String} The result.\n * @example\n *\n * R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n * R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n *\n * // Use the \"g\" (global) flag to replace all occurrences:\n * R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n */\n\nvar replace =\n/*#__PURE__*/\n_curry3(function replace(regex, replacement, str) {\n return str.replace(regex, replacement);\n});\n\nexport default replace;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Scan is similar to [`reduce`](#reduce), but returns a list of successively\n * reduced values from the left\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig ((a, b) -> a) -> a -> [b] -> [a]\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n * current element from the array\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {Array} A list of all intermediately reduced values.\n * @see R.reduce, R.mapAccum\n * @example\n *\n * const numbers = [1, 2, 3, 4];\n * const factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n * @symb R.scan(f, a, [b, c]) = [a, f(a, b), f(f(a, b), c)]\n */\n\nvar scan =\n/*#__PURE__*/\n_curry3(function scan(fn, acc, list) {\n var idx = 0;\n var len = list.length;\n var result = [acc];\n\n while (idx < len) {\n acc = fn(acc, list[idx]);\n result[idx + 1] = acc;\n idx += 1;\n }\n\n return result;\n});\n\nexport default scan;","import _curry2 from \"./internal/_curry2.js\";\nimport ap from \"./ap.js\";\nimport map from \"./map.js\";\nimport prepend from \"./prepend.js\";\nimport reduceRight from \"./reduceRight.js\";\n/**\n * Transforms a [Traversable](https://github.com/fantasyland/fantasy-land#traversable)\n * of [Applicative](https://github.com/fantasyland/fantasy-land#applicative) into an\n * Applicative of Traversable.\n *\n * Dispatches to the `sequence` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig (Applicative f, Traversable t) => (a -> f a) -> t (f a) -> f (t a)\n * @param {Function} of\n * @param {*} traversable\n * @return {*}\n * @see R.traverse\n * @example\n *\n * R.sequence(Maybe.of, [Just(1), Just(2), Just(3)]); //=> Just([1, 2, 3])\n * R.sequence(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n *\n * R.sequence(R.of, Just([1, 2, 3])); //=> [Just(1), Just(2), Just(3)]\n * R.sequence(R.of, Nothing()); //=> [Nothing()]\n */\n\nvar sequence =\n/*#__PURE__*/\n_curry2(function sequence(of, traversable) {\n return typeof traversable.sequence === 'function' ? traversable.sequence(of) : reduceRight(function (x, acc) {\n return ap(map(prepend, x), acc);\n }, of([]), traversable);\n});\n\nexport default sequence;","import _curry3 from \"./internal/_curry3.js\";\nimport always from \"./always.js\";\nimport over from \"./over.js\";\n/**\n * Returns the result of \"setting\" the portion of the given data structure\n * focused by the given lens to the given value.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Lens s a -> a -> s -> s\n * @param {Lens} lens\n * @param {*} v\n * @param {*} x\n * @return {*}\n * @see R.prop, R.lensIndex, R.lensProp\n * @example\n *\n * const xLens = R.lensProp('x');\n *\n * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}\n * R.set(xLens, 8, {x: 1, y: 2}); //=> {x: 8, y: 2}\n */\n\nvar set =\n/*#__PURE__*/\n_curry3(function set(lens, v, x) {\n return over(lens, always(v), x);\n});\n\nexport default set;","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 _curry2 from \"./internal/_curry2.js\";\n/**\n * Sorts the list according to the supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord b => (a -> b) -> [a] -> [a]\n * @param {Function} fn\n * @param {Array} list The list to sort.\n * @return {Array} A new list sorted by the keys generated by `fn`.\n * @example\n *\n * const sortByFirstItem = R.sortBy(R.prop(0));\n * const pairs = [[-1, 1], [-2, 2], [-3, 3]];\n * sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n *\n * const sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n * const alice = {\n * name: 'ALICE',\n * age: 101\n * };\n * const bob = {\n * name: 'Bob',\n * age: -10\n * };\n * const clara = {\n * name: 'clara',\n * age: 314.159\n * };\n * const people = [clara, bob, alice];\n * sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n */\n\nvar sortBy =\n/*#__PURE__*/\n_curry2(function sortBy(fn, list) {\n return Array.prototype.slice.call(list, 0).sort(function (a, b) {\n var aa = fn(a);\n var bb = fn(b);\n return aa < bb ? -1 : aa > bb ? 1 : 0;\n });\n});\n\nexport default sortBy;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Sorts a list according to a list of comparators.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Relation\n * @sig [(a, a) -> Number] -> [a] -> [a]\n * @param {Array} functions A list of comparator functions.\n * @param {Array} list The list to sort.\n * @return {Array} A new list sorted according to the comarator functions.\n * @example\n *\n * const alice = {\n * name: 'alice',\n * age: 40\n * };\n * const bob = {\n * name: 'bob',\n * age: 30\n * };\n * const clara = {\n * name: 'clara',\n * age: 40\n * };\n * const people = [clara, bob, alice];\n * const ageNameSort = R.sortWith([\n * R.descend(R.prop('age')),\n * R.ascend(R.prop('name'))\n * ]);\n * ageNameSort(people); //=> [alice, clara, bob]\n */\n\nvar sortWith =\n/*#__PURE__*/\n_curry2(function sortWith(fns, list) {\n return Array.prototype.slice.call(list, 0).sort(function (a, b) {\n var result = 0;\n var i = 0;\n\n while (result === 0 && i < fns.length) {\n result = fns[i](a, b);\n i += 1;\n }\n\n return result;\n });\n});\n\nexport default sortWith;","import invoker from \"./invoker.js\";\n/**\n * Splits a string into an array of strings based on the given\n * separator.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category String\n * @sig (String | RegExp) -> String -> [String]\n * @param {String|RegExp} sep The pattern.\n * @param {String} str The string to separate into an array.\n * @return {Array} The array of strings from `str` separated by `sep`.\n * @see R.join\n * @example\n *\n * const pathComponents = R.split('/');\n * R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n *\n * R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n */\n\nvar split =\n/*#__PURE__*/\ninvoker(1, 'split');\nexport default split;","import _curry2 from \"./internal/_curry2.js\";\nimport length from \"./length.js\";\nimport slice from \"./slice.js\";\n/**\n * Splits a given list or string at a given index.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig Number -> [a] -> [[a], [a]]\n * @sig Number -> String -> [String, String]\n * @param {Number} index The index where the array/string is split.\n * @param {Array|String} array The array/string to be split.\n * @return {Array}\n * @example\n *\n * R.splitAt(1, [1, 2, 3]); //=> [[1], [2, 3]]\n * R.splitAt(5, 'hello world'); //=> ['hello', ' world']\n * R.splitAt(-1, 'foobar'); //=> ['fooba', 'r']\n */\n\nvar splitAt =\n/*#__PURE__*/\n_curry2(function splitAt(index, array) {\n return [slice(0, index, array), slice(index, length(array), array)];\n});\n\nexport default splitAt;","import _curry2 from \"./internal/_curry2.js\";\nimport slice from \"./slice.js\";\n/**\n * Splits a collection into slices of the specified length.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig Number -> [a] -> [[a]]\n * @sig Number -> String -> [String]\n * @param {Number} n\n * @param {Array} list\n * @return {Array}\n * @example\n *\n * R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n * R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n */\n\nvar splitEvery =\n/*#__PURE__*/\n_curry2(function splitEvery(n, list) {\n if (n <= 0) {\n throw new Error('First argument to splitEvery must be a positive integer');\n }\n\n var result = [];\n var idx = 0;\n\n while (idx < list.length) {\n result.push(slice(idx, idx += n, list));\n }\n\n return result;\n});\n\nexport default splitEvery;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Takes a list and a predicate and returns a pair of lists with the following properties:\n *\n * - the result of concatenating the two output lists is equivalent to the input list;\n * - none of the elements of the first output list satisfies the predicate; and\n * - if the second output list is non-empty, its first element satisfies the predicate.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [[a], [a]]\n * @param {Function} pred The predicate that determines where the array is split.\n * @param {Array} list The array to be split.\n * @return {Array}\n * @example\n *\n * R.splitWhen(R.equals(2), [1, 2, 3, 1, 2, 3]); //=> [[1], [2, 3, 1, 2, 3]]\n */\n\nvar splitWhen =\n/*#__PURE__*/\n_curry2(function splitWhen(pred, list) {\n var idx = 0;\n var len = list.length;\n var prefix = [];\n\n while (idx < len && !pred(list[idx])) {\n prefix.push(list[idx]);\n idx += 1;\n }\n\n return [prefix, Array.prototype.slice.call(list, idx)];\n});\n\nexport default splitWhen;","import _curry2 from \"./internal/_curry2.js\";\nimport equals from \"./equals.js\";\nimport take from \"./take.js\";\n/**\n * Checks if a list starts with the provided sublist.\n *\n * Similarly, checks if a string starts with the provided substring.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category List\n * @sig [a] -> [a] -> Boolean\n * @sig String -> String -> Boolean\n * @param {*} prefix\n * @param {*} list\n * @return {Boolean}\n * @see R.endsWith\n * @example\n *\n * R.startsWith('a', 'abc') //=> true\n * R.startsWith('b', 'abc') //=> false\n * R.startsWith(['a'], ['a', 'b', 'c']) //=> true\n * R.startsWith(['b'], ['a', 'b', 'c']) //=> false\n */\n\nvar startsWith =\n/*#__PURE__*/\n_curry2(function (prefix, list) {\n return equals(take(prefix.length, list), prefix);\n});\n\nexport default startsWith;","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\";\nimport concat from \"./concat.js\";\nimport difference from \"./difference.js\";\n/**\n * Finds the set (i.e. no duplicates) of all elements contained in the first or\n * second list, but not both.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` or `list2`, but not both.\n * @see R.symmetricDifferenceWith, R.difference, R.differenceWith\n * @example\n *\n * R.symmetricDifference([1,2,3,4], [7,6,5,4,3]); //=> [1,2,7,6,5]\n * R.symmetricDifference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5,1,2]\n */\n\nvar symmetricDifference =\n/*#__PURE__*/\n_curry2(function symmetricDifference(list1, list2) {\n return concat(difference(list1, list2), difference(list2, list1));\n});\n\nexport default symmetricDifference;","import _curry3 from \"./internal/_curry3.js\";\nimport concat from \"./concat.js\";\nimport differenceWith from \"./differenceWith.js\";\n/**\n * Finds the set (i.e. no duplicates) of all elements contained in the first or\n * second list, but not both. Duplication is determined according to the value\n * returned by applying the supplied predicate to two list elements.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Relation\n * @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` or `list2`, but not both.\n * @see R.symmetricDifference, R.difference, R.differenceWith\n * @example\n *\n * const eqA = R.eqBy(R.prop('a'));\n * const l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];\n * const l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];\n * R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]\n */\n\nvar symmetricDifferenceWith =\n/*#__PURE__*/\n_curry3(function symmetricDifferenceWith(pred, list1, list2) {\n return concat(differenceWith(pred, list1, list2), differenceWith(pred, list2, list1));\n});\n\nexport default symmetricDifferenceWith;","import _curry2 from \"./internal/_curry2.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns a new list containing the last `n` elements of a given list, passing\n * each value to the supplied predicate function, and terminating when the\n * predicate function returns `false`. Excludes the element that caused the\n * predicate function to fail. The predicate function is passed one argument:\n * *(value)*.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} fn The function called per iteration.\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array.\n * @see R.dropLastWhile, R.addIndex\n * @example\n *\n * const isNotOne = x => x !== 1;\n *\n * R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n *\n * R.takeLastWhile(x => x !== 'R' , 'Ramda'); //=> 'amda'\n */\n\nvar takeLastWhile =\n/*#__PURE__*/\n_curry2(function takeLastWhile(fn, xs) {\n var idx = xs.length - 1;\n\n while (idx >= 0 && fn(xs[idx])) {\n idx -= 1;\n }\n\n return slice(idx + 1, Infinity, xs);\n});\n\nexport default takeLastWhile;","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XTakeWhile =\n/*#__PURE__*/\nfunction () {\n function XTakeWhile(f, xf) {\n this.xf = xf;\n this.f = f;\n }\n\n XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n\n XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n };\n\n return XTakeWhile;\n}();\n\nvar _xtakeWhile =\n/*#__PURE__*/\n_curry2(function _xtakeWhile(f, xf) {\n return new XTakeWhile(f, xf);\n});\n\nexport default _xtakeWhile;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xtakeWhile from \"./internal/_xtakeWhile.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns a new list containing the first `n` elements of a given list,\n * passing each value to the supplied predicate function, and terminating when\n * the predicate function returns `false`. Excludes the element that caused the\n * predicate function to fail. The predicate function is passed one argument:\n * *(value)*.\n *\n * Dispatches to the `takeWhile` 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] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} fn The function called per iteration.\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array.\n * @see R.dropWhile, R.transduce, R.addIndex\n * @example\n *\n * const isNotFour = x => x !== 4;\n *\n * R.takeWhile(isNotFour, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3]\n *\n * R.takeWhile(x => x !== 'd' , 'Ramda'); //=> 'Ram'\n */\n\nvar takeWhile =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['takeWhile'], _xtakeWhile, function takeWhile(fn, xs) {\n var idx = 0;\n var len = xs.length;\n\n while (idx < len && fn(xs[idx])) {\n idx += 1;\n }\n\n return slice(0, idx, xs);\n}));\n\nexport default takeWhile;","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XTap =\n/*#__PURE__*/\nfunction () {\n function XTap(f, xf) {\n this.xf = xf;\n this.f = f;\n }\n\n XTap.prototype['@@transducer/init'] = _xfBase.init;\n XTap.prototype['@@transducer/result'] = _xfBase.result;\n\n XTap.prototype['@@transducer/step'] = function (result, input) {\n this.f(input);\n return this.xf['@@transducer/step'](result, input);\n };\n\n return XTap;\n}();\n\nvar _xtap =\n/*#__PURE__*/\n_curry2(function _xtap(f, xf) {\n return new XTap(f, xf);\n});\n\nexport default _xtap;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xtap from \"./internal/_xtap.js\";\n/**\n * Runs the given function with the supplied object, then returns the object.\n *\n * Acts as a transducer if a transformer is given as second parameter.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (a -> *) -> a -> a\n * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n * @param {*} x\n * @return {*} `x`.\n * @example\n *\n * const sayX = x => console.log('x is ' + x);\n * R.tap(sayX, 100); //=> 100\n * // logs 'x is 100'\n * @symb R.tap(f, a) = a\n */\n\nvar tap =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xtap, function tap(fn, x) {\n fn(x);\n return x;\n}));\n\nexport default tap;","import _cloneRegExp from \"./internal/_cloneRegExp.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _isRegExp from \"./internal/_isRegExp.js\";\nimport toString from \"./toString.js\";\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @see R.match\n * @example\n *\n * R.test(/^x/, 'xyz'); //=> true\n * R.test(/^y/, 'xyz'); //=> false\n */\n\nvar test =\n/*#__PURE__*/\n_curry2(function test(pattern, str) {\n if (!_isRegExp(pattern)) {\n throw new TypeError('‘test’ requires a value of type RegExp as its first argument; received ' + toString(pattern));\n }\n\n return _cloneRegExp(pattern).test(str);\n});\n\nexport default test;","export default function _isRegExp(x) {\n return Object.prototype.toString.call(x) === '[object RegExp]';\n}","import _curry2 from \"./internal/_curry2.js\";\nimport _assertPromise from \"./internal/_assertPromise.js\";\n/**\n * Returns the result of applying the onSuccess function to the value inside\n * a successfully resolved promise. This is useful for working with promises\n * inside function compositions.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category Function\n * @sig (a -> b) -> (Promise e a) -> (Promise e b)\n * @sig (a -> (Promise e b)) -> (Promise e a) -> (Promise e b)\n * @param {Function} onSuccess The function to apply. Can return a value or a promise of a value.\n * @param {Promise} p\n * @return {Promise} The result of calling `p.then(onSuccess)`\n * @see R.otherwise\n * @example\n *\n * var makeQuery = (email) => ({ query: { email }});\n *\n * //getMemberName :: String -> Promise ({firstName, lastName})\n * var getMemberName = R.pipe(\n * makeQuery,\n * fetchMember,\n * R.andThen(R.pick(['firstName', 'lastName']))\n * );\n */\n\nvar andThen =\n/*#__PURE__*/\n_curry2(function andThen(f, p) {\n _assertPromise('andThen', p);\n\n return p.then(f);\n});\n\nexport default andThen;","import invoker from \"./invoker.js\";\n/**\n * The lower case version of a string.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category String\n * @sig String -> String\n * @param {String} str The string to lower case.\n * @return {String} The lower case version of `str`.\n * @see R.toUpper\n * @example\n *\n * R.toLower('XYZ'); //=> 'xyz'\n */\n\nvar toLower =\n/*#__PURE__*/\ninvoker(0, 'toLowerCase');\nexport default toLower;","import _curry1 from \"./internal/_curry1.js\";\nimport _has from \"./internal/_has.js\";\n/**\n * Converts an object into an array of key, value arrays. Only the object's\n * own properties are used.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.4.0\n * @category Object\n * @sig {String: *} -> [[String,*]]\n * @param {Object} obj The object to extract from\n * @return {Array} An array of key, value arrays from the object's own properties.\n * @see R.fromPairs\n * @example\n *\n * R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n */\n\nvar toPairs =\n/*#__PURE__*/\n_curry1(function toPairs(obj) {\n var pairs = [];\n\n for (var prop in obj) {\n if (_has(prop, obj)) {\n pairs[pairs.length] = [prop, obj[prop]];\n }\n }\n\n return pairs;\n});\n\nexport default toPairs;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Converts an object into an array of key, value arrays. The object's own\n * properties and prototype properties are used. Note that the order of the\n * output array is not guaranteed to be consistent across different JS\n * platforms.\n *\n * @func\n * @memberOf R\n * @since v0.4.0\n * @category Object\n * @sig {String: *} -> [[String,*]]\n * @param {Object} obj The object to extract from\n * @return {Array} An array of key, value arrays from the object's own\n * and prototype properties.\n * @example\n *\n * const F = function() { this.x = 'X'; };\n * F.prototype.y = 'Y';\n * const f = new F();\n * R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n */\n\nvar toPairsIn =\n/*#__PURE__*/\n_curry1(function toPairsIn(obj) {\n var pairs = [];\n\n for (var prop in obj) {\n pairs[pairs.length] = [prop, obj[prop]];\n }\n\n return pairs;\n});\n\nexport default toPairsIn;","import invoker from \"./invoker.js\";\n/**\n * The upper case version of a string.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category String\n * @sig String -> String\n * @param {String} str The string to upper case.\n * @return {String} The upper case version of `str`.\n * @see R.toLower\n * @example\n *\n * R.toUpper('abc'); //=> 'ABC'\n */\n\nvar toUpper =\n/*#__PURE__*/\ninvoker(0, 'toUpperCase');\nexport default toUpper;","import _reduce from \"./internal/_reduce.js\";\nimport _xwrap from \"./internal/_xwrap.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Initializes a transducer using supplied iterator function. Returns a single\n * item by iterating through the list, successively calling the transformed\n * iterator function and passing it an accumulator value and the current value\n * from the array, and then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*. It will be\n * wrapped as a transformer to initialize the transducer. A transformer can be\n * passed directly in place of an iterator function. In both cases, iteration\n * may be stopped early with the [`R.reduced`](#reduced) function.\n *\n * A transducer is a function that accepts a transformer and returns a\n * transformer and can be composed directly.\n *\n * A transformer is an an object that provides a 2-arity reducing iterator\n * function, step, 0-arity initial value function, init, and 1-arity result\n * extraction function, result. The step function is used as the iterator\n * function in reduce. The result function is used to convert the final\n * accumulator into the return type and in most cases is\n * [`R.identity`](#identity). The init function can be used to provide an\n * initial accumulator, but is ignored by transduce.\n *\n * The iteration is performed with [`R.reduce`](#reduce) after initializing the transducer.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category List\n * @sig (c -> c) -> ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n * current element from the array. Wrapped as transformer, if necessary, and used to\n * initialize the transducer\n * @param {*} acc The initial accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduce, R.reduced, R.into\n * @example\n *\n * const numbers = [1, 2, 3, 4];\n * const transducer = R.compose(R.map(R.add(1)), R.take(2));\n * R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n *\n * const isOdd = (x) => x % 2 === 1;\n * const firstOddTransducer = R.compose(R.filter(isOdd), R.take(1));\n * R.transduce(firstOddTransducer, R.flip(R.append), [], R.range(0, 100)); //=> [1]\n */\n\nvar transduce =\n/*#__PURE__*/\ncurryN(4, function transduce(xf, fn, acc, list) {\n return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n});\nexport default transduce;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Transposes the rows and columns of a 2D list.\n * When passed a list of `n` lists of length `x`,\n * returns a list of `x` lists of length `n`.\n *\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig [[a]] -> [[a]]\n * @param {Array} list A 2D list\n * @return {Array} A 2D list\n * @example\n *\n * R.transpose([[1, 'a'], [2, 'b'], [3, 'c']]) //=> [[1, 2, 3], ['a', 'b', 'c']]\n * R.transpose([[1, 2, 3], ['a', 'b', 'c']]) //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n *\n * // If some of the rows are shorter than the following rows, their elements are skipped:\n * R.transpose([[10, 11], [20], [], [30, 31, 32]]) //=> [[10, 20, 30], [11, 31], [32]]\n * @symb R.transpose([[a], [b], [c]]) = [a, b, c]\n * @symb R.transpose([[a, b], [c, d]]) = [[a, c], [b, d]]\n * @symb R.transpose([[a, b], [c]]) = [[a, c], [b]]\n */\n\nvar transpose =\n/*#__PURE__*/\n_curry1(function transpose(outerlist) {\n var i = 0;\n var result = [];\n\n while (i < outerlist.length) {\n var innerlist = outerlist[i];\n var j = 0;\n\n while (j < innerlist.length) {\n if (typeof result[j] === 'undefined') {\n result[j] = [];\n }\n\n result[j].push(innerlist[j]);\n j += 1;\n }\n\n i += 1;\n }\n\n return result;\n});\n\nexport default transpose;","import _curry3 from \"./internal/_curry3.js\";\nimport map from \"./map.js\";\nimport sequence from \"./sequence.js\";\n/**\n * Maps an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning\n * function over a [Traversable](https://github.com/fantasyland/fantasy-land#traversable),\n * then uses [`sequence`](#sequence) to transform the resulting Traversable of Applicative\n * into an Applicative of Traversable.\n *\n * Dispatches to the `traverse` method of the third argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig (Applicative f, Traversable t) => (a -> f a) -> (a -> f b) -> t a -> f (t b)\n * @param {Function} of\n * @param {Function} f\n * @param {*} traversable\n * @return {*}\n * @see R.sequence\n * @example\n *\n * // Returns `Maybe.Nothing` if the given divisor is `0`\n * const safeDiv = n => d => d === 0 ? Maybe.Nothing() : Maybe.Just(n / d)\n *\n * R.traverse(Maybe.of, safeDiv(10), [2, 4, 5]); //=> Maybe.Just([5, 2.5, 2])\n * R.traverse(Maybe.of, safeDiv(10), [2, 0, 5]); //=> Maybe.Nothing\n */\n\nvar traverse =\n/*#__PURE__*/\n_curry3(function traverse(of, f, traversable) {\n return typeof traversable['fantasy-land/traverse'] === 'function' ? traversable['fantasy-land/traverse'](f, of) : sequence(of, map(f, traversable));\n});\n\nexport default traverse;","import _curry1 from \"./internal/_curry1.js\";\nvar ws = '\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\nvar zeroWidth = '\\u200b';\nvar hasProtoTrim = typeof String.prototype.trim === 'function';\n/**\n * Removes (strips) whitespace from both ends of the string.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category String\n * @sig String -> String\n * @param {String} str The string to trim.\n * @return {String} Trimmed version of `str`.\n * @example\n *\n * R.trim(' xyz '); //=> 'xyz'\n * R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n */\n\nvar trim = !hasProtoTrim ||\n/*#__PURE__*/\nws.trim() || !\n/*#__PURE__*/\nzeroWidth.trim() ?\n/*#__PURE__*/\n_curry1(function trim(str) {\n var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n return str.replace(beginRx, '').replace(endRx, '');\n}) :\n/*#__PURE__*/\n_curry1(function trim(str) {\n return str.trim();\n});\nexport default trim;","import _arity from \"./internal/_arity.js\";\nimport _concat from \"./internal/_concat.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * `tryCatch` takes two functions, a `tryer` and a `catcher`. The returned\n * function evaluates the `tryer`; if it does not throw, it simply returns the\n * result. If the `tryer` *does* throw, the returned function evaluates the\n * `catcher` function and returns its result. Note that for effective\n * composition with this function, both the `tryer` and `catcher` functions\n * must return the same type of results.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Function\n * @sig (...x -> a) -> ((e, ...x) -> a) -> (...x -> a)\n * @param {Function} tryer The function that may throw.\n * @param {Function} catcher The function that will be evaluated if `tryer` throws.\n * @return {Function} A new function that will catch exceptions and send then to the catcher.\n * @example\n *\n * R.tryCatch(R.prop('x'), R.F)({x: true}); //=> true\n * R.tryCatch(() => { throw 'foo'}, R.always('catched'))('bar') // => 'catched'\n * R.tryCatch(R.times(R.identity), R.always([]))('s') // => []\n * R.tryCatch(() => { throw 'this is not a valid value'}, (err, value)=>({error : err, value }))('bar') // => {'error': 'this is not a valid value', 'value': 'bar'}\n */\n\nvar tryCatch =\n/*#__PURE__*/\n_curry2(function _tryCatch(tryer, catcher) {\n return _arity(tryer.length, function () {\n try {\n return tryer.apply(this, arguments);\n } catch (e) {\n return catcher.apply(this, _concat([e], arguments));\n }\n });\n});\n\nexport default tryCatch;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Takes a function `fn`, which takes a single array argument, and returns a\n * function which:\n *\n * - takes any number of positional arguments;\n * - passes these arguments to `fn` as an array; and\n * - returns the result.\n *\n * In other words, `R.unapply` derives a variadic function from a function which\n * takes an array. `R.unapply` is the inverse of [`R.apply`](#apply).\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Function\n * @sig ([*...] -> a) -> (*... -> a)\n * @param {Function} fn\n * @return {Function}\n * @see R.apply\n * @example\n *\n * R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n * @symb R.unapply(f)(a, b) = f([a, b])\n */\n\nvar unapply =\n/*#__PURE__*/\n_curry1(function unapply(fn) {\n return function () {\n return fn(Array.prototype.slice.call(arguments, 0));\n };\n});\n\nexport default unapply;","import _curry1 from \"./internal/_curry1.js\";\nimport nAry from \"./nAry.js\";\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts\n * exactly 1 parameter. Any extraneous parameters will not be passed to the\n * supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Function\n * @sig (* -> b) -> (a -> b)\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n * arity 1.\n * @see R.binary, R.nAry\n * @example\n *\n * const takesTwoArgs = function(a, b) {\n * return [a, b];\n * };\n * takesTwoArgs.length; //=> 2\n * takesTwoArgs(1, 2); //=> [1, 2]\n *\n * const takesOneArg = R.unary(takesTwoArgs);\n * takesOneArg.length; //=> 1\n * // Only 1 argument is passed to the wrapped function\n * takesOneArg(1, 2); //=> [1, undefined]\n * @symb R.unary(f)(a, b, c) = f(a)\n */\n\nvar unary =\n/*#__PURE__*/\n_curry1(function unary(fn) {\n return nAry(1, fn);\n});\n\nexport default unary;","import _curry2 from \"./internal/_curry2.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Returns a function of arity `n` from a (manually) curried function.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Function\n * @sig Number -> (a -> b) -> (a -> c)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to uncurry.\n * @return {Function} A new function.\n * @see R.curry\n * @example\n *\n * const addFour = a => b => c => d => a + b + c + d;\n *\n * const uncurriedAddFour = R.uncurryN(4, addFour);\n * uncurriedAddFour(1, 2, 3, 4); //=> 10\n */\n\nvar uncurryN =\n/*#__PURE__*/\n_curry2(function uncurryN(depth, fn) {\n return curryN(depth, function () {\n var currentDepth = 1;\n var value = fn;\n var idx = 0;\n var endIdx;\n\n while (currentDepth <= depth && typeof value === 'function') {\n endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n value = value.apply(this, Array.prototype.slice.call(arguments, idx, endIdx));\n currentDepth += 1;\n idx = endIdx;\n }\n\n return value;\n });\n});\n\nexport default uncurryN;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Builds a list from a seed value. Accepts an iterator function, which returns\n * either false to stop iteration or an array of length 2 containing the value\n * to add to the resulting list and the seed to be used in the next call to the\n * iterator function.\n *\n * The iterator function receives one argument: *(seed)*.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig (a -> [b]) -> * -> [b]\n * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n * either false to quit iteration or an array of length two to proceed. The element\n * at index 0 of this array will be added to the resulting array, and the element\n * at index 1 will be passed to the next call to `fn`.\n * @param {*} seed The seed value.\n * @return {Array} The final list.\n * @example\n *\n * const f = n => n > 50 ? false : [-n, n + 10];\n * R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n * @symb R.unfold(f, x) = [f(x)[0], f(f(x)[1])[0], f(f(f(x)[1])[1])[0], ...]\n */\n\nvar unfold =\n/*#__PURE__*/\n_curry2(function unfold(fn, seed) {\n var pair = fn(seed);\n var result = [];\n\n while (pair && pair.length) {\n result[result.length] = pair[0];\n pair = fn(pair[1]);\n }\n\n return result;\n});\n\nexport default unfold;","import _concat from \"./internal/_concat.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport compose from \"./compose.js\";\nimport uniq from \"./uniq.js\";\n/**\n * Combines two lists into a set (i.e. no duplicates) composed of the elements\n * of each list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} as The first list.\n * @param {Array} bs The second list.\n * @return {Array} The first and second lists concatenated, with\n * duplicates removed.\n * @example\n *\n * R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n */\n\nvar union =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\ncompose(uniq, _concat));\n\nexport default union;","import _includesWith from \"./internal/_includesWith.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a new list containing only one copy of each element in the original\n * list, based upon the value returned by applying the supplied predicate to\n * two list elements. Prefers the first item if two items compare equal based\n * on the predicate.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category List\n * @sig ((a, a) -> Boolean) -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list The array to consider.\n * @return {Array} The list of unique items.\n * @example\n *\n * const strEq = R.eqBy(String);\n * R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n * R.uniqWith(strEq)([{}, {}]); //=> [{}]\n * R.uniqWith(strEq)([1, '1', 1]); //=> [1]\n * R.uniqWith(strEq)(['1', 1, 1]); //=> ['1']\n */\n\nvar uniqWith =\n/*#__PURE__*/\n_curry2(function uniqWith(pred, list) {\n var idx = 0;\n var len = list.length;\n var result = [];\n var item;\n\n while (idx < len) {\n item = list[idx];\n\n if (!_includesWith(pred, item, result)) {\n result[result.length] = item;\n }\n\n idx += 1;\n }\n\n return result;\n});\n\nexport default uniqWith;","import _concat from \"./internal/_concat.js\";\nimport _curry3 from \"./internal/_curry3.js\";\nimport uniqWith from \"./uniqWith.js\";\n/**\n * Combines two lists into a set (i.e. no duplicates) composed of the elements\n * of each list. Duplication is determined according to the value returned by\n * applying the supplied predicate to two list elements.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig ((a, a) -> Boolean) -> [*] -> [*] -> [*]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The first and second lists concatenated, with\n * duplicates removed.\n * @see R.union\n * @example\n *\n * const l1 = [{a: 1}, {a: 2}];\n * const l2 = [{a: 1}, {a: 4}];\n * R.unionWith(R.eqBy(R.prop('a')), l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n */\n\nvar unionWith =\n/*#__PURE__*/\n_curry3(function unionWith(pred, list1, list2) {\n return uniqWith(pred, _concat(list1, list2));\n});\n\nexport default unionWith;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Tests the final argument by passing it to the given predicate function. If\n * the predicate is not satisfied, the function will return the result of\n * calling the `whenFalseFn` function with the same argument. If the predicate\n * is satisfied, the argument is returned as is.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Logic\n * @sig (a -> Boolean) -> (a -> a) -> a -> a\n * @param {Function} pred A predicate function\n * @param {Function} whenFalseFn A function to invoke when the `pred` evaluates\n * to a falsy value.\n * @param {*} x An object to test with the `pred` function and\n * pass to `whenFalseFn` if necessary.\n * @return {*} Either `x` or the result of applying `x` to `whenFalseFn`.\n * @see R.ifElse, R.when, R.cond\n * @example\n *\n * let safeInc = R.unless(R.isNil, R.inc);\n * safeInc(null); //=> null\n * safeInc(1); //=> 2\n */\n\nvar unless =\n/*#__PURE__*/\n_curry3(function unless(pred, whenFalseFn, x) {\n return pred(x) ? x : whenFalseFn(x);\n});\n\nexport default unless;","import _identity from \"./internal/_identity.js\";\nimport chain from \"./chain.js\";\n/**\n * Shorthand for `R.chain(R.identity)`, which removes one level of nesting from\n * any [Chain](https://github.com/fantasyland/fantasy-land#chain).\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig Chain c => c (c a) -> c a\n * @param {*} list\n * @return {*}\n * @see R.flatten, R.chain\n * @example\n *\n * R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n * R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n */\n\nvar unnest =\n/*#__PURE__*/\nchain(_identity);\nexport default unnest;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Takes a predicate, a transformation function, and an initial value,\n * and returns a value of the same type as the initial value.\n * It does so by applying the transformation until the predicate is satisfied,\n * at which point it returns the satisfactory value.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Logic\n * @sig (a -> Boolean) -> (a -> a) -> a -> a\n * @param {Function} pred A predicate function\n * @param {Function} fn The iterator function\n * @param {*} init Initial value\n * @return {*} Final value that satisfies predicate\n * @example\n *\n * R.until(R.gt(R.__, 100), R.multiply(2))(1) // => 128\n */\n\nvar until =\n/*#__PURE__*/\n_curry3(function until(pred, fn, init) {\n var val = init;\n\n while (!pred(val)) {\n val = fn(val);\n }\n\n return val;\n});\n\nexport default until;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Returns a list of all the properties, including prototype properties, of the\n * supplied object.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Object\n * @sig {k: v} -> [v]\n * @param {Object} obj The object to extract values from\n * @return {Array} An array of the values of the object's own and prototype properties.\n * @see R.values, R.keysIn\n * @example\n *\n * const F = function() { this.x = 'X'; };\n * F.prototype.y = 'Y';\n * const f = new F();\n * R.valuesIn(f); //=> ['X', 'Y']\n */\n\nvar valuesIn =\n/*#__PURE__*/\n_curry1(function valuesIn(obj) {\n var prop;\n var vs = [];\n\n for (prop in obj) {\n vs[vs.length] = obj[prop];\n }\n\n return vs;\n});\n\nexport default valuesIn;","import _curry2 from \"./internal/_curry2.js\"; // `Const` is a functor that effectively ignores the function given to `map`.\n\nvar Const = function (x) {\n return {\n value: x,\n 'fantasy-land/map': function () {\n return this;\n }\n };\n};\n/**\n * Returns a \"view\" of the given data structure, determined by the given lens.\n * The lens's focus determines which portion of the data structure is visible.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Lens s a -> s -> a\n * @param {Lens} lens\n * @param {*} x\n * @return {*}\n * @see R.prop, R.lensIndex, R.lensProp\n * @example\n *\n * const xLens = R.lensProp('x');\n *\n * R.view(xLens, {x: 1, y: 2}); //=> 1\n * R.view(xLens, {x: 4, y: 2}); //=> 4\n */\n\n\nvar view =\n/*#__PURE__*/\n_curry2(function view(lens, x) {\n // Using `Const` effectively ignores the setter function of the `lens`,\n // leaving the value returned by the getter function unmodified.\n return lens(Const)(x).value;\n});\n\nexport default view;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Tests the final argument by passing it to the given predicate function. If\n * the predicate is satisfied, the function will return the result of calling\n * the `whenTrueFn` function with the same argument. If the predicate is not\n * satisfied, the argument is returned as is.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Logic\n * @sig (a -> Boolean) -> (a -> a) -> a -> a\n * @param {Function} pred A predicate function\n * @param {Function} whenTrueFn A function to invoke when the `condition`\n * evaluates to a truthy value.\n * @param {*} x An object to test with the `pred` function and\n * pass to `whenTrueFn` if necessary.\n * @return {*} Either `x` or the result of applying `x` to `whenTrueFn`.\n * @see R.ifElse, R.unless, R.cond\n * @example\n *\n * // truncate :: String -> String\n * const truncate = R.when(\n * R.propSatisfies(R.gt(R.__, 10), 'length'),\n * R.pipe(R.take(10), R.append('…'), R.join(''))\n * );\n * truncate('12345'); //=> '12345'\n * truncate('0123456789ABC'); //=> '0123456789…'\n */\n\nvar when =\n/*#__PURE__*/\n_curry3(function when(pred, whenTrueFn, x) {\n return pred(x) ? whenTrueFn(x) : x;\n});\n\nexport default when;","import _curry2 from \"./internal/_curry2.js\";\nimport _has from \"./internal/_has.js\";\n/**\n * Takes a spec object and a test object; returns true if the test satisfies\n * the spec. Each of the spec's own properties must be a predicate function.\n * Each predicate is applied to the value of the corresponding property of the\n * test object. `where` returns true if all the predicates return true, false\n * otherwise.\n *\n * `where` is well suited to declaratively expressing constraints for other\n * functions such as [`filter`](#filter) and [`find`](#find).\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category Object\n * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n * @param {Object} spec\n * @param {Object} testObj\n * @return {Boolean}\n * @see R.propSatisfies, R.whereEq\n * @example\n *\n * // pred :: Object -> Boolean\n * const pred = R.where({\n * a: R.equals('foo'),\n * b: R.complement(R.equals('bar')),\n * x: R.gt(R.__, 10),\n * y: R.lt(R.__, 20)\n * });\n *\n * pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n * pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n * pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n * pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n * pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n */\n\nvar where =\n/*#__PURE__*/\n_curry2(function where(spec, testObj) {\n for (var prop in spec) {\n if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n return false;\n }\n }\n\n return true;\n});\n\nexport default where;","import _curry2 from \"./internal/_curry2.js\";\nimport equals from \"./equals.js\";\nimport map from \"./map.js\";\nimport where from \"./where.js\";\n/**\n * Takes a spec object and a test object; returns true if the test satisfies\n * the spec, false otherwise. An object satisfies the spec if, for each of the\n * spec's own properties, accessing that property of the object gives the same\n * value (in [`R.equals`](#equals) terms) as accessing that property of the\n * spec.\n *\n * `whereEq` is a specialization of [`where`](#where).\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Object\n * @sig {String: *} -> {String: *} -> Boolean\n * @param {Object} spec\n * @param {Object} testObj\n * @return {Boolean}\n * @see R.propEq, R.where\n * @example\n *\n * // pred :: Object -> Boolean\n * const pred = R.whereEq({a: 1, b: 2});\n *\n * pred({a: 1}); //=> false\n * pred({a: 1, b: 2}); //=> true\n * pred({a: 1, b: 2, c: 3}); //=> true\n * pred({a: 1, b: 1}); //=> false\n */\n\nvar whereEq =\n/*#__PURE__*/\n_curry2(function whereEq(spec, testObj) {\n return where(map(equals, spec), testObj);\n});\n\nexport default whereEq;","import _includes from \"./internal/_includes.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport flip from \"./flip.js\";\nimport reject from \"./reject.js\";\n/**\n * Returns a new list without values in the first argument.\n * [`R.equals`](#equals) is used to determine equality.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig [a] -> [a] -> [a]\n * @param {Array} list1 The values to be removed from `list2`.\n * @param {Array} list2 The array to remove values from.\n * @return {Array} The new array without values in `list1`.\n * @see R.transduce, R.difference, R.remove\n * @example\n *\n * R.without([1, 2], [1, 2, 1, 3, 4]); //=> [3, 4]\n */\n\nvar without =\n/*#__PURE__*/\n_curry2(function (xs, list) {\n return reject(flip(_includes)(xs), list);\n});\n\nexport default without;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Exclusive disjunction logical operation.\n * Returns `true` if one of the arguments is truthy and the other is falsy.\n * Otherwise, it returns `false`.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category Logic\n * @sig a -> b -> Boolean\n * @param {Any} a\n * @param {Any} b\n * @return {Boolean} true if one of the arguments is truthy and the other is falsy\n * @see R.or, R.and\n * @example\n *\n * R.xor(true, true); //=> false\n * R.xor(true, false); //=> true\n * R.xor(false, true); //=> true\n * R.xor(false, false); //=> false\n */\n\nvar xor =\n/*#__PURE__*/\n_curry2(function xor(a, b) {\n return Boolean(!a ^ !b);\n});\n\nexport default xor;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a new list out of the two supplied by creating each possible pair\n * from the lists.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [b] -> [[a,b]]\n * @param {Array} as The first list.\n * @param {Array} bs The second list.\n * @return {Array} The list made by combining each possible pair from\n * `as` and `bs` into pairs (`[a, b]`).\n * @example\n *\n * R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n * @symb R.xprod([a, b], [c, d]) = [[a, c], [a, d], [b, c], [b, d]]\n */\n\nvar xprod =\n/*#__PURE__*/\n_curry2(function xprod(a, b) {\n // = xprodWith(prepend); (takes about 3 times as long...)\n var idx = 0;\n var ilen = a.length;\n var j;\n var jlen = b.length;\n var result = [];\n\n while (idx < ilen) {\n j = 0;\n\n while (j < jlen) {\n result[result.length] = [a[idx], b[j]];\n j += 1;\n }\n\n idx += 1;\n }\n\n return result;\n});\n\nexport default xprod;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a new list out of the two supplied by pairing up equally-positioned\n * items from both lists. The returned list is truncated to the length of the\n * shorter of the two input lists.\n * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [b] -> [[a,b]]\n * @param {Array} list1 The first array to consider.\n * @param {Array} list2 The second array to consider.\n * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n * @example\n *\n * R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n * @symb R.zip([a, b, c], [d, e, f]) = [[a, d], [b, e], [c, f]]\n */\n\nvar zip =\n/*#__PURE__*/\n_curry2(function zip(a, b) {\n var rv = [];\n var idx = 0;\n var len = Math.min(a.length, b.length);\n\n while (idx < len) {\n rv[idx] = [a[idx], b[idx]];\n idx += 1;\n }\n\n return rv;\n});\n\nexport default zip;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a new object out of a list of keys and a list of values.\n * Key/value pairing is truncated to the length of the shorter of the two lists.\n * Note: `zipObj` is equivalent to `pipe(zip, fromPairs)`.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig [String] -> [*] -> {String: *}\n * @param {Array} keys The array that will be properties on the output object.\n * @param {Array} values The list of values on the output object.\n * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n * @example\n *\n * R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n */\n\nvar zipObj =\n/*#__PURE__*/\n_curry2(function zipObj(keys, values) {\n var idx = 0;\n var len = Math.min(keys.length, values.length);\n var out = {};\n\n while (idx < len) {\n out[keys[idx]] = values[idx];\n idx += 1;\n }\n\n return out;\n});\n\nexport default zipObj;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Creates a new list out of the two supplied by applying the function to each\n * equally-positioned pair in the lists. The returned list is truncated to the\n * length of the shorter of the two input lists.\n *\n * @function\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, b) -> c) -> [a] -> [b] -> [c]\n * @param {Function} fn The function used to combine the two elements into one value.\n * @param {Array} list1 The first array to consider.\n * @param {Array} list2 The second array to consider.\n * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n * using `fn`.\n * @example\n *\n * const f = (x, y) => {\n * // ...\n * };\n * R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n * //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n * @symb R.zipWith(fn, [a, b, c], [d, e, f]) = [fn(a, d), fn(b, e), fn(c, f)]\n */\n\nvar zipWith =\n/*#__PURE__*/\n_curry3(function zipWith(fn, a, b) {\n var rv = [];\n var idx = 0;\n var len = Math.min(a.length, b.length);\n\n while (idx < len) {\n rv[idx] = fn(a[idx], b[idx]);\n idx += 1;\n }\n\n return rv;\n});\n\nexport default zipWith;","import curryN from \"./curryN.js\";\nimport _curry1 from \"./internal/_curry1.js\";\n/**\n * Creates a thunk out of a function. A thunk delays a calculation until\n * its result is needed, providing lazy evaluation of arguments.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Function\n * @sig ((a, b, ..., j) -> k) -> (a, b, ..., j) -> (() -> k)\n * @param {Function} fn A function to wrap in a thunk\n * @return {Function} Expects arguments for `fn` and returns a new function\n * that, when called, applies those arguments to `fn`.\n * @see R.partial, R.partialRight\n * @example\n *\n * R.thunkify(R.identity)(42)(); //=> 42\n * R.thunkify((a, b) => a + b)(25, 17)(); //=> 42\n */\n\nvar thunkify =\n/*#__PURE__*/\n_curry1(function thunkify(fn) {\n return curryN(fn.length, function createThunk() {\n var fnArgs = arguments;\n return function invokeThunk() {\n return fn.apply(this, fnArgs);\n };\n });\n});\n\nexport default thunkify;"],"names":["_isPlaceholder","a","_curry1","fn","f1","arguments","length","apply","this","_curry2","f2","b","_b","_a","Number","_concat","set1","set2","idx","len1","len2","result","_arity","n","a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","Error","_curryN","received","combined","argsIdx","left","combinedIdx","curryN","origFn","list","args","Array","prototype","slice","call","_curry3","f3","c","_c","_idx","_list","isArray","val","Object","toString","_isTransformer","obj","_dispatchable","methodNames","xf","pop","_isArray","transducer","_reduced","x","init","XAll","f","all","_xfBase","input","_map","functor","len","_isString","nodeType","hasOwnProperty","XWrap","acc","_xwrap","thisObj","_iterableReduce","iter","step","next","done","value","_methodReduce","methodName","bind","symIterator","Symbol","iterator","_reduce","_isArrayLike","_arrayReduce","reduce","TypeError","XMap","_has","prop","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","hasArgsEnumBug","contains","item","keys","nIdx","ks","checkArgsLength","_isArguments","_xmap","key","isInteger","offset","charAt","pathsArray","map","paths","p","_isInteger","nth","pathAr","path","preds","max","pluck","XAny","any","applyF","applyX","ap","_aperture","limit","XAperture","pos","full","store","getCopy","el","values","props","vals","mapValues","applySpec","spec","v","aa","bb","assoc","assocPath","nextObj","isNil","arr","concat","nAry","_isFunction","type","arity","lifted","liftN","g","lift","and","curry","_makeFlat","recursive","flatt","jlen","j","ilen","rxf","ret","preservingReduced","_flatCat","monad","clamp","min","_cloneRegExp","pattern","RegExp","source","global","ignoreCase","multiline","sticky","unicode","undefined","_clone","refFrom","refTo","deep","copy","copiedValue","Date","valueOf","clone","pred","not","_pipe","_checkForMethod","methodname","fromIndex","toIndex","Infinity","pipe","tail","split","reverse","join","compose","composeK","last","chain","_pipeP","ctx","then","pipeP","composeP","_identity","identity","headList","head","tailList","pipeWith","_arrayFromIterator","push","_includesWith","is","_uniqContentEquals","aIterator","bIterator","stackA","stackB","eq","_equals","aItem","_objectIs","typeA","equals","constructor","match","String","_functionName","name","message","size","entries","keysA","extendedStackA","extendedStackB","_indexOf","inf","indexOf","_includes","_quote","s","replace","pad","toISOString","d","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","toFixed","_complement","_filter","_isObject","XFilter","filterable","filter","_toString","seen","recur","y","xs","mapPairs","k","sort","reject","test","isNaN","NaN","_toISOString","repr","cond","pairs","pair","Fn","$0","$1","$2","$3","$4","$5","$6","$7","$8","$9","constructN","after","fns","context","XReduceBy","valueFn","valueAcc","keyFn","inputs","elt","reduceBy","elem","add","hasOrAdd","shouldAdd","set","prevSize","_items","_nativeSet","has","bIdx","_Set","Set","first","second","out","firstLen","secondLen","toFilterOut","i","dissoc","start","count","splice","adjust","always","dissocPath","remove","update","XDrop","Math","XTake","dropLast","take","XDropLast","_dropLast","dropLastWhile","XDropLastWhile","retained","retain","flush","_dropLastWhile","XDropRepeatsWith","lastValue","seenFirstValue","sameAsLast","_xdropRepeatsWith","dropRepeatsWith","XDropWhile","or","empty","drop","suffix","takeLast","eqProps","obj1","obj2","evolve","transformations","object","transformation","XFind","found","XFindIndex","XFindLast","XFindLastIndex","lastIdx","keyList","res","nextidx","_path","hasPath","hasIn","condition","onTrue","onFalse","target","ys","elts","uniqBy","appliedItem","list1","list2","lookupList","filteredList","uniq","flip","separator","assign","output","nextKey","_stepCatArray","_stepCatString","_stepCatObject","_objectAssign","objOf","_stepCat","invert","invertObj","method","Ctor","invoker","converge","keysIn","lastIndexOf","_isNumber","getter","setter","toFunctorFn","focus","lens","tuple","rx","str","m","sum","width","mean","mFn","cache","l","r","mergeDeepWithKey","lObj","rObj","mergeWithKey","lVal","rVal","_","_l","_r","from","to","positiveFrom","positiveTo","_of","omit","names","index","called","_assertPromise","Identity","over","fst","snd","_createPartialApplicator","juxt","defaultTo","propPath","pickBy","pipeK","multiply","transformers","useWith","pickAll","propIs","pathOr","ps","RangeError","times","regex","replacement","sequence","of","traversable","reduceRight","prepend","comparator","array","prefix","difference","differenceWith","XTakeWhile","XTap","toPairs","toPairsIn","outerlist","innerlist","traverse","ws","trim","beginRx","endRx","tryer","catcher","e","depth","endIdx","currentDepth","unfold","seed","uniqWith","whenFalseFn","until","valuesIn","vs","Const","view","whenTrueFn","where","testObj","Boolean","rv","zipObj","fnArgs"],"sourceRoot":""}