text: "use strict";
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  /**!
   * 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 isActualNaN(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 === "undefined" ? "undefined" : _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);
  };