var require = function (file, cwd) {

var resolved = require.resolve(file, cwd || '/');

var mod = require.modules[resolved];

if (!mod) throw new Error(

'Failed to resolve module ' + file + ', tried ' + resolved

);

var cached = require.cache[resolved];

var res = cached? cached.exports : mod();

return res;

};

require.paths = [];

require.modules = {};

require.cache = {};

require.extensions = [".js",".coffee",".json"];

require._core = {

'assert': true,

'events': true,

'fs': true,

'path': true,

'vm': true

};

require.resolve = (function () {

return function (x, cwd) {

if (!cwd) cwd = '/';

if (require._core[x]) return x;

var path = require.modules.path();

cwd = path.resolve('/', cwd);

var y = cwd || '/';

if (x.match(/^(?:\.\.?\/|\/)/)) {

var m = loadAsFileSync(path.resolve(y, x))

|| loadAsDirectorySync(path.resolve(y, x));

if (m) return m;

}

var n = loadNodeModulesSync(x, y);

if (n) return n;

throw new Error("Cannot find module '" + x + "'");

function loadAsFileSync (x) {

x = path.normalize(x);

if (require.modules[x]) {

return x;

}

for (var i = 0; i < require.extensions.length; i++) {

var ext = require.extensions[i];

if (require.modules[x + ext]) return x + ext;

}

}

function loadAsDirectorySync (x) {

x = x.replace(/\/+$/, '');

var pkgfile = path.normalize(x + '/package.json');

if (require.modules[pkgfile]) {

var pkg = require.modules[pkgfile]();

var b = pkg.browserify;

if (typeof b === 'object' && b.main) {

var m = loadAsFileSync(path.resolve(x, b.main));

if (m) return m;

}

else if (typeof b === 'string') {

var m = loadAsFileSync(path.resolve(x, b));

if (m) return m;

}

else if (pkg.main) {

var m = loadAsFileSync(path.resolve(x, pkg.main));

if (m) return m;

}

}

return loadAsFileSync(x + '/index');

}

function loadNodeModulesSync (x, start) {

var dirs = nodeModulesPathsSync(start);

for (var i = 0; i < dirs.length; i++) {

var dir = dirs[i];

var m = loadAsFileSync(dir + '/' + x);

if (m) return m;

var n = loadAsDirectorySync(dir + '/' + x);

if (n) return n;

}

var m = loadAsFileSync(x);

if (m) return m;

}

function nodeModulesPathsSync (start) {

var parts;

if (start === '/') parts = [ '' ];

else parts = path.normalize(start).split('/');

var dirs = [];

for (var i = parts.length - 1; i >= 0; i--) {

if (parts[i] === 'node_modules') continue;

var dir = parts.slice(0, i + 1).join('/') + '/node_modules';

dirs.push(dir);

}

return dirs;

}

};

})();

require.alias = function (from, to) {

var path = require.modules.path();

var res = null;

try {

res = require.resolve(from + '/package.json', '/');

}

catch (err) {

res = require.resolve(from, '/');

}

var basedir = path.dirname(res);

var keys = (Object.keys || function (obj) {

var res = [];

for (var key in obj) res.push(key);

return res;

})(require.modules);

for (var i = 0; i < keys.length; i++) {

var key = keys[i];

if (key.slice(0, basedir.length + 1) === basedir + '/') {

var f = key.slice(basedir.length);

require.modules[to + f] = require.modules[basedir + f];

}

else if (key === basedir) {

require.modules[to] = require.modules[basedir];

}

}

};

