ramda-adjunct 2.34.0

package/lib/isIndexed.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isArray = _interopRequireDefault(require("./isArray"));
+
+var _isString = _interopRequireDefault(require("./isString"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Determine if input value is an indexed data type.
+ *
+ * @func isIndexed
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.26.0|v2.26.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @example
+ *
+ * RA.isIndexed([1]) //=> true
+ * RA.isIndexed('test') //=> true
+ */
+var isIndexed = (0, _ramda.curryN)(1, (0, _ramda.either)(_isString["default"], _isArray["default"]));
+var _default = isIndexed;
+exports["default"] = _default;

package/lib/isInteger.js

@@ -0,0 +1,47 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.isIntegerPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+var _Number = _interopRequireDefault(require("./internal/ponyfills/Number.isInteger"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var isIntegerPonyfill = (0, _ramda.curryN)(1, _Number["default"]);
+/**
+ * Checks whether the passed value is an `integer`.
+ *
+ * @func isInteger
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.7.0|v0.7.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotInteger|isNotInteger}
+ * @example
+ *
+ * RA.isInteger(0); //=> true
+ * RA.isInteger(1); //=> true
+ * RA.isInteger(-100000); //=> true
+ *
+ * RA.isInteger(0.1);       //=> false
+ * RA.isInteger(Math.PI);   //=> false
+ *
+ * RA.isInteger(NaN);       //=> false
+ * RA.isInteger(Infinity);  //=> false
+ * RA.isInteger(-Infinity); //=> false
+ * RA.isInteger('10');      //=> false
+ * RA.isInteger(true);      //=> false
+ * RA.isInteger(false);     //=> false
+ * RA.isInteger([1]);       //=> false
+ */
+
+exports.isIntegerPonyfill = isIntegerPonyfill;
+var isInteger = (0, _isFunction["default"])(Number.isInteger) ? (0, _ramda.curryN)(1, (0, _ramda.bind)(Number.isInteger, Number)) : isIntegerPonyfill;
+var _default = isInteger;
+exports["default"] = _default;

package/lib/isInteger32.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _toInteger = _interopRequireDefault(require("./toInteger32"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks whether the passed value is a signed 32 bit integer.
+ *
+ * @func isInteger32
+ * @aliases isInt32
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.32.0|v2.32.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.toInteger32|toInteger32}
+ * @example
+ *
+ * RA.isInteger32(0); //=> true
+ * RA.isInteger32((-2) ** 31); //=> true
+ *
+ * RA.isInteger32(Infinity); //=> false
+ * RA.isInteger32(NaN); //=> false
+ * RA.isInteger32(2 ** 31); //=> false
+ */
+var isInteger32 = (0, _ramda.curryN)(1, function (val) {
+  return (0, _toInteger["default"])(val) === val;
+});
+var _default = isInteger32;
+exports["default"] = _default;

package/lib/isIterable.js

@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks whether the passed value is iterable.
+ *
+ * @func isIterable
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.18.0|v2.18.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol}
+ * @return {boolean}
+ * @example
+ *
+ * RA.isIterable(['arrays', 'are', 'iterable']); //=> true
+ * RA.isIterable('strings are iterable, too'); //=> true
+ * RA.isIterable((function* () {})()); //=> true (generator objects are both iterable and iterators)
+ *
+ * RA.isIterable({}); //=> false
+ * RA.isIterable(-0); //=> false
+ * RA.isIterable(null); //=> false
+ * RA.isIterable(undefined); //=> false
+ */
+var isIterable = (0, _ramda.curryN)(1, function (val) {
+  if (typeof Symbol === 'undefined') {
+    return false;
+  }
+
+  return (0, _ramda.hasIn)(Symbol.iterator, Object(val)) && (0, _isFunction["default"])(val[Symbol.iterator]);
+});
+var _default = isIterable;
+exports["default"] = _default;

package/lib/isMap.js

@@ -0,0 +1,29 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Predicate for determining if a provided value is an instance of a Map.
+ *
+ * @func isMap
+ * @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.isSet|isSet}}
+ * @example
+ *
+ * RA.isMap(new Map()); //=> true
+ * RA.isMap(new Map([[1, 2], [2, 1]])); //=> true
+ * RA.isSet(new Set()); //=> false
+ * RA.isSet(new Set([1,2]); //=> false
+ * RA.isSet(new Object()); //=> false
+ */
+var isMap = (0, _ramda.curryN)(1, (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('Map')));
+var _default = isMap;
+exports["default"] = _default;

package/lib/isNaN.js

@@ -0,0 +1,54 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.isNaNPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+var _Number = _interopRequireDefault(require("./internal/ponyfills/Number.isNaN"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var isNaNPonyfill = (0, _ramda.curryN)(1, _Number["default"]);
+/**
+ * Checks whether the passed value is `NaN` and its type is `Number`.
+ * It is a more robust version of the original, global isNaN().
+ *
+ *
+ * @func isNaN
+ * @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.isNotNaN|isNotNaN}
+ * @example
+ *
+ * RA.isNaN(NaN); // => true
+ * RA.isNaN(Number.NaN); // => true
+ * RA.isNaN(0 / 0); // => true
+ *
+ * // e.g. these would have been true with global isNaN().
+ * RA.isNaN('NaN'); // => false
+ * RA.isNaN(undefined); // => false
+ * RA.isNaN({}); // => false
+ * RA.isNaN('blabla'); // => false
+ *
+ * RA.isNaN(true); // => false
+ * RA.isNaN(null); // => false
+ * RA.isNaN(37); // => false
+ * RA.isNaN('37'); // => false
+ * RA.isNaN('37.37'); // => false
+ * RA.isNaN(''); // => false
+ * RA.isNaN(' '); // => false
+ */
+
+exports.isNaNPonyfill = isNaNPonyfill;
+
+var _isNaN = (0, _isFunction["default"])(Number.isNaN) ? (0, _ramda.curryN)(1, Number.isNaN) : isNaNPonyfill;
+
+var _default = _isNaN;
+exports["default"] = _default;

package/lib/isNaturalNumber.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isInteger = _interopRequireDefault(require("./isInteger"));
+
+var _isNegative = _interopRequireDefault(require("./isNegative"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is a natural number.
+ * Natural numbers correspond to all non-negative integers and 0.
+ *
+ * @func isNaturalNumber
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @example
+ *
+ * RA.isNaturalNumber(5); // => true
+ * RA.isNaturalNumber(Number.MAX_VALUE); // => true
+ * RA.isNaturalNumber(0); // => true
+ * RA.isNaturalNumber(-1); // => false
+ * RA.isNaturalNumber(0.9); // => false
+ */
+var isNaturalNumber = (0, _ramda.curryN)(1, (0, _ramda.both)(_isInteger["default"], (0, _ramda.complement)(_isNegative["default"])));
+var _default = isNaturalNumber;
+exports["default"] = _default;

package/lib/isNegative.js

@@ -0,0 +1,34 @@
+"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 negative `Number` primitive or object. Zero is not considered neither
+ * positive or negative.
+ *
+ * @func isNegative
+ * @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.isPositive|isPositive}
+ * @example
+ *
+ * RA.isNegative(-1); // => true
+ * RA.isNegative(Number.MIN_VALUE); // => false
+ * RA.isNegative(+Infinity); // => false
+ * RA.isNegative(NaN); // => false
+ * RA.isNegative('5'); // => false
+ */
+var isNegative = (0, _ramda.curryN)(1, (0, _ramda.both)(_isNumber["default"], (0, _ramda.gt)(0)));
+var _default = isNegative;
+exports["default"] = _default;

package/lib/isNegativeZero.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if value is a negative zero (-0).
+ *
+ * @func isNegativeZero
+ * @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 @see {@link RA.isPositiveZero|isPositiveZero}
+ * @example
+ *
+ * RA.isNegativeZero(-0); //=> true
+ * RA.isNegativeZero(+0); //=> false
+ * RA.isNegativeZero(0); //=> false
+ * RA.isNegativeZero(null); //=> false
+ */
+var isNegativeZero = (0, _ramda.identical)(-0);
+var _default = isNegativeZero;
+exports["default"] = _default;

package/lib/isNilOrEmpty.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns `true` if the given value is its type's empty value, `null` or `undefined`.
+ *
+ * @func isNilOrEmpty
+ * @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 http://ramdajs.com/docs/#isEmpty|R.isEmpty}, {@link http://ramdajs.com/docs/#isNil|R.isNil}
+ * @example
+ *
+ * RA.isNilOrEmpty([1, 2, 3]); //=> false
+ * RA.isNilOrEmpty([]); //=> true
+ * RA.isNilOrEmpty(''); //=> true
+ * RA.isNilOrEmpty(null); //=> true
+ * RA.isNilOrEmpty(undefined): //=> true
+ * RA.isNilOrEmpty({}); //=> true
+ * RA.isNilOrEmpty({length: 0}); //=> false
+ */
+var isNilOrEmpty = (0, _ramda.curryN)(1, (0, _ramda.either)(_ramda.isNil, _ramda.isEmpty));
+var _default = isNilOrEmpty;
+exports["default"] = _default;

package/lib/isNonEmptyArray.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNotEmpty = _interopRequireDefault(require("./isNotEmpty"));
+
+var _isArray = _interopRequireDefault(require("./isArray"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is not an empty `Array`.
+ *
+ * @func isNonEmptyArray
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.4.0|v2.4.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isEmptyArray|isEmptyArray}
+ * @example
+ *
+ * RA.isNonEmptyArray([42]); // => true
+ * RA.isNonEmptyArray([]); // => false
+ * RA.isNonEmptyArray({}); // => false
+ * RA.isNonEmptyArray(null); // => false
+ * RA.isNonEmptyArray(undefined); // => false
+ * RA.isNonEmptyArray(42); // => false
+ * RA.isNonEmptyArray('42'); // => false
+ */
+var isNonEmptyArray = (0, _ramda.both)(_isArray["default"], _isNotEmpty["default"]);
+var _default = isNonEmptyArray;
+exports["default"] = _default;

package/lib/isNonEmptyString.js

@@ -0,0 +1,41 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isString = _interopRequireDefault(require("./isString"));
+
+var _isNotObj = _interopRequireDefault(require("./isNotObj"));
+
+var _isNotEmpty = _interopRequireDefault(require("./isNotEmpty"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is not an empty `String`.
+ *
+ * @func isNonEmptyString
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.4.0|v2.4.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isEmptyString|isEmptyString}
+ * @example
+ *
+ * RA.isNonEmptyString('42'); // => true
+ * RA.isNonEmptyString(''); // => false
+ * RA.isNonEmptyString(new String('42')); // => false
+ * RA.isNonEmptyString(new String('')); // => false
+ * RA.isNonEmptyString([42]); // => false
+ * RA.isNonEmptyString({}); // => false
+ * RA.isNonEmptyString(null); // => false
+ * RA.isNonEmptyString(undefined); // => false
+ * RA.isNonEmptyString(42); // => false
+ */
+var isNonEmptyString = (0, _ramda.allPass)([_isString["default"], _isNotObj["default"], _isNotEmpty["default"]]);
+var _default = isNonEmptyString;
+exports["default"] = _default;

package/lib/isNonNegative.js

@@ -0,0 +1,37 @@
+"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 non-negative `Number` primitive or object. This includes all positive
+ * numbers and zero.
+ *
+ * @func isNonNegative
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isPositive|isPositive}, {@link RA.isNonPositive|isNonPositive}
+ * @example
+ *
+ * RA.isNonNegative(0); // => true
+ * RA.isNonNegative(1); // => true
+ * RA.isNonNegative(Infinity); // => true
+ * RA.isNonNegative(Number.MAX_VALUE); // => true
+ *
+ * RA.isNonNegative(-Infinity); // => false
+ * RA.isNonNegative(Number.MIN_VALUE); // => false
+ * RA.isNonNegative(NaN); // => false
+ */
+var isNonNegative = (0, _ramda.curryN)(1, (0, _ramda.both)(_isNumber["default"], (0, _ramda.flip)(_ramda.gte)(0)));
+var _default = isNonNegative;
+exports["default"] = _default;

package/lib/isNonPositive.js

@@ -0,0 +1,37 @@
+"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 non-positive `Number` primitive or object. This includes all negative
+ * numbers and zero.
+ *
+ * @func isNonPositive
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNegative|isNegative}, {@link RA.isNonNegative|isNonNegative}
+ * @example
+ *
+ * RA.isNonPositive(0); // => true
+ * RA.isNonPositive(-1); // => true
+ * RA.isNonPositive(-Infinity); // => true
+ * RA.isNonPositive(Number.MIN_VALUE); // => true
+ *
+ * RA.isNonPositive(Infinity); // => false
+ * RA.isNonPositive(Number.MAX_VALUE); // => false
+ * RA.isNonPositive(NaN); // => false
+ */
+var isNonPositive = (0, _ramda.curryN)(1, (0, _ramda.both)(_isNumber["default"], (0, _ramda.flip)(_ramda.lte)(0)));
+var _default = isNonPositive;
+exports["default"] = _default;

package/lib/isNotArray.js

@@ -0,0 +1,31 @@
+"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 complement of `Array`
+ *
+ * @func isNotArray
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.3.0|v0.3.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isArray|isArray}
+ * @example
+ *
+ * RA.isNotArray([]); //=> false
+ * RA.isNotArray(null); //=> true
+ * RA.isNotArray({}); //=> true
+ */
+var isNotArray = (0, _ramda.complement)(_isArray["default"]);
+var _default = isNotArray;
+exports["default"] = _default;

package/lib/isNotArrayLike.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isArrayLike = _interopRequireDefault(require("./isArrayLike"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Tests whether or not an object is similar to an array.
+ *
+ * @func isNotArrayLike
+ * @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.isArrayLike|isArrayLike}
+ * @example
+ *
+ * RA.isNotArrayLike([]); //=> false
+ * RA.isNotArrayLike(true); //=> true
+ * RA.isNotArrayLike({}); //=> true
+ * RA.isNotArrayLike({length: 10}); //=> true
+ * RA.isNotArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> false
+ */
+var isNotArrayLike = (0, _ramda.complement)(_isArrayLike["default"]);
+var _default = isNotArrayLike;
+exports["default"] = _default;

package/lib/isNotAsyncFunction.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isAsyncFunction = _interopRequireDefault(require("./isAsyncFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/* eslint-disable max-len */
+
+/**
+ * Checks if input value is complement of `Async Function`
+ *
+ * @func isNotAsyncFunction
+ * @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.isFunction|isFunction}, {@link RA.isAsyncFunction|isAsyncFunction}, {@link RA.isGeneratorFunction|isGeneratorFunction}
+ * @example
+ *
+ * RA.isNotAsyncFunction(async function test() { }); //=> false
+ * RA.isNotAsyncFunction(null); //=> true
+ * RA.isNotAsyncFunction(function test() { }); //=> true
+ * RA.isNotAsyncFunction(() => {}); //=> true
+ */
+
+/* eslint-enable max-len */
+var isNotAsyncFunction = (0, _ramda.complement)(_isAsyncFunction["default"]);
+var _default = isNotAsyncFunction;
+exports["default"] = _default;

package/lib/isNotBoolean.js

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