/HServer/00.Server/00.Program/node_modules/is/index.js - HORIZON PROJECT - 파모즈 프로젝트 관리 페이지

통계

root / HServer / 00.Server / 00.Program / node_modules / is / index.js

이력 | 보기 | 이력해설 | 다운로드 (14.8 KB)

       /**!
        * is
        * the definitive JavaScript type testing library
+       *
        * @copyright 2013 Enrico Marino
        * @license MIT
        */
       var objProto = Object.prototype;
       var owns = objProto.hasOwnProperty;
       var toString = objProto.toString;
       var isActualNaN = function (value) {
         return value !== value;
       };
       var NON_HOST_TYPES = {
         "boolean": 1,
         "number": 1,
         "string": 1,
         "undefined": 1
       };
       /**
        * 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 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 = toString.call(value);
         var key;
         if ('[object Array]' === type || '[object Arguments]' === type) {
           return value.length === 0;
+        }
         if ('[object Object]' === type) {
           for (key in value) if (owns.call(value, key)) return false;
           return true;
+        }
         if ('[object String]' === type) {
           return '' === value;
+        }
         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 type = toString.call(value)
         var key;
         if (type !== toString.call(other)) {
           return false;
+        }
         if ('[object Object]' === type) {
           for (key in value) {
             if (!is.equal(value[key], other[key])) {
               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 value === other;
       };
       /**
        * 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.null
        * Test if `value` is null.
+       *
        * @param {Mixed} value value to test
        * @return {Boolean} true if `value` is null, false otherwise
        * @api public
        */
       is['null'] = function (value) {
         return value === null;
       };
       /**
        * 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.undefined = function (value) {
         return value === undefined;
       };
       /**
        * Test arguments.
        */
       /**
        * is.arguments
        * 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.arguments = function (value) {
         var isStandardArguments = '[object Arguments]' === toString.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]' === toString.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.arguments.empty = function (value) {
         return is.arguments(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]' === toString.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) && (value === false || value.valueOf() === 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) && (value === true || value.valueOf() === 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]' === toString.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]' === toString.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]' === toString.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]' === toString.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 value && '[object Object]' === toString.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]' === toString.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]' === toString.call(value);
       };