text: (function() {
    var Server, TCP, key, net, utils, value, _ref,
      __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
      __hasProp = {}.hasOwnProperty,
      __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      __slice = [].slice;
  
    net = require("net");
  
    TCP = process.binding("tcp_wrap").TCP;
  
    utils = require("./utils");
  
    Server = (function(_super) {
      __extends(Server, _super);
  
      function Server() {
        this.listen = __bind(this.listen, this);
        this._netClusterListen = __bind(this._netClusterListen, this);      _ref = Server.__super__.constructor.apply(this, arguments);
        return _ref;
      }
  
      Server.prototype._netClusterListen = function(address, port, addressType) {
        var errno, handle,
          _this = this;
  
        handle = new TCP();
        errno = 0;
        if (addressType === 6) {
          errno = handle.bind6(address, port);
        } else {
          errno = handle.bind(address, port);
        }
        if (errno) {
          handle.close();
          return process.nextTick(function() {
            return _this.emit("error", utils.errnoException(errno, "listen"));
          });
        }
        this._handle = handle;
        return this._listen2.apply(this, arguments);
      };
  
      Server.prototype.listen = function() {
        var args, lastArg,
          _this = this;
  
        args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
        if (!utils.shouldDoIntercept(args)) {
          return Server.__super__.listen.apply(this, arguments);
        }
        lastArg = args[args.length - 1];
        if (typeof lastArg === "function") {
          this.once("listening", lastArg);
        }
        return utils.getPortArguments(args, function(err, portArgs) {
          if (err) {
            return _this.emit("error", err);
          }
          return _this._netClusterListen.apply(_this, portArgs);
        });
      };
  
      return Server;
  
    })(net.Server);
  
    for (key in net) {
      if (!__hasProp.call(net, key)) continue;
      value = net[key];
      exports[key] = value;
    }
  
    exports.Server = Server;
  
    exports.createServer = function() {
      var args;
  
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return new Server(args);
    };
  
  }).call(this);
  