ramda-adjunct 3.2.0 → 3.4.0

package/es/isPlainObj.js

@@ -5,8 +5,8 @@ import isFunction from './isFunction';
 var isObject = pipe(type, identical('Object'));
 var isObjectConstructor = pipe(toString, equals(toString(Object)));
 var hasObjectConstructor = pathSatisfies(both(isFunction, isObjectConstructor), ['constructor']);
-/* eslint-disable max-len */
 
+/* eslint-disable max-len */
 /**
  * Check to see if an object is a plain object (created using `{}`, `new Object()` or `Object.create(null)`).
  *
@@ -33,20 +33,15 @@ var hasObjectConstructor = pathSatisfies(both(isFunction, isObjectConstructor),
  * RA.isPlainObj(Object.create(null); //=> true
  * RA.isPlainObj(new Object()); //=> true
  */
-
 /* eslint-enable max-len */
-
 var isPlainObj = curryN(1, function (val) {
   if (!isObjLike(val) || !isObject(val)) {
     return false;
   }
-
   var proto = Object.getPrototypeOf(val);
-
   if (isNull(proto)) {
     return true;
   }
-
   return hasObjectConstructor(proto);
 });
 export default isPlainObj;

package/es/isPositive.js

@@ -1,5 +1,6 @@
 import { both, lt } from 'ramda';
 import isNumber from './isNumber';
+
 /**
  * Checks if value is a positive `Number` primitive or object. Zero is not considered positive.
  *
@@ -19,6 +20,5 @@ import isNumber from './isNumber';
  * RA.isPositive(NaN); // => false
  * RA.isPositive('5'); // => false
  */
-
 var isPositive = both(isNumber, lt(0));
 export default isPositive;

package/es/isPositiveZero.js

@@ -1,4 +1,5 @@
 import { identical } from 'ramda';
+
 /**
  * Checks if value is a positive zero (+0).
  *
@@ -17,6 +18,5 @@ import { identical } from 'ramda';
  * RA.isPositiveZero(-0); //=> false
  * RA.isPositiveZero(null); //=> false
  */
-
 var isPositiveZero = identical(+0);
 export default isPositiveZero;

package/es/isPrimitive.js

@@ -7,12 +7,14 @@ import isBoolean from './isBoolean';
 import isUndefined from './isUndefined';
 import isNull from './isNull';
 import isSymbol from './isSymbol';
+
 /**
  * Checks if value is a primitive data type. There are 6 primitive data types: `string`, `number`, `bigint`, `boolean`, `undefined`, `symbol` and a special case of `null`.
  * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Primitive_values
  * for definition of what sub-types comprise a primitive.
  *
  * @func isPrimitive
+ * @memberOf RA
  * @category Type
  * @sig * -> Boolean
  * @since {@link https://char0n.github.io/ramda-adjunct/2.32.0|v2.32.0}

package/es/isPromise.js

@@ -1,5 +1,6 @@
 import { both, pipe, toString, equals, curryN } from 'ramda';
 import isObj from './isObj';
+
 /**
  * Checks if input value is a native `Promise`.
  * The Promise object represents the eventual completion (or failure)
@@ -22,6 +23,5 @@ import isObj from './isObj';
  * RA.isPromise(Promise.reject()); // => true
  * RA.isPromise({ then: () => 1 }); // => false
  */
-
 var isPromise = curryN(1, both(isObj, pipe(toString, equals('[object Promise]'))));
 export default isPromise;

package/es/isPrototypeOf.js

@@ -1,5 +1,6 @@
 import { curry } from 'ramda';
 import invokeArgs from './invokeArgs';
+
 /**
  * Checks if an object exists in another object's prototype chain.
  *
@@ -27,7 +28,6 @@ import invokeArgs from './invokeArgs';
  * RA.isPrototypeOf(Foo, baz); // => true
  * RA.isPrototypeOf(Object, baz); // => true
  */
-
 var isPrototypeOf = curry(function (type, object) {
   return Boolean(invokeArgs(['prototype', 'isPrototypeOf'], [object], type));
 });

package/es/isRegExp.js

@@ -1,4 +1,5 @@
 import { type, identical, pipe, curryN } from 'ramda';
