text: var events = require('events');
  
  exports.print = function () {};
  exports.puts = function () {};
  exports.debug = function() {};
  
  exports.inspect = function(obj, showHidden, depth, colors) {
    var seen = [];
  
    var stylize = function(str, styleType) {
      // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
      var styles =
          { 'bold' : [1, 22],
            'italic' : [3, 23],
            'underline' : [4, 24],
            'inverse' : [7, 27],
            'white' : [37, 39],
            'grey' : [90, 39],
            'black' : [30, 39],
            'blue' : [34, 39],
            'cyan' : [36, 39],
            'green' : [32, 39],
            'magenta' : [35, 39],
            'red' : [31, 39],
            'yellow' : [33, 39] };
  
      var style =
          { 'special': 'cyan',
            'number': 'blue',
            'boolean': 'yellow',
            'undefined': 'grey',
            'null': 'bold',
            'string': 'green',
            'date': 'magenta',
            // "name": intentionally not styling
            'regexp': 'red' }[styleType];
  
      if (style) {
        return '\033[' + styles[style][0] + 'm' + str +
               '\033[' + styles[style][1] + 'm';
      } else {
        return str;
      }
    };
    if (! colors) {
      stylize = function(str, styleType) { return str; };
    }
  
    function format(value, recurseTimes) {
      // Provide a hook for user-specified inspect functions.
      // Check that value is an object with an inspect function on it
      if (value && typeof value.inspect === 'function' &&
          // Filter out the util module, it's inspect function is special
          value !== exports &&
          // Also filter out any prototype objects using the circular check.
          !(value.constructor && value.constructor.prototype === value)) {
        return value.inspect(recurseTimes);
      }
  
      // Primitive types cannot have properties
      switch (typeof value) {
        case 'undefined':
          return stylize('undefined', 'undefined');
  
        case 'string':
          var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
                                                   .replace(/'/g, "\\'")
                                                   .replace(/\\"/g, '"') + '\'';
          return stylize(simple, 'string');
  
        case 'number':
          return stylize('' + value, 'number');
  
        case 'boolean':
          return stylize('' + value, 'boolean');
      }
      // For some reason typeof null is "object", so special case here.
      if (value === null) {
        return stylize('null', 'null');
      }
  
      // Look up the keys of the object.
      var visible_keys = Object_keys(value);
      var keys = showHidden ? Object_getOwnPropertyNames(value) : visible_keys;
  
      // Functions without properties can be shortcutted.
      if (typeof value === 'function' && keys.length === 0) {
        if (isRegExp(value)) {
          return stylize('' + value, 'regexp');
        } else {
          var name = value.name ? ': ' + value.name : '';
          return stylize('[Function' + name + ']', 'special');
        }
      }
  
      // Dates without properties can be shortcutted
      if (isDate(value) && keys.length === 0) {
        return stylize(value.toUTCString(), 'date');
      }
  
      var base, type, braces;
      // Determine the object type
      if (isArray(value)) {
        type = 'Array';
        braces = ['[', ']'];
      } else {
        type = 'Object';
        braces = ['{', '}'];
      }
  
      // Make functions say that they are functions
      if (typeof value === 'function') {
        var n = value.name ? ': ' + value.name : '';
        base = (isRegExp(value)) ? ' ' + value : ' [Function' + n + ']';
      } else {
        base = '';
      }
  
      // Make dates with properties first say the date
      if (isDate(value)) {
        base = ' ' + value.toUTCString();
      }
  
      if (keys.length === 0) {
        return braces[0] + base + braces[1];
      }
  
      if (recurseTimes < 0) {
        if (isRegExp(value)) {
          return stylize('' + value, 'regexp');
        } else {
          return stylize('[Object]', 'special');
        }
      }
  
      seen.push(value);
  
      var output = keys.map(function(key) {
        var name, str;
        if (value.__lookupGetter__) {
          if (value.__lookupGetter__(key)) {
            if (value.__lookupSetter__(key)) {
              str = stylize('[Getter/Setter]', 'special');
            } else {
              str = stylize('[Getter]', 'special');
            }
          } else {
            if (value.__lookupSetter__(key)) {
              str = stylize('[Setter]', 'special');
            }
          }
        }
        if (visible_keys.indexOf(key) < 0) {
          name = '[' + key + ']';
        }
        if (!str) {
          if (seen.indexOf(value[key]) < 0) {
            if (recurseTimes === null) {
              str = format(value[key]);
            } else {
              str = format(value[key], recurseTimes - 1);
            }
            if (str.indexOf('\n') > -1) {
              if (isArray(value)) {
                str = str.split('\n').map(function(line) {
                  return '  ' + line;
                }).join('\n').substr(2);
              } else {
                str = '\n' + str.split('\n').map(function(line) {
                  return '   ' + line;
                }).join('\n');
              }
            }
          } else {
            str = stylize('[Circular]', 'special');
          }
        }
        if (typeof name === 'undefined') {
          if (type === 'Array' && key.match(/^\d+$/)) {
            return str;
          }
          name = JSON.stringify('' + key);
          if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
            name = name.substr(1, name.length - 2);
            name = stylize(name, 'name');
          } else {
            name = name.replace(/'/g, "\\'")
                       .replace(/\\"/g, '"')
                       .replace(/(^"|"$)/g, "'");
            name = stylize(name, 'string');
          }
        }
  
        return name + ': ' + str;
      });
  
      seen.pop();
  
      var numLinesEst = 0;
      var length = output.reduce(function(prev, cur) {
        numLinesEst++;
        if (cur.indexOf('\n') >= 0) numLinesEst++;
        return prev + cur.length + 1;
      }, 0);
  
      if (length > 50) {
        output = braces[0] +
                 (base === '' ? '' : base + '\n ') +
                 ' ' +
                 output.join(',\n  ') +
                 ' ' +
                 braces[1];
  
      } else {
        output = braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
      }
  
      return output;
    }
    return format(obj, (typeof depth === 'undefined' ? 2 : depth));
  };
  
  
  function isArray(ar) {
    return ar instanceof Array ||
           Array.isArray(ar) ||
           (ar && ar !== Object.prototype && isArray(ar.__proto__));
  }
  
  
  function isRegExp(re) {
    return re instanceof RegExp ||
      (typeof re === 'object' && Object.prototype.toString.call(re) === '[object RegExp]');
  }
  
  
  function isDate(d) {
    if (d instanceof Date) return true;
    if (typeof d !== 'object') return false;
    var properties = Date.prototype && Object_getOwnPropertyNames(Date.prototype);
    var proto = d.__proto__ && Object_getOwnPropertyNames(d.__proto__);
    return JSON.stringify(proto) === JSON.stringify(properties);
  }
  
  function pad(n) {
    return n < 10 ? '0' + n.toString(10) : n.toString(10);
  }
  
  var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
                'Oct', 'Nov', 'Dec'];
  
  // 26 Feb 16:19:34
  function timestamp() {
    var d = new Date();
    var time = [pad(d.getHours()),
                pad(d.getMinutes()),
                pad(d.getSeconds())].join(':');
    return [d.getDate(), months[d.getMonth()], time].join(' ');
  }
  
  exports.log = function (msg) {};
  
  exports.pump = null;
  
  var Object_keys = Object.keys || function (obj) {
      var res = [];
      for (var key in obj) res.push(key);
      return res;
  };
  
  var Object_getOwnPropertyNames = Object.getOwnPropertyNames || function (obj) {
      var res = [];
      for (var key in obj) {
          if (Object.hasOwnProperty.call(obj, key)) res.push(key);
      }
      return res;
  };
  
  var Object_create = Object.create || function (prototype, properties) {
      // from es5-shim
      var object;
      if (prototype === null) {
          object = { '__proto__' : null };
      }
      else {
          if (typeof prototype !== 'object') {
              throw new TypeError(
                  'typeof prototype[' + (typeof prototype) + '] != \'object\''
              );
          }
          var Type = function () {};
          Type.prototype = prototype;
          object = new Type();
          object.__proto__ = prototype;
      }
      if (typeof properties !== 'undefined' && Object.defineProperties) {
          Object.defineProperties(object, properties);
      }
      return object;
  };
  
  exports.inherits = function(ctor, superCtor) {
    ctor.super_ = superCtor;
    ctor.prototype = Object_create(superCtor.prototype, {
      constructor: {
        value: ctor,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
  };
  