text: 'use strict';
  
  var getHashes = require('crypto').getHashes;
  var createHash = require('crypto').createHash;
  
  /**
   * Exported function
   *
   * Options:
   *
   *  - `algorithm` hash algo to be used by this instance: *'sha1', 'md5'
   *  - `excludeValues` {true|*false} hash object keys, values ignored
   *  - `encoding` hash encoding, supports 'buffer', '*hex', 'binary', 'base64'
   *  - `ignoreUnknown` {true|*false} ignore unknown object types
   *  - `replacer` optional function that replaces values before hashing
   *  - `respectFunctionProperties` {*true|false} consider function properties when hashing
   *  - `respectFunctionNames` {*true|false} consider 'name' property of functions for hashing
   *  - `respectType` {*true|false} Respect special properties (prototype, constructor)
   *    when hashing to distinguish between types
   *  - `unorderedArrays` {true|*false} Sort all arrays before hashing
   *  - `unorderedSets` {*true|false} Sort `Set` and `Map` instances before hashing
   *  * = default
   *
   * @param {object} object value to hash
   * @param {object} options hashing options
   * @return {string} hash value
   * @api public
   */
  exports = module.exports = objectHash;
  
  function objectHash(object, options){
    options = applyDefaults(object, options);
  
    return hash(object, options);
  }
  
  /**
   * Exported sugar methods
   *
   * @param {object} object value to hash
   * @return {string} hash value
   * @api public
   */
  exports.sha1 = function(object){
    return objectHash(object);
  };
  exports.keys = function(object){
    return objectHash(object, {excludeValues: true, algorithm: 'sha1', encoding: 'hex'});
  };
  exports.MD5 = function(object){
    return objectHash(object, {algorithm: 'md5', encoding: 'hex'});
  };
  exports.keysMD5 = function(object){
    return objectHash(object, {algorithm: 'md5', encoding: 'hex', excludeValues: true});
  };
  
  // Internals
  var hashes = getHashes ? getHashes().slice() : ['sha1', 'md5'];
  hashes.push('passthrough');
  var encodings = ['buffer', 'hex', 'binary', 'base64'];
  
  function applyDefaults(object, sourceOptions){
    sourceOptions = sourceOptions || {};
  
    // create a copy rather than mutating
    var options = {};
    options.algorithm = sourceOptions.algorithm || 'sha1';
    options.encoding = sourceOptions.encoding || 'hex';
    options.excludeValues = sourceOptions.excludeValues ? true : false;
    options.algorithm = options.algorithm.toLowerCase();
    options.encoding = options.encoding.toLowerCase();
    options.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true; // default to false
    options.respectType = sourceOptions.respectType === false ? false : true; // default to true
    options.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
    options.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
    options.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true; // default to false
    options.unorderedSets = sourceOptions.unorderedSets === false ? false : true; // default to false
    options.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true; // default to true
    options.replacer = sourceOptions.replacer || undefined;
    options.excludeKeys = sourceOptions.excludeKeys || undefined;
  
    if(typeof object === 'undefined') {
      throw new Error('Object argument required.');
    }
  
    // if there is a case-insensitive match in the hashes list, accept it
    // (i.e. SHA256 for sha256)
    for (var i = 0; i < hashes.length; ++i) {
      if (hashes[i].toLowerCase() === options.algorithm.toLowerCase()) {
        options.algorithm = hashes[i];
      }
    }
  
    if(hashes.indexOf(options.algorithm) === -1){
      throw new Error('Algorithm "' + options.algorithm + '"  not supported. ' +
        'supported values: ' + hashes.join(', '));
    }
  
    if(encodings.indexOf(options.encoding) === -1 &&
       options.algorithm !== 'passthrough'){
      throw new Error('Encoding "' + options.encoding + '"  not supported. ' +
        'supported values: ' + encodings.join(', '));
    }
  
    return options;
  }
  
  /** Check if the given function is a native function */
  function isNativeFunction(f) {
    if ((typeof f) !== 'function') {
      return false;
    }
    var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
    return exp.exec(Function.prototype.toString.call(f)) != null;
  }
  
  function hash(object, options) {
    var hashingStream;
  
    if (options.algorithm !== 'passthrough') {
      hashingStream = createHash(options.algorithm);
    } else {
      hashingStream = new PassThrough();
    }
  
    if (typeof hashingStream.write === 'undefined') {
      hashingStream.write = hashingStream.update;
      hashingStream.end   = hashingStream.update;
    }
  
    var hasher = typeHasher(options, hashingStream);
    hasher.dispatch(object);
    if (!hashingStream.update) {
      hashingStream.end('');
    }
  
    if (hashingStream.digest) {
      return hashingStream.digest(options.encoding === 'buffer' ? undefined : options.encoding);
    }
  
    var buf = hashingStream.read();
    if (options.encoding === 'buffer') {
      return buf;
    }
  
    return buf.toString(options.encoding);
  }
  
  /**
   * Expose streaming API
   *
   * @param {object} object  Value to serialize
   * @param {object} options  Options, as for hash()
   * @param {object} stream  A stream to write the serializiation to
   * @api public
   */
  exports.writeToStream = function(object, options, stream) {
    if (typeof stream === 'undefined') {
      stream = options;
      options = {};
    }
  
    options = applyDefaults(object, options);
  
    return typeHasher(options, stream).dispatch(object);
  };
  
  function typeHasher(options, writeTo, context){
    context = context || [];
    var write = function(str) {
      if (writeTo.update) {
        return writeTo.update(str, 'utf8');
      } else {
        return writeTo.write(str, 'utf8');
      }
    };
  
    return {
      dispatch: function(value){
        if (options.replacer) {
          value = options.replacer(value);
        }
  
        var type = typeof value;
        if (value === null) {
          type = 'null';
        }
  
        //console.log("[DEBUG] Dispatch: ", value, "->", type, " -> ", "_" + type);
  
        return this['_' + type](value);
      },
      _object: function(object) {
        var pattern = (/\[object (.*)\]/i);
        var objString = Object.prototype.toString.call(object);
        var objType = pattern.exec(objString);
        if (!objType) { // object type did not match [object ...]
          objType = 'unknown:[' + objString + ']';
        } else {
          objType = objType[1]; // take only the class name
        }
  
        objType = objType.toLowerCase();
  
        var objectNumber = null;
  
        if ((objectNumber = context.indexOf(object)) >= 0) {
          return this.dispatch('[CIRCULAR:' + objectNumber + ']');
        } else {
          context.push(object);
        }
  
        if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(object)) {
          write('buffer:');
          return write(object);
        }
  
        if(objType !== 'object' && objType !== 'function' && objType !== 'asyncfunction') {
          if(this['_' + objType]) {
            this['_' + objType](object);
          } else if (options.ignoreUnknown) {
            return write('[' + objType + ']');
          } else {
            throw new Error('Unknown object type "' + objType + '"');
          }
        }else{
          var keys = Object.keys(object);
          if (options.unorderedObjects) {
            keys = keys.sort();
          }
          // Make sure to incorporate special properties, so
          // Types with different prototypes will produce
          // a different hash and objects derived from
          // different functions (`new Foo`, `new Bar`) will
          // produce different hashes.
          // We never do this for native functions since some
          // seem to break because of that.
          if (options.respectType !== false && !isNativeFunction(object)) {
            keys.splice(0, 0, 'prototype', '__proto__', 'constructor');
          }
  
          if (options.excludeKeys) {
            keys = keys.filter(function(key) { return !options.excludeKeys(key); });
          }
  
          write('object:' + keys.length + ':');
          var self = this;
          return keys.forEach(function(key){
            self.dispatch(key);
            write(':');
            if(!options.excludeValues) {
              self.dispatch(object[key]);
            }
            write(',');
          });
        }
      },
      _array: function(arr, unordered){
        unordered = typeof unordered !== 'undefined' ? unordered :
          options.unorderedArrays !== false; // default to options.unorderedArrays
  
        var self = this;
        write('array:' + arr.length + ':');
        if (!unordered || arr.length <= 1) {
          return arr.forEach(function(entry) {
            return self.dispatch(entry);
          });
        }
  
        // the unordered case is a little more complicated:
        // since there is no canonical ordering on objects,
        // i.e. {a:1} < {a:2} and {a:1} > {a:2} are both false,
        // we first serialize each entry using a PassThrough stream
        // before sorting.
        // also: we can’t use the same context array for all entries
        // since the order of hashing should *not* matter. instead,
        // we keep track of the additions to a copy of the context array
        // and add all of them to the global context array when we’re done
        var contextAdditions = [];
        var entries = arr.map(function(entry) {
          var strm = new PassThrough();
          var localContext = context.slice(); // make copy
          var hasher = typeHasher(options, strm, localContext);
          hasher.dispatch(entry);
          // take only what was added to localContext and append it to contextAdditions
          contextAdditions = contextAdditions.concat(localContext.slice(context.length));
          return strm.read().toString();
        });
        context = context.concat(contextAdditions);
        entries.sort();
        return this._array(entries, false);
      },
      _date: function(date){
        return write('date:' + date.toJSON());
      },
      _symbol: function(sym){
        return write('symbol:' + sym.toString());
      },
      _error: function(err){
        return write('error:' + err.toString());
      },
      _boolean: function(bool){
        return write('bool:' + bool.toString());
      },
      _string: function(string){
        write('string:' + string.length + ':');
        write(string.toString());
      },
      _function: function(fn){
        write('fn:');
        if (isNativeFunction(fn)) {
          this.dispatch('[native]');
        } else {
          this.dispatch(fn.toString());
        }
  
        if (options.respectFunctionNames !== false) {
          // Make sure we can still distinguish native functions
          // by their name, otherwise String and Function will
          // have the same hash
          this.dispatch("function-name:" + String(fn.name));
        }
  
        if (options.respectFunctionProperties) {
          this._object(fn);
        }
      },
      _number: function(number){
        return write('number:' + number.toString());
      },
      _xml: function(xml){
        return write('xml:' + xml.toString());
      },
      _null: function() {
        return write('Null');
      },
      _undefined: function() {
        return write('Undefined');
      },
      _regexp: function(regex){
        return write('regex:' + regex.toString());
      },
      _uint8array: function(arr){
        write('uint8array:');
        return this.dispatch(Array.prototype.slice.call(arr));
      },
      _uint8clampedarray: function(arr){
        write('uint8clampedarray:');
        return this.dispatch(Array.prototype.slice.call(arr));
      },
      _int8array: function(arr){
        write('uint8array:');
        return this.dispatch(Array.prototype.slice.call(arr));
      },
      _uint16array: function(arr){
        write('uint16array:');
        return this.dispatch(Array.prototype.slice.call(arr));
      },
      _int16array: function(arr){
        write('uint16array:');
        return this.dispatch(Array.prototype.slice.call(arr));
      },
      _uint32array: function(arr){
        write('uint32array:');
        return this.dispatch(Array.prototype.slice.call(arr));
      },
      _int32array: function(arr){
        write('uint32array:');
        return this.dispatch(Array.prototype.slice.call(arr));
      },
      _float32array: function(arr){
        write('float32array:');
        return this.dispatch(Array.prototype.slice.call(arr));
      },
      _float64array: function(arr){
        write('float64array:');
        return this.dispatch(Array.prototype.slice.call(arr));
      },
      _arraybuffer: function(arr){
        write('arraybuffer:');
        return this.dispatch(new Uint8Array(arr));
      },
      _url: function(url) {
        return write('url:' + url.toString(), 'utf8');
      },
      _map: function(map) {
        write('map:');
        var arr = Array.from(map);
        return this._array(arr, options.unorderedSets !== false);
      },
      _set: function(set) {
        write('set:');
        var arr = Array.from(set);
        return this._array(arr, options.unorderedSets !== false);
      },
      _blob: function() {
        if (options.ignoreUnknown) {
          return write('[blob]');
        }
  
        throw Error('Hashing Blob objects is currently not supported\n' +
          '(see https://github.com/puleos/object-hash/issues/26)\n' +
          'Use "options.replacer" or "options.ignoreUnknown"\n');
      },
      _domwindow: function() { return write('domwindow'); },
      /* Node.js standard native objects */
      _process: function() { return write('process'); },
      _timer: function() { return write('timer'); },
      _pipe: function() { return write('pipe'); },
      _tcp: function() { return write('tcp'); },
      _udp: function() { return write('udp'); },
      _tty: function() { return write('tty'); },
      _statwatcher: function() { return write('statwatcher'); },
      _securecontext: function() { return write('securecontext'); },
      _connection: function() { return write('connection'); },
      _zlib: function() { return write('zlib'); },
      _context: function() { return write('context'); },
      _nodescript: function() { return write('nodescript'); },
      _httpparser: function() { return write('httpparser'); },
      _dataview: function() { return write('dataview'); },
      _signal: function() { return write('signal'); },
      _fsevent: function() { return write('fsevent'); },
      _tlswrap: function() { return write('tlswrap'); }
    };
  }
  
  // Mini-implementation of stream.PassThrough
  // We are far from having need for the full implementation, and we can
  // make assumptions like "many writes, then only one final read"
  // and we can ignore encoding specifics
  function PassThrough() {
    return {
      buf: '',
  
      write: function(b) {
        this.buf += b;
      },
  
      end: function(b) {
        this.buf += b;
      },
  
      read: function() {
        return this.buf;
      }
    };
  }
  