ramda-adjunct 2.34.0

package/es/isNotMap.js

@@ -0,0 +1,24 @@
+import { complement } from 'ramda';
+import isMap from './isMap';
+/**
+ * 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 = complement(isMap);
+export default isNotMap;

package/es/isNotNaN.js

@@ -0,0 +1,35 @@
+import { complement } from 'ramda';
+import _isNaN from './isNaN';
+/**
+ * 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 = complement(_isNaN);
+export default isNotNaN;

package/es/isNotNil.js

@@ -0,0 +1,22 @@
+import { isNil, complement } from '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 = complement(isNil);
+export default isNotNil;

package/es/isNotNilOrEmpty.js

@@ -0,0 +1,26 @@
+import { complement } from 'ramda';
+import isNilOrEmpty from './isNilOrEmpty';
+/**
+ * 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 = complement(isNilOrEmpty);
+export default isNotNilOrEmpty;

package/es/isNotNull.js

@@ -0,0 +1,22 @@
+import { complement } from 'ramda';
+import isNull from './isNull';
+/**
+ * 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 = complement(isNull);
+export default isNotNull;

package/es/isNotNumber.js

@@ -0,0 +1,23 @@
+import { complement } from 'ramda';
+import isNumber from './isNumber';
+/**
+ * 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 = complement(isNumber);
+export default isNotNumber;

package/es/isNotObj.js

@@ -0,0 +1,29 @@
+import { complement } from 'ramda';
+import isObj from './isObj';
+/* 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 = complement(isObj);
+export default isNotObj;

package/es/isNotObjLike.js

@@ -0,0 +1,29 @@
+import { complement } from 'ramda';
+import isObjLike from './isObjLike';
+/* 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 = complement(isObjLike);
+export default isNotObjLike;

package/es/isNotPair.js

@@ -0,0 +1,25 @@
+import { complement } from 'ramda';
+import isPair from './isPair';
+/**
+ * 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 = complement(isPair);
+export default isNotPair;

package/es/isNotPlainObj.js

@@ -0,0 +1,35 @@
+import { complement } from 'ramda';
+import isPlainObj from './isPlainObj';
+/* 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 = complement(isPlainObj);
+export default isNotPlainObj;

package/es/isNotPrimitive.js

@@ -0,0 +1,22 @@
+import { complement, curryN } from 'ramda';
+import isPrimitive from './isPrimitive';
+/**
+ * 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 = curryN(1, complement(isPrimitive));
+export default isNotPrimitive;

package/es/isNotRegExp.js

@@ -0,0 +1,22 @@
+import { complement } from 'ramda';
+import isRegExp from './isRegExp';
+/**
+ * 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 = complement(isRegExp);
+export default isNotRegExp;

package/es/isNotSet.js

@@ -0,0 +1,23 @@
+import { complement } from 'ramda';
+import isSet from './isSet';
+/**
+ * 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 = complement(isSet);
+export default isNotSet;

package/es/isNotString.js

@@ -0,0 +1,21 @@
+import { complement } from 'ramda';
+import isString from './isString';
+/**
+ * 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 = complement(isString);
+export default isNotString;

package/es/isNotUndefined.js

@@ -0,0 +1,22 @@
+import { complement } from 'ramda';
+import isUndefined from './isUndefined';
+/**
+ * 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 = complement(isUndefined);
+export default isNotUndefined;

package/es/isNotValidDate.js

@@ -0,0 +1,22 @@
+import { complement } from 'ramda';
+import isValidDate from './isValidDate';
+/**
+ * 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 = complement(isValidDate);
+export default isNotValidDate;

package/es/isNotValidNumber.js

@@ -0,0 +1,25 @@
+import { complement } from 'ramda';
+import isValidNumber from './isValidNumber';
+/**
+ * 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 = complement(isValidNumber);
+export default isNotValidNumber;

package/es/isNull.js

@@ -0,0 +1,21 @@
+import { equals } from '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 = equals(null);
+export default isNull;

package/es/isNumber.js

@@ -0,0 +1,23 @@
+import { curryN, pipe, type, identical } from '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 = curryN(1, pipe(type, identical('Number')));
+export default isNumber;

package/es/isObj.js

@@ -0,0 +1,31 @@
+import { both, either, curryN } from 'ramda';
+import isNotNull from './isNotNull';
+import isFunction from './isFunction';
+import isOfTypeObject from './internal/isOfTypeObject';
+/* 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 = curryN(1, both(isNotNull, either(isOfTypeObject, isFunction)));
+export default isObj;

package/es/isObjLike.js

@@ -0,0 +1,30 @@
+import { both, curryN } from 'ramda';
+import isNotNull from './isNotNull';
+import isOfTypeObject from './internal/isOfTypeObject';
+/* 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 = curryN(1, both(isNotNull, isOfTypeObject));
+export default isObjLike;

package/es/isOdd.js

@@ -0,0 +1,24 @@
+import { both, pipe, modulo, flip, equals, complement, curryN } from 'ramda';
+import isInteger from './isInteger';
+/**
+ * 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 = curryN(1, both(isInteger, pipe(flip(modulo)(2), complement(equals)(0))));
+export default isOdd;

package/es/isPair.js

@@ -0,0 +1,25 @@
+import { both, equals, length, pipe, curryN } from 'ramda';
+import isArray from './isArray';
+/**
+ * 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 = curryN(1, both(isArray, pipe(length, equals(2))));
+export default isPair;

package/es/isPlainObj.js

@@ -0,0 +1,52 @@
+import { pipe, type, identical, both, equals, toString, pathSatisfies, curryN } from 'ramda';
+import isNull from './isNull';
+import isObjLike from './isObjLike';
+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 */
+
+/**
+ * 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 = 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;