ramda-adjunct 2.34.0

package/lib/isNotDate.js

@@ -0,0 +1,30 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isDate = _interopRequireDefault(require("./isDate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is complement of `Date` object.
+ *
+ * @func isNotDate
+ * @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.isDate|isDate}
+ * @example
+ *
+ * RA.isNotDate(new Date()); //=> false
+ * RA.isNotDate('1997-07-16T19:20+01:00'); //=> true
+ */
+var isNotDate = (0, _ramda.complement)(_isDate["default"]);
+var _default = isNotDate;
+exports["default"] = _default;

package/lib/isNotEmpty.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 not its type's empty value; `false` otherwise.
+ *
+ * @func isNotEmpty
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.4.0|v0.4.0}
+ * @category Logic
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link http://ramdajs.com/docs/#isEmpty|R.isEmpty}
+ * @example
+ *
+ * RA.isNotEmpty([1, 2, 3]); //=> true
+ * RA.isNotEmpty([]); //=> false
+ * RA.isNotEmpty(''); //=> false
+ * RA.isNotEmpty(null); //=> true
+ * RA.isNotEmpty(undefined): //=> true
+ * RA.isNotEmpty({}); //=> false
+ * RA.isNotEmpty({length: 0}); //=> true
+ */
+var isNotEmpty = (0, _ramda.complement)(_ramda.isEmpty);
+var _default = isNotEmpty;
+exports["default"] = _default;

package/lib/isNotFinite.js