+
 /**
  * Checks if value is `RegExp` object.
  *
@@ -16,6 +17,5 @@ import { type, identical, pipe, curryN } from 'ramda';
  * RA.isRegExp(/(?:)/); //=> true
  * RA.isRegExp(1); //=> false
  */
-
 var isRegExp = curryN(1, pipe(type, identical('RegExp')));
 export default isRegExp;

package/es/isSafeInteger.js

@@ -2,6 +2,7 @@ import { bind, curryN } from 'ramda';
 import isFunction from './isFunction';
 import ponyfill from './internal/ponyfills/Number.isSafeInteger';
 export var isSafeIntegerPonyfill = curryN(1, ponyfill);
+
 /**
  * Checks whether the passed value is a safe `integer`.
  *

package/es/isSentinelValue.js

@@ -1,5 +1,6 @@
 import { curryN } from 'ramda';
 import isInteger32 from './isInteger32';
+
 /**
  * Checks whether the passed value is {@link https://github.com/getify/You-Dont-Know-JS/blob/9959fc904d584bbf0b02cf41c192f74ff4238581/types-grammar/ch4.md#the-curious-case-of-the-|a sentinel value}.
  *
@@ -19,7 +20,6 @@ import isInteger32 from './isInteger32';
  * RA.isSentinelValue([-1]); //=> false
  */
 // eslint-disable-next-line no-bitwise
-
 var isSentinelValue = curryN(1, function (val) {
   return isInteger32(val) && ~val === 0;
 });

package/es/isSet.js

@@ -1,4 +1,5 @@
 import { type, identical, pipe, curryN } from 'ramda';
+
 /**
  * Predicate for determining if a provided value is an instance of a Set.
  *

package/es/isSparseArray.js

@@ -1,5 +1,6 @@
 import { values, both, complement, pipe, converge, identical, length } from 'ramda';
 import isArray from './isArray';
+
 /**
  * Checks if input value is a sparse Array.
  * An array with at least one "empty slot" in it is often called a "sparse array."
@@ -25,6 +26,5 @@ import isArray from './isArray';
  *
  * RA.isSparseArray([1, 2, 3]); // => false
  */
-
 var isSparseArray = both(isArray, converge(complement(identical), [pipe(values, length), length]));
 export default isSparseArray;

package/es/isString.js

@@ -1,4 +1,5 @@
 import { curryN, pipe, type, identical } from 'ramda';
+
 /**
  * Checks if input value is `String`.
  *
@@ -15,6 +16,5 @@ import { curryN, pipe, type, identical } from 'ramda';
  * RA.isString('abc'); //=> true
  * RA.isString(1); //=> false
  */
-
 var isString = curryN(1, pipe(type, identical('String')));
 export default isString;

package/es/isSymbol.js

@@ -1,6 +1,6 @@
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
-
 import { type, curryN } from 'ramda';
+
 /**
  * Checks if input value is a Symbol.
  *
@@ -20,7 +20,6 @@ import { type, curryN } from 'ramda';
  * RA.isSymbol(undefined); //=> false
  * RA.isSymbol(null); //=> false
  */
-
 var isSymbol = curryN(1, function (val) {
   return _typeof(val) === 'symbol' || _typeof(val) === 'object' && type(val) === 'Symbol';
 });

package/es/isThenable.js

@@ -1,5 +1,6 @@
 import { pathSatisfies } from 'ramda';
 import isFunction from './isFunction';
+
 /**
  * Checks if input value is a `thenable`.
  * `thenable` is an object or function that defines a `then` method.
@@ -21,6 +22,5 @@ import isFunction from './isFunction';
  * RA.isThenable(Promise.reject()); // => true
  * RA.isThenable({ then: () => 1 }); // => true
  */
-
 var isThenable = pathSatisfies(isFunction, ['then']);
 export default isThenable;

package/es/isTrue.js

@@ -1,4 +1,5 @@
 import { identical } from 'ramda';