(function () {

var process = {};

var global = typeof window !== 'undefined' ? window : {};

var definedProcess = false;

require.define = function (filename, fn) {

if (!definedProcess && require.modules.__browserify_process) {

process = require.modules.__browserify_process();

definedProcess = true;

}

var dirname = require._core[filename]

? ''

: require.modules.path().dirname(filename)

;

var require_ = function (file) {

var requiredModule = require(file, dirname);

var cached = require.cache[require.resolve(file, dirname)];

if (cached && cached.parent === null) {

cached.parent = module_;

}

return requiredModule;

};

require_.resolve = function (name) {

return require.resolve(name, dirname);

};

require_.modules = require.modules;

require_.define = require.define;

require_.cache = require.cache;

var module_ = {

id : filename,

filename: filename,

exports : {},

loaded : false,

parent: null

};

require.modules[filename] = function () {

require.cache[filename] = module_;

fn.call(

module_.exports,

require_,

module_,

module_.exports,

dirname,

filename,

process,

global

);

module_.loaded = true;

return module_.exports;

};

};

})();

require.define("path",function(require,module,exports,__dirname,__filename,process,global){function filter (xs, fn) {

var res = [];

for (var i = 0; i < xs.length; i++) {

if (fn(xs[i], i, xs)) res.push(xs[i]);

}

return res;

}

// resolves . and .. elements in a path array with directory names there

// must be no slashes, empty elements, or device names (c:\) in the array

// (so also no leading and trailing slashes - it does not distinguish

// relative and absolute paths)

function normalizeArray(parts, allowAboveRoot) {

// if the path tries to go above the root, `up` ends up > 0

var up = 0;

for (var i = parts.length; i >= 0; i--) {

var last = parts[i];

if (last == '.') {

parts.splice(i, 1);

} else if (last === '..') {

parts.splice(i, 1);

up++;

} else if (up) {

parts.splice(i, 1);

up--;

}

}

// if the path is allowed to go above the root, restore leading ..s

if (allowAboveRoot) {

for (; up--; up) {

parts.unshift('..');

}

}

return parts;

}

// Regex to split a filename into [*, dir, basename, ext]

// posix version

var splitPathRe = /^(.+\/(?!$)|\/)?((?:.+?)?(\.[^.]*)?)$/;

// path.resolve([from ...], to)

// posix version

exports.resolve = function() {

var resolvedPath = '',

resolvedAbsolute = false;

for (var i = arguments.length; i >= -1 && !resolvedAbsolute; i--) {

var path = (i >= 0)

? arguments[i]

: process.cwd();

// Skip empty and invalid entries

if (typeof path !== 'string' || !path) {

continue;

}

resolvedPath = path + '/' + resolvedPath;

resolvedAbsolute = path.charAt(0) === '/';

}

// At this point the path should be resolved to a full absolute path, but

// handle relative paths to be safe (might happen when process.cwd() fails)

// Normalize the path

resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {

return !!p;

}), !resolvedAbsolute).join('/');

return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';

};

// path.normalize(path)

// posix version

exports.normalize = function(path) {

var isAbsolute = path.charAt(0) === '/',

trailingSlash = path.slice(-1) === '/';

// Normalize the path

path = normalizeArray(filter(path.split('/'), function(p) {

return !!p;

}), !isAbsolute).join('/');

if (!path && !isAbsolute) {

path = '.';

}

if (path && trailingSlash) {

path += '/';

}

return (isAbsolute ? '/' : '') + path;

};

// posix version

exports.join = function() {

var paths = Array.prototype.slice.call(arguments, 0);

return exports.normalize(filter(paths, function(p, index) {

return p && typeof p === 'string';

}).join('/'));

};

exports.dirname = function(path) {

var dir = splitPathRe.exec(path)[1] || '';

var isWindows = false;

if (!dir) {

// No dirname

return '.';

} else if (dir.length === 1 ||

(isWindows && dir.length <= 3 && dir.charAt(1) === ':')) {

// It is just a slash or a drive letter with a slash

return dir;

} else {

// It is a full dirname, strip trailing slash

return dir.substring(0, dir.length - 1);

}

};

exports.basename = function(path, ext) {

var f = splitPathRe.exec(path)[2] || '';

// TODO: make this comparison case-insensitive on windows?

if (ext && f.substr(-1 * ext.length) === ext) {

f = f.substr(0, f.length - ext.length);

}

return f;

};

exports.extname = function(path) {

return splitPathRe.exec(path)[3] || '';

};

});

