text: 'use strict';
  
  var util = require('util');
  var union = require('arr-union');
  var define = require('define-property');
  var staticExtend = require('static-extend');
  var isObj = require('isobject');
  
  /**
   * Expose class utils
   */
  
  var cu = module.exports;
  
  /**
   * Expose class utils: `cu`
   */
  
  cu.isObject = function isObject(val) {
    return isObj(val) || typeof val === 'function';
  };
  
  /**
   * Returns true if an array has any of the given elements, or an
   * object has any of the give keys.
   *
   * ```js
   * cu.has(['a', 'b', 'c'], 'c');
   * //=> true
   *
   * cu.has(['a', 'b', 'c'], ['c', 'z']);
   * //=> true
   *
   * cu.has({a: 'b', c: 'd'}, ['c', 'z']);
   * //=> true
   * ```
   * @param {Object} `obj`
   * @param {String|Array} `val`
   * @return {Boolean}
   * @api public
   */
  
  cu.has = function has(obj, val) {
    val = cu.arrayify(val);
    var len = val.length;
  
    if (cu.isObject(obj)) {
      for (var key in obj) {
        if (val.indexOf(key) > -1) {
          return true;
        }
      }
  
      var keys = cu.nativeKeys(obj);
      return cu.has(keys, val);
    }
  
    if (Array.isArray(obj)) {
      var arr = obj;
      while (len--) {
        if (arr.indexOf(val[len]) > -1) {
          return true;
        }
      }
      return false;
    }
  
    throw new TypeError('expected an array or object.');
  };
  
  /**
   * Returns true if an array or object has all of the given values.
   *
   * ```js
   * cu.hasAll(['a', 'b', 'c'], 'c');
   * //=> true
   *
   * cu.hasAll(['a', 'b', 'c'], ['c', 'z']);
   * //=> false
   *
   * cu.hasAll({a: 'b', c: 'd'}, ['c', 'z']);
   * //=> false
   * ```
   * @param {Object|Array} `val`
   * @param {String|Array} `values`
   * @return {Boolean}
   * @api public
   */
  
  cu.hasAll = function hasAll(val, values) {
    values = cu.arrayify(values);
    var len = values.length;
    while (len--) {
      if (!cu.has(val, values[len])) {
        return false;
      }
    }
    return true;
  };
  
  /**
   * Cast the given value to an array.
   *
   * ```js
   * cu.arrayify('foo');
   * //=> ['foo']
   *
   * cu.arrayify(['foo']);
   * //=> ['foo']
   * ```
   *
   * @param {String|Array} `val`
   * @return {Array}
   * @api public
   */
  
  cu.arrayify = function arrayify(val) {
    return val ? (Array.isArray(val) ? val : [val]) : [];
  };
  
  /**
   * Noop
   */
  
  cu.noop = function noop() {
    return;
  };
  
  /**
   * Returns the first argument passed to the function.
   */
  
  cu.identity = function identity(val) {
    return val;
  };
  
  /**
   * Returns true if a value has a `contructor`
   *
   * ```js
   * cu.hasConstructor({});
   * //=> true
   *
   * cu.hasConstructor(Object.create(null));
   * //=> false
   * ```
   * @param  {Object} `value`
   * @return {Boolean}
   * @api public
   */
  
  cu.hasConstructor = function hasConstructor(val) {
    return cu.isObject(val) && typeof val.constructor !== 'undefined';
  };
  
  /**
   * Get the native `ownPropertyNames` from the constructor of the
   * given `object`. An empty array is returned if the object does
   * not have a constructor.
   *
   * ```js
   * cu.nativeKeys({a: 'b', b: 'c', c: 'd'})
   * //=> ['a', 'b', 'c']
   *
   * cu.nativeKeys(function(){})
   * //=> ['length', 'caller']
   * ```
   *
   * @param  {Object} `obj` Object that has a `constructor`.
   * @return {Array} Array of keys.
   * @api public
   */
  
  cu.nativeKeys = function nativeKeys(val) {
    if (!cu.hasConstructor(val)) return [];
    var keys = Object.getOwnPropertyNames(val);
    if ('caller' in val) keys.push('caller');
    return keys;
  };
  
  /**
   * Returns property descriptor `key` if it's an "own" property
   * of the given object.
   *
   * ```js
   * function App() {}
   * Object.defineProperty(App.prototype, 'count', {
   *   get: function() {
   *     return Object.keys(this).length;
   *   }
   * });
   * cu.getDescriptor(App.prototype, 'count');
   * // returns:
   * // {
   * //   get: [Function],
   * //   set: undefined,
   * //   enumerable: false,
   * //   configurable: false
   * // }
   * ```
   *
   * @param {Object} `obj`
   * @param {String} `key`
   * @return {Object} Returns descriptor `key`
   * @api public
   */
  
  cu.getDescriptor = function getDescriptor(obj, key) {
    if (!cu.isObject(obj)) {
      throw new TypeError('expected an object.');
    }
    if (typeof key !== 'string') {
      throw new TypeError('expected key to be a string.');
    }
    return Object.getOwnPropertyDescriptor(obj, key);
  };
  
  /**
   * Copy a descriptor from one object to another.
   *
   * ```js
   * function App() {}
   * Object.defineProperty(App.prototype, 'count', {
   *   get: function() {
   *     return Object.keys(this).length;
   *   }
   * });
   * var obj = {};
   * cu.copyDescriptor(obj, App.prototype, 'count');
   * ```
   * @param {Object} `receiver`
   * @param {Object} `provider`
   * @param {String} `name`
   * @return {Object}
   * @api public
   */
  
  cu.copyDescriptor = function copyDescriptor(receiver, provider, name) {
    if (!cu.isObject(receiver)) {
      throw new TypeError('expected receiving object to be an object.');
    }
    if (!cu.isObject(provider)) {
      throw new TypeError('expected providing object to be an object.');
    }
    if (typeof name !== 'string') {
      throw new TypeError('expected name to be a string.');
    }
  
    var val = cu.getDescriptor(provider, name);
    if (val) Object.defineProperty(receiver, name, val);
  };
  
  /**
   * Copy static properties, prototype properties, and descriptors
   * from one object to another.
   *
   * @param {Object} `receiver`
   * @param {Object} `provider`
   * @param {String|Array} `omit` One or more properties to omit
   * @return {Object}
   * @api public
   */
  
  cu.copy = function copy(receiver, provider, omit) {
    if (!cu.isObject(receiver)) {
      throw new TypeError('expected receiving object to be an object.');
    }
    if (!cu.isObject(provider)) {
      throw new TypeError('expected providing object to be an object.');
    }
    var props = Object.getOwnPropertyNames(provider);
    var keys = Object.keys(provider);
    var len = props.length,
      key;
    omit = cu.arrayify(omit);
  
    while (len--) {
      key = props[len];
  
      if (cu.has(keys, key)) {
        define(receiver, key, provider[key]);
      } else if (!(key in receiver) && !cu.has(omit, key)) {
        cu.copyDescriptor(receiver, provider, key);
      }
    }
  };
  
  /**
   * Inherit the static properties, prototype properties, and descriptors
   * from of an object.
   *
   * @param {Object} `receiver`
   * @param {Object} `provider`
   * @param {String|Array} `omit` One or more properties to omit
   * @return {Object}
   * @api public
   */
  
  cu.inherit = function inherit(receiver, provider, omit) {
    if (!cu.isObject(receiver)) {
      throw new TypeError('expected receiving object to be an object.');
    }
    if (!cu.isObject(provider)) {
      throw new TypeError('expected providing object to be an object.');
    }
  
    var keys = [];
    for (var key in provider) {
      keys.push(key);
      receiver[key] = provider[key];
    }
  
    keys = keys.concat(cu.arrayify(omit));
  
    var a = provider.prototype || provider;
    var b = receiver.prototype || receiver;
    cu.copy(b, a, keys);
  };
  
  /**
   * Returns a function for extending the static properties,
   * prototype properties, and descriptors from the `Parent`
   * constructor onto `Child` constructors.
   *
   * ```js
   * var extend = cu.extend(Parent);
   * Parent.extend(Child);
   *
   * // optional methods
   * Parent.extend(Child, {
   *   foo: function() {},
   *   bar: function() {}
   * });
   * ```
   * @param {Function} `Parent` Parent ctor
   * @param {Function} `extend` Optional extend function to handle custom extensions. Useful when updating methods that require a specific prototype.
   *   @param {Function} `Child` Child ctor
   *   @param {Object} `proto` Optionally pass additional prototype properties to inherit.
   *   @return {Object}
   * @api public
   */
  
  cu.extend = function() {
    // keep it lazy, instead of assigning to `cu.extend`
    return staticExtend.apply(null, arguments);
  };
  
  /**
   * Bubble up events emitted from static methods on the Parent ctor.
   *
   * @param {Object} `Parent`
   * @param {Array} `events` Event names to bubble up
   * @api public
   */
  
  cu.bubble = function(Parent, events) {
    events = events || [];
    Parent.bubble = function(Child, arr) {
      if (Array.isArray(arr)) {
        events = union([], events, arr);
      }
      var len = events.length;
      var idx = -1;
      while (++idx < len) {
        var name = events[idx];
        Parent.on(name, Child.emit.bind(Child, name));
      }
      cu.bubble(Child, events);
    };
  };
  