+
 /**
  * Checks if input value is the Boolean primitive `true`. Will return false for Boolean objects
  * created using the `Boolean` function as a constructor.

package/es/isTruthy.js

@@ -1,4 +1,5 @@
 import { curryN } from 'ramda';
+
 /**
  * In JavaScript, a `truthy` value is a value that is considered true
  * when evaluated in a Boolean context. All values are truthy unless
@@ -22,6 +23,5 @@ import { curryN } from 'ramda';
  * RA.isTruthy(new Date()); // => true
  * RA.isTruthy(Infinity); // => true
  */
-
 var isTruthy = curryN(1, Boolean);
 export default isTruthy;

package/es/isUinteger32.js

@@ -1,5 +1,6 @@
 import { curryN } from 'ramda';
 import toUinteger32 from './toUinteger32';
+
 /**
  * Checks whether the passed value is an unsigned 32 bit integer.
  *
@@ -22,7 +23,6 @@ import toUinteger32 from './toUinteger32';
  * RA.isUinteger32(-1); //=> false
  * RA.isUinteger32(2 ** 32); //=> false
  */
-
 var isUinteger32 = curryN(1, function (val) {
   return toUinteger32(val) === val;
 });

package/es/isUndefined.js

@@ -1,5 +1,6 @@
 import { equals } from 'ramda';
 import stubUndefined from './stubUndefined';
+
 /**
  * Checks if input value is `undefined`.
  *
@@ -17,6 +18,5 @@ import stubUndefined from './stubUndefined';
  * RA.isUndefined(undefined); //=> true
  * RA.isUndefined(null); //=> false
  */
-
 var isUndefined = equals(stubUndefined());
 export default isUndefined;

package/es/isValidDate.js

@@ -1,8 +1,8 @@
 import { invoker, both, pipe, curryN } from 'ramda';
 import isDate from './isDate';
 import isNotNaN from './isNotNaN';
-/* eslint-disable max-len */
 
+/* eslint-disable max-len */
 /**
  * Checks if value is valid `Date` object.
  *
@@ -19,8 +19,6 @@ import isNotNaN from './isNotNaN';
  * RA.isValidDate(new Date()); //=> true
  * RA.isValidDate(new Date('a')); //=> false
  */
-
 /* eslint-enable max-len */
-
 var isValidDate = curryN(1, both(isDate, pipe(invoker(0, 'getTime'), isNotNaN)));
 export default isValidDate;

package/es/isValidNumber.js

@@ -1,6 +1,7 @@
 import { either, curryN } from 'ramda';
 import isFloat from './isFloat';
 import isInteger from './isInteger';
+
 /**
  * Checks if value is a valid `Number`. A valid `Number` is a number that is not `NaN`, `Infinity`
  * or `-Infinity`.
@@ -21,6 +22,5 @@ import isInteger from './isInteger';
  * RA.isValidNumber(Infinity); //=> false
  * RA.isValidNumber(-Infinity); //=> false
  */
-
 var isValidNumber = curryN(1, either(isInteger, isFloat));
 export default isValidNumber;

package/es/lastP.js

@@ -1,21 +1,16 @@
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
 import { bind, last, map, curryN } from 'ramda';
 import allP from './allP';
 import lengthEq from './lengthEq';
 import lengthGte from './lengthGte';
 import rejectP from './rejectP';
 import resolveP from './resolveP';
+
 /**
  * Returns a promise that is fulfilled by the last given promise to be fulfilled,
  * or rejected with an array of rejection reasons if all of the given promises are rejected.
@@ -39,7 +34,6 @@ import resolveP from './resolveP';
  *   delayP.reject(1000),
  * ]); //=> Promise(100)
  */
-
 var lastP = curryN(1, function (iterable) {
   var fulfilled = [];
   var rejected = [];
@@ -52,11 +46,9 @@ var lastP = curryN(1, function (iterable) {
     if (lengthEq(0, fulfilled) && lengthEq(0, rejected)) {
       return undefined;
     }
-
     if (lengthGte(1, fulfilled)) {
       return last(fulfilled);
     }
-
     return rejectP(rejected);
   });
 });

package/es/lengthEq.js

@@ -1,5 +1,6 @@
 import { equals } from 'ramda';
 import compareLength from './internal/compareLength';
