{"version":3,"file":"static/js/npm.ramda.1f871e00c58b6b24d7ce.js","mappings":"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","sources":["webpack:///./node_modules/ramda/es/T.js","webpack:///./node_modules/ramda/es/adjust.js","webpack:///./node_modules/ramda/es/always.js","webpack:///./node_modules/ramda/es/ascend.js","webpack:///./node_modules/ramda/es/bind.js","webpack:///./node_modules/ramda/es/clone.js","webpack:///./node_modules/ramda/es/compose.js","webpack:///./node_modules/ramda/es/cond.js","webpack:///./node_modules/ramda/es/converge.js","webpack:///./node_modules/ramda/es/curryN.js","webpack:///./node_modules/ramda/es/defaultTo.js","webpack:///./node_modules/ramda/es/descend.js","webpack:///./node_modules/ramda/es/empty.js","webpack:///./node_modules/ramda/es/equals.js","webpack:///./node_modules/ramda/es/filter.js","webpack:///./node_modules/ramda/es/find.js","webpack:///./node_modules/ramda/es/findIndex.js","webpack:///./node_modules/ramda/es/flatten.js","webpack:///./node_modules/ramda/es/flip.js","webpack:///./node_modules/ramda/es/head.js","webpack:///./node_modules/ramda/es/identity.js","webpack:///./node_modules/ramda/es/internal/_Set.js","webpack:///./node_modules/ramda/es/internal/_arity.js","webpack:///./node_modules/ramda/es/internal/_arrayFromIterator.js","webpack:///./node_modules/ramda/es/internal/_checkForMethod.js","webpack:///./node_modules/ramda/es/internal/_clone.js","webpack:///./node_modules/ramda/es/internal/_cloneRegExp.js","webpack:///./node_modules/ramda/es/internal/_complement.js","webpack:///./node_modules/ramda/es/internal/_concat.js","webpack:///./node_modules/ramda/es/internal/_curry1.js","webpack:///./node_modules/ramda/es/internal/_curry2.js","webpack:///./node_modules/ramda/es/internal/_curry3.js","webpack:///./node_modules/ramda/es/internal/_curryN.js","webpack:///./node_modules/ramda/es/internal/_dispatchable.js","webpack:///./node_modules/ramda/es/internal/_equals.js","webpack:///./node_modules/ramda/es/internal/_filter.js","webpack:///./node_modules/ramda/es/internal/_functionName.js","webpack:///./node_modules/ramda/es/internal/_has.js","webpack:///./node_modules/ramda/es/internal/_identity.js","webpack:///./node_modules/ramda/es/internal/_includes.js","webpack:///./node_modules/ramda/es/internal/_includesWith.js","webpack:///./node_modules/ramda/es/internal/_indexOf.js","webpack:///./node_modules/ramda/es/internal/_isArguments.js","webpack:///./node_modules/ramda/es/internal/_isArray.js","webpack:///./node_modules/ramda/es/internal/_isArrayLike.js","webpack:///./node_modules/ramda/es/internal/_isFunction.js","webpack:///./node_modules/ramda/es/internal/_isObject.js","webpack:///./node_modules/ramda/es/internal/_isPlaceholder.js","webpack:///./node_modules/ramda/es/internal/_isString.js","webpack:///./node_modules/ramda/es/internal/_isTransformer.js","webpack:///./node_modules/ramda/es/internal/_makeFlat.js","webpack:///./node_modules/ramda/es/internal/_map.js","webpack:///./node_modules/ramda/es/internal/_objectIs.js","webpack:///./node_modules/ramda/es/internal/_of.js","webpack:///./node_modules/ramda/es/internal/_pipe.js","webpack:///./node_modules/ramda/es/internal/_quote.js","webpack:///./node_modules/ramda/es/internal/_reduce.js","webpack:///./node_modules/ramda/es/internal/_reduced.js","webpack:///./node_modules/ramda/es/internal/_toISOString.js","webpack:///./node_modules/ramda/es/internal/_toString.js","webpack:///./node_modules/ramda/es/internal/_xfBase.js","webpack:///./node_modules/ramda/es/internal/_xfilter.js","webpack:///./node_modules/ramda/es/internal/_xfind.js","webpack:///./node_modules/ramda/es/internal/_xfindIndex.js","webpack:///./node_modules/ramda/es/internal/_xmap.js","webpack:///./node_modules/ramda/es/internal/_xwrap.js","webpack:///./node_modules/ramda/es/intersection.js","webpack:///./node_modules/ramda/es/invoker.js","webpack:///./node_modules/ramda/es/is.js","webpack:///./node_modules/ramda/es/isEmpty.js","webpack:///./node_modules/ramda/es/isNil.js","webpack:///./node_modules/ramda/es/juxt.js","webpack:///./node_modules/ramda/es/keys.js","webpack:///./node_modules/ramda/es/last.js","webpack:///./node_modules/ramda/es/map.js","webpack:///./node_modules/ramda/es/max.js","webpack:///./node_modules/ramda/es/mergeWithKey.js","webpack:///./node_modules/ramda/es/nth.js","webpack:///./node_modules/ramda/es/of.js","webpack:///./node_modules/ramda/es/partition.js","webpack:///./node_modules/ramda/es/path.js","webpack:///./node_modules/ramda/es/pathOr.js","webpack:///./node_modules/ramda/es/pick.js","webpack:///./node_modules/ramda/es/pipe.js","webpack:///./node_modules/ramda/es/pluck.js","webpack:///./node_modules/ramda/es/prop.js","webpack:///./node_modules/ramda/es/propEq.js","webpack:///./node_modules/ramda/es/reduce.js","webpack:///./node_modules/ramda/es/reject.js","webpack:///./node_modules/ramda/es/reverse.js","webpack:///./node_modules/ramda/es/slice.js","webpack:///./node_modules/ramda/es/tail.js","webpack:///./node_modules/ramda/es/toLower.js","webpack:///./node_modules/ramda/es/toString.js","webpack:///./node_modules/ramda/es/type.js","webpack:///./node_modules/ramda/es/uniq.js","webpack:///./node_modules/ramda/es/uniqBy.js","webpack:///./node_modules/ramda/es/update.js","webpack:///./node_modules/ramda/es/useWith.js","webpack:///./node_modules/ramda/es/values.js"],"sourcesContent":["\n\n/**\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};\nexport default T;","import _concat from './internal/_concat.js';\nimport _curry3 from './internal/_curry3.js';\n\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 */\nvar adjust = /*#__PURE__*/_curry3(function adjust(idx, fn, list) {\n if (idx >= list.length || idx < -list.length) {\n return list;\n }\n var start = idx < 0 ? list.length : 0;\n var _idx = start + idx;\n var _list = _concat(list);\n _list[_idx] = fn(list[_idx]);\n return _list;\n});\nexport default adjust;","import _curry1 from './internal/_curry1.js';\n\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 */\nvar always = /*#__PURE__*/_curry1(function always(val) {\n return function () {\n return val;\n };\n});\nexport default always;","import _curry3 from './internal/_curry3.js';\n\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 */\nvar ascend = /*#__PURE__*/_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});\nexport default ascend;","import _arity from './internal/_arity.js';\nimport _curry2 from './internal/_curry2.js';\n\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 */\nvar bind = /*#__PURE__*/_curry2(function bind(fn, thisObj) {\n return _arity(fn.length, function () {\n return fn.apply(thisObj, arguments);\n });\n});\nexport default bind;","import _clone from './internal/_clone.js';\nimport _curry1 from './internal/_curry1.js';\n\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 */\nvar clone = /*#__PURE__*/_curry1(function clone(value) {\n return value != null && typeof value.clone === 'function' ? value.clone() : _clone(value, [], [], true);\n});\nexport default clone;","import pipe from './pipe.js';\nimport reverse from './reverse.js';\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions 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 */\nexport default function compose() {\n if (arguments.length === 0) {\n throw new Error('compose requires at least one argument');\n }\n return pipe.apply(this, reverse(arguments));\n}","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/**\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 */\nvar cond = /*#__PURE__*/_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 while (idx < pairs.length) {\n if (pairs[idx][0].apply(this, arguments)) {\n return pairs[idx][1].apply(this, arguments);\n }\n idx += 1;\n }\n });\n});\nexport default cond;","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/**\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 */\nvar converge = /*#__PURE__*/_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});\nexport default converge;","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/**\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 */\nvar curryN = /*#__PURE__*/_curry2(function curryN(length, fn) {\n if (length === 1) {\n return _curry1(fn);\n }\n return _arity(length, _curryN(length, [], fn));\n});\nexport default curryN;","import _curry2 from './internal/_curry2.js';\n\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 */\nvar defaultTo = /*#__PURE__*/_curry2(function defaultTo(d, v) {\n return v == null || v !== v ? d : v;\n});\nexport default defaultTo;","import _curry3 from './internal/_curry3.js';\n\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 */\nvar descend = /*#__PURE__*/_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});\nexport default descend;","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/**\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 */\nvar empty = /*#__PURE__*/_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});\nexport default empty;","import _curry2 from './internal/_curry2.js';\nimport _equals from './internal/_equals.js';\n\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 */\nvar equals = /*#__PURE__*/_curry2(function equals(a, b) {\n return _equals(a, b, [], []);\n});\nexport default equals;","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/**\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 */\nvar filter = /*#__PURE__*/_curry2( /*#__PURE__*/_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 return acc;\n }, {}, keys(filterable)) :\n // else\n _filter(pred, filterable);\n}));\nexport default filter;","import _curry2 from './internal/_curry2.js';\nimport _dispatchable from './internal/_dispatchable.js';\nimport _xfind from './internal/_xfind.js';\n\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 */\nvar find = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['find'], _xfind, function find(fn, list) {\n var idx = 0;\n var len = list.length;\n while (idx < len) {\n if (fn(list[idx])) {\n return list[idx];\n }\n idx += 1;\n }\n}));\nexport default find;","import _curry2 from './internal/_curry2.js';\nimport _dispatchable from './internal/_dispatchable.js';\nimport _xfindIndex from './internal/_xfindIndex.js';\n\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 */\nvar findIndex = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable([], _xfindIndex, function findIndex(fn, list) {\n var idx = 0;\n var len = list.length;\n while (idx < len) {\n if (fn(list[idx])) {\n return idx;\n }\n idx += 1;\n }\n return -1;\n}));\nexport default findIndex;","import _curry1 from './internal/_curry1.js';\nimport _makeFlat from './internal/_makeFlat.js';\n\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 */\nvar flatten = /*#__PURE__*/_curry1( /*#__PURE__*/_makeFlat(true));\nexport default flatten;","import _curry1 from './internal/_curry1.js';\nimport curryN from './curryN.js';\n\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 */\nvar flip = /*#__PURE__*/_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});\nexport default flip;","import nth from './nth.js';\n\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 */\nvar head = /*#__PURE__*/nth(0);\nexport default head;","import _curry1 from './internal/_curry1.js';\nimport _identity from './internal/_identity.js';\n\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 */\nvar identity = /*#__PURE__*/_curry1(_identity);\nexport default identity;","import _includes from './_includes.js';\n\nvar _Set = /*#__PURE__*/function () {\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\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 _Set.prototype.has = function (item) {\n return hasOrAdd(item, false, this);\n };\n\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 return _Set;\n}();\n\nfunction hasOrAdd(item, shouldAdd, set) {\n var type = typeof item;\n var prevSize, newSize;\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 return false;\n }\n }\n // these types can all utilise the native Set\n if (set._nativeSet !== null) {\n if (shouldAdd) {\n prevSize = set._nativeSet.size;\n set._nativeSet.add(item);\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 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 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 if (set._items[type][bIdx]) {\n return true;\n } else {\n if (shouldAdd) {\n set._items[type][bIdx] = true;\n }\n return false;\n }\n } else {\n if (shouldAdd) {\n set._items[type] = item ? [false, true] : [true, false];\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 set._nativeSet.add(item);\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 return false;\n }\n if (!_includes(item, set._items[type])) {\n if (shouldAdd) {\n set._items[type].push(item);\n }\n return false;\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 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 return false;\n }\n return true;\n }\n /* falls through */\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 if (!(type in set._items)) {\n if (shouldAdd) {\n set._items[type] = [item];\n }\n return false;\n }\n // scan through all previously applied items\n if (!_includes(item, set._items[type])) {\n if (shouldAdd) {\n set._items[type].push(item);\n }\n return false;\n }\n return true;\n }\n}\n\n// A simple Set type that honours R.equals semantics\nexport default _Set;","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 case 1:\n return function (a0) {\n return fn.apply(this, arguments);\n };\n case 2:\n return function (a0, a1) {\n return fn.apply(this, arguments);\n };\n case 3:\n return function (a0, a1, a2) {\n return fn.apply(this, arguments);\n };\n case 4:\n return function (a0, a1, a2, a3) {\n return fn.apply(this, arguments);\n };\n case 5:\n return function (a0, a1, a2, a3, a4) {\n return fn.apply(this, arguments);\n };\n case 6:\n return function (a0, a1, a2, a3, a4, a5) {\n return fn.apply(this, arguments);\n };\n case 7:\n return function (a0, a1, a2, a3, a4, a5, a6) {\n return fn.apply(this, arguments);\n };\n case 8:\n return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n return fn.apply(this, arguments);\n };\n case 9:\n return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n return fn.apply(this, arguments);\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 default:\n throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n }\n}","export default function _arrayFromIterator(iter) {\n var list = [];\n var next;\n while (!(next = iter.next()).done) {\n list.push(next.value);\n }\n return list;\n}","import _isArray from './_isArray.js';\n\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 */\nexport default function _checkForMethod(methodname, fn) {\n return function () {\n var length = arguments.length;\n if (length === 0) {\n return fn();\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 _cloneRegExp from './_cloneRegExp.js';\nimport type from '../type.js';\n\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 */\nexport default function _clone(value, refFrom, refTo, deep) {\n var copy = function copy(copiedValue) {\n var len = refFrom.length;\n var idx = 0;\n while (idx < len) {\n if (value === refFrom[idx]) {\n return refTo[idx];\n }\n idx += 1;\n }\n refFrom[idx + 1] = value;\n refTo[idx + 1] = copiedValue;\n for (var key in value) {\n copiedValue[key] = deep ? _clone(value[key], refFrom, refTo, true) : value[key];\n }\n return copiedValue;\n };\n switch (type(value)) {\n case 'Object':\n return copy({});\n case 'Array':\n return copy([]);\n case 'Date':\n return new Date(value.valueOf());\n case 'RegExp':\n return _cloneRegExp(value);\n default:\n return value;\n }\n}","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}","export default function _complement(f) {\n return function () {\n return !f.apply(this, arguments);\n };\n}","/**\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\n idx = 0;\n while (idx < len1) {\n result[result.length] = set1[idx];\n idx += 1;\n }\n idx = 0;\n while (idx < len2) {\n result[result.length] = set2[idx];\n idx += 1;\n }\n return result;\n}","import _isPlaceholder from './_isPlaceholder.js';\n\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 */\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/**\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 */\nexport default function _curry2(fn) {\n return function f2(a, b) {\n switch (arguments.length) {\n case 0:\n return f2;\n case 1:\n return _isPlaceholder(a) ? f2 : _curry1(function (_b) {\n return fn(a, _b);\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 _curry1 from './_curry1.js';\nimport _curry2 from './_curry2.js';\nimport _isPlaceholder from './_isPlaceholder.js';\n\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 */\nexport default function _curry3(fn) {\n return function f3(a, b, c) {\n switch (arguments.length) {\n case 0:\n return f3;\n case 1:\n return _isPlaceholder(a) ? f3 : _curry2(function (_b, _c) {\n return fn(a, _b, _c);\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 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 _arity from './_arity.js';\nimport _isPlaceholder from './_isPlaceholder.js';\n\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 */\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 while (combinedIdx < received.length || argsIdx < arguments.length) {\n var result;\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 combined[combinedIdx] = result;\n if (!_isPlaceholder(result)) {\n left -= 1;\n }\n combinedIdx += 1;\n }\n return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n };\n}","import _isArray from './_isArray.js';\nimport _isTransformer from './_isTransformer.js';\n\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 */\nexport default function _dispatchable(methodNames, xf, fn) {\n return function () {\n if (arguments.length === 0) {\n return fn();\n }\n var args = Array.prototype.slice.call(arguments, 0);\n var obj = args.pop();\n if (!_isArray(obj)) {\n var idx = 0;\n while (idx < methodNames.length) {\n if (typeof obj[methodNames[idx]] === 'function') {\n return obj[methodNames[idx]].apply(obj, args);\n }\n idx += 1;\n }\n if (_isTransformer(obj)) {\n var transducer = xf.apply(null, args);\n return transducer(obj);\n }\n }\n return fn.apply(this, arguments);\n };\n}","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/**\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 var b = _arrayFromIterator(bIterator);\n\n function eq(_a, _b) {\n return _equals(_a, _b, stackA.slice(), stackB.slice());\n }\n\n // if *a* array contains any element that is not included in *b*\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 break;\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 break;\n case 'Date':\n if (!_objectIs(a.valueOf(), b.valueOf())) {\n return false;\n }\n break;\n case 'Error':\n return a.name === b.name && a.message === b.message;\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 break;\n }\n\n var idx = stackA.length - 1;\n while (idx >= 0) {\n if (stackA[idx] === a) {\n return stackB[idx] === b;\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 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 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 default:\n // Values of other types are only equal if identical.\n return false;\n }\n\n var keysA = keys(a);\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\n idx = keysA.length - 1;\n while (idx >= 0) {\n var key = keysA[idx];\n if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) {\n return false;\n }\n idx -= 1;\n }\n return true;\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 idx += 1;\n }\n return result;\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}","export default function _has(prop, obj) {\n return Object.prototype.hasOwnProperty.call(obj, prop);\n}","export default function _identity(x) {\n return x;\n}","import _indexOf from './_indexOf.js';\n\nexport default function _includes(a, list) {\n return _indexOf(list, a, 0) >= 0;\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 idx += 1;\n }\n return false;\n}","import equals from '../equals.js';\n\nexport default function _indexOf(list, a, idx) {\n var inf, item;\n // Array.prototype.indexOf doesn't exist below IE9\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 while (idx < list.length) {\n item = list[idx];\n if (item === 0 && 1 / item === inf) {\n return idx;\n }\n idx += 1;\n }\n return -1;\n } else if (a !== a) {\n // NaN\n while (idx < list.length) {\n item = list[idx];\n if (typeof item === 'number' && item !== item) {\n return idx;\n }\n idx += 1;\n }\n return -1;\n }\n // non-zero numbers can utilise Set\n return list.indexOf(a, idx);\n\n // all these types can utilise Set\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 while (idx < list.length) {\n if (equals(list[idx], a)) {\n return idx;\n }\n idx += 1;\n }\n return -1;\n}","import _has from './_has.js';\n\nvar toString = Object.prototype.toString;\nvar _isArguments = /*#__PURE__*/function () {\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;","/**\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};","import _curry1 from './_curry1.js';\nimport _isArray from './_isArray.js';\nimport _isString from './_isString.js';\n\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 */\nvar _isArrayLike = /*#__PURE__*/_curry1(function isArrayLike(x) {\n if (_isArray(x)) {\n return true;\n }\n if (!x) {\n return false;\n }\n if (typeof x !== 'object') {\n return false;\n }\n if (_isString(x)) {\n return false;\n }\n if (x.nodeType === 1) {\n return !!x.length;\n }\n if (x.length === 0) {\n return true;\n }\n if (x.length > 0) {\n return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n }\n return false;\n});\nexport default _isArrayLike;","export default function _isFunction(x) {\n return Object.prototype.toString.call(x) === '[object Function]';\n}","export default function _isObject(x) {\n return Object.prototype.toString.call(x) === '[object Object]';\n}","export default function _isPlaceholder(a) {\n return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;\n}","export default function _isString(x) {\n return Object.prototype.toString.call(x) === '[object String]';\n}","export default function _isTransformer(obj) {\n return obj != null && typeof obj['@@transducer/step'] === 'function';\n}","import _isArrayLike from './_isArrayLike.js';\n\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 */\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 while (j < jlen) {\n result[result.length] = value[j];\n j += 1;\n }\n } else {\n result[result.length] = list[idx];\n }\n idx += 1;\n }\n return result;\n };\n}","export default function _map(fn, functor) {\n var idx = 0;\n var len = functor.length;\n var result = Array(len);\n while (idx < len) {\n result[idx] = fn(functor[idx]);\n idx += 1;\n }\n return result;\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;","export default function _of(x) {\n return [x];\n}","export default function _pipe(f, g) {\n return function () {\n return g.call(this, f.apply(this, arguments));\n };\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\n return '\"' + escaped.replace(/\"/g, '\\\\\"') + '\"';\n}","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 while (idx < len) {\n acc = xf['@@transducer/step'](acc, list[idx]);\n if (acc && acc['@@transducer/reduced']) {\n acc = acc['@@transducer/value'];\n break;\n }\n idx += 1;\n }\n return xf['@@transducer/result'](acc);\n}\n\nfunction _iterableReduce(xf, acc, iter) {\n var step = iter.next();\n while (!step.done) {\n acc = xf['@@transducer/step'](acc, step.value);\n if (acc && acc['@@transducer/reduced']) {\n acc = acc['@@transducer/value'];\n break;\n }\n step = iter.next();\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';\n\nexport default function _reduce(fn, acc, list) {\n if (typeof fn === 'function') {\n fn = _xwrap(fn);\n }\n if (_isArrayLike(list)) {\n return _arrayReduce(fn, acc, list);\n }\n if (typeof list['fantasy-land/reduce'] === 'function') {\n return _methodReduce(fn, acc, list, 'fantasy-land/reduce');\n }\n if (list[symIterator] != null) {\n return _iterableReduce(fn, acc, list[symIterator]());\n }\n if (typeof list.next === 'function') {\n return _iterableReduce(fn, acc, list);\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}","export default function _reduced(x) {\n return x && x['@@transducer/reduced'] ? x : {\n '@@transducer/value': x,\n '@@transducer/reduced': true\n };\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;","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';\n\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 };\n\n // mapPairs :: (Object, [String]) -> [String]\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 case '[object Array]':\n return '[' + _map(recur, x).concat(mapPairs(x, reject(function (k) {\n return (/^\\d+$/.test(k)\n );\n }, keys(x)))).join(', ') + ']';\n case '[object Boolean]':\n return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n case '[object Date]':\n return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';\n case '[object Null]':\n return 'null';\n case '[object Number]':\n return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n case '[object String]':\n return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n case '[object Undefined]':\n return 'undefined';\n default:\n if (typeof x.toString === 'function') {\n var repr = x.toString();\n if (repr !== '[object Object]') {\n return repr;\n }\n }\n return '{' + mapPairs(x, keys(x)).join(', ') + '}';\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 _xfBase from './_xfBase.js';\n\nvar XFilter = /*#__PURE__*/function () {\n function XFilter(f, xf) {\n this.xf = xf;\n this.f = f;\n }\n XFilter.prototype['@@transducer/init'] = _xfBase.init;\n XFilter.prototype['@@transducer/result'] = _xfBase.result;\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 = /*#__PURE__*/_curry2(function _xfilter(f, xf) {\n return new XFilter(f, xf);\n});\nexport default _xfilter;","import _curry2 from './_curry2.js';\nimport _reduced from './_reduced.js';\nimport _xfBase from './_xfBase.js';\n\nvar XFind = /*#__PURE__*/function () {\n function XFind(f, xf) {\n this.xf = xf;\n this.f = f;\n this.found = false;\n }\n XFind.prototype['@@transducer/init'] = _xfBase.init;\n XFind.prototype['@@transducer/result'] = function (result) {\n if (!this.found) {\n result = this.xf['@@transducer/step'](result, void 0);\n }\n return this.xf['@@transducer/result'](result);\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 return result;\n };\n\n return XFind;\n}();\n\nvar _xfind = /*#__PURE__*/_curry2(function _xfind(f, xf) {\n return new XFind(f, xf);\n});\nexport default _xfind;","import _curry2 from './_curry2.js';\nimport _reduced from './_reduced.js';\nimport _xfBase from './_xfBase.js';\n\nvar XFindIndex = /*#__PURE__*/function () {\n function XFindIndex(f, xf) {\n this.xf = xf;\n this.f = f;\n this.idx = -1;\n this.found = false;\n }\n XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n XFindIndex.prototype['@@transducer/result'] = function (result) {\n if (!this.found) {\n result = this.xf['@@transducer/step'](result, -1);\n }\n return this.xf['@@transducer/result'](result);\n };\n XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n this.idx += 1;\n if (this.f(input)) {\n this.found = true;\n result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n }\n return result;\n };\n\n return XFindIndex;\n}();\n\nvar _xfindIndex = /*#__PURE__*/_curry2(function _xfindIndex(f, xf) {\n return new XFindIndex(f, xf);\n});\nexport default _xfindIndex;","import _curry2 from './_curry2.js';\nimport _xfBase from './_xfBase.js';\n\nvar XMap = /*#__PURE__*/function () {\n function XMap(f, xf) {\n this.xf = xf;\n this.f = f;\n }\n XMap.prototype['@@transducer/init'] = _xfBase.init;\n XMap.prototype['@@transducer/result'] = _xfBase.result;\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 = /*#__PURE__*/_curry2(function _xmap(f, xf) {\n return new XMap(f, xf);\n});\nexport default _xmap;","var XWrap = /*#__PURE__*/function () {\n function XWrap(fn) {\n this.f = fn;\n }\n XWrap.prototype['@@transducer/init'] = function () {\n throw new Error('init not implemented on XWrap');\n };\n XWrap.prototype['@@transducer/result'] = function (acc) {\n return acc;\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 _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/**\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 */\nvar intersection = /*#__PURE__*/_curry2(function intersection(list1, list2) {\n var lookupList, filteredList;\n if (list1.length > list2.length) {\n lookupList = list1;\n filteredList = list2;\n } else {\n lookupList = list2;\n filteredList = list1;\n }\n return uniq(_filter(flip(_includes)(lookupList), filteredList));\n});\nexport default intersection;","import _curry2 from './internal/_curry2.js';\nimport _isFunction from './internal/_isFunction.js';\nimport curryN from './curryN.js';\nimport toString from './toString.js';\n\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 the method 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 * @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 */\nvar invoker = /*#__PURE__*/_curry2(function invoker(arity, method) {\n return curryN(arity + 1, function () {\n var target = arguments[arity];\n if (target != null && _isFunction(target[method])) {\n return target[method].apply(target, Array.prototype.slice.call(arguments, 0, arity));\n }\n throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n });\n});\nexport default invoker;","import _curry2 from './internal/_curry2.js';\n\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 */\nvar is = /*#__PURE__*/_curry2(function is(Ctor, val) {\n return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\nexport default is;","import _curry1 from './internal/_curry1.js';\nimport empty from './empty.js';\nimport equals from './equals.js';\n\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 */\nvar isEmpty = /*#__PURE__*/_curry1(function isEmpty(x) {\n return x != null && equals(x, empty(x));\n});\nexport default isEmpty;","import _curry1 from './internal/_curry1.js';\n\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 */\nvar isNil = /*#__PURE__*/_curry1(function isNil(x) {\n return x == null;\n});\nexport default isNil;","import _curry1 from './internal/_curry1.js';\nimport converge from './converge.js';\n\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 */\nvar juxt = /*#__PURE__*/_curry1(function juxt(fns) {\n return converge(function () {\n return Array.prototype.slice.call(arguments, 0);\n }, fns);\n});\nexport default juxt;","import _curry1 from './internal/_curry1.js';\nimport _has from './internal/_has.js';\nimport _isArguments from './internal/_isArguments.js';\n\n// cover IE < 9 keys issues\nvar hasEnumBug = ! /*#__PURE__*/{ toString: null }.propertyIsEnumerable('toString');\nvar nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n// Safari bug\nvar hasArgsEnumBug = /*#__PURE__*/function () {\n 'use strict';\n\n return arguments.propertyIsEnumerable('length');\n}();\n\nvar contains = function contains(list, item) {\n var idx = 0;\n while (idx < list.length) {\n if (list[idx] === item) {\n return true;\n }\n idx += 1;\n }\n return false;\n};\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 */\nvar keys = typeof Object.keys === 'function' && !hasArgsEnumBug ? /*#__PURE__*/_curry1(function keys(obj) {\n return Object(obj) !== obj ? [] : Object.keys(obj);\n}) : /*#__PURE__*/_curry1(function keys(obj) {\n if (Object(obj) !== obj) {\n return [];\n }\n var prop, nIdx;\n var ks = [];\n var checkArgsLength = hasArgsEnumBug && _isArguments(obj);\n for (prop in obj) {\n if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {\n ks[ks.length] = prop;\n }\n }\n if (hasEnumBug) {\n nIdx = nonEnumerableProps.length - 1;\n while (nIdx >= 0) {\n prop = nonEnumerableProps[nIdx];\n if (_has(prop, obj) && !contains(ks, prop)) {\n ks[ks.length] = prop;\n }\n nIdx -= 1;\n }\n }\n return ks;\n});\nexport default keys;","import nth from './nth.js';\n\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 */\nvar last = /*#__PURE__*/nth(-1);\nexport default last;","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/**\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 */\nvar map = /*#__PURE__*/_curry2( /*#__PURE__*/_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 case '[object Object]':\n return _reduce(function (acc, key) {\n acc[key] = fn(functor[key]);\n return acc;\n }, {}, keys(functor));\n default:\n return _map(fn, functor);\n }\n}));\nexport default map;","import _curry2 from './internal/_curry2.js';\n\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 */\nvar max = /*#__PURE__*/_curry2(function max(a, b) {\n return b > a ? b : a;\n});\nexport default max;","import _curry3 from './internal/_curry3.js';\nimport _has from './internal/_has.js';\n\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 */\nvar mergeWithKey = /*#__PURE__*/_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});\nexport default mergeWithKey;","import _curry2 from './internal/_curry2.js';\nimport _isString from './internal/_isString.js';\n\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 */\nvar nth = /*#__PURE__*/_curry2(function nth(offset, list) {\n var idx = offset < 0 ? list.length + offset : offset;\n return _isString(list) ? list.charAt(idx) : list[idx];\n});\nexport default nth;","import _curry1 from './internal/_curry1.js';\nimport _of from './internal/_of.js';\n\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 */\nvar of = /*#__PURE__*/_curry1(_of);\nexport default of;","import filter from './filter.js';\nimport juxt from './juxt.js';\nimport reject from './reject.js';\n\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 */\nvar partition = /*#__PURE__*/juxt([filter, reject]);\nexport default partition;","import _curry2 from './internal/_curry2.js';\n\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\n * @example\n *\n * R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n * R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n */\nvar path = /*#__PURE__*/_curry2(function path(paths, obj) {\n var val = obj;\n var idx = 0;\n while (idx < paths.length) {\n if (val == null) {\n return;\n }\n val = val[paths[idx]];\n idx += 1;\n }\n return val;\n});\nexport default path;","import _curry3 from './internal/_curry3.js';\nimport defaultTo from './defaultTo.js';\nimport path from './path.js';\n\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 */\nvar pathOr = /*#__PURE__*/_curry3(function pathOr(d, p, obj) {\n return defaultTo(d, path(p, obj));\n});\nexport default pathOr;","import _curry2 from './internal/_curry2.js';\n\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 */\nvar pick = /*#__PURE__*/_curry2(function pick(names, obj) {\n var result = {};\n var idx = 0;\n while (idx < names.length) {\n if (names[idx] in obj) {\n result[names[idx]] = obj[names[idx]];\n }\n idx += 1;\n }\n return result;\n});\nexport default pick;","import _arity from './internal/_arity.js';\nimport _pipe from './internal/_pipe.js';\nimport reduce from './reduce.js';\nimport tail from './tail.js';\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions 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 */\nexport default function pipe() {\n if (arguments.length === 0) {\n throw new Error('pipe requires at least one argument');\n }\n return _arity(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n}","import _curry2 from './internal/_curry2.js';\nimport map from './map.js';\nimport prop from './prop.js';\n\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 */\nvar pluck = /*#__PURE__*/_curry2(function pluck(p, list) {\n return map(prop(p), list);\n});\nexport default pluck;","import _curry2 from './internal/_curry2.js';\nimport path from './path.js';\n\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 * @sig s -> {s: a} -> a | Undefined\n * @param {String} p The property name\n * @param {Object} obj The object to query\n * @return {*} The value at `obj.p`.\n * @see R.path\n * @example\n *\n * R.prop('x', {x: 100}); //=> 100\n * R.prop('x', {}); //=> undefined\n * R.compose(R.inc, R.prop('x'))({ x: 3 }) //=> 4\n */\n\nvar prop = /*#__PURE__*/_curry2(function prop(p, obj) {\n return path([p], obj);\n});\nexport default prop;","import _curry3 from './internal/_curry3.js';\nimport equals from './equals.js';\n\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 */\nvar propEq = /*#__PURE__*/_curry3(function propEq(name, val, obj) {\n return equals(val, obj[name]);\n});\nexport default propEq;","import _curry3 from './internal/_curry3.js';\nimport _reduce from './internal/_reduce.js';\n\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 */\nvar reduce = /*#__PURE__*/_curry3(_reduce);\nexport default reduce;","import _complement from './internal/_complement.js';\nimport _curry2 from './internal/_curry2.js';\nimport filter from './filter.js';\n\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 */\nvar reject = /*#__PURE__*/_curry2(function reject(pred, filterable) {\n return filter(_complement(pred), filterable);\n});\nexport default reject;","import _curry1 from './internal/_curry1.js';\nimport _isString from './internal/_isString.js';\n\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 */\nvar reverse = /*#__PURE__*/_curry1(function reverse(list) {\n return _isString(list) ? list.split('').reverse().join('') : Array.prototype.slice.call(list, 0).reverse();\n});\nexport default reverse;","import _checkForMethod from './internal/_checkForMethod.js';\nimport _curry3 from './internal/_curry3.js';\n\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 */\nvar slice = /*#__PURE__*/_curry3( /*#__PURE__*/_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\nexport default slice;","import _checkForMethod from './internal/_checkForMethod.js';\nimport _curry1 from './internal/_curry1.js';\nimport slice from './slice.js';\n\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 */\nvar tail = /*#__PURE__*/_curry1( /*#__PURE__*/_checkForMethod('tail', /*#__PURE__*/slice(1, Infinity)));\nexport default tail;","import invoker from './invoker.js';\n\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 */\nvar toLower = /*#__PURE__*/invoker(0, 'toLowerCase');\nexport default toLower;","import _curry1 from './internal/_curry1.js';\nimport _toString from './internal/_toString.js';\n\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 */\nvar toString = /*#__PURE__*/_curry1(function toString(val) {\n return _toString(val, []);\n});\nexport default toString;","import _curry1 from './internal/_curry1.js';\n\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 */\nvar type = /*#__PURE__*/_curry1(function type(val) {\n return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n});\nexport default type;","import identity from './identity.js';\nimport uniqBy from './uniqBy.js';\n\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 */\nvar uniq = /*#__PURE__*/uniqBy(identity);\nexport default uniq;","import _Set from './internal/_Set.js';\nimport _curry2 from './internal/_curry2.js';\n\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 */\nvar uniqBy = /*#__PURE__*/_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 if (set.add(appliedItem)) {\n result.push(item);\n }\n idx += 1;\n }\n return result;\n});\nexport default uniqBy;","import _curry3 from './internal/_curry3.js';\nimport adjust from './adjust.js';\nimport always from './always.js';\n\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 */\nvar update = /*#__PURE__*/_curry3(function update(idx, x, list) {\n return adjust(idx, always(x), list);\n});\nexport default update;","import _curry2 from './internal/_curry2.js';\nimport curryN from './curryN.js';\n\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 */\nvar useWith = /*#__PURE__*/_curry2(function useWith(fn, transformers) {\n return curryN(transformers.length, function () {\n var args = [];\n var idx = 0;\n while (idx < transformers.length) {\n args.push(transformers[idx].call(this, arguments[idx]));\n idx += 1;\n }\n return fn.apply(this, args.concat(Array.prototype.slice.call(arguments, transformers.length)));\n });\n});\nexport default useWith;","import _curry1 from './internal/_curry1.js';\nimport keys from './keys.js';\n\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 */\nvar values = /*#__PURE__*/_curry1(function values(obj) {\n var props = keys(obj);\n var len = props.length;\n var vals = [];\n var idx = 0;\n while (idx < len) {\n vals[idx] = obj[props[idx]];\n idx += 1;\n }\n return vals;\n});\nexport default values;"],"names":["T","_concat","_curry3","adjust","idx","fn","list","length","start","_idx","_list","_curry1","always","val","ascend","a","b","aa","bb","_arity","_curry2","bind","thisObj","apply","arguments","_clone","clone","value","pipe","reverse","compose","Error","map","max","reduce","cond","pairs","arity","pair","_map","curryN","pluck","converge","after","fns","args","context","_curryN","defaultTo","d","v","descend","_isArguments","_isArray","_isObject","_isString","empty","x","constructor","_equals","equals","_dispatchable","_filter","_reduce","_xfilter","keys","filter","pred","filterable","acc","key","_xfind","find","len","_xfindIndex","findIndex","_makeFlat","flatten","flip","Array","prototype","slice","call","nth","head","_identity","identity","_includes","_Set","_nativeSet","Set","_items","add","item","hasOrAdd","has","shouldAdd","set","type","prevSize","newSize","Infinity","size","bIdx","push","Object","toString","n","a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","_arrayFromIterator","iter","next","done","_checkForMethod","methodname","obj","_cloneRegExp","refFrom","refTo","deep","copy","copiedValue","Date","valueOf","pattern","RegExp","source","global","ignoreCase","multiline","sticky","unicode","_complement","f","set1","set2","len1","len2","result","_isPlaceholder","f1","f2","_b","_a","f3","c","_c","received","combined","argsIdx","left","combinedIdx","_isTransformer","methodNames","xf","pop","transducer","_includesWith","_functionName","_has","_objectIs","_uniqContentEquals","aIterator","bIterator","stackA","stackB","eq","aItem","typeA","_typeof","name","message","entries","concat","values","keysA","extendedStackA","extendedStackB","match","String","prop","hasOwnProperty","_indexOf","inf","indexOf","isArray","_isArrayLike","isArrayLike","nodeType","_isFunction","recursive","flatt","jlen","j","ilen","functor","is","_of","_pipe","g","_quote","s","escaped","replace","_xwrap","_arrayReduce","_iterableReduce","step","_methodReduce","methodName","symIterator","Symbol","iterator","TypeError","_reduced","pad","_toISOString","toISOString","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","toFixed","reject","_toString","seen","recur","y","xs","mapPairs","k","sort","join","test","isNaN","NaN","repr","init","_xfBase","XFilter","input","XFind","found","XFindIndex","XMap","_xmap","XWrap","uniq","intersection","list1","list2","lookupList","filteredList","invoker","method","target","Ctor","isEmpty","isNil","juxt","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","hasArgsEnumBug","contains","nIdx","ks","checkArgsLength","last","mergeWithKey","l","r","offset","charAt","of","partition","path","paths","pathOr","p","pick","names","tail","propEq","split","fromIndex","toIndex","toLower","undefined","uniqBy","appliedItem","update","useWith","transformers","props","vals"],"sourceRoot":""}