@@ -0,0 +1,38 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isFinite2 = _interopRequireDefault(require("./isFinite"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks whether the passed value is complement of finite `Number`.
+ *
+ *
+ * @func isNotFinite
+ * @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.isFinite|isFinite}
+ * @example
+ *
+ * RA.isNotFinite(Infinity); //=> true
+ * RA.isNotFinite(NaN); //=> true
+ * RA.isNotFinite(-Infinity); //=> true
+ *
+ * RA.isNotFinite(0); // false
+ * RA.isNotFinite(2e64); // false
+ *
+ * RA.isNotFinite('0');  // => true
+ * RA.isNotFinite(null); // => true
+ */
+var isNotFinite = (0, _ramda.complement)(_isFinite2["default"]);
+var _default = isNotFinite;
+exports["default"] = _default;

package/lib/isNotFloat.js

@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isFloat = _interopRequireDefault(require("./isFloat"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks whether the passed value is complement of a `float`.
+ *
+ * @func isNotFloat
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.14.0|v1.14.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isFloat|isFloat}
+ * @example
+ *
+ * RA.isNotFloat(0); //=> true
+ * RA.isNotFloat(1); //=> true
+ * RA.isNotFloat(-100000); //=> true
+ *
+ * RA.isNotFloat(0.1);       //=> false
+ * RA.isNotFloat(Math.PI);   //=> false
+ *
+ * RA.isNotFloat(NaN);       //=> true
+ * RA.isNotFloat(Infinity);  //=> true
+ * RA.isNotFloat(-Infinity); //=> true
+ * RA.isNotFloat('10');      //=> true
+ * RA.isNotFloat(true);      //=> true
+ * RA.isNotFloat(false);     //=> true
+ * RA.isNotFloat([1]);       //=> true
+ */
+var isNotFloat = (0, _ramda.curryN)(1, (0, _ramda.complement)(_isFloat["default"]));
+var _default = isNotFloat;
+exports["default"] = _default;

package/lib/isNotFunction.js

@@ -0,0 +1,38 @@
+"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 }; }
+
+/* eslint-disable max-len */
+
+/**
+ * Checks if input value is complement of `Function`.
+ *
+ * @func isNotFunction
+ * @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|isNotAsyncFunction}, {@link RA.isGeneratorFunction|isGeneratorFunction}
+ * @example
+ *
+ * RA.isNotFunction(function test() { }); //=> false
+ * RA.isNotFunction(function* test() { }); //=> false
+ * RA.isNotFunction(async function test() { }); //=> false
+ * RA.isNotFunction(() => {}); //=> false
+ * RA.isNotFunction(null); //=> true
+ * RA.isNotFunction('abc'); //=> true
+ */
+
+/* eslint-enable max-len */
+var isNotFunction = (0, _ramda.complement)(_isFunction["default"]);
+var _default = isNotFunction;
+exports["default"] = _default;

package/lib/isNotGeneratorFunction.js

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

package/lib/isNotInteger.js

@@ -0,0 +1,43 @@
+"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 whether the passed value is complement of an `integer`.
+ *
+ *
+ * @func isNotInteger
+ * @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.isInteger|isInteger}
+ * @example
+ *
+ * RA.isNotInteger(0); //=> false
+ * RA.isNotInteger(1); //=> false
+ * RA.isNotInteger(-100000); //=> false
+ *
+ * RA.isNotInteger(0.1);       //=> true
+ * RA.isNotInteger(Math.PI);   //=> true
+ *
+ * RA.isNotInteger(NaN);       //=> true
+ * RA.isNotInteger(Infinity);  //=> true
+ * RA.isNotInteger(-Infinity); //=> true
+ * RA.isNotInteger('10');      //=> true
+ * RA.isNotInteger(true);      //=> true
+ * RA.isNotInteger(false);     //=> true
+ * RA.isNotInteger([1]);       //=> true
+ */
+var isNotInteger = (0, _ramda.complement)(_isInteger["default"]);
+var _default = isNotInteger;
+exports["default"] = _default;

package/lib/isNotMap.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isMap = _interopRequireDefault(require("./isMap"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is complement of `Map` object.
+ *
+ * @func isNotMap
+ * @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.isMap|isMap}
+ * @example
+ *
+ * RA.isNotMap(new Map()); //=> false
+ * RA.isNotMap(new Map([[1, 2], [2, 1]])); //=> false
+ * RA.isNotMap(new Set()); //=> true
+ * RA.isNotMap({}); //=> true
+ * RA.isNotMap(12); //=> true
+ */
+var isNotMap = (0, _ramda.complement)(_isMap["default"]);
+var _default = isNotMap;
+exports["default"] = _default;

package/lib/isNotNaN.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNaN2 = _interopRequireDefault(require("./isNaN"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks whether the passed value is complement of `NaN` and its type is not `Number`.
+ *
+ * @func isNotNaN
+ * @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.isNaN|isNaN}
+ * @example
+ *
+ * RA.isNotNaN(NaN); // => false
+ * RA.isNotNaN(Number.NaN); // => false
+ * RA.isNotNaN(0 / 0); // => false
+ *
+ * RA.isNotNaN('NaN'); // => true
+ * RA.isNotNaN(undefined); // => true
+ * RA.isNotNaN({}); // => true
+ * RA.isNotNaN('blabla'); // => true
+ *
+ * RA.isNotNaN(true); // => true
+ * RA.isNotNaN(null); // => true
+ * RA.isNotNaN(37); // => true
+ * RA.isNotNaN('37'); // => true
+ * RA.isNotNaN('37.37'); // => true
+ * RA.isNotNaN(''); // => true
+ * RA.isNotNaN(' '); // => true
+ */
+var isNotNaN = (0, _ramda.complement)(_isNaN2["default"]);
+var _default = isNotNaN;
+exports["default"] = _default;

package/lib/isNotNil.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if input value is complement of `null` or `undefined`.
+ *
+ * @func isNotNil
+ * @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 http://ramdajs.com/docs/#isNil|R.isNil}
+ * @example
+ *
+ * RA.isNotNil(null); //=> false
+ * RA.isNotNil(undefined); //=> false
+ * RA.isNotNil(0); //=> true
+ * RA.isNotNil([]); //=> true
+ */
+var isNotNil = (0, _ramda.complement)(_ramda.isNil);
+var _default = isNotNil;
+exports["default"] = _default;

package/lib/isNotNilOrEmpty.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNilOrEmpty = _interopRequireDefault(require("./isNilOrEmpty"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns `true` if the given value is its type's empty value, `null` or `undefined`.
+ *
+ * @func isNotNilOrEmpty
+ * @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
+ * @return {boolean}
+ * @see {@link RA.isNilOrEmpty|isNilOrEmpty}
+ * @example
+ *
+ * RA.isNotNilOrEmpty([1, 2, 3]); //=> true
+ * RA.isNotNilOrEmpty([]); //=> false
+ * RA.isNotNilOrEmpty(''); //=> false
+ * RA.isNotNilOrEmpty(null); //=> false
+ * RA.isNotNilOrEmpty(undefined): //=> false
+ * RA.isNotNilOrEmpty({}); //=> false
+ * RA.isNotNilOrEmpty({length: 0}); //=> true
+ */
+var isNotNilOrEmpty = (0, _ramda.complement)(_isNilOrEmpty["default"]);
+var _default = isNotNilOrEmpty;
+exports["default"] = _default;

package/lib/isNotNull.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNull = _interopRequireDefault(require("./isNull"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is complement of `null`.
+ *
+ * @func isNotNull
+ * @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.isNull|isNull}
+ * @example
+ *
+ * RA.isNotNull(1); //=> true
+ * RA.isNotNull(undefined); //=> true
+ * RA.isNotNull(null); //=> false
+ */
+var isNotNull = (0, _ramda.complement)(_isNull["default"]);
+var _default = isNotNull;
+exports["default"] = _default;

package/lib/isNotNumber.js

@@ -0,0 +1,32 @@
+"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 complement of `Number` primitive or object.
+ *
+ * @func isNotNumber
+ * @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.isNumber|isNumber}
+ * @example
+ *
+ * RA.isNotNumber(5); // => false
+ * RA.isNotNumber(Number.MAX_VALUE); // => false
+ * RA.isNotNumber(-Infinity); // => false
+ * RA.isNotNumber('5'); // => true
+ */
+var isNotNumber = (0, _ramda.complement)(_isNumber["default"]);
+var _default = isNotNumber;
+exports["default"] = _default;

package/lib/isNotObj.js

@@ -0,0 +1,38 @@
+"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 }; }
+
+/* eslint-disable max-len */
+
+/**
+ * Checks if input value is complement of language type of `Object`.
+ *
+ * @func isNotObj
+ * @aliases isNotObject
+ * @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.isObj|isObj}, {@link RA.isObjLike|isObjLike}, {@link RA.isPlainObj|isPlainObj}
+ * @example
+ *
+ * RA.isNotObj({}); //=> false
+ * RA.isNotObj([]); //=> false
+ * RA.isNotObj(() => {}); //=> false
+ * RA.isNotObj(null); //=> true
+ * RA.isNotObj(undefined); //=> true
+ */
+
+/* eslint-enable max-len */
+var isNotObj = (0, _ramda.complement)(_isObj["default"]);
+var _default = isNotObj;
+exports["default"] = _default;

package/lib/isNotObjLike.js

@@ -0,0 +1,38 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isObjLike = _interopRequireDefault(require("./isObjLike"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/* eslint-disable max-len */
+
+/**
+ * Checks if value is not object-like. A value is object-like if it's not null and has a typeof result of "object".
+ *
+ * @func isNotObjLike
+ * @aliases isNotObjectLike
+ * @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.isObjLike|isObjLike}, {@link RA.isObj|isObj}, {@link RA.isPlainObj|isPlainObj}
+ * @example
+ *
+ * RA.isNotObjLike({}); //=> false
+ * RA.isNotObjLike([]); //=> false
+ * RA.isNotObjLike(() => {}); //=> true
+ * RA.isNotObjLike(null); //=> true
+ * RA.isNotObjLike(undefined); //=> true
+ */
+
+/* eslint-enable max-len */
+var isNotObjLike = (0, _ramda.complement)(_isObjLike["default"]);
+var _default = isNotObjLike;
+exports["default"] = _default;

package/lib/isNotPair.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isPair = _interopRequireDefault(require("./isPair"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is complement of a pair.
+ *
+ * @func isNotPair
+ * @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.isPair|isPair}
+ * @example
+ *
+ * RA.isNotPair([]); // => true
+ * RA.isNotPair([0]); // => true
+ * RA.isNotPair([0, 1]); // => false
+ * RA.isNotPair([0, 1, 2]); // => true
+ * RA.isNotPair({0: 0, 1: 1}); // => true
+ * RA.isNotPair({foo: 0, bar: 0}); // => true
+ */
+var isNotPair = (0, _ramda.complement)(_isPair["default"]);
+var _default = isNotPair;
+exports["default"] = _default;

package/lib/isNotPlainObj.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isPlainObj = _interopRequireDefault(require("./isPlainObj"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/* eslint-disable max-len */
+
+/**
+ * Check to see if an object is a not plain object (created using `{}`, `new Object()` or `Object.create(null)`).
+ *
+ * @func isNotPlainObj
+ * @aliases isNotPlainObject
+ * @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.isPlainObj|isPlainObj}, {@link RA.isObjLike|isObjLike}, {@link RA.isObj|isObj}
+ * @example
+ *
+ * class Bar {
+ *   constructor() {
+ *     this.prop = 'value';
+ *   }
+ * }
+ *
+ * RA.isNotPlainObj(new Bar()); //=> true
+ * RA.isNotPlainObj({ prop: 'value' }); //=> false
+ * RA.isNotPlainObj(['a', 'b', 'c']); //=> true
+ * RA.isNotPlainObj(Object.create(null); //=> false
+ * RA.isNotPlainObj(new Object()); //=> false
+ */
+
+/* eslint-enable max-len */
+var isNotPlainObj = (0, _ramda.complement)(_isPlainObj["default"]);
+var _default = isNotPlainObj;
+exports["default"] = _default;

package/lib/isNotPrimitive.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isPrimitive = _interopRequireDefault(require("./isPrimitive"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is not a primitive data type. There are 6 primitive data types: `string`, `number`, `bigint`, `boolean`, `undefined`, `symbol` and a special case of `null`.
+ *
+ * @func isNotPrimitive
+ * @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.isPrimitive|isPrimitive}, {@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.isNotPrimitive(new String("string")); //=> true
+ * RA.isNotPrimitive(new Number(1)); //=> true
+ * RA.isNotPrimitive("string"); //=> false
+ * RA.isNotPrimitive(1); //=> false
+ */
+var isNotPrimitive = (0, _ramda.curryN)(1, (0, _ramda.complement)(_isPrimitive["default"]));
+var _default = isNotPrimitive;
+exports["default"] = _default;