+
 /**
  * Returns `true` if the supplied list or string has a length equal to `valueLength`.
  *
@@ -17,6 +18,5 @@ import compareLength from './internal/compareLength';
  * RA.lengthEq(3, [1,2,3]); //=> true
  * RA.lengthEq(3, [1,2,3,4]); //=> false
  */
-
 var lengthEq = compareLength(equals);
 export default lengthEq;

package/es/lengthGt.js

@@ -1,5 +1,6 @@
 import { flip, gt } from 'ramda';
 import compareLength from './internal/compareLength';
+
 /**
  * Returns `true` if the supplied list or string has a length greater than `valueLength`.
  *
@@ -17,6 +18,5 @@ import compareLength from './internal/compareLength';
  * RA.lengthGt(3, [1,2,3,4]); //=> true
  * RA.lengthGt(3, [1,2,3]); //=> false
  */
-
 var lengthGt = compareLength(flip(gt));
 export default lengthGt;

package/es/lengthGte.js

@@ -1,5 +1,6 @@
 import { flip, gte } from 'ramda';
 import compareLength from './internal/compareLength';
+
 /**
  * Returns `true` if the supplied list or string has a length greater than or equal to
  * `valueLength`.
@@ -19,6 +20,5 @@ import compareLength from './internal/compareLength';
  * RA.lengthGte(3, [1,2,3]); //=> true
  * RA.lengthGte(3, [1,2]); //=> false
  */
-
 var lengthGte = compareLength(flip(gte));
 export default lengthGte;

package/es/lengthLt.js

@@ -1,5 +1,6 @@
 import { flip, lt } from 'ramda';
 import compareLength from './internal/compareLength';
+
 /**
  * Returns `true` if the supplied list or string has a length less than `valueLength`.
  *
@@ -17,6 +18,5 @@ import compareLength from './internal/compareLength';
  * RA.lengthLt(3, [1,2]); //=> true
  * RA.lengthLt(3, [1,2,3]); //=> false
  */
-
 var lengthLt = compareLength(flip(lt));
 export default lengthLt;

package/es/lengthLte.js

@@ -1,5 +1,6 @@
 import { flip, lte } from 'ramda';
 import compareLength from './internal/compareLength';
+
 /**
  * Returns `true` if the supplied list or string has a length less than or equal to `valueLength`.
  *
@@ -18,6 +19,5 @@ import compareLength from './internal/compareLength';
  * RA.lengthLte(3, [1,2,3]); //=> true
  * RA.lengthLte(3, [1,2,3,4]); //=> false
  */
-
 var lengthLte = compareLength(flip(lte));
 export default lengthLte;

package/es/lengthNotEq.js

@@ -1,5 +1,6 @@
 import { complement, equals } from 'ramda';
 import compareLength from './internal/compareLength';
+
 /**
  * Returns `true` if the supplied list or string has a length not equal to `valueLength`.
  *
@@ -17,6 +18,5 @@ import compareLength from './internal/compareLength';
  * RA.lengthNotEq(3, [1,2,3,4]); //=> true
  * RA.lengthNotEq(3, [1,2,3]); //=> false
  */
-
 var lengthNotEq = compareLength(complement(equals));
 export default lengthNotEq;

package/es/lensEq.js

@@ -1,4 +1,5 @@
 import { view, curryN, equals, pipe } from 'ramda';
+
 /**
  * Returns `true` if data structure focused by the given lens equals provided value.
  *
@@ -20,7 +21,6 @@ import { view, curryN, equals, pipe } from 'ramda';
  * RA.lensEq(R.lensIndex(1), 1, [0, 1, 2]); // => true
  * RA.lensEq(R.lensPath(['a', 'b']), 'foo', { a: { b: 'foo' } }) // => true
  */
-
 var lensEq = curryN(3, function (lens, val, data) {
   return pipe(view(lens), equals(val))(data);
 });

package/es/lensIso.js

@@ -1,32 +1,34 @@
-import { curry, map } from 'ramda'; // This implementation was highly inspired by the implementations
+import { curry, map } from 'ramda';
+
+// This implementation was highly inspired by the implementations
 // in ramda-lens library.
 //
 // https://github.com/ramda/ramda-lens
