Tysox/BOS-Pinneberg_m
3
0
Fork 0
mirror of http://git.frickel.earth/Tysox/BOS-Pinneberg.git synced 2025-05-22 01:34:30 +02:00
Code Releases Activity
BOS-Pinneberg_m/admin/global/js/socket.io-1.4.5.js

4193 lines
198 KiB
JavaScript
Raw Blame History

(function (f) {
if (typeof exports === "object" && typeof module !== "undefined") {
module.exports = f()
} else if (typeof define === "function" && define.amd) {
define([], f)
} else {
var g;
if (typeof window !== "undefined") {
g = window
} else if (typeof global !== "undefined") {
g = global
} else if (typeof self !== "undefined") {
g = self
} else {
g = this
}
g.io = f()
}
})(function () {
var define, module, exports;
return function e(t, n, r) {
function s(o, u) {
if (!n[o]) {
if (!t[o]) {
var a = typeof require == "function" && require;
if (!u && a)return a(o, !0);
if (i)return i(o, !0);
var f = new Error("Cannot find module '" + o + "'");
throw f.code = "MODULE_NOT_FOUND", f
}
var l = n[o] = {exports: {}};
t[o][0].call(l.exports, function (e) {
var n = t[o][1][e];
return s(n ? n : e)
}, l, l.exports, e, t, n, r)
}
return n[o].exports
}
var i = typeof require == "function" && require;
for (var o = 0; o < r.length; o++)s(r[o]);
return s
}({
1: [function (_dereq_, module, exports) {
module.exports = _dereq_("./lib/")
}, {"./lib/": 2}],
2: [function (_dereq_, module, exports) {
module.exports = _dereq_("./socket");
module.exports.parser = _dereq_("engine.io-parser")
}, {"./socket": 3, "engine.io-parser": 19}],
3: [function (_dereq_, module, exports) {
(function (global) {
var transports = _dereq_("./transports");
var Emitter = _dereq_("component-emitter");
var debug = _dereq_("debug")("engine.io-client:socket");
var index = _dereq_("indexof");
var parser = _dereq_("engine.io-parser");
var parseuri = _dereq_("parseuri");
var parsejson = _dereq_("parsejson");
var parseqs = _dereq_("parseqs");
module.exports = Socket;
function noop() {
}
function Socket(uri, opts) {
if (!(this instanceof Socket))return new Socket(uri, opts);
opts = opts || {};
if (uri && "object" == typeof uri) {
opts = uri;
uri = null
}
if (uri) {
uri = parseuri(uri);
opts.hostname = uri.host;
opts.secure = uri.protocol == "https" || uri.protocol == "wss";
opts.port = uri.port;
if (uri.query)opts.query = uri.query
} else if (opts.host) {
opts.hostname = parseuri(opts.host).host
}
this.secure = null != opts.secure ? opts.secure : global.location && "https:" == location.protocol;
if (opts.hostname && !opts.port) {
opts.port = this.secure ? "443" : "80"
}
this.agent = opts.agent || false;
this.hostname = opts.hostname || (global.location ? location.hostname : "localhost");
this.port = opts.port || (global.location && location.port ? location.port : this.secure ? 443 : 80);
this.query = opts.query || {};
if ("string" == typeof this.query)this.query = parseqs.decode(this.query);
this.upgrade = false !== opts.upgrade;
this.path = (opts.path || "/engine.io").replace(/\/$/, "") + "/";
this.forceJSONP = !!opts.forceJSONP;
this.jsonp = false !== opts.jsonp;
this.forceBase64 = !!opts.forceBase64;
this.enablesXDR = !!opts.enablesXDR;
this.timestampParam = opts.timestampParam || "t";
this.timestampRequests = opts.timestampRequests;
this.transports = opts.transports || ["polling", "websocket"];
this.readyState = "";
this.writeBuffer = [];
this.policyPort = opts.policyPort || 843;
this.rememberUpgrade = opts.rememberUpgrade || false;
this.binaryType = null;
this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;
this.perMessageDeflate = false !== opts.perMessageDeflate ? opts.perMessageDeflate || {} : false;
if (true === this.perMessageDeflate)this.perMessageDeflate = {};
if (this.perMessageDeflate && null == this.perMessageDeflate.threshold) {
this.perMessageDeflate.threshold = 1024
}
this.pfx = opts.pfx || null;
this.key = opts.key || null;
this.passphrase = opts.passphrase || null;
this.cert = opts.cert || null;
this.ca = opts.ca || null;
this.ciphers = opts.ciphers || null;
this.rejectUnauthorized = opts.rejectUnauthorized === undefined ? null : opts.rejectUnauthorized;
var freeGlobal = typeof global == "object" && global;
if (freeGlobal.global === freeGlobal) {
if (opts.extraHeaders && Object.keys(opts.extraHeaders).length > 0) {
this.extraHeaders = opts.extraHeaders
}
}
this.open()
}
Socket.priorWebsocketSuccess = false;
Emitter(Socket.prototype);
Socket.protocol = parser.protocol;
Socket.Socket = Socket;
Socket.Transport = _dereq_("./transport");
Socket.transports = _dereq_("./transports");
Socket.parser = _dereq_("engine.io-parser");
Socket.prototype.createTransport = function (name) {
debug('creating transport "%s"', name);
var query = clone(this.query);
query.EIO = parser.protocol;
query.transport = name;
if (this.id)query.sid = this.id;
var transport = new transports[name]({
agent: this.agent,
hostname: this.hostname,
port: this.port,
secure: this.secure,
path: this.path,
query: query,
forceJSONP: this.forceJSONP,
jsonp: this.jsonp,
forceBase64: this.forceBase64,
enablesXDR: this.enablesXDR,
timestampRequests: this.timestampRequests,
timestampParam: this.timestampParam,
policyPort: this.policyPort,
socket: this,
pfx: this.pfx,
key: this.key,
passphrase: this.passphrase,
cert: this.cert,
ca: this.ca,
ciphers: this.ciphers,
rejectUnauthorized: this.rejectUnauthorized,
perMessageDeflate: this.perMessageDeflate,
extraHeaders: this.extraHeaders
});
return transport
};
function clone(obj) {
var o = {};
for (var i in obj) {
if (obj.hasOwnProperty(i)) {
o[i] = obj[i]
}
}
return o
}
Socket.prototype.open = function () {
var transport;
if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf("websocket") != -1) {
transport = "websocket"
} else if (0 === this.transports.length) {
var self = this;
setTimeout(function () {
self.emit("error", "No transports available")
}, 0);
return
} else {
transport = this.transports[0]
}
this.readyState = "opening";
try {
transport = this.createTransport(transport)
} catch (e) {
this.transports.shift();
this.open();
return
}
transport.open();
this.setTransport(transport)
};
Socket.prototype.setTransport = function (transport) {
debug("setting transport %s", transport.name);
var self = this;
if (this.transport) {
debug("clearing existing transport %s", this.transport.name);
this.transport.removeAllListeners()
}
this.transport = transport;
transport.on("drain", function () {
self.onDrain()
}).on("packet", function (packet) {
self.onPacket(packet)
}).on("error", function (e) {
self.onError(e)
}).on("close", function () {
self.onClose("transport close")
})
};
Socket.prototype.probe = function (name) {
debug('probing transport "%s"', name);
var transport = this.createTransport(name, {probe: 1}), failed = false, self = this;
Socket.priorWebsocketSuccess = false;
function onTransportOpen() {
if (self.onlyBinaryUpgrades) {
var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;
failed = failed || upgradeLosesBinary
}
if (failed)return;
debug('probe transport "%s" opened', name);
transport.send([{type: "ping", data: "probe"}]);
transport.once("packet", function (msg) {
if (failed)return;
if ("pong" == msg.type && "probe" == msg.data) {
debug('probe transport "%s" pong', name);
self.upgrading = true;
self.emit("upgrading", transport);
if (!transport)return;
Socket.priorWebsocketSuccess = "websocket" == transport.name;
debug('pausing current transport "%s"', self.transport.name);
self.transport.pause(function () {
if (failed)return;
if ("closed" == self.readyState)return;
debug("changing transport and sending upgrade packet");
cleanup();
self.setTransport(transport);
transport.send([{type: "upgrade"}]);
self.emit("upgrade", transport);
transport = null;
self.upgrading = false;
self.flush()
})
} else {
debug('probe transport "%s" failed', name);
var err = new Error("probe error");
err.transport = transport.name;
self.emit("upgradeError", err)
}
})
}
function freezeTransport() {
if (failed)return;
failed = true;
cleanup();
transport.close();
transport = null
}
function onerror(err) {
var error = new Error("probe error: " + err);
error.transport = transport.name;
freezeTransport();
debug('probe transport "%s" failed because of error: %s', name, err);
self.emit("upgradeError", error)
}
function onTransportClose() {
onerror("transport closed")
}
function onclose() {
onerror("socket closed")
}
function onupgrade(to) {
if (transport && to.name != transport.name) {
debug('"%s" works - aborting "%s"', to.name, transport.name);
freezeTransport()
}
}
function cleanup() {
transport.removeListener("open", onTransportOpen);
transport.removeListener("error", onerror);
transport.removeListener("close", onTransportClose);
self.removeListener("close", onclose);
self.removeListener("upgrading", onupgrade)
}
transport.once("open", onTransportOpen);
transport.once("error", onerror);
transport.once("close", onTransportClose);
this.once("close", onclose);
this.once("upgrading", onupgrade);
transport.open()
};
Socket.prototype.onOpen = function () {
debug("socket open");
this.readyState = "open";
Socket.priorWebsocketSuccess = "websocket" == this.transport.name;
this.emit("open");
this.flush();
if ("open" == this.readyState && this.upgrade && this.transport.pause) {
debug("starting upgrade probes");
for (var i = 0, l = this.upgrades.length; i < l; i++) {
this.probe(this.upgrades[i])
}
}
};
Socket.prototype.onPacket = function (packet) {
if ("opening" == this.readyState || "open" == this.readyState) {
debug('socket receive: type "%s", data "%s"', packet.type, packet.data);
this.emit("packet", packet);
this.emit("heartbeat");
switch (packet.type) {
case"open":
this.onHandshake(parsejson(packet.data));
break;
case"pong":
this.setPing();
this.emit("pong");
break;
case"error":
var err = new Error("server error");
err.code = packet.data;
this.onError(err);
break;
case"message":
this.emit("data", packet.data);
this.emit("message", packet.data);
break
}
} else {
debug('packet received with socket readyState "%s"', this.readyState)
}
};
Socket.prototype.onHandshake = function (data) {
this.emit("handshake", data);
this.id = data.sid;
this.transport.query.sid = data.sid;
this.upgrades = this.filterUpgrades(data.upgrades);
this.pingInterval = data.pingInterval;
this.pingTimeout = data.pingTimeout;
this.onOpen();
if ("closed" == this.readyState)return;
this.setPing();
this.removeListener("heartbeat", this.onHeartbeat);
this.on("heartbeat", this.onHeartbeat)
};
Socket.prototype.onHeartbeat = function (timeout) {
clearTimeout(this.pingTimeoutTimer);
var self = this;
self.pingTimeoutTimer = setTimeout(function () {
if ("closed" == self.readyState)return;
self.onClose("ping timeout")
}, timeout || self.pingInterval + self.pingTimeout)
};
Socket.prototype.setPing = function () {
var self = this;
clearTimeout(self.pingIntervalTimer);
self.pingIntervalTimer = setTimeout(function () {
debug("writing ping packet - expecting pong within %sms", self.pingTimeout);
self.ping();
self.onHeartbeat(self.pingTimeout)
}, self.pingInterval)
};
Socket.prototype.ping = function () {
var self = this;
this.sendPacket("ping", function () {
self.emit("ping")
})
};
Socket.prototype.onDrain = function () {
this.writeBuffer.splice(0, this.prevBufferLen);
this.prevBufferLen = 0;
if (0 === this.writeBuffer.length) {
this.emit("drain")
} else {
this.flush()
}
};
Socket.prototype.flush = function () {
if ("closed" != this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
debug("flushing %d packets in socket", this.writeBuffer.length);
this.transport.send(this.writeBuffer);
this.prevBufferLen = this.writeBuffer.length;
this.emit("flush")
}
};
Socket.prototype.write = Socket.prototype.send = function (msg, options, fn) {
this.sendPacket("message", msg, options, fn);
return this
};
Socket.prototype.sendPacket = function (type, data, options, fn) {
if ("function" == typeof data) {
fn = data;
data = undefined
}
if ("function" == typeof options) {
fn = options;
options = null
}
if ("closing" == this.readyState || "closed" == this.readyState) {
return
}
options = options || {};
options.compress = false !== options.compress;
var packet = {type: type, data: data, options: options};
this.emit("packetCreate", packet);
this.writeBuffer.push(packet);
if (fn)this.once("flush", fn);
this.flush()
};
Socket.prototype.close = function () {
if ("opening" == this.readyState || "open" == this.readyState) {
this.readyState = "closing";
var self = this;
if (this.writeBuffer.length) {
this.once("drain", function () {
if (this.upgrading) {
waitForUpgrade()
} else {
close()
}
})
} else if (this.upgrading) {
waitForUpgrade()
} else {
close()
}
}
function close() {
self.onClose("forced close");
debug("socket closing - telling transport to close");
self.transport.close()
}
function cleanupAndClose() {
self.removeListener("upgrade", cleanupAndClose);
self.removeListener("upgradeError", cleanupAndClose);
close()
}
function waitForUpgrade() {
self.once("upgrade", cleanupAndClose);
self.once("upgradeError", cleanupAndClose)
}
return this
};
Socket.prototype.onError = function (err) {
debug("socket error %j", err);
Socket.priorWebsocketSuccess = false;
this.emit("error", err);
this.onClose("transport error", err)
};
Socket.prototype.onClose = function (reason, desc) {
if ("opening" == this.readyState || "open" == this.readyState || "closing" == this.readyState) {
debug('socket close with reason: "%s"', reason);
var self = this;
clearTimeout(this.pingIntervalTimer);
clearTimeout(this.pingTimeoutTimer);
this.transport.removeAllListeners("close");
this.transport.close();
this.transport.removeAllListeners();
this.readyState = "closed";
this.id = null;
this.emit("close", reason, desc);
self.writeBuffer = [];
self.prevBufferLen = 0
}
};
Socket.prototype.filterUpgrades = function (upgrades) {
var filteredUpgrades = [];
for (var i = 0, j = upgrades.length; i < j; i++) {
if (~index(this.transports, upgrades[i]))filteredUpgrades.push(upgrades[i])
}
return filteredUpgrades
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {
"./transport": 4,
"./transports": 5,
"component-emitter": 15,
debug: 17,
"engine.io-parser": 19,
indexof: 23,
parsejson: 26,
parseqs: 27,
parseuri: 28
}],
4: [function (_dereq_, module, exports) {
var parser = _dereq_("engine.io-parser");
var Emitter = _dereq_("component-emitter");
module.exports = Transport;
function Transport(opts) {
this.path = opts.path;
this.hostname = opts.hostname;
this.port = opts.port;
this.secure = opts.secure;
this.query = opts.query;
this.timestampParam = opts.timestampParam;
this.timestampRequests = opts.timestampRequests;
this.readyState = "";
this.agent = opts.agent || false;
this.socket = opts.socket;
this.enablesXDR = opts.enablesXDR;
this.pfx = opts.pfx;
this.key = opts.key;
this.passphrase = opts.passphrase;
this.cert = opts.cert;
this.ca = opts.ca;
this.ciphers = opts.ciphers;
this.rejectUnauthorized = opts.rejectUnauthorized;
this.extraHeaders = opts.extraHeaders
}
Emitter(Transport.prototype);
Transport.prototype.onError = function (msg, desc) {
var err = new Error(msg);
err.type = "TransportError";
err.description = desc;
this.emit("error", err);
return this
};
Transport.prototype.open = function () {
if ("closed" == this.readyState || "" == this.readyState) {
this.readyState = "opening";
this.doOpen()
}
return this
};
Transport.prototype.close = function () {
if ("opening" == this.readyState || "open" == this.readyState) {
this.doClose();
this.onClose()
}
return this
};
Transport.prototype.send = function (packets) {
if ("open" == this.readyState) {
this.write(packets)
} else {
throw new Error("Transport not open")
}
};
Transport.prototype.onOpen = function () {
this.readyState = "open";
this.writable = true;
this.emit("open")
};
Transport.prototype.onData = function (data) {
var packet = parser.decodePacket(data, this.socket.binaryType);
this.onPacket(packet)
};
Transport.prototype.onPacket = function (packet) {
this.emit("packet", packet)
};
Transport.prototype.onClose = function () {
this.readyState = "closed";
this.emit("close")
}
}, {"component-emitter": 15, "engine.io-parser": 19}],
5: [function (_dereq_, module, exports) {
(function (global) {
var XMLHttpRequest = _dereq_("xmlhttprequest-ssl");
var XHR = _dereq_("./polling-xhr");
var JSONP = _dereq_("./polling-jsonp");
var websocket = _dereq_("./websocket");
exports.polling = polling;
exports.websocket = websocket;
function polling(opts) {
var xhr;
var xd = false;
var xs = false;
var jsonp = false !== opts.jsonp;
if (global.location) {
var isSSL = "https:" == location.protocol;
var port = location.port;
if (!port) {
port = isSSL ? 443 : 80
}
xd = opts.hostname != location.hostname || port != opts.port;
xs = opts.secure != isSSL
}
opts.xdomain = xd;
opts.xscheme = xs;
xhr = new XMLHttpRequest(opts);
if ("open" in xhr && !opts.forceJSONP) {
return new XHR(opts)
} else {
if (!jsonp)throw new Error("JSONP disabled");
return new JSONP(opts)
}
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {"./polling-jsonp": 6, "./polling-xhr": 7, "./websocket": 9, "xmlhttprequest-ssl": 10}],
6: [function (_dereq_, module, exports) {
(function (global) {
var Polling = _dereq_("./polling");
var inherit = _dereq_("component-inherit");
module.exports = JSONPPolling;
var rNewline = /\n/g;
var rEscapedNewline = /\\n/g;
var callbacks;
var index = 0;
function empty() {
}
function JSONPPolling(opts) {
Polling.call(this, opts);
this.query = this.query || {};
if (!callbacks) {
if (!global.___eio)global.___eio = [];
callbacks = global.___eio
}
this.index = callbacks.length;
var self = this;
callbacks.push(function (msg) {
self.onData(msg)
});
this.query.j = this.index;
if (global.document && global.addEventListener) {
global.addEventListener("beforeunload", function () {
if (self.script)self.script.onerror = empty
}, false)
}
}
inherit(JSONPPolling, Polling);
JSONPPolling.prototype.supportsBinary = false;
JSONPPolling.prototype.doClose = function () {
if (this.script) {
this.script.parentNode.removeChild(this.script);
this.script = null
}
if (this.form) {
this.form.parentNode.removeChild(this.form);
this.form = null;
this.iframe = null
}
Polling.prototype.doClose.call(this)
};
JSONPPolling.prototype.doPoll = function () {
var self = this;
var script = document.createElement("script");
if (this.script) {
this.script.parentNode.removeChild(this.script);
this.script = null
}
script.async = true;
script.src = this.uri();
script.onerror = function (e) {
self.onError("jsonp poll error", e)
};
var insertAt = document.getElementsByTagName("script")[0];
if (insertAt) {
insertAt.parentNode.insertBefore(script, insertAt)
} else {
(document.head || document.body).appendChild(script)
}
this.script = script;
var isUAgecko = "undefined" != typeof navigator && /gecko/i.test(navigator.userAgent);
if (isUAgecko) {
setTimeout(function () {
var iframe = document.createElement("iframe");
document.body.appendChild(iframe);
document.body.removeChild(iframe)
}, 100)
}
};
JSONPPolling.prototype.doWrite = function (data, fn) {
var self = this;
if (!this.form) {
var form = document.createElement("form");
var area = document.createElement("textarea");
var id = this.iframeId = "eio_iframe_" + this.index;
var iframe;
form.className = "socketio";
form.style.position = "absolute";
form.style.top = "-1000px";
form.style.left = "-1000px";
form.target = id;
form.method = "POST";
form.setAttribute("accept-charset", "utf-8");
area.name = "d";
form.appendChild(area);
document.body.appendChild(form);
this.form = form;
this.area = area
}
this.form.action = this.uri();
function complete() {
initIframe();
fn()
}
function initIframe() {
if (self.iframe) {
try {
self.form.removeChild(self.iframe)
} catch (e) {
self.onError("jsonp polling iframe removal error", e)
}
}
try {
var html = '<iframe src="javascript:0" name="' + self.iframeId + '">';
iframe = document.createElement(html)
} catch (e) {
iframe = document.createElement("iframe");
iframe.name = self.iframeId;
iframe.src = "javascript:0"
}
iframe.id = self.iframeId;
self.form.appendChild(iframe);
self.iframe = iframe
}
initIframe();
data = data.replace(rEscapedNewline, "\\\n");
this.area.value = data.replace(rNewline, "\\n");
try {
this.form.submit()
} catch (e) {
}
if (this.iframe.attachEvent) {
this.iframe.onreadystatechange = function () {
if (self.iframe.readyState == "complete") {
complete()
}
}
} else {
this.iframe.onload = complete
}
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {"./polling": 8, "component-inherit": 16}],
7: [function (_dereq_, module, exports) {
(function (global) {
var XMLHttpRequest = _dereq_("xmlhttprequest-ssl");
var Polling = _dereq_("./polling");
var Emitter = _dereq_("component-emitter");
var inherit = _dereq_("component-inherit");
var debug = _dereq_("debug")("engine.io-client:polling-xhr");
module.exports = XHR;
module.exports.Request = Request;
function empty() {
}
function XHR(opts) {
Polling.call(this, opts);
if (global.location) {
var isSSL = "https:" == location.protocol;
var port = location.port;
if (!port) {
port = isSSL ? 443 : 80
}
this.xd = opts.hostname != global.location.hostname || port != opts.port;
this.xs = opts.secure != isSSL
} else {
this.extraHeaders = opts.extraHeaders
}
}
inherit(XHR, Polling);
XHR.prototype.supportsBinary = true;
XHR.prototype.request = function (opts) {
opts = opts || {};
opts.uri = this.uri();
opts.xd = this.xd;
opts.xs = this.xs;
opts.agent = this.agent || false;
opts.supportsBinary = this.supportsBinary;
opts.enablesXDR = this.enablesXDR;
opts.pfx = this.pfx;
opts.key = this.key;
opts.passphrase = this.passphrase;
opts.cert = this.cert;
opts.ca = this.ca;
opts.ciphers = this.ciphers;
opts.rejectUnauthorized = this.rejectUnauthorized;
opts.extraHeaders = this.extraHeaders;
return new Request(opts)
};
XHR.prototype.doWrite = function (data, fn) {
var isBinary = typeof data !== "string" && data !== undefined;
var req = this.request({method: "POST", data: data, isBinary: isBinary});
var self = this;
req.on("success", fn);
req.on("error", function (err) {
self.onError("xhr post error", err)
});
this.sendXhr = req
};
XHR.prototype.doPoll = function () {
debug("xhr poll");
var req = this.request();
var self = this;
req.on("data", function (data) {
self.onData(data)
});
req.on("error", function (err) {
self.onError("xhr poll error", err)
});
this.pollXhr = req
};
function Request(opts) {
this.method = opts.method || "GET";
this.uri = opts.uri;
this.xd = !!opts.xd;
this.xs = !!opts.xs;
this.async = false !== opts.async;
this.data = undefined != opts.data ? opts.data : null;
this.agent = opts.agent;
this.isBinary = opts.isBinary;
this.supportsBinary = opts.supportsBinary;
this.enablesXDR = opts.enablesXDR;
this.pfx = opts.pfx;
this.key = opts.key;
this.passphrase = opts.passphrase;
this.cert = opts.cert;
this.ca = opts.ca;
this.ciphers = opts.ciphers;
this.rejectUnauthorized = opts.rejectUnauthorized;
this.extraHeaders = opts.extraHeaders;
this.create()
}
Emitter(Request.prototype);
Request.prototype.create = function () {
var opts = {agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR};
opts.pfx = this.pfx;
opts.key = this.key;
opts.passphrase = this.passphrase;
opts.cert = this.cert;
opts.ca = this.ca;
opts.ciphers = this.ciphers;
opts.rejectUnauthorized = this.rejectUnauthorized;
var xhr = this.xhr = new XMLHttpRequest(opts);
var self = this;
try {
debug("xhr open %s: %s", this.method, this.uri);
xhr.open(this.method, this.uri, this.async);
try {
if (this.extraHeaders) {
xhr.setDisableHeaderCheck(true);
for (var i in this.extraHeaders) {
if (this.extraHeaders.hasOwnProperty(i)) {
xhr.setRequestHeader(i, this.extraHeaders[i])
}
}
}
} catch (e) {
}
if (this.supportsBinary) {
xhr.responseType = "arraybuffer"
}
if ("POST" == this.method) {
try {
if (this.isBinary) {
xhr.setRequestHeader("Content-type", "application/octet-stream")
} else {
xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8")
}
} catch (e) {
}
}
if ("withCredentials" in xhr) {
xhr.withCredentials = true
}
if (this.hasXDR()) {
xhr.onload = function () {
self.onLoad()
};
xhr.onerror = function () {
self.onError(xhr.responseText)
}
} else {
xhr.onreadystatechange = function () {
if (4 != xhr.readyState)return;
if (200 == xhr.status || 1223 == xhr.status) {
self.onLoad()
} else {
setTimeout(function () {
self.onError(xhr.status)
}, 0)
}
}
}
debug("xhr data %s", this.data);
xhr.send(this.data)
} catch (e) {
setTimeout(function () {
self.onError(e)
}, 0);
return
}
if (global.document) {
this.index = Request.requestsCount++;
Request.requests[this.index] = this
}
};
Request.prototype.onSuccess = function () {
this.emit("success");
this.cleanup()
};
Request.prototype.onData = function (data) {
this.emit("data", data);
this.onSuccess()
};
Request.prototype.onError = function (err) {
this.emit("error", err);
this.cleanup(true)
};
Request.prototype.cleanup = function (fromError) {
if ("undefined" == typeof this.xhr || null === this.xhr) {
return
}
if (this.hasXDR()) {
this.xhr.onload = this.xhr.onerror = empty
} else {
this.xhr.onreadystatechange = empty
}
if (fromError) {
try {
this.xhr.abort()
} catch (e) {
}
}
if (global.document) {
delete Request.requests[this.index]
}
this.xhr = null
};
Request.prototype.onLoad = function () {
var data;
try {
var contentType;
try {
contentType = this.xhr.getResponseHeader("Content-Type").split(";")[0]
} catch (e) {
}
if (contentType === "application/octet-stream") {
data = this.xhr.response
} else {
if (!this.supportsBinary) {
data = this.xhr.responseText
} else {
try {
data = String.fromCharCode.apply(null, new Uint8Array(this.xhr.response))
} catch (e) {
var ui8Arr = new Uint8Array(this.xhr.response);
var dataArray = [];
for (var idx = 0, length = ui8Arr.length; idx < length; idx++) {
dataArray.push(ui8Arr[idx])
}
data = String.fromCharCode.apply(null, dataArray)
}
}
}
} catch (e) {
this.onError(e)
}
if (null != data) {
this.onData(data)
}
};
Request.prototype.hasXDR = function () {
return "undefined" !== typeof global.XDomainRequest && !this.xs && this.enablesXDR
};
Request.prototype.abort = function () {
this.cleanup()
};
if (global.document) {
Request.requestsCount = 0;
Request.requests = {};
if (global.attachEvent) {
global.attachEvent("onunload", unloadHandler)
} else if (global.addEventListener) {
global.addEventListener("beforeunload", unloadHandler, false)
}
}
function unloadHandler() {
for (var i in Request.requests) {
if (Request.requests.hasOwnProperty(i)) {
Request.requests[i].abort()
}
}
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {"./polling": 8, "component-emitter": 15, "component-inherit": 16, debug: 17, "xmlhttprequest-ssl": 10}],
8: [function (_dereq_, module, exports) {
var Transport = _dereq_("../transport");
var parseqs = _dereq_("parseqs");
var parser = _dereq_("engine.io-parser");
var inherit = _dereq_("component-inherit");
var yeast = _dereq_("yeast");
var debug = _dereq_("debug")("engine.io-client:polling");
module.exports = Polling;
var hasXHR2 = function () {
var XMLHttpRequest = _dereq_("xmlhttprequest-ssl");
var xhr = new XMLHttpRequest({xdomain: false});
return null != xhr.responseType
}();
function Polling(opts) {
var forceBase64 = opts && opts.forceBase64;
if (!hasXHR2 || forceBase64) {
this.supportsBinary = false
}
Transport.call(this, opts)
}
inherit(Polling, Transport);
Polling.prototype.name = "polling";
Polling.prototype.doOpen = function () {
this.poll()
};
Polling.prototype.pause = function (onPause) {
var pending = 0;
var self = this;
this.readyState = "pausing";
function pause() {
debug("paused");
self.readyState = "paused";
onPause()
}
if (this.polling || !this.writable) {
var total = 0;
if (this.polling) {
debug("we are currently polling - waiting to pause");
total++;
this.once("pollComplete", function () {
debug("pre-pause polling complete");
--total || pause()
})
}
if (!this.writable) {
debug("we are currently writing - waiting to pause");
total++;
this.once("drain", function () {
debug("pre-pause writing complete");
--total || pause()
})
}
} else {
pause()
}
};
Polling.prototype.poll = function () {
debug("polling");
this.polling = true;
this.doPoll();
this.emit("poll")
};
Polling.prototype.onData = function (data) {
var self = this;
debug("polling got data %s", data);
var callback = function (packet, index, total) {
if ("opening" == self.readyState) {
self.onOpen()
}
if ("close" == packet.type) {
self.onClose();
return false
}
self.onPacket(packet)
};
parser.decodePayload(data, this.socket.binaryType, callback);
if ("closed" != this.readyState) {
this.polling = false;
this.emit("pollComplete");
if ("open" == this.readyState) {
this.poll()
} else {
debug('ignoring poll - transport state "%s"', this.readyState)
}
}
};
Polling.prototype.doClose = function () {
var self = this;
function close() {
debug("writing close packet");
self.write([{type: "close"}])
}
if ("open" == this.readyState) {
debug("transport open - closing");
close()
} else {
debug("transport not open - deferring close");
this.once("open", close)
}
};
Polling.prototype.write = function (packets) {
var self = this;
this.writable = false;
var callbackfn = function () {
self.writable = true;
self.emit("drain")
};
var self = this;
parser.encodePayload(packets, this.supportsBinary, function (data) {
self.doWrite(data, callbackfn)
})
};
Polling.prototype.uri = function () {
var query = this.query || {};
var schema = this.secure ? "https" : "http";
var port = "";
if (false !== this.timestampRequests) {
query[this.timestampParam] = yeast()
}
if (!this.supportsBinary && !query.sid) {
query.b64 = 1
}
query = parseqs.encode(query);
if (this.port && ("https" == schema && this.port != 443 || "http" == schema && this.port != 80)) {
port = ":" + this.port
}
if (query.length) {
query = "?" + query
}
var ipv6 = this.hostname.indexOf(":") !== -1;
return schema + "://" + (ipv6 ? "[" + this.hostname + "]" : this.hostname) + port + this.path + query
}
}, {
"../transport": 4,
"component-inherit": 16,
debug: 17,
"engine.io-parser": 19,
parseqs: 27,
"xmlhttprequest-ssl": 10,
yeast: 30
}],
9: [function (_dereq_, module, exports) {
(function (global) {
var Transport = _dereq_("../transport");
var parser = _dereq_("engine.io-parser");
var parseqs = _dereq_("parseqs");
var inherit = _dereq_("component-inherit");
var yeast = _dereq_("yeast");
var debug = _dereq_("debug")("engine.io-client:websocket");
var BrowserWebSocket = global.WebSocket || global.MozWebSocket;
var WebSocket = BrowserWebSocket;
if (!WebSocket && typeof window === "undefined") {
try {
WebSocket = _dereq_("ws")
} catch (e) {
}
}
module.exports = WS;
function WS(opts) {
var forceBase64 = opts && opts.forceBase64;
if (forceBase64) {
this.supportsBinary = false
}
this.perMessageDeflate = opts.perMessageDeflate;
Transport.call(this, opts)
}
inherit(WS, Transport);
WS.prototype.name = "websocket";
WS.prototype.supportsBinary = true;
WS.prototype.doOpen = function () {
if (!this.check()) {
return
}
var self = this;
var uri = this.uri();
var protocols = void 0;
var opts = {agent: this.agent, perMessageDeflate: this.perMessageDeflate};
opts.pfx = this.pfx;
opts.key = this.key;
opts.passphrase = this.passphrase;
opts.cert = this.cert;
opts.ca = this.ca;
opts.ciphers = this.ciphers;
opts.rejectUnauthorized = this.rejectUnauthorized;
if (this.extraHeaders) {
opts.headers = this.extraHeaders
}
this.ws = BrowserWebSocket ? new WebSocket(uri) : new WebSocket(uri, protocols, opts);
if (this.ws.binaryType === undefined) {
this.supportsBinary = false
}
if (this.ws.supports && this.ws.supports.binary) {
this.supportsBinary = true;
this.ws.binaryType = "buffer"
} else {
this.ws.binaryType = "arraybuffer"
}
this.addEventListeners()
};
WS.prototype.addEventListeners = function () {
var self = this;
this.ws.onopen = function () {
self.onOpen()
};
this.ws.onclose = function () {
self.onClose()
};
this.ws.onmessage = function (ev) {
self.onData(ev.data)
};
this.ws.onerror = function (e) {
self.onError("websocket error", e)
}
};
if ("undefined" != typeof navigator && /iPad|iPhone|iPod/i.test(navigator.userAgent)) {
WS.prototype.onData = function (data) {
var self = this;
setTimeout(function () {
Transport.prototype.onData.call(self, data)
}, 0)
}
}
WS.prototype.write = function (packets) {
var self = this;
this.writable = false;
var total = packets.length;
for (var i = 0, l = total; i < l; i++) {
(function (packet) {
parser.encodePacket(packet, self.supportsBinary, function (data) {
if (!BrowserWebSocket) {
var opts = {};
if (packet.options) {
opts.compress = packet.options.compress
}
if (self.perMessageDeflate) {
var len = "string" == typeof data ? global.Buffer.byteLength(data) : data.length;
if (len < self.perMessageDeflate.threshold) {
opts.compress = false
}
}
}
try {
if (BrowserWebSocket) {
self.ws.send(data)
} else {
self.ws.send(data, opts)
}
} catch (e) {
debug("websocket closed before onclose event")
}
--total || done()
})
})(packets[i])
}
function done() {
self.emit("flush");
setTimeout(function () {
self.writable = true;
self.emit("drain")
}, 0)
}
};
WS.prototype.onClose = function () {
Transport.prototype.onClose.call(this)
};
WS.prototype.doClose = function () {
if (typeof this.ws !== "undefined") {
this.ws.close()
}
};
WS.prototype.uri = function () {
var query = this.query || {};
var schema = this.secure ? "wss" : "ws";
var port = "";
if (this.port && ("wss" == schema && this.port != 443 || "ws" == schema && this.port != 80)) {
port = ":" + this.port
}
if (this.timestampRequests) {
query[this.timestampParam] = yeast()
}
if (!this.supportsBinary) {
query.b64 = 1
}
query = parseqs.encode(query);
if (query.length) {
query = "?" + query
}
var ipv6 = this.hostname.indexOf(":") !== -1;
return schema + "://" + (ipv6 ? "[" + this.hostname + "]" : this.hostname) + port + this.path + query
};
WS.prototype.check = function () {
return !!WebSocket && !("__initialize" in WebSocket && this.name === WS.prototype.name)
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {
"../transport": 4,
"component-inherit": 16,
debug: 17,
"engine.io-parser": 19,
parseqs: 27,
ws: undefined,
yeast: 30
}],
10: [function (_dereq_, module, exports) {
var hasCORS = _dereq_("has-cors");
module.exports = function (opts) {
var xdomain = opts.xdomain;
var xscheme = opts.xscheme;
var enablesXDR = opts.enablesXDR;
try {
if ("undefined" != typeof XMLHttpRequest && (!xdomain || hasCORS)) {
return new XMLHttpRequest
}
} catch (e) {
}
try {
if ("undefined" != typeof XDomainRequest && !xscheme && enablesXDR) {
return new XDomainRequest
}
} catch (e) {
}
if (!xdomain) {
try {
return new ActiveXObject("Microsoft.XMLHTTP")
} catch (e) {
}
}
}
}, {"has-cors": 22}],
11: [function (_dereq_, module, exports) {
module.exports = after;
function after(count, callback, err_cb) {
var bail = false;
err_cb = err_cb || noop;
proxy.count = count;
return count === 0 ? callback() : proxy;
function proxy(err, result) {
if (proxy.count <= 0) {
throw new Error("after called too many times")
}
--proxy.count;
if (err) {
bail = true;
callback(err);
callback = err_cb
} else if (proxy.count === 0 && !bail) {
callback(null, result)
}
}
}
function noop() {
}
}, {}],
12: [function (_dereq_, module, exports) {
module.exports = function (arraybuffer, start, end) {
var bytes = arraybuffer.byteLength;
start = start || 0;
end = end || bytes;
if (arraybuffer.slice) {
return arraybuffer.slice(start, end)
}
if (start < 0) {
start += bytes
}
if (end < 0) {
end += bytes
}
if (end > bytes) {
end = bytes
}
if (start >= bytes || start >= end || bytes === 0) {
return new ArrayBuffer(0)
}
var abv = new Uint8Array(arraybuffer);
var result = new Uint8Array(end - start);
for (var i = start, ii = 0; i < end; i++, ii++) {
result[ii] = abv[i]
}
return result.buffer
}
}, {}],
13: [function (_dereq_, module, exports) {
(function (chars) {
"use strict";
exports.encode = function (arraybuffer) {
var bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = "";
for (i = 0; i < len; i += 3) {
base64 += chars[bytes[i] >> 2];
base64 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
base64 += chars[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];
base64 += chars[bytes[i + 2] & 63]
}
if (len % 3 === 2) {
base64 = base64.substring(0, base64.length - 1) + "="
} else if (len % 3 === 1) {
base64 = base64.substring(0, base64.length - 2) + "=="
}
return base64
};
exports.decode = function (base64) {
var bufferLength = base64.length * .75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;
if (base64[base64.length - 1] === "=") {
bufferLength--;
if (base64[base64.length - 2] === "=") {
bufferLength--
}
}
var arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
for (i = 0; i < len; i += 4) {
encoded1 = chars.indexOf(base64[i]);
encoded2 = chars.indexOf(base64[i + 1]);
encoded3 = chars.indexOf(base64[i + 2]);
encoded4 = chars.indexOf(base64[i + 3]);
bytes[p++] = encoded1 << 2 | encoded2 >> 4;
bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63
}
return arraybuffer
}
})("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
}, {}],
14: [function (_dereq_, module, exports) {
(function (global) {
var BlobBuilder = global.BlobBuilder || global.WebKitBlobBuilder || global.MSBlobBuilder || global.MozBlobBuilder;
var blobSupported = function () {
try {
var a = new Blob(["hi"]);
return a.size === 2
} catch (e) {
return false
}
}();
var blobSupportsArrayBufferView = blobSupported && function () {
try {
var b = new Blob([new Uint8Array([1, 2])]);
return b.size === 2
} catch (e) {
return false
}
}();
var blobBuilderSupported = BlobBuilder && BlobBuilder.prototype.append && BlobBuilder.prototype.getBlob;
function mapArrayBufferViews(ary) {
for (var i = 0; i < ary.length; i++) {
var chunk = ary[i];
if (chunk.buffer instanceof ArrayBuffer) {
var buf = chunk.buffer;
if (chunk.byteLength !== buf.byteLength) {
var copy = new Uint8Array(chunk.byteLength);
copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));
buf = copy.buffer
}
ary[i] = buf
}
}
}
function BlobBuilderConstructor(ary, options) {
options = options || {};
var bb = new BlobBuilder;
mapArrayBufferViews(ary);
for (var i = 0; i < ary.length; i++) {
bb.append(ary[i])
}
return options.type ? bb.getBlob(options.type) : bb.getBlob()
}
function BlobConstructor(ary, options) {
mapArrayBufferViews(ary);
return new Blob(ary, options || {})
}
module.exports = function () {
if (blobSupported) {
return blobSupportsArrayBufferView ? global.Blob : BlobConstructor
} else if (blobBuilderSupported) {
return BlobBuilderConstructor
} else {
return undefined
}
}()
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {}],
15: [function (_dereq_, module, exports) {
module.exports = Emitter;
function Emitter(obj) {
if (obj)return mixin(obj)
}
function mixin(obj) {
for (var key in Emitter.prototype) {
obj[key] = Emitter.prototype[key]
}
return obj
}
Emitter.prototype.on = Emitter.prototype.addEventListener = function (event, fn) {
this._callbacks = this._callbacks || {};
(this._callbacks[event] = this._callbacks[event] || []).push(fn);
return this
};
Emitter.prototype.once = function (event, fn) {
var self = this;
this._callbacks = this._callbacks || {};
function on() {
self.off(event, on);
fn.apply(this, arguments)
}
on.fn = fn;
this.on(event, on);
return this
};
Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function (event, fn) {
this._callbacks = this._callbacks || {};
if (0 == arguments.length) {
this._callbacks = {};
return this
}
var callbacks = this._callbacks[event];
if (!callbacks)return this;
if (1 == arguments.length) {
delete this._callbacks[event];
return this
}
var cb;
for (var i = 0; i < callbacks.length; i++) {
cb = callbacks[i];
if (cb === fn || cb.fn === fn) {
callbacks.splice(i, 1);
break
}
}
return this
};
Emitter.prototype.emit = function (event) {
this._callbacks = this._callbacks || {};
var args = [].slice.call(arguments, 1), callbacks = this._callbacks[event];
if (callbacks) {
callbacks = callbacks.slice(0);
for (var i = 0, len = callbacks.length; i < len; ++i) {
callbacks[i].apply(this, args)
}
}
return this
};
Emitter.prototype.listeners = function (event) {
this._callbacks = this._callbacks || {};
return this._callbacks[event] || []
};
Emitter.prototype.hasListeners = function (event) {
return !!this.listeners(event).length
}
}, {}],
16: [function (_dereq_, module, exports) {
module.exports = function (a, b) {
var fn = function () {
};
fn.prototype = b.prototype;
a.prototype = new fn;
a.prototype.constructor = a
}
}, {}],
17: [function (_dereq_, module, exports) {
exports = module.exports = _dereq_("./debug");
exports.log = log;
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.storage = "undefined" != typeof chrome && "undefined" != typeof chrome.storage ? chrome.storage.local : localstorage();
exports.colors = ["lightseagreen", "forestgreen", "goldenrod", "dodgerblue", "darkorchid", "crimson"];
function useColors() {
return "WebkitAppearance" in document.documentElement.style || window.console && (console.firebug || console.exception && console.table) || navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31
}
exports.formatters.j = function (v) {
return JSON.stringify(v)
};
function formatArgs() {
var args = arguments;
var useColors = this.useColors;
args[0] = (useColors ? "%c" : "") + this.namespace + (useColors ? " %c" : " ") + args[0] + (useColors ? "%c " : " ") + "+" + exports.humanize(this.diff);
if (!useColors)return args;
var c = "color: " + this.color;
args = [args[0], c, "color: inherit"].concat(Array.prototype.slice.call(args, 1));
var index = 0;
var lastC = 0;
args[0].replace(/%[a-z%]/g, function (match) {
if ("%%" === match)return;
index++;
if ("%c" === match) {
lastC = index
}
});
args.splice(lastC, 0, c);
return args
}
function log() {
return "object" === typeof console && console.log && Function.prototype.apply.call(console.log, console, arguments)
}
function save(namespaces) {
try {
if (null == namespaces) {
exports.storage.removeItem("debug")
} else {
exports.storage.debug = namespaces
}
} catch (e) {
}
}
function load() {
var r;
try {
r = exports.storage.debug
} catch (e) {
}
return r
}
exports.enable(load());
function localstorage() {
try {
return window.localStorage
} catch (e) {
}
}
}, {"./debug": 18}],
18: [function (_dereq_, module, exports) {
exports = module.exports = debug;
exports.coerce = coerce;
exports.disable = disable;
exports.enable = enable;
exports.enabled = enabled;
exports.humanize = _dereq_("ms");
exports.names = [];
exports.skips = [];
exports.formatters = {};
var prevColor = 0;
var prevTime;
function selectColor() {
return exports.colors[prevColor++ % exports.colors.length]
}
function debug(namespace) {
function disabled() {
}
disabled.enabled = false;
function enabled() {
var self = enabled;
var curr = +new Date;
var ms = curr - (prevTime || curr);
self.diff = ms;
self.prev = prevTime;
self.curr = curr;
prevTime = curr;
if (null == self.useColors)self.useColors = exports.useColors();
if (null == self.color && self.useColors)self.color = selectColor();
var args = Array.prototype.slice.call(arguments);
args[0] = exports.coerce(args[0]);
if ("string" !== typeof args[0]) {
args = ["%o"].concat(args)
}
var index = 0;
args[0] = args[0].replace(/%([a-z%])/g, function (match, format) {
if (match === "%%")return match;
index++;
var formatter = exports.formatters[format];
if ("function" === typeof formatter) {
var val = args[index];
match = formatter.call(self, val);
args.splice(index, 1);
index--
}
return match
});
if ("function" === typeof exports.formatArgs) {
args = exports.formatArgs.apply(self, args)
}
var logFn = enabled.log || exports.log || console.log.bind(console);
logFn.apply(self, args)
}
enabled.enabled = true;
var fn = exports.enabled(namespace) ? enabled : disabled;
fn.namespace = namespace;
return fn
}
function enable(namespaces) {
exports.save(namespaces);
var split = (namespaces || "").split(/[\s,]+/);
var len = split.length;
for (var i = 0; i < len; i++) {
if (!split[i])continue;
namespaces = split[i].replace(/\*/g, ".*?");
if (namespaces[0] === "-") {
exports.skips.push(new RegExp("^" + namespaces.substr(1) + "$"))
} else {
exports.names.push(new RegExp("^" + namespaces + "$"))
}
}
}
function disable() {
exports.enable("")
}
function enabled(name) {
var i, len;
for (i = 0, len = exports.skips.length; i < len; i++) {
if (exports.skips[i].test(name)) {
return false
}
}
for (i = 0, len = exports.names.length; i < len; i++) {
if (exports.names[i].test(name)) {
return true
}
}
return false
}
function coerce(val) {
if (val instanceof Error)return val.stack || val.message;
return val
}
}, {ms: 25}],
19: [function (_dereq_, module, exports) {
(function (global) {
var keys = _dereq_("./keys");
var hasBinary = _dereq_("has-binary");
var sliceBuffer = _dereq_("arraybuffer.slice");
var base64encoder = _dereq_("base64-arraybuffer");
var after = _dereq_("after");
var utf8 = _dereq_("utf8");
var isAndroid = navigator.userAgent.match(/Android/i);
var isPhantomJS = /PhantomJS/i.test(navigator.userAgent);
var dontSendBlobs = isAndroid || isPhantomJS;
exports.protocol = 3;
var packets = exports.packets = {open: 0, close: 1, ping: 2, pong: 3, message: 4, upgrade: 5, noop: 6};
var packetslist = keys(packets);
var err = {type: "error", data: "parser error"};
var Blob = _dereq_("blob");
exports.encodePacket = function (packet, supportsBinary, utf8encode, callback) {
if ("function" == typeof supportsBinary) {
callback = supportsBinary;
supportsBinary = false
}
if ("function" == typeof utf8encode) {
callback = utf8encode;
utf8encode = null
}
var data = packet.data === undefined ? undefined : packet.data.buffer || packet.data;
if (global.ArrayBuffer && data instanceof ArrayBuffer) {
return encodeArrayBuffer(packet, supportsBinary, callback)
} else if (Blob && data instanceof global.Blob) {
return encodeBlob(packet, supportsBinary, callback)
}
if (data && data.base64) {
return encodeBase64Object(packet, callback)
}
var encoded = packets[packet.type];
if (undefined !== packet.data) {
encoded += utf8encode ? utf8.encode(String(packet.data)) : String(packet.data)
}
return callback("" + encoded)
};
function encodeBase64Object(packet, callback) {
var message = "b" + exports.packets[packet.type] + packet.data.data;
return callback(message)
}
function encodeArrayBuffer(packet, supportsBinary, callback) {
if (!supportsBinary) {
return exports.encodeBase64Packet(packet, callback)
}
var data = packet.data;
var contentArray = new Uint8Array(data);
var resultBuffer = new Uint8Array(1 + data.byteLength);
resultBuffer[0] = packets[packet.type];
for (var i = 0; i < contentArray.length; i++) {
resultBuffer[i + 1] = contentArray[i]
}
return callback(resultBuffer.buffer)
}
function encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {
if (!supportsBinary) {
return exports.encodeBase64Packet(packet, callback)
}
var fr = new FileReader;
fr.onload = function () {
packet.data = fr.result;
exports.encodePacket(packet, supportsBinary, true, callback)
};
return fr.readAsArrayBuffer(packet.data)
}
function encodeBlob(packet, supportsBinary, callback) {
if (!supportsBinary) {
return exports.encodeBase64Packet(packet, callback)
}
if (dontSendBlobs) {
return encodeBlobAsArrayBuffer(packet, supportsBinary, callback)
}
var length = new Uint8Array(1);
length[0] = packets[packet.type];
var blob = new Blob([length.buffer, packet.data]);
return callback(blob)
}
exports.encodeBase64Packet = function (packet, callback) {
var message = "b" + exports.packets[packet.type];
if (Blob && packet.data instanceof global.Blob) {
var fr = new FileReader;
fr.onload = function () {
var b64 = fr.result.split(",")[1];
callback(message + b64)
};
return fr.readAsDataURL(packet.data)
}
var b64data;
try {
b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data))
} catch (e) {
var typed = new Uint8Array(packet.data);
var basic = new Array(typed.length);
for (var i = 0; i < typed.length; i++) {
basic[i] = typed[i]
}
b64data = String.fromCharCode.apply(null, basic)
}
message += global.btoa(b64data);
return callback(message)
};
exports.decodePacket = function (data, binaryType, utf8decode) {
if (typeof data == "string" || data === undefined) {
if (data.charAt(0) == "b") {
return exports.decodeBase64Packet(data.substr(1), binaryType)
}
if (utf8decode) {
try {
data = utf8.decode(data)
} catch (e) {
return err
}
}
var type = data.charAt(0);
if (Number(type) != type || !packetslist[type]) {
return err
}
if (data.length > 1) {
return {type: packetslist[type], data: data.substring(1)}
} else {
return {type: packetslist[type]}
}
}
var asArray = new Uint8Array(data);
var type = asArray[0];
var rest = sliceBuffer(data, 1);
if (Blob && binaryType === "blob") {
rest = new Blob([rest])
}
return {type: packetslist[type], data: rest}
};
exports.decodeBase64Packet = function (msg, binaryType) {
var type = packetslist[msg.charAt(0)];
if (!global.ArrayBuffer) {
return {type: type, data: {base64: true, data: msg.substr(1)}}
}
var data = base64encoder.decode(msg.substr(1));
if (binaryType === "blob" && Blob) {
data = new Blob([data])
}
return {type: type, data: data}
};
exports.encodePayload = function (packets, supportsBinary, callback) {
if (typeof supportsBinary == "function") {
callback = supportsBinary;
supportsBinary = null
}
var isBinary = hasBinary(packets);
if (supportsBinary && isBinary) {
if (Blob && !dontSendBlobs) {
return exports.encodePayloadAsBlob(packets, callback)
}
return exports.encodePayloadAsArrayBuffer(packets, callback)
}
if (!packets.length) {
return callback("0:")
}
function setLengthHeader(message) {
return message.length + ":" + message
}
function encodeOne(packet, doneCallback) {
exports.encodePacket(packet, !isBinary ? false : supportsBinary, true, function (message) {
doneCallback(null, setLengthHeader(message))
})
}
map(packets, encodeOne, function (err, results) {
return callback(results.join(""))
})
};
function map(ary, each, done) {
var result = new Array(ary.length);
var next = after(ary.length, done);
var eachWithIndex = function (i, el, cb) {
each(el, function (error, msg) {
result[i] = msg;
cb(error, result)
})
};
for (var i = 0; i < ary.length; i++) {
eachWithIndex(i, ary[i], next)
}
}
exports.decodePayload = function (data, binaryType, callback) {
if (typeof data != "string") {
return exports.decodePayloadAsBinary(data, binaryType, callback)
}
if (typeof binaryType === "function") {
callback = binaryType;
binaryType = null
}
var packet;
if (data == "") {
return callback(err, 0, 1)
}
var length = "", n, msg;
for (var i = 0, l = data.length; i < l; i++) {
var chr = data.charAt(i);
if (":" != chr) {
length += chr
} else {
if ("" == length || length != (n = Number(length))) {
return callback(err, 0, 1)
}
msg = data.substr(i + 1, n);
if (length != msg.length) {
return callback(err, 0, 1)
}
if (msg.length) {
packet = exports.decodePacket(msg, binaryType, true);
if (err.type == packet.type && err.data == packet.data) {
return callback(err, 0, 1)
}
var ret = callback(packet, i + n, l);
if (false === ret)return
}
i += n;
length = ""
}
}
if (length != "") {
return callback(err, 0, 1)
}
};
exports.encodePayloadAsArrayBuffer = function (packets, callback) {
if (!packets.length) {
return callback(new ArrayBuffer(0))
}
function encodeOne(packet, doneCallback) {
exports.encodePacket(packet, true, true, function (data) {
return doneCallback(null, data)
})
}
map(packets, encodeOne, function (err, encodedPackets) {
var totalLength = encodedPackets.reduce(function (acc, p) {
var len;
if (typeof p === "string") {
len = p.length
} else {
len = p.byteLength
}
return acc + len.toString().length + len + 2
}, 0);
var resultArray = new Uint8Array(totalLength);
var bufferIndex = 0;
encodedPackets.forEach(function (p) {
var isString = typeof p === "string";
var ab = p;
if (isString) {
var view = new Uint8Array(p.length);
for (var i = 0; i < p.length; i++) {
view[i] = p.charCodeAt(i)
}
ab = view.buffer
}
if (isString) {
resultArray[bufferIndex++] = 0
} else {
resultArray[bufferIndex++] = 1
}
var lenStr = ab.byteLength.toString();
for (var i = 0; i < lenStr.length; i++) {
resultArray[bufferIndex++] = parseInt(lenStr[i])
}
resultArray[bufferIndex++] = 255;
var view = new Uint8Array(ab);
for (var i = 0; i < view.length; i++) {
resultArray[bufferIndex++] = view[i]
}
});
return callback(resultArray.buffer)
})
};
exports.encodePayloadAsBlob = function (packets, callback) {
function encodeOne(packet, doneCallback) {
exports.encodePacket(packet, true, true, function (encoded) {
var binaryIdentifier = new Uint8Array(1);
binaryIdentifier[0] = 1;
if (typeof encoded === "string") {
var view = new Uint8Array(encoded.length);
for (var i = 0; i < encoded.length; i++) {
view[i] = encoded.charCodeAt(i)
}
encoded = view.buffer;
binaryIdentifier[0] = 0
}
var len = encoded instanceof ArrayBuffer ? encoded.byteLength : encoded.size;
var lenStr = len.toString();
var lengthAry = new Uint8Array(lenStr.length + 1);
for (var i = 0; i < lenStr.length; i++) {
lengthAry[i] = parseInt(lenStr[i])
}
lengthAry[lenStr.length] = 255;
if (Blob) {
var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);
doneCallback(null, blob)
}
})
}
map(packets, encodeOne, function (err, results) {
return callback(new Blob(results))
})
};
exports.decodePayloadAsBinary = function (data, binaryType, callback) {
if (typeof binaryType === "function") {
callback = binaryType;
binaryType = null
}
var bufferTail = data;
var buffers = [];
var numberTooLong = false;
while (bufferTail.byteLength > 0) {
var tailArray = new Uint8Array(bufferTail);
var isString = tailArray[0] === 0;
var msgLength = "";
for (var i = 1; ; i++) {
if (tailArray[i] == 255)break;
if (msgLength.length > 310) {
numberTooLong = true;
break
}
msgLength += tailArray[i]
}
if (numberTooLong)return callback(err, 0, 1);
bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);
msgLength = parseInt(msgLength);
var msg = sliceBuffer(bufferTail, 0, msgLength);
if (isString) {
try {
msg = String.fromCharCode.apply(null, new Uint8Array(msg))
} catch (e) {
var typed = new Uint8Array(msg);
msg = "";
for (var i = 0; i < typed.length; i++) {
msg += String.fromCharCode(typed[i])
}
}
}
buffers.push(msg);
bufferTail = sliceBuffer(bufferTail, msgLength)
}
var total = buffers.length;
buffers.forEach(function (buffer, i) {
callback(exports.decodePacket(buffer, binaryType, true), i, total)
})
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {
"./keys": 20,
after: 11,
"arraybuffer.slice": 12,
"base64-arraybuffer": 13,
blob: 14,
"has-binary": 21,
utf8: 29
}],
20: [function (_dereq_, module, exports) {
module.exports = Object.keys || function keys(obj) {
var arr = [];
var has = Object.prototype.hasOwnProperty;
for (var i in obj) {
if (has.call(obj, i)) {
arr.push(i)
}
}
return arr
}
}, {}],
21: [function (_dereq_, module, exports) {
(function (global) {
var isArray = _dereq_("isarray");
module.exports = hasBinary;
function hasBinary(data) {
function _hasBinary(obj) {
if (!obj)return false;
if (global.Buffer && global.Buffer.isBuffer(obj) || global.ArrayBuffer && obj instanceof ArrayBuffer || global.Blob && obj instanceof Blob || global.File && obj instanceof File) {
return true
}
if (isArray(obj)) {
for (var i = 0; i < obj.length; i++) {
if (_hasBinary(obj[i])) {
return true
}
}
} else if (obj && "object" == typeof obj) {
if (obj.toJSON) {
obj = obj.toJSON()
}
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {
return true
}
}
}
return false
}
return _hasBinary(data)
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {isarray: 24}],
22: [function (_dereq_, module, exports) {
try {
module.exports = typeof XMLHttpRequest !== "undefined" && "withCredentials" in new XMLHttpRequest
} catch (err) {
module.exports = false
}
}, {}],
23: [function (_dereq_, module, exports) {
var indexOf = [].indexOf;
module.exports = function (arr, obj) {
if (indexOf)return arr.indexOf(obj);
for (var i = 0; i < arr.length; ++i) {
if (arr[i] === obj)return i
}
return -1
}
}, {}],
24: [function (_dereq_, module, exports) {
module.exports = Array.isArray || function (arr) {
return Object.prototype.toString.call(arr) == "[object Array]"
}
}, {}],
25: [function (_dereq_, module, exports) {
var s = 1e3;
var m = s * 60;
var h = m * 60;
var d = h * 24;
var y = d * 365.25;
module.exports = function (val, options) {
options = options || {};
if ("string" == typeof val)return parse(val);
return options.long ? long(val) : short(val)
};
function parse(str) {
str = "" + str;
if (str.length > 1e4)return;
var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);
if (!match)return;
var n = parseFloat(match[1]);
var type = (match[2] || "ms").toLowerCase();
switch (type) {
case"years":
case"year":
case"yrs":
case"yr":
case"y":
return n * y;
case"days":
case"day":
case"d":
return n * d;
case"hours":
case"hour":
case"hrs":
case"hr":
case"h":
return n * h;
case"minutes":
case"minute":
case"mins":
case"min":
case"m":
return n * m;
case"seconds":
case"second":
case"secs":
case"sec":
case"s":
return n * s;
case"milliseconds":
case"millisecond":
case"msecs":
case"msec":
case"ms":
return n
}
}
function short(ms) {
if (ms >= d)return Math.round(ms / d) + "d";
if (ms >= h)return Math.round(ms / h) + "h";
if (ms >= m)return Math.round(ms / m) + "m";
if (ms >= s)return Math.round(ms / s) + "s";
return ms + "ms"
}
function long(ms) {
return plural(ms, d, "day") || plural(ms, h, "hour") || plural(ms, m, "minute") || plural(ms, s, "second") || ms + " ms"
}
function plural(ms, n, name) {
if (ms < n)return;
if (ms < n * 1.5)return Math.floor(ms / n) + " " + name;
return Math.ceil(ms / n) + " " + name + "s"
}
}, {}],
26: [function (_dereq_, module, exports) {
(function (global) {
var rvalidchars = /^[\],:{}\s]*$/;
var rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g;
var rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
var rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g;
var rtrimLeft = /^\s+/;
var rtrimRight = /\s+$/;
module.exports = function parsejson(data) {
if ("string" != typeof data || !data) {
return null
}
data = data.replace(rtrimLeft, "").replace(rtrimRight, "");
if (global.JSON && JSON.parse) {
return JSON.parse(data)
}
if (rvalidchars.test(data.replace(rvalidescape, "@").replace(rvalidtokens, "]").replace(rvalidbraces, ""))) {
return new Function("return " + data)()
}
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {}],
27: [function (_dereq_, module, exports) {
exports.encode = function (obj) {
var str = "";
for (var i in obj) {
if (obj.hasOwnProperty(i)) {
if (str.length)str += "&";
str += encodeURIComponent(i) + "=" + encodeURIComponent(obj[i])
}
}
return str
};
exports.decode = function (qs) {
var qry = {};
var pairs = qs.split("&");
for (var i = 0, l = pairs.length; i < l; i++) {
var pair = pairs[i].split("=");
qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1])
}
return qry
}
}, {}],
28: [function (_dereq_, module, exports) {
var re = /^(?:(?![^:@]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
var parts = ["source", "protocol", "authority", "userInfo", "user", "password", "host", "port", "relative", "path", "directory", "file", "query", "anchor"];
module.exports = function parseuri(str) {
var src = str, b = str.indexOf("["), e = str.indexOf("]");
if (b != -1 && e != -1) {
str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ";") + str.substring(e, str.length)
}
var m = re.exec(str || ""), uri = {}, i = 14;
while (i--) {
uri[parts[i]] = m[i] || ""
}
if (b != -1 && e != -1) {
uri.source = src;
uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ":");
uri.authority = uri.authority.replace("[", "").replace("]", "").replace(/;/g, ":");
uri.ipv6uri = true
}
return uri
}
}, {}],
29: [function (_dereq_, module, exports) {
(function (global) {
(function (root) {
var freeExports = typeof exports == "object" && exports;
var freeModule = typeof module == "object" && module && module.exports == freeExports && module;
var freeGlobal = typeof global == "object" && global;
if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
root = freeGlobal
}
var stringFromCharCode = String.fromCharCode;
function ucs2decode(string) {
var output = [];
var counter = 0;
var length = string.length;
var value;
var extra;
while (counter < length) {
value = string.charCodeAt(counter++);
if (value >= 55296 && value <= 56319 && counter < length) {
extra = string.charCodeAt(counter++);
if ((extra & 64512) == 56320) {
output.push(((value & 1023) << 10) + (extra & 1023) + 65536)
} else {
output.push(value);
counter--
}
} else {
output.push(value)
}
}
return output
}
function ucs2encode(array) {
var length = array.length;
var index = -1;
var value;
var output = "";
while (++index < length) {
value = array[index];
if (value > 65535) {
value -= 65536;
output += stringFromCharCode(value >>> 10 & 1023 | 55296);
value = 56320 | value & 1023
}
output += stringFromCharCode(value)
}
return output
}
function checkScalarValue(codePoint) {
if (codePoint >= 55296 && codePoint <= 57343) {
throw Error("Lone surrogate U+" + codePoint.toString(16).toUpperCase() + " is not a scalar value")
}
}
function createByte(codePoint, shift) {
return stringFromCharCode(codePoint >> shift & 63 | 128)
}
function encodeCodePoint(codePoint) {
if ((codePoint & 4294967168) == 0) {
return stringFromCharCode(codePoint)
}
var symbol = "";
if ((codePoint & 4294965248) == 0) {
symbol = stringFromCharCode(codePoint >> 6 & 31 | 192)
} else if ((codePoint & 4294901760) == 0) {
checkScalarValue(codePoint);
symbol = stringFromCharCode(codePoint >> 12 & 15 | 224);
symbol += createByte(codePoint, 6)
} else if ((codePoint & 4292870144) == 0) {
symbol = stringFromCharCode(codePoint >> 18 & 7 | 240);
symbol += createByte(codePoint, 12);
symbol += createByte(codePoint, 6)
}
symbol += stringFromCharCode(codePoint & 63 | 128);
return symbol
}
function utf8encode(string) {
var codePoints = ucs2decode(string);
var length = codePoints.length;
var index = -1;
var codePoint;
var byteString = "";
while (++index < length) {
codePoint = codePoints[index];
byteString += encodeCodePoint(codePoint)
}
return byteString
}
function readContinuationByte() {
if (byteIndex >= byteCount) {
throw Error("Invalid byte index")
}
var continuationByte = byteArray[byteIndex] & 255;
byteIndex++;
if ((continuationByte & 192) == 128) {
return continuationByte & 63
}
throw Error("Invalid continuation byte")
}
function decodeSymbol() {
var byte1;
var byte2;
var byte3;
var byte4;
var codePoint;
if (byteIndex > byteCount) {
throw Error("Invalid byte index")
}
if (byteIndex == byteCount) {
return false
}
byte1 = byteArray[byteIndex] & 255;
byteIndex++;
if ((byte1 & 128) == 0) {
return byte1
}
if ((byte1 & 224) == 192) {
var byte2 = readContinuationByte();
codePoint = (byte1 & 31) << 6 | byte2;
if (codePoint >= 128) {
return codePoint
} else {
throw Error("Invalid continuation byte")
}
}
if ((byte1 & 240) == 224) {
byte2 = readContinuationByte();
byte3 = readContinuationByte();
codePoint = (byte1 & 15) << 12 | byte2 << 6 | byte3;
if (codePoint >= 2048) {
checkScalarValue(codePoint);
return codePoint
} else {
throw Error("Invalid continuation byte")
}
}
if ((byte1 & 248) == 240) {
byte2 = readContinuationByte();
byte3 = readContinuationByte();
byte4 = readContinuationByte();
codePoint = (byte1 & 15) << 18 | byte2 << 12 | byte3 << 6 | byte4;
if (codePoint >= 65536 && codePoint <= 1114111) {
return codePoint
}
}
throw Error("Invalid UTF-8 detected")
}
var byteArray;
var byteCount;
var byteIndex;
function utf8decode(byteString) {
byteArray = ucs2decode(byteString);
byteCount = byteArray.length;
byteIndex = 0;
var codePoints = [];
var tmp;
while ((tmp = decodeSymbol()) !== false) {
codePoints.push(tmp)
}
return ucs2encode(codePoints)
}
var utf8 = {version: "2.0.0", encode: utf8encode, decode: utf8decode};
if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
define(function () {
return utf8
})
} else if (freeExports && !freeExports.nodeType) {
if (freeModule) {
freeModule.exports = utf8
} else {
var object = {};
var hasOwnProperty = object.hasOwnProperty;
for (var key in utf8) {
hasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key])
}
}
} else {
root.utf8 = utf8
}
})(this)
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {}],
30: [function (_dereq_, module, exports) {
"use strict";
var alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_".split(""), length = 64, map = {}, seed = 0, i = 0, prev;
function encode(num) {
var encoded = "";
do {
encoded = alphabet[num % length] + encoded;
num = Math.floor(num / length)
} while (num > 0);
return encoded
}
function decode(str) {
var decoded = 0;
for (i = 0; i < str.length; i++) {
decoded = decoded * length + map[str.charAt(i)]
}
return decoded
}
function yeast() {
var now = encode(+new Date);
if (now !== prev)return seed = 0, prev = now;
return now + "." + encode(seed++)
}
for (; i < length; i++)map[alphabet[i]] = i;
yeast.encode = encode;
yeast.decode = decode;
module.exports = yeast
}, {}],
31: [function (_dereq_, module, exports) {
var url = _dereq_("./url");
var parser = _dereq_("socket.io-parser");
var Manager = _dereq_("./manager");
var debug = _dereq_("debug")("socket.io-client");
module.exports = exports = lookup;
var cache = exports.managers = {};
function lookup(uri, opts) {
if (typeof uri == "object") {
opts = uri;
uri = undefined
}
opts = opts || {};
var parsed = url(uri);
var source = parsed.source;
var id = parsed.id;
var path = parsed.path;
var sameNamespace = cache[id] && path in cache[id].nsps;
var newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;
var io;
if (newConnection) {
debug("ignoring socket cache for %s", source);
io = Manager(source, opts)
} else {
if (!cache[id]) {
debug("new io instance for %s", source);
cache[id] = Manager(source, opts)
}
io = cache[id]
}
return io.socket(parsed.path)
}
exports.protocol = parser.protocol;
exports.connect = lookup;
exports.Manager = _dereq_("./manager");
exports.Socket = _dereq_("./socket")
}, {"./manager": 32, "./socket": 34, "./url": 35, debug: 39, "socket.io-parser": 47}],
32: [function (_dereq_, module, exports) {
var eio = _dereq_("engine.io-client");
var Socket = _dereq_("./socket");
var Emitter = _dereq_("component-emitter");
var parser = _dereq_("socket.io-parser");
var on = _dereq_("./on");
var bind = _dereq_("component-bind");
var debug = _dereq_("debug")("socket.io-client:manager");
var indexOf = _dereq_("indexof");
var Backoff = _dereq_("backo2");
var has = Object.prototype.hasOwnProperty;
module.exports = Manager;
function Manager(uri, opts) {
if (!(this instanceof Manager))return new Manager(uri, opts);
if (uri && "object" == typeof uri) {
opts = uri;
uri = undefined
}
opts = opts || {};
opts.path = opts.path || "/socket.io";
this.nsps = {};
this.subs = [];
this.opts = opts;
this.reconnection(opts.reconnection !== false);
this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
this.reconnectionDelay(opts.reconnectionDelay || 1e3);
this.reconnectionDelayMax(opts.reconnectionDelayMax || 5e3);
this.randomizationFactor(opts.randomizationFactor || .5);
this.backoff = new Backoff({
min: this.reconnectionDelay(),
max: this.reconnectionDelayMax(),
jitter: this.randomizationFactor()
});
this.timeout(null == opts.timeout ? 2e4 : opts.timeout);
this.readyState = "closed";
this.uri = uri;
this.connecting = [];
this.lastPing = null;
this.encoding = false;
this.packetBuffer = [];
this.encoder = new parser.Encoder;
this.decoder = new parser.Decoder;
this.autoConnect = opts.autoConnect !== false;
if (this.autoConnect)this.open()
}
Manager.prototype.emitAll = function () {
this.emit.apply(this, arguments);
for (var nsp in this.nsps) {
if (has.call(this.nsps, nsp)) {
this.nsps[nsp].emit.apply(this.nsps[nsp], arguments)
}
}
};
Manager.prototype.updateSocketIds = function () {
for (var nsp in this.nsps) {
if (has.call(this.nsps, nsp)) {
this.nsps[nsp].id = this.engine.id
}
}
};
Emitter(Manager.prototype);
Manager.prototype.reconnection = function (v) {
if (!arguments.length)return this._reconnection;
this._reconnection = !!v;
return this
};
Manager.prototype.reconnectionAttempts = function (v) {
if (!arguments.length)return this._reconnectionAttempts;
this._reconnectionAttempts = v;
return this
};
Manager.prototype.reconnectionDelay = function (v) {
if (!arguments.length)return this._reconnectionDelay;
this._reconnectionDelay = v;
this.backoff && this.backoff.setMin(v);
return this
};
Manager.prototype.randomizationFactor = function (v) {
if (!arguments.length)return this._randomizationFactor;
this._randomizationFactor = v;
this.backoff && this.backoff.setJitter(v);
return this
};
Manager.prototype.reconnectionDelayMax = function (v) {
if (!arguments.length)return this._reconnectionDelayMax;
this._reconnectionDelayMax = v;
this.backoff && this.backoff.setMax(v);
return this
};
Manager.prototype.timeout = function (v) {
if (!arguments.length)return this._timeout;
this._timeout = v;
return this
};
Manager.prototype.maybeReconnectOnOpen = function () {
if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) {
this.reconnect()
}
};
Manager.prototype.open = Manager.prototype.connect = function (fn) {
debug("readyState %s", this.readyState);
if (~this.readyState.indexOf("open"))return this;
debug("opening %s", this.uri);
this.engine = eio(this.uri, this.opts);
var socket = this.engine;
var self = this;
this.readyState = "opening";
this.skipReconnect = false;
var openSub = on(socket, "open", function () {
self.onopen();
fn && fn()
});
var errorSub = on(socket, "error", function (data) {
debug("connect_error");
self.cleanup();
self.readyState = "closed";
self.emitAll("connect_error", data);
if (fn) {
var err = new Error("Connection error");
err.data = data;
fn(err)
} else {
self.maybeReconnectOnOpen()
}
});
if (false !== this._timeout) {
var timeout = this._timeout;
debug("connect attempt will timeout after %d", timeout);
var timer = setTimeout(function () {
debug("connect attempt timed out after %d", timeout);
openSub.destroy();
socket.close();
socket.emit("error", "timeout");
self.emitAll("connect_timeout", timeout)
}, timeout);
this.subs.push({
destroy: function () {
clearTimeout(timer)
}
})
}
this.subs.push(openSub);
this.subs.push(errorSub);
return this
};
Manager.prototype.onopen = function () {
debug("open");
this.cleanup();
this.readyState = "open";
this.emit("open");
var socket = this.engine;
this.subs.push(on(socket, "data", bind(this, "ondata")));
this.subs.push(on(socket, "ping", bind(this, "onping")));
this.subs.push(on(socket, "pong", bind(this, "onpong")));
this.subs.push(on(socket, "error", bind(this, "onerror")));
this.subs.push(on(socket, "close", bind(this, "onclose")));
this.subs.push(on(this.decoder, "decoded", bind(this, "ondecoded")))
};
Manager.prototype.onping = function () {
this.lastPing = new Date;
this.emitAll("ping")
};
Manager.prototype.onpong = function () {
this.emitAll("pong", new Date - this.lastPing)
};
Manager.prototype.ondata = function (data) {
this.decoder.add(data)
};
Manager.prototype.ondecoded = function (packet) {
this.emit("packet", packet)
};
Manager.prototype.onerror = function (err) {
debug("error", err);
this.emitAll("error", err)
};
Manager.prototype.socket = function (nsp) {
var socket = this.nsps[nsp];
if (!socket) {
socket = new Socket(this, nsp);
this.nsps[nsp] = socket;
var self = this;
socket.on("connecting", onConnecting);
socket.on("connect", function () {
socket.id = self.engine.id
});
if (this.autoConnect) {
onConnecting()
}
}
function onConnecting() {
if (!~indexOf(self.connecting, socket)) {
self.connecting.push(socket)
}
}
return socket
};
Manager.prototype.destroy = function (socket) {
var index = indexOf(this.connecting, socket);
if (~index)this.connecting.splice(index, 1);
if (this.connecting.length)return;
this.close()
};
Manager.prototype.packet = function (packet) {
debug("writing packet %j", packet);
var self = this;
if (!self.encoding) {
self.encoding = true;
this.encoder.encode(packet, function (encodedPackets) {
for (var i = 0; i < encodedPackets.length; i++) {
self.engine.write(encodedPackets[i], packet.options)
}
self.encoding = false;
self.processPacketQueue()
})
} else {
self.packetBuffer.push(packet)
}
};
Manager.prototype.processPacketQueue = function () {
if (this.packetBuffer.length > 0 && !this.encoding) {
var pack = this.packetBuffer.shift();
this.packet(pack)
}
};
Manager.prototype.cleanup = function () {
debug("cleanup");
var sub;
while (sub = this.subs.shift())sub.destroy();
this.packetBuffer = [];
this.encoding = false;
this.lastPing = null;
this.decoder.destroy()
};
Manager.prototype.close = Manager.prototype.disconnect = function () {
debug("disconnect");
this.skipReconnect = true;
this.reconnecting = false;
if ("opening" == this.readyState) {
this.cleanup()
}
this.backoff.reset();
this.readyState = "closed";
if (this.engine)this.engine.close()
};
Manager.prototype.onclose = function (reason) {
debug("onclose");
this.cleanup();
this.backoff.reset();
this.readyState = "closed";
this.emit("close", reason);
if (this._reconnection && !this.skipReconnect) {
this.reconnect()
}
};
Manager.prototype.reconnect = function () {
if (this.reconnecting || this.skipReconnect)return this;
var self = this;
if (this.backoff.attempts >= this._reconnectionAttempts) {
debug("reconnect failed");
this.backoff.reset();
this.emitAll("reconnect_failed");
this.reconnecting = false
} else {
var delay = this.backoff.duration();
debug("will wait %dms before reconnect attempt", delay);
this.reconnecting = true;
var timer = setTimeout(function () {
if (self.skipReconnect)return;
debug("attempting reconnect");
self.emitAll("reconnect_attempt", self.backoff.attempts);
self.emitAll("reconnecting", self.backoff.attempts);
if (self.skipReconnect)return;
self.open(function (err) {
if (err) {
debug("reconnect attempt error");
self.reconnecting = false;
self.reconnect();
self.emitAll("reconnect_error", err.data)
} else {
debug("reconnect success");
self.onreconnect()
}
})
}, delay);
this.subs.push({
destroy: function () {
clearTimeout(timer)
}
})
}
};
Manager.prototype.onreconnect = function () {
var attempt = this.backoff.attempts;
this.reconnecting = false;
this.backoff.reset();
this.updateSocketIds();
this.emitAll("reconnect", attempt)
}
}, {
"./on": 33,
"./socket": 34,
backo2: 36,
"component-bind": 37,
"component-emitter": 38,
debug: 39,
"engine.io-client": 1,
indexof: 42,
"socket.io-parser": 47
}],
33: [function (_dereq_, module, exports) {
module.exports = on;
function on(obj, ev, fn) {
obj.on(ev, fn);
return {
destroy: function () {
obj.removeListener(ev, fn)
}
}
}
}, {}],
34: [function (_dereq_, module, exports) {
var parser = _dereq_("socket.io-parser");
var Emitter = _dereq_("component-emitter");
var toArray = _dereq_("to-array");
var on = _dereq_("./on");
var bind = _dereq_("component-bind");
var debug = _dereq_("debug")("socket.io-client:socket");
var hasBin = _dereq_("has-binary");
module.exports = exports = Socket;
var events = {
connect: 1,
connect_error: 1,
connect_timeout: 1,
connecting: 1,
disconnect: 1,
error: 1,
reconnect: 1,
reconnect_attempt: 1,
reconnect_failed: 1,
reconnect_error: 1,
reconnecting: 1,
ping: 1,
pong: 1
};
var emit = Emitter.prototype.emit;
function Socket(io, nsp) {
this.io = io;
this.nsp = nsp;
this.json = this;
this.ids = 0;
this.acks = {};
this.receiveBuffer = [];
this.sendBuffer = [];
this.connected = false;
this.disconnected = true;
if (this.io.autoConnect)this.open()
}
Emitter(Socket.prototype);
Socket.prototype.subEvents = function () {
if (this.subs)return;
var io = this.io;
this.subs = [on(io, "open", bind(this, "onopen")), on(io, "packet", bind(this, "onpacket")), on(io, "close", bind(this, "onclose"))]
};
Socket.prototype.open = Socket.prototype.connect = function () {
if (this.connected)return this;
this.subEvents();
this.io.open();
if ("open" == this.io.readyState)this.onopen();
this.emit("connecting");
return this
};
Socket.prototype.send = function () {
var args = toArray(arguments);
args.unshift("message");
this.emit.apply(this, args);
return this
};
Socket.prototype.emit = function (ev) {
if (events.hasOwnProperty(ev)) {
emit.apply(this, arguments);
return this
}
var args = toArray(arguments);
var parserType = parser.EVENT;
if (hasBin(args)) {
parserType = parser.BINARY_EVENT
}
var packet = {type: parserType, data: args};
packet.options = {};
packet.options.compress = !this.flags || false !== this.flags.compress;
if ("function" == typeof args[args.length - 1]) {
debug("emitting packet with ack id %d", this.ids);
this.acks[this.ids] = args.pop();
packet.id = this.ids++
}
if (this.connected) {
this.packet(packet)
} else {
this.sendBuffer.push(packet)
}
delete this.flags;
return this
};
Socket.prototype.packet = function (packet) {
packet.nsp = this.nsp;
this.io.packet(packet)
};
Socket.prototype.onopen = function () {
debug("transport is open - connecting");
if ("/" != this.nsp) {
this.packet({type: parser.CONNECT})
}
};
Socket.prototype.onclose = function (reason) {
debug("close (%s)", reason);
this.connected = false;
this.disconnected = true;
delete this.id;
this.emit("disconnect", reason)
};
Socket.prototype.onpacket = function (packet) {
if (packet.nsp != this.nsp)return;
switch (packet.type) {
case parser.CONNECT:
this.onconnect();
break;
case parser.EVENT:
this.onevent(packet);
break;
case parser.BINARY_EVENT:
this.onevent(packet);
break;
case parser.ACK:
this.onack(packet);
break;
case parser.BINARY_ACK:
this.onack(packet);
break;
case parser.DISCONNECT:
this.ondisconnect();
break;
case parser.ERROR:
this.emit("error", packet.data);
break
}
};
Socket.prototype.onevent = function (packet) {
var args = packet.data || [];
debug("emitting event %j", args);
if (null != packet.id) {
debug("attaching ack callback to event");
args.push(this.ack(packet.id))
}
if (this.connected) {
emit.apply(this, args)
} else {
this.receiveBuffer.push(args)
}
};
Socket.prototype.ack = function (id) {
var self = this;
var sent = false;
return function () {
if (sent)return;
sent = true;
var args = toArray(arguments);
debug("sending ack %j", args);
var type = hasBin(args) ? parser.BINARY_ACK : parser.ACK;
self.packet({type: type, id: id, data: args})
}
};
Socket.prototype.onack = function (packet) {
var ack = this.acks[packet.id];
if ("function" == typeof ack) {
debug("calling ack %s with %j", packet.id, packet.data);
ack.apply(this, packet.data);
delete this.acks[packet.id]
} else {
debug("bad ack %s", packet.id)
}
};
Socket.prototype.onconnect = function () {
this.connected = true;
this.disconnected = false;
this.emit("connect");
this.emitBuffered()
};
Socket.prototype.emitBuffered = function () {
var i;
for (i = 0; i < this.receiveBuffer.length; i++) {
emit.apply(this, this.receiveBuffer[i])
}
this.receiveBuffer = [];
for (i = 0; i < this.sendBuffer.length; i++) {
this.packet(this.sendBuffer[i])
}
this.sendBuffer = []
};
Socket.prototype.ondisconnect = function () {
debug("server disconnect (%s)", this.nsp);
this.destroy();
this.onclose("io server disconnect")
};
Socket.prototype.destroy = function () {
if (this.subs) {
for (var i = 0; i < this.subs.length; i++) {
this.subs[i].destroy()
}
this.subs = null
}
this.io.destroy(this)
};
Socket.prototype.close = Socket.prototype.disconnect = function () {
if (this.connected) {
debug("performing disconnect (%s)", this.nsp);
this.packet({type: parser.DISCONNECT})
}
this.destroy();
if (this.connected) {
this.onclose("io client disconnect")
}
return this
};
Socket.prototype.compress = function (compress) {
this.flags = this.flags || {};
this.flags.compress = compress;
return this
}
}, {
"./on": 33,
"component-bind": 37,
"component-emitter": 38,
debug: 39,
"has-binary": 41,
"socket.io-parser": 47,
"to-array": 51
}],
35: [function (_dereq_, module, exports) {
(function (global) {
var parseuri = _dereq_("parseuri");
var debug = _dereq_("debug")("socket.io-client:url");
module.exports = url;
function url(uri, loc) {
var obj = uri;
var loc = loc || global.location;
if (null == uri)uri = loc.protocol + "//" + loc.host;
if ("string" == typeof uri) {
if ("/" == uri.charAt(0)) {
if ("/" == uri.charAt(1)) {
uri = loc.protocol + uri
} else {
uri = loc.host + uri
}
}
if (!/^(https?|wss?):\/\//.test(uri)) {
debug("protocol-less url %s", uri);
if ("undefined" != typeof loc) {
uri = loc.protocol + "//" + uri
} else {
uri = "https://" + uri
}
}
debug("parse %s", uri);
obj = parseuri(uri)
}
if (!obj.port) {
if (/^(http|ws)$/.test(obj.protocol)) {
obj.port = "80"
} else if (/^(http|ws)s$/.test(obj.protocol)) {
obj.port = "443"
}
}
obj.path = obj.path || "/";
var ipv6 = obj.host.indexOf(":") !== -1;
var host = ipv6 ? "[" + obj.host + "]" : obj.host;
obj.id = obj.protocol + "://" + host + ":" + obj.port;
obj.href = obj.protocol + "://" + host + (loc && loc.port == obj.port ? "" : ":" + obj.port);
return obj
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {debug: 39, parseuri: 45}],
36: [function (_dereq_, module, exports) {
module.exports = Backoff;
function Backoff(opts) {
opts = opts || {};
this.ms = opts.min || 100;
this.max = opts.max || 1e4;
this.factor = opts.factor || 2;
this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
this.attempts = 0
}
Backoff.prototype.duration = function () {
var ms = this.ms * Math.pow(this.factor, this.attempts++);
if (this.jitter) {
var rand = Math.random();
var deviation = Math.floor(rand * this.jitter * ms);
ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation
}
return Math.min(ms, this.max) | 0
};
Backoff.prototype.reset = function () {
this.attempts = 0
};
Backoff.prototype.setMin = function (min) {
this.ms = min
};
Backoff.prototype.setMax = function (max) {
this.max = max
};
Backoff.prototype.setJitter = function (jitter) {
this.jitter = jitter
}
}, {}],
37: [function (_dereq_, module, exports) {
var slice = [].slice;
module.exports = function (obj, fn) {
if ("string" == typeof fn)fn = obj[fn];
if ("function" != typeof fn)throw new Error("bind() requires a function");
var args = slice.call(arguments, 2);
return function () {
return fn.apply(obj, args.concat(slice.call(arguments)))
}
}
}, {}],
38: [function (_dereq_, module, exports) {
module.exports = Emitter;
function Emitter(obj) {
if (obj)return mixin(obj)
}
function mixin(obj) {
for (var key in Emitter.prototype) {
obj[key] = Emitter.prototype[key]
}
return obj
}
Emitter.prototype.on = Emitter.prototype.addEventListener = function (event, fn) {
this._callbacks = this._callbacks || {};
(this._callbacks["$" + event] = this._callbacks["$" + event] || []).push(fn);
return this
};
Emitter.prototype.once = function (event, fn) {
function on() {
this.off(event, on);
fn.apply(this, arguments)
}
on.fn = fn;
this.on(event, on);
return this
};
Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function (event, fn) {
this._callbacks = this._callbacks || {};
if (0 == arguments.length) {
this._callbacks = {};
return this
}
var callbacks = this._callbacks["$" + event];
if (!callbacks)return this;
if (1 == arguments.length) {
delete this._callbacks["$" + event];
return this
}
var cb;
for (var i = 0; i < callbacks.length; i++) {
cb = callbacks[i];
if (cb === fn || cb.fn === fn) {
callbacks.splice(i, 1);
break
}
}
return this
};
Emitter.prototype.emit = function (event) {
this._callbacks = this._callbacks || {};
var args = [].slice.call(arguments, 1), callbacks = this._callbacks["$" + event];
if (callbacks) {
callbacks = callbacks.slice(0);
for (var i = 0, len = callbacks.length; i < len; ++i) {
callbacks[i].apply(this, args)
}
}
return this
};
Emitter.prototype.listeners = function (event) {
this._callbacks = this._callbacks || {};
return this._callbacks["$" + event] || []
};
Emitter.prototype.hasListeners = function (event) {
return !!this.listeners(event).length
}
}, {}],
39: [function (_dereq_, module, exports) {
arguments[4][17][0].apply(exports, arguments)
}, {"./debug": 40, dup: 17}],
40: [function (_dereq_, module, exports) {
arguments[4][18][0].apply(exports, arguments)
}, {dup: 18, ms: 44}],
41: [function (_dereq_, module, exports) {
(function (global) {
var isArray = _dereq_("isarray");
module.exports = hasBinary;
function hasBinary(data) {
function _hasBinary(obj) {
if (!obj)return false;
if (global.Buffer && global.Buffer.isBuffer && global.Buffer.isBuffer(obj) || global.ArrayBuffer && obj instanceof ArrayBuffer || global.Blob && obj instanceof Blob || global.File && obj instanceof File) {
return true
}
if (isArray(obj)) {
for (var i = 0; i < obj.length; i++) {
if (_hasBinary(obj[i])) {
return true
}
}
} else if (obj && "object" == typeof obj) {
if (obj.toJSON && "function" == typeof obj.toJSON) {
obj = obj.toJSON()
}
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {
return true
}
}
}
return false
}
return _hasBinary(data)
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {isarray: 43}],
42: [function (_dereq_, module, exports) {
arguments[4][23][0].apply(exports, arguments)
}, {dup: 23}],
43: [function (_dereq_, module, exports) {
arguments[4][24][0].apply(exports, arguments)
}, {dup: 24}],
44: [function (_dereq_, module, exports) {
arguments[4][25][0].apply(exports, arguments)
}, {dup: 25}],
45: [function (_dereq_, module, exports) {
arguments[4][28][0].apply(exports, arguments)
}, {dup: 28}],
46: [function (_dereq_, module, exports) {
(function (global) {
var isArray = _dereq_("isarray");
var isBuf = _dereq_("./is-buffer");
exports.deconstructPacket = function (packet) {
var buffers = [];
var packetData = packet.data;
function _deconstructPacket(data) {
if (!data)return data;
if (isBuf(data)) {
var placeholder = {_placeholder: true, num: buffers.length};
buffers.push(data);
return placeholder
} else if (isArray(data)) {
var newData = new Array(data.length);
for (var i = 0; i < data.length; i++) {
newData[i] = _deconstructPacket(data[i])
}
return newData
} else if ("object" == typeof data && !(data instanceof Date)) {
var newData = {};
for (var key in data) {
newData[key] = _deconstructPacket(data[key])
}
return newData
}
return data
}
var pack = packet;
pack.data = _deconstructPacket(packetData);
pack.attachments = buffers.length;
return {packet: pack, buffers: buffers}
};
exports.reconstructPacket = function (packet, buffers) {
var curPlaceHolder = 0;
function _reconstructPacket(data) {
if (data && data._placeholder) {
var buf = buffers[data.num];
return buf
} else if (isArray(data)) {
for (var i = 0; i < data.length; i++) {
data[i] = _reconstructPacket(data[i])
}
return data
} else if (data && "object" == typeof data) {
for (var key in data) {
data[key] = _reconstructPacket(data[key])
}
return data
}
return data
}
packet.data = _reconstructPacket(packet.data);
packet.attachments = undefined;
return packet
};
exports.removeBlobs = function (data, callback) {
function _removeBlobs(obj, curKey, containingObject) {
if (!obj)return obj;
if (global.Blob && obj instanceof Blob || global.File && obj instanceof File) {
pendingBlobs++;
var fileReader = new FileReader;
fileReader.onload = function () {
if (containingObject) {
containingObject[curKey] = this.result
} else {
bloblessData = this.result
}
if (!--pendingBlobs) {
callback(bloblessData)
}
};
fileReader.readAsArrayBuffer(obj)
} else if (isArray(obj)) {
for (var i = 0; i < obj.length; i++) {
_removeBlobs(obj[i], i, obj)
}
} else if (obj && "object" == typeof obj && !isBuf(obj)) {
for (var key in obj) {
_removeBlobs(obj[key], key, obj)
}
}
}
var pendingBlobs = 0;
var bloblessData = data;
_removeBlobs(bloblessData);
if (!pendingBlobs) {
callback(bloblessData)
}
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {"./is-buffer": 48, isarray: 43}],
47: [function (_dereq_, module, exports) {
var debug = _dereq_("debug")("socket.io-parser");
var json = _dereq_("json3");
var isArray = _dereq_("isarray");
var Emitter = _dereq_("component-emitter");
var binary = _dereq_("./binary");
var isBuf = _dereq_("./is-buffer");
exports.protocol = 4;
exports.types = ["CONNECT", "DISCONNECT", "EVENT", "BINARY_EVENT", "ACK", "BINARY_ACK", "ERROR"];
exports.CONNECT = 0;
exports.DISCONNECT = 1;
exports.EVENT = 2;
exports.ACK = 3;
exports.ERROR = 4;
exports.BINARY_EVENT = 5;
exports.BINARY_ACK = 6;
exports.Encoder = Encoder;
exports.Decoder = Decoder;
function Encoder() {
}
Encoder.prototype.encode = function (obj, callback) {
debug("encoding packet %j", obj);
if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {
encodeAsBinary(obj, callback)
} else {
var encoding = encodeAsString(obj);
callback([encoding])
}
};
function encodeAsString(obj) {
var str = "";
var nsp = false;
str += obj.type;
if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {
str += obj.attachments;
str += "-"
}
if (obj.nsp && "/" != obj.nsp) {
nsp = true;
str += obj.nsp
}
if (null != obj.id) {
if (nsp) {
str += ",";
nsp = false
}
str += obj.id
}
if (null != obj.data) {
if (nsp)str += ",";
str += json.stringify(obj.data)
}
debug("encoded %j as %s", obj, str);
return str
}
function encodeAsBinary(obj, callback) {
function writeEncoding(bloblessData) {
var deconstruction = binary.deconstructPacket(bloblessData);
var pack = encodeAsString(deconstruction.packet);
var buffers = deconstruction.buffers;
buffers.unshift(pack);
callback(buffers)
}
binary.removeBlobs(obj, writeEncoding)
}
function Decoder() {
this.reconstructor = null
}
Emitter(Decoder.prototype);
Decoder.prototype.add = function (obj) {
var packet;
if ("string" == typeof obj) {
packet = decodeString(obj);
if (exports.BINARY_EVENT == packet.type || exports.BINARY_ACK == packet.type) {
this.reconstructor = new BinaryReconstructor(packet);
if (this.reconstructor.reconPack.attachments === 0) {
this.emit("decoded", packet)
}
} else {
this.emit("decoded", packet)
}
} else if (isBuf(obj) || obj.base64) {
if (!this.reconstructor) {
throw new Error("got binary data when not reconstructing a packet")
} else {
packet = this.reconstructor.takeBinaryData(obj);
if (packet) {
this.reconstructor = null;
this.emit("decoded", packet)
}
}
} else {
throw new Error("Unknown type: " + obj)
}
};
function decodeString(str) {
var p = {};
var i = 0;
p.type = Number(str.charAt(0));
if (null == exports.types[p.type])return error();
if (exports.BINARY_EVENT == p.type || exports.BINARY_ACK == p.type) {
var buf = "";
while (str.charAt(++i) != "-") {
buf += str.charAt(i);
if (i == str.length)break
}
if (buf != Number(buf) || str.charAt(i) != "-") {
throw new Error("Illegal attachments")
}
p.attachments = Number(buf)
}
if ("/" == str.charAt(i + 1)) {
p.nsp = "";
while (++i) {
var c = str.charAt(i);
if ("," == c)break;
p.nsp += c;
if (i == str.length)break
}
} else {
p.nsp = "/"
}
var next = str.charAt(i + 1);
if ("" !== next && Number(next) == next) {
p.id = "";
while (++i) {
var c = str.charAt(i);
if (null == c || Number(c) != c) {
--i;
break
}
p.id += str.charAt(i);
if (i == str.length)break
}
p.id = Number(p.id)
}
if (str.charAt(++i)) {
try {
p.data = json.parse(str.substr(i))
} catch (e) {
return error()
}
}
debug("decoded %s as %j", str, p);
return p
}
Decoder.prototype.destroy = function () {
if (this.reconstructor) {
this.reconstructor.finishedReconstruction()
}
};
function BinaryReconstructor(packet) {
this.reconPack = packet;
this.buffers = []
}
BinaryReconstructor.prototype.takeBinaryData = function (binData) {
this.buffers.push(binData);
if (this.buffers.length == this.reconPack.attachments) {
var packet = binary.reconstructPacket(this.reconPack, this.buffers);
this.finishedReconstruction();
return packet
}
return null
};
BinaryReconstructor.prototype.finishedReconstruction = function () {
this.reconPack = null;
this.buffers = []
};
function error(data) {
return {type: exports.ERROR, data: "parser error"}
}
}, {"./binary": 46, "./is-buffer": 48, "component-emitter": 49, debug: 39, isarray: 43, json3: 50}],
48: [function (_dereq_, module, exports) {
(function (global) {
module.exports = isBuf;
function isBuf(obj) {
return global.Buffer && global.Buffer.isBuffer(obj) || global.ArrayBuffer && obj instanceof ArrayBuffer
}
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {}],
49: [function (_dereq_, module, exports) {
arguments[4][15][0].apply(exports, arguments)
}, {dup: 15}],
50: [function (_dereq_, module, exports) {
(function (global) {
(function () {
var isLoader = typeof define === "function" && define.amd;
var objectTypes = {"function": true, object: true};
var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
var root = objectTypes[typeof window] && window || this, freeGlobal = freeExports && objectTypes[typeof module] && module && !module.nodeType && typeof global == "object" && global;
if (freeGlobal && (freeGlobal["global"] === freeGlobal || freeGlobal["window"] === freeGlobal || freeGlobal["self"] === freeGlobal)) {
root = freeGlobal
}
function runInContext(context, exports) {
context || (context = root["Object"]());
exports || (exports = root["Object"]());
var Number = context["Number"] || root["Number"], String = context["String"] || root["String"], Object = context["Object"] || root["Object"], Date = context["Date"] || root["Date"], SyntaxError = context["SyntaxError"] || root["SyntaxError"], TypeError = context["TypeError"] || root["TypeError"], Math = context["Math"] || root["Math"], nativeJSON = context["JSON"] || root["JSON"];
if (typeof nativeJSON == "object" && nativeJSON) {
exports.stringify = nativeJSON.stringify;
exports.parse = nativeJSON.parse
}
var objectProto = Object.prototype, getClass = objectProto.toString, isProperty, forEach, undef;
var isExtended = new Date(-0xc782b5b800cec);
try {
isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 && isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708
} catch (exception) {
}
function has(name) {
if (has[name] !== undef) {
return has[name]
}
var isSupported;
if (name == "bug-string-char-index") {
isSupported = "a"[0] != "a"
} else if (name == "json") {
isSupported = has("json-stringify") && has("json-parse")
} else {
var value, serialized = '{"a":[1,true,false,null,"\\u0000\\b\\n\\f\\r\\t"]}';
if (name == "json-stringify") {
var stringify = exports.stringify, stringifySupported = typeof stringify == "function" && isExtended;
if (stringifySupported) {
(value = function () {
return 1
}).toJSON = value;
try {
stringifySupported = stringify(0) === "0" && stringify(Number) === "0" && stringify(String) == '""' && stringify(getClass) === undef && stringify(undef) === undef && stringify() === undef && stringify(value) === "1" && stringify([value]) == "[1]" && stringify([undef]) == "[null]" && stringify(null) == "null" && stringify([undef, getClass, null]) == "[null,null,null]" && stringify({a: [value, true, false, null, "\x00\b\n\f\r "]}) == serialized && stringify(null, value) === "1" && stringify([1, 2], null, 1) == "[\n 1,\n 2\n]" && stringify(new Date(-864e13)) == '"-271821-04-20T00:00:00.000Z"' && stringify(new Date(864e13)) == '"+275760-09-13T00:00:00.000Z"' && stringify(new Date(-621987552e5)) == '"-000001-01-01T00:00:00.000Z"' && stringify(new Date(-1)) == '"1969-12-31T23:59:59.999Z"'
} catch (exception) {
stringifySupported = false
}
}
isSupported = stringifySupported
}
if (name == "json-parse") {
var parse = exports.parse;
if (typeof parse == "function") {
try {
if (parse("0") === 0 && !parse(false)) {
value = parse(serialized);
var parseSupported = value["a"].length == 5 && value["a"][0] === 1;
if (parseSupported) {
try {
parseSupported = !parse('" "')
} catch (exception) {
}
if (parseSupported) {
try {
parseSupported = parse("01") !== 1
} catch (exception) {
}
}
if (parseSupported) {
try {
parseSupported = parse("1.") !== 1
} catch (exception) {
}
}
}
}
} catch (exception) {
parseSupported = false
}
}
isSupported = parseSupported
}
}
return has[name] = !!isSupported
}
if (!has("json")) {
var functionClass = "[object Function]", dateClass = "[object Date]", numberClass = "[object Number]", stringClass = "[object String]", arrayClass = "[object Array]", booleanClass = "[object Boolean]";
var charIndexBuggy = has("bug-string-char-index");
if (!isExtended) {
var floor = Math.floor;
var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
var getDay = function (year, month) {
return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400)
}
}
if (!(isProperty = objectProto.hasOwnProperty)) {
isProperty = function (property) {
var members = {}, constructor;
if ((members.__proto__ = null, members.__proto__ = {toString: 1}, members).toString != getClass) {
isProperty = function (property) {
var original = this.__proto__, result = property in (this.__proto__ = null, this);
this.__proto__ = original;
return result
}
} else {
constructor = members.constructor;
isProperty = function (property) {
var parent = (this.constructor || constructor).prototype;
return property in this && !(property in parent && this[property] === parent[property])
}
}
members = null;
return isProperty.call(this, property)
}
}
forEach = function (object, callback) {
var size = 0, Properties, members, property;
(Properties = function () {
this.valueOf = 0
}).prototype.valueOf = 0;
members = new Properties;
for (property in members) {
if (isProperty.call(members, property)) {
size++
}
}
Properties = members = null;
if (!size) {
members = ["valueOf", "toString", "toLocaleString", "propertyIsEnumerable", "isPrototypeOf", "hasOwnProperty", "constructor"];
forEach = function (object, callback) {
var isFunction = getClass.call(object) == functionClass, property, length;
var hasProperty = !isFunction && typeof object.constructor != "function" && objectTypes[typeof object.hasOwnProperty] && object.hasOwnProperty || isProperty;
for (property in object) {
if (!(isFunction && property == "prototype") && hasProperty.call(object, property)) {
callback(property)
}
}
for (length = members.length; property = members[--length]; hasProperty.call(object, property) && callback(property));
}
} else if (size == 2) {
forEach = function (object, callback) {
var members = {}, isFunction = getClass.call(object) == functionClass, property;
for (property in object) {
if (!(isFunction && property == "prototype") && !isProperty.call(members, property) && (members[property] = 1) && isProperty.call(object, property)) {
callback(property)
}
}
}
} else {
forEach = function (object, callback) {
var isFunction = getClass.call(object) == functionClass, property, isConstructor;
for (property in object) {
if (!(isFunction && property == "prototype") && isProperty.call(object, property) && !(isConstructor = property === "constructor")) {
callback(property)
}
}
if (isConstructor || isProperty.call(object, property = "constructor")) {
callback(property)
}
}
}
return forEach(object, callback)
};
if (!has("json-stringify")) {
var Escapes = {
92: "\\\\",
34: '\\"',
8: "\\b",
12: "\\f",
10: "\\n",
13: "\\r",
9: "\\t"
};
var leadingZeroes = "000000";
var toPaddedString = function (width, value) {
return (leadingZeroes + (value || 0)).slice(-width)
};
var unicodePrefix = "\\u00";
var quote = function (value) {
var result = '"', index = 0, length = value.length, useCharIndex = !charIndexBuggy || length > 10;
var symbols = useCharIndex && (charIndexBuggy ? value.split("") : value);
for (; index < length; index++) {
var charCode = value.charCodeAt(index);
switch (charCode) {
case 8:
case 9:
case 10:
case 12:
case 13:
case 34:
case 92:
result += Escapes[charCode];
break;
default:
if (charCode < 32) {
result += unicodePrefix + toPaddedString(2, charCode.toString(16));
break
}
result += useCharIndex ? symbols[index] : value.charAt(index)
}
}
return result + '"'
};
var serialize = function (property, object, callback, properties, whitespace, indentation, stack) {
var value, className, year, month, date, time, hours, minutes, seconds, milliseconds, results, element, index, length, prefix, result;
try {
value = object[property]
} catch (exception) {
}
if (typeof value == "object" && value) {
className = getClass.call(value);
if (className == dateClass && !isProperty.call(value, "toJSON")) {
if (value > -1 / 0 && value < 1 / 0) {
if (getDay) {
date = floor(value / 864e5);
for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);
for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);
date = 1 + date - getDay(year, month);
time = (value % 864e5 + 864e5) % 864e5;
hours = floor(time / 36e5) % 24;
minutes = floor(time / 6e4) % 60;
seconds = floor(time / 1e3) % 60;
milliseconds = time % 1e3
} else {
year = value.getUTCFullYear();
month = value.getUTCMonth();
date = value.getUTCDate();
hours = value.getUTCHours();
minutes = value.getUTCMinutes();
seconds = value.getUTCSeconds();
milliseconds = value.getUTCMilliseconds()
}
value = (year <= 0 || year >= 1e4 ? (year < 0 ? "-" : "+") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) + "-" + toPaddedString(2, month + 1) + "-" + toPaddedString(2, date) + "T" + toPaddedString(2, hours) + ":" + toPaddedString(2, minutes) + ":" + toPaddedString(2, seconds) + "." + toPaddedString(3, milliseconds) + "Z"
} else {
value = null
}
} else if (typeof value.toJSON == "function" && (className != numberClass && className != stringClass && className != arrayClass || isProperty.call(value, "toJSON"))) {
value = value.toJSON(property)
}
}
if (callback) {
value = callback.call(object, property, value)
}
if (value === null) {
return "null"
}
className = getClass.call(value);
if (className == booleanClass) {
return "" + value
} else if (className == numberClass) {
return value > -1 / 0 && value < 1 / 0 ? "" + value : "null"
} else if (className == stringClass) {
return quote("" + value)
}
if (typeof value == "object") {
for (length = stack.length; length--;) {
if (stack[length] === value) {
throw TypeError()
}
}
stack.push(value);
results = [];
prefix = indentation;
indentation += whitespace;
if (className == arrayClass) {
for (index = 0, length = value.length; index < length; index++) {
element = serialize(index, value, callback, properties, whitespace, indentation, stack);
results.push(element === undef ? "null" : element)
}
result = results.length ? whitespace ? "[\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "]" : "[" + results.join(",") + "]" : "[]"
} else {
forEach(properties || value, function (property) {
var element = serialize(property, value, callback, properties, whitespace, indentation, stack);
if (element !== undef) {
results.push(quote(property) + ":" + (whitespace ? " " : "") + element)
}
});
result = results.length ? whitespace ? "{\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "}" : "{" + results.join(",") + "}" : "{}"
}
stack.pop();
return result
}
};
exports.stringify = function (source, filter, width) {
var whitespace, callback, properties, className;
if (objectTypes[typeof filter] && filter) {
if ((className = getClass.call(filter)) == functionClass) {
callback = filter
} else if (className == arrayClass) {
properties = {};
for (var index = 0, length = filter.length, value; index < length; value = filter[index++], (className = getClass.call(value), className == stringClass || className == numberClass) && (properties[value] = 1));
}
}
if (width) {
if ((className = getClass.call(width)) == numberClass) {
if ((width -= width % 1) > 0) {
for (whitespace = "", width > 10 && (width = 10); whitespace.length < width; whitespace += " ");
}
} else if (className == stringClass) {
whitespace = width.length <= 10 ? width : width.slice(0, 10)
}
}
return serialize("", (value = {}, value[""] = source, value), callback, properties, whitespace, "", [])
}
}
if (!has("json-parse")) {
var fromCharCode = String.fromCharCode;
var Unescapes = {
92: "\\",
34: '"',
47: "/",
98: "\b",
116: " ",
110: "\n",
102: "\f",
114: "\r"
};
var Index, Source;
var abort = function () {
Index = Source = null;
throw SyntaxError()
};
var lex = function () {
var source = Source, length = source.length, value, begin, position, isSigned, charCode;
while (Index < length) {
charCode = source.charCodeAt(Index);
switch (charCode) {
case 9:
case 10:
case 13:
case 32:
Index++;
break;
case 123:
case 125:
case 91:
case 93:
case 58:
case 44:
value = charIndexBuggy ? source.charAt(Index) : source[Index];
Index++;
return value;
case 34:
for (value = "@", Index++; Index < length;) {
charCode = source.charCodeAt(Index);
if (charCode < 32) {
abort()
} else if (charCode == 92) {
charCode = source.charCodeAt(++Index);
switch (charCode) {
case 92:
case 34:
case 47:
case 98:
case 116:
case 110:
case 102:
case 114:
value += Unescapes[charCode];
Index++;
break;
case 117:
begin = ++Index;
for (position = Index + 4; Index < position; Index++) {
charCode = source.charCodeAt(Index);
if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {
abort()
}
}
value += fromCharCode("0x" + source.slice(begin, Index));
break;
default:
abort()
}
} else {
if (charCode == 34) {
break
}
charCode = source.charCodeAt(Index);
begin = Index;
while (charCode >= 32 && charCode != 92 && charCode != 34) {
charCode = source.charCodeAt(++Index)
}
value += source.slice(begin, Index)
}
}
if (source.charCodeAt(Index) == 34) {
Index++;
return value
}
abort();
default:
begin = Index;
if (charCode == 45) {
isSigned = true;
charCode = source.charCodeAt(++Index)
}
if (charCode >= 48 && charCode <= 57) {
if (charCode == 48 && (charCode = source.charCodeAt(Index + 1), charCode >= 48 && charCode <= 57)) {
abort()
}
isSigned = false;
for (; Index < length && (charCode = source.charCodeAt(Index), charCode >= 48 && charCode <= 57); Index++);
if (source.charCodeAt(Index) == 46) {
position = ++Index;
for (; position < length && (charCode = source.charCodeAt(position), charCode >= 48 && charCode <= 57); position++);
if (position == Index) {
abort()
}
Index = position
}
charCode = source.charCodeAt(Index);
if (charCode == 101 || charCode == 69) {
charCode = source.charCodeAt(++Index);
if (charCode == 43 || charCode == 45) {
Index++
}
for (position = Index; position < length && (charCode = source.charCodeAt(position), charCode >= 48 && charCode <= 57); position++);
if (position == Index) {
abort()
}
Index = position
}
return +source.slice(begin, Index)
}
if (isSigned) {
abort()
}
if (source.slice(Index, Index + 4) == "true") {
Index += 4;
return true
} else if (source.slice(Index, Index + 5) == "false") {
Index += 5;
return false
} else if (source.slice(Index, Index + 4) == "null") {
Index += 4;
return null
}
abort()
}
}
return "$"
};
var get = function (value) {
var results, hasMembers;
if (value == "$") {
abort()
}
if (typeof value == "string") {
if ((charIndexBuggy ? value.charAt(0) : value[0]) == "@") {
return value.slice(1)
}
if (value == "[") {
results = [];
for (; ; hasMembers || (hasMembers = true)) {
value = lex();
if (value == "]") {
break
}
if (hasMembers) {
if (value == ",") {
value = lex();
if (value == "]") {
abort()
}
} else {
abort()
}
}
if (value == ",") {
abort()
}
results.push(get(value))
}
return results
} else if (value == "{") {
results = {};
for (; ; hasMembers || (hasMembers = true)) {
value = lex();
if (value == "}") {
break
}
if (hasMembers) {
if (value == ",") {
value = lex();
if (value == "}") {
abort()
}
} else {
abort()
}
}
if (value == "," || typeof value != "string" || (charIndexBuggy ? value.charAt(0) : value[0]) != "@" || lex() != ":") {
abort()
}
results[value.slice(1)] = get(lex())
}
return results
}
abort()
}
return value
};
var update = function (source, property, callback) {
var element = walk(source, property, callback);
if (element === undef) {
delete source[property]
} else {
source[property] = element
}
};
var walk = function (source, property, callback) {
var value = source[property], length;
if (typeof value == "object" && value) {
if (getClass.call(value) == arrayClass) {
for (length = value.length; length--;) {
update(value, length, callback)
}
} else {
forEach(value, function (property) {
update(value, property, callback)
})
}
}
return callback.call(source, property, value)
};
exports.parse = function (source, callback) {
var result, value;
Index = 0;
Source = "" + source;
result = get(lex());
if (lex() != "$") {
abort()
}
Index = Source = null;
return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[""] = result, value), "", callback) : result
}
}
}
exports["runInContext"] = runInContext;
return exports
}
if (freeExports && !isLoader) {
runInContext(root, freeExports)
} else {
var nativeJSON = root.JSON, previousJSON = root["JSON3"], isRestored = false;
var JSON3 = runInContext(root, root["JSON3"] = {
noConflict: function () {
if (!isRestored) {
isRestored = true;
root.JSON = nativeJSON;
root["JSON3"] = previousJSON;
nativeJSON = previousJSON = null
}
return JSON3
}
});
root.JSON = {parse: JSON3.parse, stringify: JSON3.stringify}
}
if (isLoader) {
define(function () {
return JSON3
})
}
}).call(this)
}).call(this, typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {})
}, {}],
51: [function (_dereq_, module, exports) {
module.exports = toArray;
function toArray(list, index) {
var array = [];
index = index || 0;
for (var i = index || 0; i < list.length; i++) {
array[i - index] = list[i]
}
return array
}
}, {}]
}, {}, [31])(31)
});
View Git Blame Copy Permalink