require.define("__browserify_process",function(require,module,exports,__dirname,__filename,process,global){var process = module.exports = {};

process.nextTick = (function () {

var canSetImmediate = typeof window !== 'undefined'

&& window.setImmediate;

var canPost = typeof window !== 'undefined'

&& window.postMessage && window.addEventListener

;

if (canSetImmediate) {

return window.setImmediate;

}

if (canPost) {

var queue = [];

window.addEventListener('message', function (ev) {

if (ev.source === window && ev.data === 'browserify-tick') {

ev.stopPropagation();

if (queue.length > 0) {

var fn = queue.shift();

fn();

}

}

}, true);

return function nextTick(fn) {

queue.push(fn);

window.postMessage('browserify-tick', '*');

};

}

return function nextTick(fn) {

setTimeout(fn, 0);

};

})();

process.title = 'browser';

process.browser = true;

process.env = {};

process.argv = [];

process.binding = function (name) {

if (name === 'evals') return (require)('vm')

else throw new Error('No such module. (Possibly not yet loaded)')

};

(function () {

var cwd = '/';

var path;

process.cwd = function () { return cwd };

process.chdir = function (dir) {

if (!path) path = require('path');

cwd = path.resolve(dir, cwd);

};

})();

});

require.define("/node_modules/string_decoder-chromify/package.json",function(require,module,exports,__dirname,__filename,process,global){module.exports = {"main":"index.js"}

});

require.define("/node_modules/string_decoder-chromify/index.js",function(require,module,exports,__dirname,__filename,process,global){// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

var StringDecoder = exports.StringDecoder = function(encoding) {

this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');

switch (this.encoding) {

case 'utf8':

// CESU-8 represents each of Surrogate Pair by 3-bytes

this.surrogateSize = 3;

break;

case 'ucs2':

case 'utf16le':

// UTF-16 represents each of Surrogate Pair by 2-bytes

this.surrogateSize = 2;

this.detectIncompleteChar = utf16DetectIncompleteChar;

break;

case 'base64':

// Base-64 stores 3 bytes in 4 chars, and pads the remainder.

this.surrogateSize = 3;

this.detectIncompleteChar = base64DetectIncompleteChar;

break;

default:

this.write = passThroughWrite;

return;

}

this.charBuffer = new Buffer(6);

this.charReceived = 0;

this.charLength = 0;

};

StringDecoder.prototype.write = function(buffer) {

var charStr = '';

var offset = 0;

// if our last write ended with an incomplete multibyte character

while (this.charLength) {

// determine how many remaining bytes this buffer has to offer for this char

var i = (buffer.length >= this.charLength - this.charReceived) ?

this.charLength - this.charReceived :

buffer.length;

// add the new bytes to the char buffer

buffer.copy(this.charBuffer, this.charReceived, offset, i);

this.charReceived += (i - offset);

offset = i;

if (this.charReceived < this.charLength) {

// still not enough chars in this buffer? wait for more ...

return '';

}

// get the character that was split

charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);

// lead surrogate (D800-DBFF) is also the incomplete character

var charCode = charStr.charCodeAt(charStr.length - 1);

if (charCode >= 0xD800 && charCode <= 0xDBFF) {

this.charLength += this.surrogateSize;

charStr = '';

continue;

}

this.charReceived = this.charLength = 0;

// if there are no more bytes in this buffer, just emit our char

if (i == buffer.length) return charStr;

// otherwise cut off the characters end from the beginning of this buffer

buffer = buffer.slice(i, buffer.length);

break;

}

var lenIncomplete = this.detectIncompleteChar(buffer);

var end = buffer.length;

if (this.charLength) {

// buffer the incomplete character bytes we got

buffer.copy(this.charBuffer, 0, buffer.length - lenIncomplete, end);

this.charReceived = lenIncomplete;

end -= lenIncomplete;

}

charStr += buffer.toString(this.encoding, 0, end);

var end = charStr.length - 1;

var charCode = charStr.charCodeAt(end);

// lead surrogate (D800-DBFF) is also the incomplete character

if (charCode >= 0xD800 && charCode <= 0xDBFF) {

var size = this.surrogateSize;

this.charLength += size;

this.charReceived += size;

this.charBuffer.copy(this.charBuffer, size, 0, size);

this.charBuffer.write(charStr.charAt(charStr.length - 1), this.encoding);

return charStr.substring(0, end);

}

// or just emit the charStr

return charStr;

};

StringDecoder.prototype.detectIncompleteChar = function(buffer) {

// determine how many bytes we have to check at the end of this buffer

var i = (buffer.length >= 3) ? 3 : buffer.length;

// Figure out if one of the last i bytes of our buffer announces an

// incomplete char.

for (; i > 0; i--) {

var c = buffer[buffer.length - i];

// See http://en.wikipedia.org/wiki/UTF-8#Description

// 110XXXXX

if (i == 1 && c >> 5 == 0x06) {

this.charLength = 2;

break;

}

// 1110XXXX

if (i <= 2 && c >> 4 == 0x0E) {

this.charLength = 3;

break;

}

// 11110XXX

if (i <= 3 && c >> 3 == 0x1E) {

this.charLength = 4;

break;

}

}

return i;

};

StringDecoder.prototype.end = function(buffer) {

var res = '';

if (buffer && buffer.length)

res = this.write(buffer);

if (this.charReceived) {

var cr = this.charReceived;

var buf = this.charBuffer;

var enc = this.encoding;

res += buf.slice(0, cr).toString(enc);

}

return res;

};

function passThroughWrite(buffer) {

return buffer.toString(this.encoding);

}

function utf16DetectIncompleteChar(buffer) {

var incomplete = this.charReceived = buffer.length % 2;

this.charLength = incomplete ? 2 : 0;

return incomplete;

}

function base64DetectIncompleteChar(buffer) {

var incomplete = this.charReceived = buffer.length % 3;

this.charLength = incomplete ? 3 : 0;

return incomplete;

}

});