+
 // isomorphic :: ((a -> b), (b -> a)) -> Isomorphism
 //     Isomorphism = x -> y
-
 var isomorphic = function isomorphic(to, from) {
   var isomorphism = function isomorphism(x) {
     return to(x);
   };
-
   isomorphism.from = from;
   return isomorphism;
-}; // isomorphisms :: ((a -> b), (b -> a)) -> (a -> b)
-
+};
 
+// isomorphisms :: ((a -> b), (b -> a)) -> (a -> b)
 var isomorphisms = function isomorphisms(to, from) {
   return isomorphic(curry(function (toFunctorFn, target) {
     return map(from, toFunctorFn(to(target)));
   }), curry(function (toFunctorFn, target) {
     return map(to, toFunctorFn(from(target)));
   }));
-}; // from :: Isomorphism -> a -> b
-
+};
 
+// from :: Isomorphism -> a -> b
 var from = curry(function (isomorphism, x) {
   return isomorphism.from(x);
 });
+
 /**
  * Defines an isomorphism that will work like a lens. It takes two functions.
  * The function that converts and the function that recovers.
@@ -49,7 +51,6 @@ var from = curry(function (isomorphism, x) {
  * R.over(lensJSON, assoc('b', 2), '{"a":1}'); //=> '{"a":1,"b":2}'
  * R.over(RA.lensIso.from(lensJSON), R.replace('}', ',"b":2}'), { a: 1 }); // => { a: 1, b: 2 }
  */
-
 var lensIso = curry(isomorphisms);
 lensIso.from = from;
 export default lensIso;

package/es/lensNotEq.js

@@ -1,5 +1,6 @@
 import { complement } from 'ramda';
 import lensEq from './lensEq';
+
 /**
  * Returns `true` if data structure focused by the given lens doesn't equal provided value.
  *
@@ -21,6 +22,5 @@ import lensEq from './lensEq';
  * RA.lensNotEq(R.lensIndex(1), 1, [0, 1, 2]); // => false
  * RA.lensNotEq(R.lensPath(['a', 'b']), 'foo', { a: { b: 'foo' } }) // => false
  */
-
 var lensNotEq = complement(lensEq);
 export default lensNotEq;

package/es/lensNotSatisfy.js

@@ -1,5 +1,6 @@
 import { complement } from 'ramda';
 import lensSatisfies from './lensSatisfies';
+
 /**
  * Returns `true` if data structure focused by the given lens doesn't satisfy the predicate.
  * Note that the predicate is expected to return boolean value.
@@ -23,6 +24,5 @@ import lensSatisfies from './lensSatisfies';
  * RA.lensNotSatisfy(RA.isTrue, R.lensIndex(2), [false, true, 1]); // => true
  * RA.lensNotSatisfy(R.identity, R.lensProp('x'), { x: 1 }); // => true
  */
-
 var lensNotSatisfy = complement(lensSatisfies);
 export default lensNotSatisfy;

package/es/lensSatisfies.js

@@ -1,5 +1,6 @@
 import { view, curryN, pipe } from 'ramda';
 import isTrue from './isTrue';
+
 /**
  * Returns `true` if data structure focused by the given lens satisfies the predicate.
  * Note that the predicate is expected to return boolean value and will be evaluated
@@ -24,7 +25,6 @@ import isTrue from './isTrue';
  * RA.lensSatisfies(RA.isTrue, R.lensIndex(2), [false, true, 1]); // => false
  * RA.lensSatisfies(R.identity, R.lensProp('x'), { x: 1 }); // => false
  */
-
 var lensSatisfies = curryN(3, function (predicate, lens, data) {
   return pipe(view(lens), predicate, isTrue)(data);
 });

package/es/lensTraverse.js

@@ -1,5 +1,6 @@
 import { traverse, curry, pipe, prop, curryN } from 'ramda';
 import Identity from './fantasy-land/Identity';
+
 /**
  * Creates a [Traversable](https://github.com/fantasyland/fantasy-land#traversable) lens
  * from an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning function.
@@ -33,7 +34,6 @@ import Identity from './fantasy-land/Identity';
  *
  * R.set(maybeLens, Maybe.Just(1), [Maybe.just(2), Maybe.Just(3)]); // => Maybe.Just([1, 1])
  */
