Include _object_ which may be a hash or Module instance.

@param  {hash, Module} object
@return {JSpec}
@api public
547806
function(object) {
      var module = object.constructor == JSpec.Module ? object : new JSpec.Module(object)
      this.modules.push(module)
      if ('init' in module) module.init()
      if ('utilities' in module) extend(this.defaultContext, module.utilities)
      if ('matchers' in module) this.addMatchers(module.matchers)
      if ('reporters' in module) extend(this.reporters, module.reporters)
      if ('DSLs' in module)
        each(module.DSLs, function(name, methods){
          JSpec.DSLs[name] = JSpec.DSLs[name] || {}
          extend(JSpec.DSLs[name], methods)
        })
      return this
    }
1178261
function (object) {
  let names = Object.getOwnPropertyNames(object)
  // For Function, we should not override following properties even though they
  // are "own" properties.
  if (typeof object === 'function') {
    names = names.filter((name) => {
      return !FUNCTION_PROPERTIES.includes(name)
    })
  }
  // Map properties to descriptors.
  return names.map((name) => {
    const descriptor = Object.getOwnPropertyDescriptor(object, name)
    const member = { name, enumerable: descriptor.enumerable, writable: false }
    if (descriptor.get === undefined && typeof object[name] === 'function') {
      member.type = 'method'
    } else {
      if (descriptor.set || descriptor.writable) member.writable = true
      member.type = 'get'
    }
    return member
  })
}
34656
function(object) {
      var str = '';

      var first = true;

      for (var key in object) {
        if (Object.prototype.hasOwnProperty.call(object, key)) {
          var val = object[key];

          str += first ? '?' : '&';
          str += key;
          str += '=';
          str += val;

          first = false;
        }
      }

      return str;
    }
254382
function objectHash(obj) {
	var hash = crypto.createHash('md5');
	hash.update(makeHashKey(obj));
	return hash.digest('hex');
}
351899
function getOrderIndependentHash(object) {
    var accum = 0;
    var type = realTypeOf(object);

    if (type === 'array') {
      object.forEach(function (item) {
        // Addition is commutative so this is order indep
        accum += getOrderIndependentHash(item);
      });

      var arrayString = '[type: array, hash: ' + accum + ']';
      return accum + hashThisString(arrayString);
    }

    if (type === 'object') {
      for (var key in object) {
        if (object.hasOwnProperty(key)) {
          var keyValueString = '[ type: object, key: ' + key + ', value hash: ' + getOrderIndependentHash(object[key]) + ']';
          accum += hashThisString(keyValueString);
        }
      }

      return accum;
    }

    // Non object, non array...should be good?
    var stringToHash = '[ type: ' + type + ' ; value: ' + object + ']';
    return accum + hashThisString(stringToHash);
  }
1116478
function checkObj(instance, objTypeDef, path, additionalProp, errors) {

	if (typeof objTypeDef =='object') {
		if (typeof instance != 'object' || Array.isArray(instance)) {
			errors.push({
				property: path,
				message: "an object is required"
			});
		}

		for(var i in objTypeDef) {
			if (objTypeDef.hasOwnProperty(i) && !(i.charAt(0) == '_' && i.charAt(1) == '_')) {
				var value = instance[i];
				var propDef = objTypeDef[i];
				checkProp(value,propDef,path,i, errors);
			}
		}
	}

	for(i in instance) {
		if (instance.hasOwnProperty(i)
				&& !(i.charAt(0) == '_'
				&& i.charAt(1) == '_')
				&& objTypeDef
				&& !objTypeDef[i]
				&& additionalProp === false)
		{
			errors.push({
				property: path,
				message: (typeof value) + "The property " + i +
					" is not defined in the schema and the schema does not allow additional properties"
			});
		}

		var requires = objTypeDef && objTypeDef[i] && objTypeDef[i].requires;
		if (requires && !(requires in instance)) {
			errors.push({
				property: path,
				message: "the presence of the property " + i + " requires that "
					+ requires + " also be present"
			});
		}

		value = instance[i];
		if (objTypeDef && typeof objTypeDef == 'object' && !(i in objTypeDef)) {
			checkProp(value, additionalProp, path, i, errors);
		}

		if (!gCheckPropChange && value && value.$schema) {
			errors = errors.concat(checkProp(value, value.$schema, path, i, errors));
		}
	}

	return errors;
}
650548
function dependencies(dependencyObject) {
    'use strict';

    function extractSpecificPath(depPath, loadType) {
        if (typeof depPath === 'object') {
            return depPath[loadType];
        }

        return depPath;
    }

    var depNames, depPaths;

    depNames = Object.keys(dependencyObject);
    depPaths = depNames.map(function (depName) {return dependencyObject[depName]; });

    function init(root, factory) {

        if (typeof module === 'object' && module.exports) {
            // Node/CommonJS
            console.log("NODE MODE");
            factory.apply(root, depPaths.map(function (depPath) {return require(extractSpecificPath(depPath, 'node')); }));
        } else if (typeof define === 'function' && define.amd) {
            // AMD
            console.log("AMD MODE");
            define(depPaths.map(function (depPath) { return extractSpecificPath(depPath, 'browser'); }), factory);
        } else {
            // Browser globals
            console.log("GLOBALS MODE");
            factory.apply(root, depNames.map(function (depName) {return root[depName]; }));
        }
    }

    return { init: init };
}
570042
def getmodule(object):
    """"""
    if ismodule(object):
        return object
    if isclass(object):
        return sys.modules.get(object.__module__)
    try:
        file = getabsfile(object)
    except TypeError:
        return None
    if modulesbyfile.has_key(file):
        return sys.modules[modulesbyfile[file]]
    for module in sys.modules.values():
        if hasattr(module, '__file__'):
            modulesbyfile[getabsfile(module)] = module.__name__
    if modulesbyfile.has_key(file):
        return sys.modules[modulesbyfile[file]]
    main = sys.modules['__main__']
    if hasattr(main, object.__name__):
        mainobject = getattr(main, object.__name__)
        if mainobject is object:
            return main
    builtin = sys.modules['__builtin__']
    if hasattr(builtin, object.__name__):
        builtinobject = getattr(builtin, object.__name__)
        if builtinobject is object:
            return builtin
