ramda-adjunct 2.34.0

package/lib/isNotRegExp.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isRegExp = _interopRequireDefault(require("./isRegExp"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is complement of `RegExp` object.
+ *
+ * @func isNotRegExp
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isRegExp|isRegExp}
+ * @example
+ *
+ * RA.isNotRegExp(1); //=> true
+ * RA.isNotRegExp(/(?:)/); //=> false
+ * RA.isNotRegExp(new RegExp()); //=> false
+ */
+var isNotRegExp = (0, _ramda.complement)(_isRegExp["default"]);
+var _default = isNotRegExp;
+exports["default"] = _default;

package/lib/isNotSet.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isSet = _interopRequireDefault(require("./isSet"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is complement of `Set` object.
+ *
+ * @func isNotSet
+ * @memberOf RA
+ * @category Type
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.27.0|v2.27.0}
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isSet|isSet}
+ * @example
+ *
+ * RA.isNotSet(new Map()); //=> true
+ * RA.isNotSet(new Set()); //=> false
+ * RA.isNotSet(new Set([1,2]); //=> false
+ * RA.isNotSet(new Object()); //=> true
+ */
+var isNotSet = (0, _ramda.complement)(_isSet["default"]);
+var _default = isNotSet;
+exports["default"] = _default;

package/lib/isNotString.js

@@ -0,0 +1,30 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isString = _interopRequireDefault(require("./isString"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is complement of `String`.
+ *
+ * @func isNotString
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.4.0|v0.4.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isString|isString}
+ * @example
+ *
+ * RA.isNotString('abc'); //=> false
+ * RA.isNotString(1); //=> true
+ */
+var isNotString = (0, _ramda.complement)(_isString["default"]);
+var _default = isNotString;
+exports["default"] = _default;

package/lib/isNotUndefined.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isUndefined = _interopRequireDefault(require("./isUndefined"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is complement `undefined`.
+ *
+ * @func isNotUndefined
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.0.1|v0.0.1}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isUndefined|isUndefined}
+ * @example
+ *
+ * RA.isNotUndefined(1); //=> true
+ * RA.isNotUndefined(undefined); //=> false
+ * RA.isNotUndefined(null); //=> true
+ */
+var isNotUndefined = (0, _ramda.complement)(_isUndefined["default"]);
+var _default = isNotUndefined;
+exports["default"] = _default;

package/lib/isNotValidDate.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isValidDate = _interopRequireDefault(require("./isValidDate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is complement of valid `Date` object.
+ *
+ * @func isNotValidDate
+ * @aliases isInvalidDate
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.8.0|v1.8.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isValidDate|isValidDate}, {@link RA.isDate|isDate}, {@link RA.isNotDate|isNotDate}
+ * @example
+ *
+ * RA.isNotValidDate(new Date()); //=> false
+ * RA.isNotValidDate(new Date('a')); //=> true
+ */
+var isNotValidDate = (0, _ramda.complement)(_isValidDate["default"]);
+var _default = isNotValidDate;
+exports["default"] = _default;

package/lib/isNotValidNumber.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isValidNumber = _interopRequireDefault(require("./isValidNumber"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is not a valid `Number`. A valid `Number` is a number that is not `NaN`,
+ * `Infinity` or `-Infinity`.
+ *
+ * @func isNotValidNumber
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.2.0|v2.2.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isValidNumber|isValidNumber}
+ * @example
+ *
+ * RA.isNotValidNumber(1); //=> false
+ * RA.isNotValidNumber(''); //=> true
+ * RA.isNotValidNumber(NaN); //=> true
+ * RA.isNotValidNumber(Infinity); //=> true
+ * RA.isNotValidNumber(-Infinity); //=> true
+ */
+var isNotValidNumber = (0, _ramda.complement)(_isValidNumber["default"]);
+var _default = isNotValidNumber;
+exports["default"] = _default;

package/lib/isNull.js

@@ -0,0 +1,27 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if input value is `null`.
+ *
+ * @func isNull
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.1.0|v0.1.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotNull|isNotNull}
+ * @example
+ *
+ * RA.isNull(1); //=> false
+ * RA.isNull(undefined); //=> false
+ * RA.isNull(null); //=> true
+ */
+var isNull = (0, _ramda.equals)(null);
+var _default = isNull;
+exports["default"] = _default;

package/lib/isNumber.js

@@ -0,0 +1,29 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if value is a `Number` primitive or object.
+ *
+ * @func isNumber
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.6.0|v0.6.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotNumber|isNotNumber}
+ * @example
+ *
+ * RA.isNumber(5); // => true
+ * RA.isNumber(Number.MAX_VALUE); // => true
+ * RA.isNumber(-Infinity); // => true
+ * RA.isNumber(NaN); // => true
+ * RA.isNumber('5'); // => false
+ */
+var isNumber = (0, _ramda.curryN)(1, (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('Number')));
+var _default = isNumber;
+exports["default"] = _default;

package/lib/isObj.js

@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNotNull = _interopRequireDefault(require("./isNotNull"));
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+var _isOfTypeObject = _interopRequireDefault(require("./internal/isOfTypeObject"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/* eslint-disable max-len */
+
+/**
+ * Checks if input value is language type of `Object`.
+ *
+ * @func isObj
+ * @aliases isObject
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.5.0|v0.5.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotObj|isNotObj}, {@link RA.isObjLike|isObjLike}, {@link RA.isPlainObj|isPlainObj}
+ * @example
+ *
+ * RA.isObj({}); //=> true
+ * RA.isObj([]); //=> true
+ * RA.isObj(() => {}); //=> true
+ * RA.isObj(null); //=> false
+ * RA.isObj(undefined); //=> false
+ */
+
+/* eslint-enable max-len */
+var isObj = (0, _ramda.curryN)(1, (0, _ramda.both)(_isNotNull["default"], (0, _ramda.either)(_isOfTypeObject["default"], _isFunction["default"])));
+var _default = isObj;
+exports["default"] = _default;

package/lib/isObjLike.js

@@ -0,0 +1,40 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNotNull = _interopRequireDefault(require("./isNotNull"));
+
+var _isOfTypeObject = _interopRequireDefault(require("./internal/isOfTypeObject"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/* eslint-disable max-len */
+
+/**
+ * Checks if value is object-like. A value is object-like if it's not null and has a typeof result of "object".
+ *
+ * @func isObjLike
+ * @aliases isObjectLike
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.5.0|v0.5.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotObjLike|isNotObjLike}, {@link RA.isObj|isObj}, {@link RA.isPlainObj|isPlainObj}
+ * @example
+ *
+ * RA.isObjLike({}); //=> true
+ * RA.isObjLike([]); //=> true
+ * RA.isObjLike(() => {}); //=> false
+ * RA.isObjLike(null); //=> false
+ * RA.isObjLike(undefined); //=> false
+ */
+
+/* eslint-enable max-len */
+var isObjLike = (0, _ramda.curryN)(1, (0, _ramda.both)(_isNotNull["default"], _isOfTypeObject["default"]));
+var _default = isObjLike;
+exports["default"] = _default;

package/lib/isOdd.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isInteger = _interopRequireDefault(require("./isInteger"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is odd integer number.
+ * An odd number is an integer which is not a multiple DIVISIBLE of two.
+ *
+ * @func isOdd
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.18.0|v1.18.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isEven|isEven}
+ * @example
+ *
+ * RA.isOdd(1); // => true
+ * RA.isOdd(-Infinity); // => false
+ * RA.isOdd(4); // => false
+ * RA.isOdd(3); // => true
+ */
+var isOdd = (0, _ramda.curryN)(1, (0, _ramda.both)(_isInteger["default"], (0, _ramda.pipe)((0, _ramda.flip)(_ramda.modulo)(2), (0, _ramda.complement)(_ramda.equals)(0))));
+var _default = isOdd;
+exports["default"] = _default;

package/lib/isPair.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isArray = _interopRequireDefault(require("./isArray"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is a pair.
+ *
+ * @func isPair
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link http://ramdajs.com/docs/#pair|R.pair}, {@link RA.isNotPair|isNotPair}
+ * @example
+ *
+ * RA.isPair([]); // => false
+ * RA.isPair([0]); // => false
+ * RA.isPair([0, 1]); // => true
+ * RA.isPair([0, 1, 2]); // => false
+ * RA.isPair({ 0: 0, 1: 1 }); // => false
+ * RA.isPair({ foo: 0, bar: 0 }); // => false
+ */
+var isPair = (0, _ramda.curryN)(1, (0, _ramda.both)(_isArray["default"], (0, _ramda.pipe)(_ramda.length, (0, _ramda.equals)(2))));
+var _default = isPair;
+exports["default"] = _default;

package/lib/isPlainObj.js

@@ -0,0 +1,64 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNull = _interopRequireDefault(require("./isNull"));
+
+var _isObjLike = _interopRequireDefault(require("./isObjLike"));
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var isObject = (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('Object'));
+var isObjectConstructor = (0, _ramda.pipe)(_ramda.toString, (0, _ramda.equals)((0, _ramda.toString)(Object)));
+var hasObjectConstructor = (0, _ramda.pathSatisfies)((0, _ramda.both)(_isFunction["default"], isObjectConstructor), ['constructor']);
+/* eslint-disable max-len */
+
+/**
+ * Check to see if an object is a plain object (created using `{}`, `new Object()` or `Object.create(null)`).
+ *
+ * @func isPlainObj
+ * @aliases isPlainObject
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.5.0|v0.5.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotPlainObj|isNotPlainObj}, {@link RA.isObjLike|isObjLike}, {@link RA.isObj|isObj}
+ * @example
+ *
+ * class Bar {
+ *   constructor() {
+ *     this.prop = 'value';
+ *   }
+ * }
+ *
+ * RA.isPlainObj(new Bar()); //=> false
+ * RA.isPlainObj({ prop: 'value' }); //=> true
+ * RA.isPlainObj(['a', 'b', 'c']); //=> false
+ * RA.isPlainObj(Object.create(null); //=> true
+ * RA.isPlainObj(new Object()); //=> true
+ */
+
+/* eslint-enable max-len */
+
+var isPlainObj = (0, _ramda.curryN)(1, function (val) {
+  if (!(0, _isObjLike["default"])(val) || !isObject(val)) {
+    return false;
+  }
+
+  var proto = Object.getPrototypeOf(val);
+
+  if ((0, _isNull["default"])(proto)) {
+    return true;
+  }
+
+  return hasObjectConstructor(proto);
+});
+var _default = isPlainObj;
+exports["default"] = _default;

package/lib/isPositive.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNumber = _interopRequireDefault(require("./isNumber"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is a positive `Number` primitive or object. Zero is not considered positive.
+ *
+ * @func isPositive
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.15.0|v1.15.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNegative|isNegative}
+ * @example
+ *
+ * RA.isPositive(1); // => true
+ * RA.isPositive(Number.MAX_VALUE); // => true
+ * RA.isPositive(-Infinity); // => false
+ * RA.isPositive(NaN); // => false
+ * RA.isPositive('5'); // => false
+ */
+var isPositive = (0, _ramda.both)(_isNumber["default"], (0, _ramda.lt)(0));
+var _default = isPositive;
+exports["default"] = _default;

package/lib/isPositiveZero.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if value is a positive zero (+0).
+ *
+ * @func isPositiveZero
+ * @memberof RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNegativeZero|isNegativeZero}
+ * @example
+ *
+ * RA.isPositiveZero(+0); //=> true
+ * RA.isPositiveZero(0); //=> true
+ * RA.isPositiveZero(-0); //=> false
+ * RA.isPositiveZero(null); //=> false
+ */
+var isPositiveZero = (0, _ramda.identical)(+0);
+var _default = isPositiveZero;
+exports["default"] = _default;

package/lib/isPrimitive.js

@@ -0,0 +1,47 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNotObj = _interopRequireDefault(require("./isNotObj"));
+
+var _isString = _interopRequireDefault(require("./isString"));
+
+var _isNumber = _interopRequireDefault(require("./isNumber"));
+
+var _isBigInt = _interopRequireDefault(require("./isBigInt"));
+
+var _isBoolean = _interopRequireDefault(require("./isBoolean"));
+
+var _isUndefined = _interopRequireDefault(require("./isUndefined"));
+
+var _isNull = _interopRequireDefault(require("./isNull"));
+
+var _isSymbol = _interopRequireDefault(require("./isSymbol"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * 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
+ * @category Type
+ * @sig * -> Boolean
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.32.0|v2.32.0}
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotPrimitive|isNotPrimitive}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#primitive_values|MDN Primitive values}, {@link https://developer.mozilla.org/en-US/docs/Glossary/Primitive|MDN Primitive}
+ * @example
+ *
+ * RA.isPrimitive("string"); //=> true
+ * RA.isPrimitive(1); //=> true
+ * RA.isPrimitive(new String("string")); //=> false
+ * RA.isPrimitive(new Number(1)); //=> false
+ */
+var isPrimitive = (0, _ramda.both)(_isNotObj["default"], (0, _ramda.anyPass)([_isString["default"], _isNumber["default"], _isBigInt["default"], _isBoolean["default"], _isUndefined["default"], _isNull["default"], _isSymbol["default"]]));
+var _default = isPrimitive;
+exports["default"] = _default;

package/lib/isPromise.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isObj = _interopRequireDefault(require("./isObj"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is a native `Promise`.
+ * The Promise object represents the eventual completion (or failure)
+ * of an asynchronous operation, and its resulting value.
+ *
+ * @func isPromise
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link https://promisesaplus.com/|Promises/A+}, {@link RA.isThenable|isThenable}
+ * @example
+ *
+ * RA.isPromise(null); // => false
+ * RA.isPromise(undefined); // => false
+ * RA.isPromise([]); // => false
+ * RA.isPromise(Promise.resolve()); // => true
+ * RA.isPromise(Promise.reject()); // => true
+ * RA.isPromise({ then: () => 1 }); // => false
+ */
+var isPromise = (0, _ramda.curryN)(1, (0, _ramda.both)(_isObj["default"], (0, _ramda.pipe)(_ramda.toString, (0, _ramda.equals)('[object Promise]'))));
+var _default = isPromise;
+exports["default"] = _default;

package/lib/isPrototypeOf.js

@@ -0,0 +1,43 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _invokeArgs = _interopRequireDefault(require("./invokeArgs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if an object exists in another object's prototype chain.
+ *
+ * @func isPrototypeOf
+ * @category Object
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.31.0|v2.31.0}
+ * @sig * -> Boolean
+ * @param {Object} type The prototype that we're searching for
+ * @param {Object} object The object whose prototype chain will be searched
+ * @return {boolean}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf|Object.prorotype.isPrototypeOf}
+ * @example
+ * function Foo() {}
+ * function Bar() {}
+ * function Baz() {}
+ *
+ * Bar.prototype = Object.create(Foo.prototype);
+ * Baz.prototype = Object.create(Bar.prototype);
+ *
+ * const baz = new Baz();
+ *
+ * RA.isPrototypeOf(Baz, baz); // => true
+ * RA.isPrototypeOf(Bar, baz); // => true
+ * RA.isPrototypeOf(Foo, baz); // => true
+ * RA.isPrototypeOf(Object, baz); // => true
+ */
+var isPrototypeOf = (0, _ramda.curry)(function (type, object) {
+  return Boolean((0, _invokeArgs["default"])(['prototype', 'isPrototypeOf'], [object], type));
+});
+var _default = isPrototypeOf;
+exports["default"] = _default;