require.define("/node_modules/freelist-chromify/package.json",function(require,module,exports,__dirname,__filename,process,global){module.exports = {"main":"index.js"}

});

require.define("/node_modules/freelist-chromify/index.js",function(require,module,exports,__dirname,__filename,process,global){// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

// This is a free list to avoid creating so many of the same object.

exports.FreeList = function(name, max, constructor) {

this.name = name;

this.constructor = constructor;

this.max = max;

this.list = [];

};

exports.FreeList.prototype.alloc = function() {

//debug("alloc " + this.name + " " + this.list.length);

return this.list.length ? this.list.shift() :

this.constructor.apply(this, arguments);

};

exports.FreeList.prototype.free = function(obj) {

//debug("free " + this.name + " " + this.list.length);

if (this.list.length < this.max) {

this.list.push(obj);

}

};

});

require.define("/node_modules/net-chromify/package.json",function(require,module,exports,__dirname,__filename,process,global){module.exports = {"main":"index.js"}

});

require.define("/node_modules/net-chromify/index.js",function(require,module,exports,__dirname,__filename,process,global){/*

Copyright 2012 Google Inc

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

*/

var net = module.exports;

var events = require('events');

var util = require('util');

var Stream = require('stream');

var Buffer = require('buffer').Buffer;

var stringToArrayBuffer = function(str) {

var buffer = new ArrayBuffer(str.length);

var uint8Array = new Uint8Array(buffer);

for(var i = 0; i < str.length; i++) {

uint8Array[i] = str.charCodeAt(i);

}

return buffer;

};

var bufferToArrayBuffer = function(buffer) {

return stringToArrayBuffer(buf.toString())

};

var arrayBufferToBuffer = function(arrayBuffer) {

var buffer = new Buffer(arrayBuffer.byteLength);

var uint8Array = new Uint8Array(arrayBuffer);

for(var i = 0; i < uint8Array.length; i++) {

buffer.writeUInt8(uint8Array[i], i);

}

return buffer;

};

net.createServer = function() {

var options = {

};

var args = arguments;

var cb = args[args.length -1];

cb = (typeof cb === 'function') ? cb : function() {};

if(typeof args[0] === 'object') {

options = args[0];

}

var server = new net.Server(options);

server.on("connection", cb);

return server;

};

net.connect = net.createConnection = function() {

var options = {};

var args = arguments;

if(typeof args[0] === 'object') {

options.port = args[0].port;

options.host = args[0].host || "127.0.0.1";

}

else if(typeof args[0] === 'number') {

// there is a port

options.port = args[0];

if(typeof args[1] === 'string') {

options.host = args[1];

}

}

else if(typeof args[0] === 'string') {

return; // can't do this.

}

var cb = args[args.length -1];

cb = (typeof cb === 'function') ? cb : function() {};

var socket = new net.Socket(options, function() {

socket.connect(options, cb);

});

return socket;

};

function Server() {

var _maxConnections = 0;

this.__defineGetter__("maxConnections", function() { return _maxConnections; });

var _connections = 0;

this.__defineGetter__("connections", function() { return _connections; });

events.EventEmitter.call(this);

// if (!(this instanceof Server)) return new Server(arguments[0], arguments[1]);

// events.EventEmitter.call(this);

// var self = this;

// var options;

// if (typeof arguments[0] == 'function') {

// options = {};

// self.on('connection', arguments[0]);

// } else {

// options = arguments[0] || {};

// if (typeof arguments[1] == 'function') {

// self.on('connection', arguments[1]);

// }

// }

// this._connections = 0;

// // when server is using slaves .connections is not reliable

// // so null will be return if thats the case

// Object.defineProperty(this, 'connections', {

// get: function() {

// if (self._usingSlaves) {

// return null;

// }

// return self._connections;

// },

// set: function(val) {

// return (self._connections = val);

// },

// configurable: true, enumerable: true

// });

// this.allowHalfOpen = options.allowHalfOpen || false;

// this._handle = null;

}

net.Server = Server;

util.inherits(net.Server, events.EventEmitter);

net.Server.prototype.listen = function() {

var self = this;

var options = {};

var args = arguments;

if (typeof args[0] === 'number') {

// assume port. and host.

options.port = args[0];

options.host = "127.0.0.1";

options.backlog = 511;

if(typeof args[1] === 'string') {

options.host = args[1];

}

else if(typeof args[1] === 'number') {

options.backlog = args[1];

}

if(typeof args[2] === 'number') {

options.backlog = args[2];

}

}

else {

// throw.

}

this._serverSocket = new net.Socket(options);

var cb = args[args.length -1];

cb = (typeof cb === 'function') ? cb : function() {};

self.on('listening', cb);

self._serverSocket.on("_created", function() {

// Socket created, now turn it into a server socket.

chrome.socket.listen(self._serverSocket._socketInfo.socketId, options.host, options.port, options.backlog, function() {

self.emit('listening');

chrome.socket.accept(self._serverSocket._socketInfo.socketId, self._accept.bind(self));

});

});

};

net.Server.prototype._accept = function(acceptInfo) {

// Create a new socket for the handle the response.

var self = this;

var socket = new net.Socket();

socket._socketInfo = acceptInfo;

self.emit("connection", socket);

chrome.socket.accept(self._serverSocket._socketInfo.socketId, self._accept.bind(self));

socket._read();

};

net.Server.prototype.close = function(callback) {

self.on("close", callback || function() {});

self._serverSocket.destroy();

self.emit("close");

};

net.Server.prototype.address = function() {};

net.Socket = function(options) {

var createNew = false;

if(options){

createNew = true;

}

var self = this;

options = options || {};

this._fd = options.fd;

this._type = options.type || "tcp";

//assert(this._type === "tcp6", "Only tcp4 is allowed");

//assert(this._type === "unix", "Only tcp4 is allowed");

this._type = allowHalfOpen = options.allowHalfOpen || false;

this._socketInfo = 0;

this._encoding;

if(createNew){

chrome.socket.create("tcp", {}, function(createInfo) {

self._socketInfo = createInfo;

self.emit("_created"); // This event doesn't exist in the API, it is here because Chrome is async

// start trying to read

// self._read();

});

}

};

util.inherits(net.Socket, Stream);

/*

Events:

close

connect

data

drain

end

error

timeout

*/

/*

Methods

*/

net.Socket.prototype.connect = function() {

var self = this;

var options = {};

var args = arguments;

if(typeof args[0] === 'object') {

// we have an options object.

options.port = args[0].port;

options.host = args[0].host || "127.0.0.1";

}

else if (typeof args[0] === 'string') {

// throw an error, we can't do named pipes.

}

else if (typeof args[0] === 'number') {

// assume port. and host.

options.port = args[0];

options.host = "127.0.0.1";

if(typeof args[1] === 'string') {

options.host = args[1];

}

}

var cb = args[args.length -1];

cb = (typeof cb === 'function') ? cb : function() {};

self.on('connect', cb);

chrome.socket.connect(self._socketInfo.socketId, options.host, options.port, function(result) {

if(result == 0) {

self.emit('connect');

}

else {

self.emit('error', new Error("Unable to connect"));

}

});

};

net.Socket.prototype.destroy = function() {

chrome.socket.disconnect(this._socketInfo.socketId);

chrome.socket.destroy(this._socketInfo.socketId);

clearTimeout(this._readTimer);

};

net.Socket.prototype.destroySoon = function() {

// Blaine's solution to this stub - probably not correct impl

chrome.socket.disconnect(this._socketInfo.socketId);

clearTimeout(this._readTimer);

};

net.Socket.prototype.setEncoding = function(encoding) {

this._encoding = encoding;

};

net.Socket.prototype.setNoDelay = function(noDelay) {

noDelay = (noDelay === undefined) ? true : noDelay;

chrome.socket.setNoDely(self._socketInfo.socketId, noDelay, function() {});

};

net.Socket.prototype.setKeepAlive = function(enable, delay) {

enable = (enable === 'undefined') ? false : enable;

delay = (delay === 'undefined') ? 0 : delay;

chrome.socket.setKeepAlive(self._socketInfo.socketId, enable, initialDelay, function() {});

};

net.Socket.prototype._read = function() {

var self = this;

chrome.socket.read(self._socketInfo.socketId, function(readInfo) {

if(readInfo.resultCode < 0) return;

// ArrayBuffer to Buffer if no encoding.

var buffer = arrayBufferToBuffer(readInfo.data);

self.emit('data', buffer);

if (self.ondata) self.ondata(buffer.parent, buffer.offset, buffer.offset + buffer.length);

});

// enque another read soon. TODO: Is there are better way to controll speed.

self._readTimer = setTimeout(self._read.bind(self), 100);

};

net.Socket.prototype.write = function(data, encoding, callback) {

var buffer;

var self = this;

encoding = encoding || "UTF8";

callback = callback || function() {};

if(typeof data === 'string') {

buffer = stringToArrayBuffer(data);

}

else if(data instanceof Buffer) {

buffer = bufferToArrayBuffer(data);

}

else {

// throw an error because we can't do anything.

}

self._resetTimeout();

chrome.socket.write(self._socketInfo.socketId, buffer, function(writeInfo) {

callback();

});

return true;

};

net.Socket.prototype._resetTimeout = function() {

var self = this;

if(!!self._timeout == false) clearTimeout(self._timeout);

if(!!self._timeoutValue) self._timeout = setTimeout(function() { self.emit('timeout') }, self._timeoutValue);

};

net.Socket.prototype.setTimeout = function(timeout, callback) {

this._timeoutValue = timeout;

this._resetTimeout();

};

net.Socket.prototype.ref = function() {};

net.Socket.prototype.unref = function() {};

net.Socket.prototype.pause = function() {};

net.Socket.prototype.resume = function() {};

net.Socket.prototype.end = function() {

};

Object.defineProperty(net.Socket.prototype, 'readyState', {

get: function() {}