1336552
function isHostMethod(object, property){
    var t = typeof object[property];
    return t == 'function' ||
    (!!(t == 'object' && object[property])) ||
    t == 'unknown';
}
39961
function isObject(obj) {
    return obj !== undefined &&
        (obj === null || typeof obj === "object" ||
         typeof obj === "array" || obj instanceof Array ||
         Object.prototype.toString.call(obj) ===  "[object Function]"
    );
}
1020721
function hashObject (obj) {
  if (!isObject(obj)) return null;
  return shortHash(JSON.stringify(sortKeys(obj, { deep: true })));
}
240359
function areHostMethods(object) {
    var methodNames = Array.prototype.slice.call(arguments, 1),
        t, i, len = methodNames.length;
    for (i = 0; i < len; i++) {
      t = typeof object[methodNames[i]];
      if (!(/^(?:function|object|unknown)$/).test(t)) return false;
    }
    return true;
  }
1191290
function (obj) {
        this.obj = obj;
        /**
             * Check if the wrapped object is defined
             * @returns true if the wrapped object is defined, false otherwise
             */
        this.isPresent = function () {
          return angular.isDefined(this.obj) && this.obj !== null;
        };
        /**
             * Return the wrapped object or an empty object
             * @returns the wrapped objector an empty object
             */
        this.orEmptyObj = function () {
          if (this.isPresent()) {
            return this.obj;
          }
          return {};
        };
        /**
             * Return the wrapped object or the given second choice
             * @returns the wrapped object or the given second choice
             */
        this.or = function (secondChoice) {
          if (this.isPresent()) {
            return this.obj;
          }
          return secondChoice;
        };
      }
453497
function wash(obj) {
  var washed = {}

  defaults.includes.forEach(key => {
    if (obj[key]) 
      washed[key] = obj[key]
  })

  return washed
}
839817
function ( object ) {
      this.__class__ = 'Unique';

      if ( 'object' === typeof object )
        this.key = object.key;

      this.validate = function ( array ) {
        var value, store = [];

        if ( !_isArray( array ) )
          throw new Violation( this, array, { value: Validator.errorCode.must_be_an_array } );

        for ( var i = 0; i < array.length; i++ ) {
          value = 'object' === typeof array[ i ] ? array[ i ][ this.key ] : array[ i ];

          if ( 'undefined' === typeof value )
            continue;

          if ( -1 !== store.indexOf( value ) )
            throw new Violation( this, array, { value: value } );

          store.push( value );
        }

        return true;
      };

      return this;
    }
434962
function(target) {
                // Only store the `module` in the local cache since `module.exports` may not be accurate
                // if there was a circular dependency
                var module = localCache[target] || (localCache[target] = requireModule(target, dirname));
                return module.exports;
            }
1113502
private static Object formatObject(Object object) {
    if (object instanceof Class) {
      return formatArg((Class<?>) object);
    } else if (object instanceof Key) {
      return formatArg((Key<?>) object);
    } else if (object instanceof List) {
      List<?> list = (List<?>) object;
      // Empirically check if this is a List<Dependency>.
      boolean allDependencies = true;
      for (Object entry : list) {
        if (!(entry instanceof Dependency)) {
          allDependencies = false;
          break;
        }
      }

      if (allDependencies) {
        return formatArg((List<Dependency>) list);
      } else {
        return object;
      }
    } else {
      return object;
    }
  }