764 lines
16 KiB
JavaScript
764 lines
16 KiB
JavaScript
|
|
/**!
|
|
* is
|
|
* the definitive JavaScript type testing library
|
|
*
|
|
* @copyright 2013-2014 Enrico Marino / Jordan Harband
|
|
* @license MIT
|
|
*/
|
|
|
|
var objProto = Object.prototype;
|
|
var owns = objProto.hasOwnProperty;
|
|
var toStr = objProto.toString;
|
|
var symbolValueOf;
|
|
if (typeof Symbol === 'function') {
|
|
symbolValueOf = Symbol.prototype.valueOf;
|
|
}
|
|
var isActualNaN = function (value) {
|
|
return value !== value;
|
|
};
|
|
var NON_HOST_TYPES = {
|
|
boolean: 1,
|
|
number: 1,
|
|
string: 1,
|
|
undefined: 1
|
|
};
|
|
|
|
var base64Regex = /^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$/;
|
|
var hexRegex = /^[A-Fa-f0-9]+$/;
|
|
|
|
/**
|
|
* Expose `is`
|
|
*/
|
|
|
|
var is = module.exports = {};
|
|
|
|
/**
|
|
* Test general.
|
|
*/
|
|
|
|
/**
|
|
* is.type
|
|
* Test if `value` is a type of `type`.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @param {String} type type
|
|
* @return {Boolean} true if `value` is a type of `type`, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.a = is.type = function (value, type) {
|
|
return typeof value === type;
|
|
};
|
|
|
|
/**
|
|
* is.defined
|
|
* Test if `value` is defined.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if 'value' is defined, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.defined = function (value) {
|
|
return typeof value !== 'undefined';
|
|
};
|
|
|
|
/**
|
|
* is.empty
|
|
* Test if `value` is empty.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is empty, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.empty = function (value) {
|
|
var type = toStr.call(value);
|
|
var key;
|
|
|
|
if ('[object Array]' === type || '[object Arguments]' === type || '[object String]' === type) {
|
|
return value.length === 0;
|
|
}
|
|
|
|
if ('[object Object]' === type) {
|
|
for (key in value) {
|
|
if (owns.call(value, key)) { return false; }
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* is.equal
|
|
* Test if `value` is equal to `other`.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @param {Mixed} other value to compare with
|
|
* @return {Boolean} true if `value` is equal to `other`, false otherwise
|
|
*/
|
|
|
|
is.equal = function (value, other) {
|
|
var strictlyEqual = value === other;
|
|
if (strictlyEqual) {
|
|
return true;
|
|
}
|
|
|
|
var type = toStr.call(value);
|
|
var key;
|
|
|
|
if (type !== toStr.call(other)) {
|
|
return false;
|
|
}
|
|
|
|
if ('[object Object]' === type) {
|
|
for (key in value) {
|
|
if (!is.equal(value[key], other[key]) || !(key in other)) {
|
|
return false;
|
|
}
|
|
}
|
|
for (key in other) {
|
|
if (!is.equal(value[key], other[key]) || !(key in value)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if ('[object Array]' === type) {
|
|
key = value.length;
|
|
if (key !== other.length) {
|
|
return false;
|
|
}
|
|
while (--key) {
|
|
if (!is.equal(value[key], other[key])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if ('[object Function]' === type) {
|
|
return value.prototype === other.prototype;
|
|
}
|
|
|
|
if ('[object Date]' === type) {
|
|
return value.getTime() === other.getTime();
|
|
}
|
|
|
|
return strictlyEqual;
|
|
};
|
|
|
|
/**
|
|
* is.hosted
|
|
* Test if `value` is hosted by `host`.
|
|
*
|
|
* @param {Mixed} value to test
|
|
* @param {Mixed} host host to test with
|
|
* @return {Boolean} true if `value` is hosted by `host`, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.hosted = function (value, host) {
|
|
var type = typeof host[value];
|
|
return type === 'object' ? !!host[value] : !NON_HOST_TYPES[type];
|
|
};
|
|
|
|
/**
|
|
* is.instance
|
|
* Test if `value` is an instance of `constructor`.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is an instance of `constructor`
|
|
* @api public
|
|
*/
|
|
|
|
is.instance = is['instanceof'] = function (value, constructor) {
|
|
return value instanceof constructor;
|
|
};
|
|
|
|
/**
|
|
* is.nil / is.null
|
|
* Test if `value` is null.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is null, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.nil = is['null'] = function (value) {
|
|
return value === null;
|
|
};
|
|
|
|
/**
|
|
* is.undef / is.undefined
|
|
* Test if `value` is undefined.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is undefined, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.undef = is.undefined = function (value) {
|
|
return typeof value === 'undefined';
|
|
};
|
|
|
|
/**
|
|
* Test arguments.
|
|
*/
|
|
|
|
/**
|
|
* is.args
|
|
* Test if `value` is an arguments object.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is an arguments object, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.args = is.arguments = function (value) {
|
|
var isStandardArguments = '[object Arguments]' === toStr.call(value);
|
|
var isOldArguments = !is.array(value) && is.arraylike(value) && is.object(value) && is.fn(value.callee);
|
|
return isStandardArguments || isOldArguments;
|
|
};
|
|
|
|
/**
|
|
* Test array.
|
|
*/
|
|
|
|
/**
|
|
* is.array
|
|
* Test if 'value' is an array.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is an array, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.array = function (value) {
|
|
return '[object Array]' === toStr.call(value);
|
|
};
|
|
|
|
/**
|
|
* is.arguments.empty
|
|
* Test if `value` is an empty arguments object.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is an empty arguments object, false otherwise
|
|
* @api public
|
|
*/
|
|
is.args.empty = function (value) {
|
|
return is.args(value) && value.length === 0;
|
|
};
|
|
|
|
/**
|
|
* is.array.empty
|
|
* Test if `value` is an empty array.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is an empty array, false otherwise
|
|
* @api public
|
|
*/
|
|
is.array.empty = function (value) {
|
|
return is.array(value) && value.length === 0;
|
|
};
|
|
|
|
/**
|
|
* is.arraylike
|
|
* Test if `value` is an arraylike object.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is an arguments object, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.arraylike = function (value) {
|
|
return !!value && !is.boolean(value)
|
|
&& owns.call(value, 'length')
|
|
&& isFinite(value.length)
|
|
&& is.number(value.length)
|
|
&& value.length >= 0;
|
|
};
|
|
|
|
/**
|
|
* Test boolean.
|
|
*/
|
|
|
|
/**
|
|
* is.boolean
|
|
* Test if `value` is a boolean.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is a boolean, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.boolean = function (value) {
|
|
return '[object Boolean]' === toStr.call(value);
|
|
};
|
|
|
|
/**
|
|
* is.false
|
|
* Test if `value` is false.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is false, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is['false'] = function (value) {
|
|
return is.boolean(value) && Boolean(Number(value)) === false;
|
|
};
|
|
|
|
/**
|
|
* is.true
|
|
* Test if `value` is true.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is true, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is['true'] = function (value) {
|
|
return is.boolean(value) && Boolean(Number(value)) === true;
|
|
};
|
|
|
|
/**
|
|
* Test date.
|
|
*/
|
|
|
|
/**
|
|
* is.date
|
|
* Test if `value` is a date.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is a date, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.date = function (value) {
|
|
return '[object Date]' === toStr.call(value);
|
|
};
|
|
|
|
/**
|
|
* Test element.
|
|
*/
|
|
|
|
/**
|
|
* is.element
|
|
* Test if `value` is an html element.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is an HTML Element, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.element = function (value) {
|
|
return value !== undefined
|
|
&& typeof HTMLElement !== 'undefined'
|
|
&& value instanceof HTMLElement
|
|
&& value.nodeType === 1;
|
|
};
|
|
|
|
/**
|
|
* Test error.
|
|
*/
|
|
|
|
/**
|
|
* is.error
|
|
* Test if `value` is an error object.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is an error object, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.error = function (value) {
|
|
return '[object Error]' === toStr.call(value);
|
|
};
|
|
|
|
/**
|
|
* Test function.
|
|
*/
|
|
|
|
/**
|
|
* is.fn / is.function (deprecated)
|
|
* Test if `value` is a function.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is a function, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.fn = is['function'] = function (value) {
|
|
var isAlert = typeof window !== 'undefined' && value === window.alert;
|
|
return isAlert || '[object Function]' === toStr.call(value);
|
|
};
|
|
|
|
/**
|
|
* Test number.
|
|
*/
|
|
|
|
/**
|
|
* is.number
|
|
* Test if `value` is a number.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is a number, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.number = function (value) {
|
|
return '[object Number]' === toStr.call(value);
|
|
};
|
|
|
|
/**
|
|
* is.infinite
|
|
* Test if `value` is positive or negative infinity.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is positive or negative Infinity, false otherwise
|
|
* @api public
|
|
*/
|
|
is.infinite = function (value) {
|
|
return value === Infinity || value === -Infinity;
|
|
};
|
|
|
|
/**
|
|
* is.decimal
|
|
* Test if `value` is a decimal number.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is a decimal number, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.decimal = function (value) {
|
|
return is.number(value) && !isActualNaN(value) && !is.infinite(value) && value % 1 !== 0;
|
|
};
|
|
|
|
/**
|
|
* is.divisibleBy
|
|
* Test if `value` is divisible by `n`.
|
|
*
|
|
* @param {Number} value value to test
|
|
* @param {Number} n dividend
|
|
* @return {Boolean} true if `value` is divisible by `n`, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.divisibleBy = function (value, n) {
|
|
var isDividendInfinite = is.infinite(value);
|
|
var isDivisorInfinite = is.infinite(n);
|
|
var isNonZeroNumber = is.number(value) && !isActualNaN(value) && is.number(n) && !isActualNaN(n) && n !== 0;
|
|
return isDividendInfinite || isDivisorInfinite || (isNonZeroNumber && value % n === 0);
|
|
};
|
|
|
|
/**
|
|
* is.int
|
|
* Test if `value` is an integer.
|
|
*
|
|
* @param value to test
|
|
* @return {Boolean} true if `value` is an integer, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.int = function (value) {
|
|
return is.number(value) && !isActualNaN(value) && value % 1 === 0;
|
|
};
|
|
|
|
/**
|
|
* is.maximum
|
|
* Test if `value` is greater than 'others' values.
|
|
*
|
|
* @param {Number} value value to test
|
|
* @param {Array} others values to compare with
|
|
* @return {Boolean} true if `value` is greater than `others` values
|
|
* @api public
|
|
*/
|
|
|
|
is.maximum = function (value, others) {
|
|
if (isActualNaN(value)) {
|
|
throw new TypeError('NaN is not a valid value');
|
|
} else if (!is.arraylike(others)) {
|
|
throw new TypeError('second argument must be array-like');
|
|
}
|
|
var len = others.length;
|
|
|
|
while (--len >= 0) {
|
|
if (value < others[len]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* is.minimum
|
|
* Test if `value` is less than `others` values.
|
|
*
|
|
* @param {Number} value value to test
|
|
* @param {Array} others values to compare with
|
|
* @return {Boolean} true if `value` is less than `others` values
|
|
* @api public
|
|
*/
|
|
|
|
is.minimum = function (value, others) {
|
|
if (isActualNaN(value)) {
|
|
throw new TypeError('NaN is not a valid value');
|
|
} else if (!is.arraylike(others)) {
|
|
throw new TypeError('second argument must be array-like');
|
|
}
|
|
var len = others.length;
|
|
|
|
while (--len >= 0) {
|
|
if (value > others[len]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* is.nan
|
|
* Test if `value` is not a number.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is not a number, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.nan = function (value) {
|
|
return !is.number(value) || value !== value;
|
|
};
|
|
|
|
/**
|
|
* is.even
|
|
* Test if `value` is an even number.
|
|
*
|
|
* @param {Number} value value to test
|
|
* @return {Boolean} true if `value` is an even number, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.even = function (value) {
|
|
return is.infinite(value) || (is.number(value) && value === value && value % 2 === 0);
|
|
};
|
|
|
|
/**
|
|
* is.odd
|
|
* Test if `value` is an odd number.
|
|
*
|
|
* @param {Number} value value to test
|
|
* @return {Boolean} true if `value` is an odd number, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.odd = function (value) {
|
|
return is.infinite(value) || (is.number(value) && value === value && value % 2 !== 0);
|
|
};
|
|
|
|
/**
|
|
* is.ge
|
|
* Test if `value` is greater than or equal to `other`.
|
|
*
|
|
* @param {Number} value value to test
|
|
* @param {Number} other value to compare with
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
is.ge = function (value, other) {
|
|
if (isActualNaN(value) || isActualNaN(other)) {
|
|
throw new TypeError('NaN is not a valid value');
|
|
}
|
|
return !is.infinite(value) && !is.infinite(other) && value >= other;
|
|
};
|
|
|
|
/**
|
|
* is.gt
|
|
* Test if `value` is greater than `other`.
|
|
*
|
|
* @param {Number} value value to test
|
|
* @param {Number} other value to compare with
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
is.gt = function (value, other) {
|
|
if (isActualNaN(value) || isActualNaN(other)) {
|
|
throw new TypeError('NaN is not a valid value');
|
|
}
|
|
return !is.infinite(value) && !is.infinite(other) && value > other;
|
|
};
|
|
|
|
/**
|
|
* is.le
|
|
* Test if `value` is less than or equal to `other`.
|
|
*
|
|
* @param {Number} value value to test
|
|
* @param {Number} other value to compare with
|
|
* @return {Boolean} if 'value' is less than or equal to 'other'
|
|
* @api public
|
|
*/
|
|
|
|
is.le = function (value, other) {
|
|
if (isActualNaN(value) || isActualNaN(other)) {
|
|
throw new TypeError('NaN is not a valid value');
|
|
}
|
|
return !is.infinite(value) && !is.infinite(other) && value <= other;
|
|
};
|
|
|
|
/**
|
|
* is.lt
|
|
* Test if `value` is less than `other`.
|
|
*
|
|
* @param {Number} value value to test
|
|
* @param {Number} other value to compare with
|
|
* @return {Boolean} if `value` is less than `other`
|
|
* @api public
|
|
*/
|
|
|
|
is.lt = function (value, other) {
|
|
if (isActualNaN(value) || isActualNaN(other)) {
|
|
throw new TypeError('NaN is not a valid value');
|
|
}
|
|
return !is.infinite(value) && !is.infinite(other) && value < other;
|
|
};
|
|
|
|
/**
|
|
* is.within
|
|
* Test if `value` is within `start` and `finish`.
|
|
*
|
|
* @param {Number} value value to test
|
|
* @param {Number} start lower bound
|
|
* @param {Number} finish upper bound
|
|
* @return {Boolean} true if 'value' is is within 'start' and 'finish'
|
|
* @api public
|
|
*/
|
|
is.within = function (value, start, finish) {
|
|
if (isActualNaN(value) || isActualNaN(start) || isActualNaN(finish)) {
|
|
throw new TypeError('NaN is not a valid value');
|
|
} else if (!is.number(value) || !is.number(start) || !is.number(finish)) {
|
|
throw new TypeError('all arguments must be numbers');
|
|
}
|
|
var isAnyInfinite = is.infinite(value) || is.infinite(start) || is.infinite(finish);
|
|
return isAnyInfinite || (value >= start && value <= finish);
|
|
};
|
|
|
|
/**
|
|
* Test object.
|
|
*/
|
|
|
|
/**
|
|
* is.object
|
|
* Test if `value` is an object.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is an object, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.object = function (value) {
|
|
return '[object Object]' === toStr.call(value);
|
|
};
|
|
|
|
/**
|
|
* is.hash
|
|
* Test if `value` is a hash - a plain object literal.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is a hash, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.hash = function (value) {
|
|
return is.object(value) && value.constructor === Object && !value.nodeType && !value.setInterval;
|
|
};
|
|
|
|
/**
|
|
* Test regexp.
|
|
*/
|
|
|
|
/**
|
|
* is.regexp
|
|
* Test if `value` is a regular expression.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is a regexp, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.regexp = function (value) {
|
|
return '[object RegExp]' === toStr.call(value);
|
|
};
|
|
|
|
/**
|
|
* Test string.
|
|
*/
|
|
|
|
/**
|
|
* is.string
|
|
* Test if `value` is a string.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if 'value' is a string, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.string = function (value) {
|
|
return '[object String]' === toStr.call(value);
|
|
};
|
|
|
|
/**
|
|
* Test base64 string.
|
|
*/
|
|
|
|
/**
|
|
* is.base64
|
|
* Test if `value` is a valid base64 encoded string.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if 'value' is a base64 encoded string, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.base64 = function (value) {
|
|
return is.string(value) && (!value.length || base64Regex.test(value));
|
|
};
|
|
|
|
/**
|
|
* Test base64 string.
|
|
*/
|
|
|
|
/**
|
|
* is.hex
|
|
* Test if `value` is a valid hex encoded string.
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if 'value' is a hex encoded string, false otherwise
|
|
* @api public
|
|
*/
|
|
|
|
is.hex = function (value) {
|
|
return is.string(value) && (!value.length || hexRegex.test(value));
|
|
};
|
|
|
|
/**
|
|
* is.symbol
|
|
* Test if `value` is an ES6 Symbol
|
|
*
|
|
* @param {Mixed} value value to test
|
|
* @return {Boolean} true if `value` is a Symbol, false otherise
|
|
* @api public
|
|
*/
|
|
|
|
is.symbol = function (value) {
|
|
return typeof Symbol === 'function' && toStr.call(value) === '[object Symbol]' && typeof symbolValueOf.call(value) === 'symbol';
|
|
};
|
|
|