-
 var lensTraverse = curryN(1, function (of) {
   return curry(function (toFunctorFn, target) {
     return Identity.of(traverse(of, pipe(toFunctorFn, prop('value')), target));

package/es/liftF.js

@@ -1,5 +1,6 @@
 import { curryN } from 'ramda';
 import liftFN from './liftFN';
+
 /**
  * "lifts" a function to be the specified arity, so that it may "map over" objects that satisfy
  * the fantasy land Apply spec of algebraic structures.
@@ -30,7 +31,6 @@ import liftFN from './liftFN';
  * madd3(Maybe.Some(10), Maybe.Some(15), Maybe.Some(17)); //=> Maybe.Some(42)
  * madd3(Maybe.Some(10), Maybe.Nothing(), Maybe.Some(17)); //=> Maybe.Nothing()
  */
-
 var liftF = curryN(1, function (fn) {
   return liftFN(fn.length, fn);
 });

package/es/liftFN.js

@@ -1,5 +1,6 @@
 import { curry, head, slice, reduce, curryN, map } from 'ramda';
 import ap from './internal/ap';
+
 /**
  * "lifts" a function to be the specified arity, so that it may "map over" objects that satisfy
  * the fantasy land Apply spec of algebraic structures.
@@ -31,14 +32,12 @@ import ap from './internal/ap';
  * madd3(Maybe.Some(10), Maybe.Some(15), Maybe.Some(17)); //=> Maybe.Some(42)
  * madd3(Maybe.Some(10), Maybe.Nothing(), Maybe.Some(17)); //=> Maybe.Nothing()
  */
-
 var liftFN = curry(function (arity, fn) {
   var lifted = curryN(arity, fn);
   return curryN(arity, function () {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
     var accumulator = map(lifted, head(args));
     var apps = slice(1, Infinity, args);
     return reduce(ap, accumulator, apps);

package/es/list.js

@@ -1,4 +1,5 @@
 import { unapply, identity } from 'ramda';
+
 /**
  * Creates a list from arguments.
  *
@@ -14,6 +15,5 @@ import { unapply, identity } from 'ramda';
  *
  * RA.list('a', 'b', 'c'); //=> ['a', 'b', 'c']
  */
-
 var list = unapply(identity);
 export default list;

package/es/mapIndexed.js

@@ -1,4 +1,5 @@
 import { addIndex, map } from 'ramda';
+
 /**
  * {@link http://ramdajs.com/docs/#map|R.map} function that more closely resembles Array.prototype.map.
  * It takes two new parameters to its callback function: the current index, and the entire list.
@@ -21,6 +22,5 @@ import { addIndex, map } from 'ramda';
  * RA.mapIndexed((val, idx, list) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);
  * //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']
  */
-
 var mapIndexed = addIndex(map);
 export default mapIndexed;

package/es/mergePath.js

@@ -1,4 +1,5 @@
 import { curry, over, lensPath, mergeLeft } from 'ramda';
+
 /**
  * Create a new object with the own properties of the object under the `path`
  * merged with the own properties of the provided `source`.
@@ -22,7 +23,6 @@ import { curry, over, lensPath, mergeLeft } from 'ramda';
  *  { outer: { inner: { foo: 2 } } }
  * ); //=> { outer: { inner: { foo: 3, bar: 4 } }
  */
-
 var mergePath = curry(function (path, source, obj) {
   return over(lensPath(path), mergeLeft(source), obj);
 });

package/es/mergePaths.js

@@ -1,5 +1,6 @@
 import { curryN, pipe, mergeAll } from 'ramda';
 import paths from './paths';
+
 /**
  * Merge objects under corresponding paths.
  *
@@ -22,6 +23,5 @@ import paths from './paths';
  * { ...obj.foo.fooInner, ...obj.bar }; //=>  { fooInner2: 1, barInner: 2 }
  * RA.mergePaths([['foo', 'fooInner'], ['bar']], obj); //=> { fooInner2: 1, barInner: 2 }
  */
-
 var mergePaths = curryN(2, pipe(paths, mergeAll));
 export default mergePaths;